1、总结一下局部内部类的成员特点。
答：和内部成员一样，没有静态声明。
没有静态成员变量，静态成员方法，以及静态代码块、但是可以定义字面值常量赋值的全局常量
第二题：局部内部类2、总结一下局部内部类的访问特点。（要分外围类成员方法中和静态方法中的局部内部类两种情况）
答：外围类成员方法中局部内部类对象，由于会持有外围类的对象的引用作为成员变量，所以可以直接访问外围类
而外围类静态成员方法中局部内部类对象，不持有任何外围对象，所以需要先创建外围类的对象再访问成员
第三题：局部内部类访问3、在局部内部类当中访问作用域内部的局部变量，可以修改它的取值吗？
答：不可以修改，是常量
第四题：匿名内部类4、匿名内部类的语法得到的是什么？（对象还是类？什么对象？）
答：对象，而且是语法结构中"类名/接口名"的子类对象
第五题：匿名内部类结构5、匿名内部类语法中的大括号是什么结构？这个大括号中能定义什么？
答：是匿名子类的类体，可以定义成员变量，成员方法，但没有构造器，也没有代码块以及静态声明
第六题：Lambda的语法6、Lambda的语法得到的是什么？（对象还是类？什么对象？）
答：是功能接口的子类对象
第七题：Lambda的语法结构答：是功能接口中，必须要子类实现的抽象方法的重写方法体。方法体中定义的是局部变量
第八题：功能接口8、什么是功能接口？
答：功能接口要求接口中有且仅有一个必须要实现的抽象方法
可以使用注解"@FunctionalInterface"标记它。
1、功能接口中只能有一个方法吗？
答：不是，Java8之后接口中允许定义默认方法和静态方法，这两种方法不需要子类实现
2、功能接口中只能有一个抽象方法吗？
不是，实际上来说：某些抽象方法不需要子类实现Java中每个类都继承父类Object那么如果一个抽象方法，可以用Object类的方法作为实现，那么该抽象方法，就不需要子类实现。
比如接口中的以下抽象方法：
boolean equals(Object o); int hashCode();
编程题： 成员内部类语法练习成员内部类对象依赖于它的外围类对象
package day10;
public class InnerClazzDemo {
public static void main(String[] args) {
Dog dog = new Dog(10, "Tom", "黄色");
dog.showDog();
}
}
class Dog {
private int age;
private String name;
private DogBody db;
// 成员内部类
private class DogBody {
private String color;
private DogBody(String color) {
this.color = color;
}
private DogBody() {
}
}
public void showDog() {
System.out.println("狗的年龄是：" + this.age + "岁t名字是：" + this.name + "t颜色是：" + this.db.color);
}
public Dog(int age, String name, String color) {
this.age = age;
this.name = name;
this.db = new DogBody(color);
}
// 为了保证正常给DogBody对象初始化，私有化无参构造或者干脆不提供
private Dog() {
}
}
运行结果图：
定义一个接口Compute，用来完成计算器的功能，比如最简单的加减乘除功能。 请用以下两种方式测试： 1，编写实现类进行测试 2，用局部内部类进行测试 3，使用匿名内部类进行测试
package day10;
@SuppressWarnings({"all"})
public class InterfaceInnerDemo {
public static void main(String[] args) {
System.out.println("-----创建实现类对象的方式-------");
ICalcImpl iCalc = new ICalcImpl();
System.out.println(iCalc.add(10, 20));
System.out.println(iCalc.subtract(10, 20));
System.out.println(iCalc.multiply(10, 20));
System.out.println(iCalc.divide(10, 20));
System.out.println("------创建实现类对象的方式------");
System.out.println("----------局部内部类的方式-----------");
class Inner implements ICalc {
@Override
public int add(int a, int b) {
return a + b;
}
@Override
public int subtract(int a, int b) {
return a - b;
}
@Override
public int multiply(int a, int b) {
return a * b;
}
@Override
public int divide(int a, int b) {
return a / b;
}
}
Inner inner = new Inner();
System.out.println(inner.add(10, 20));
System.out.println(inner.subtract(10, 20));
System.out.println(inner.multiply(10, 20));
System.out.println(inner.divide(10, 20));
System.out.println("----------局部内部类的方式-----------");
System.out.println("-------匿名内部类的方式----------");
ICalc ic = new ICalc() {
@Override
public int add(int a, int b) {
return a + b;
}
@Override
public int subtract(int a, int b) {
return a - b;
}
@Override
public int multiply(int a, int b) {
return a * b;
}
@Override
public int divide(int a, int b) {
return a / b;
}
};
System.out.println(inner.add(10, 20));
System.out.println(inner.subtract(10, 20));
System.out.println(inner.multiply(10, 20));
System.out.println(inner.divide(10, 20));
}
// @FunctionalInterface
interface ICalc {
int add(int a, int b);
int subtract(int a, int b);
int multiply(int a, int b);
int divide(int a, int b);
}
// 写实现类，然后创建对象
static class ICalcImpl implements ICalc {
@Override
public int add(int a, int b) {
return a + b;
}
@Override
public int subtract(int a, int b) {
return a - b;
}
@Override
public int multiply(int a, int b) {
return a * b;
}
@Override
public int divide(int a, int b) {
return a / b;
}
}
}
运行结果如图：
lambda表达式的书写，除了注意格式外，最重要的是关注类型推断
- 提供以下6个功能接口，请用lambda表达式分别创建对象，调用test()方法
- 自由发挥lambda表达式的书写
//无返回值无参数的功能接口
@FunctionalInterface
interface INoReturnNoParam {
void test();
}
//无返回值有一个参数的功能接口
@FunctionalInterface
interface INoReturnOneParam {
void test(int a);
}
//无返回值两个参数的功能接口
@FunctionalInterface
interface INoReturnTwoParam {
void test(int a, int b);
}
//有返回值无参数的功能接口
@FunctionalInterface
interface IHasReturnNoParam {
int test();
}
//有返回值一个参数的功能接口
@FunctionalInterface
interface IHasReturnOneParam {
int method(int a);
}
//有返回值两个参数的功能接口
@FunctionalInterface
interface IHasReturnTwoParam {
int test(int a, int b);
}
package day10;
public class LambdaBasicDemo {
public static void main(String[] args) {
INoReturnNoParam irl = () -> {
System.out.println("无返回值无参数的功能接口");
};
irl.test();
((INoReturnOneParam) a -> {
System.out.println("无返回值有一个参数的功能接口,其参数是：" + a);
}).test(10);
INoReturnTwoParam ir2 = (a, b) -> System.out.println("无返回值两个参数的功能接口,两个参数是a：" + a + " b: " + b);
ir2.test(10, 20);
IHasReturnNoParam ir3 = () -> {
int a = 10;
int b = 20;
return a + b;
};
System.out.println("有返回值无参数的功能接口,其返回值是：" + ir3.test());
IHasReturnOneParam ir4 = a -> ++a;
System.out.println("有返回值一个参数的功能接口,其返回值是" + ir4.test(10));
IHasReturnTwoParam ir5 = (a, b) -> a + b;
System.out.println("有返回值两个参数的功能接口,其返回值是：" + ir5.test(1, 2));
}
}
//无返回值无参数的功能接口
@FunctionalInterface
interface INoReturnNoParam {
void test();
}
//无返回值有一个参数的功能接口
@FunctionalInterface
interface INoReturnOneParam {
void test(int a);
}
//无返回值两个参数的功能接口
@FunctionalInterface
interface INoReturnTwoParam {
void test(int a, int b);
}
//有返回值无参数的功能接口
@FunctionalInterface
interface IHasReturnNoParam {
int test();
}
//有返回值一个参数的功能接口
@FunctionalInterface
interface IHasReturnOneParam {
int test(int a);
}
//有返回值两个参数的功能接口
@FunctionalInterface
interface IHasReturnTwoParam {
int test(int a, int b);
}
运行结果图：
alInterface
interface INoReturnTwoParam {
void test(int a, int b);
}
//有返回值无参数的功能接口
@FunctionalInterface
interface IHasReturnNoParam {
int test();
}
//有返回值一个参数的功能接口
@FunctionalInterface
interface IHasReturnOneParam {
int test(int a);
}
//有返回值两个参数的功能接口
@FunctionalInterface
interface IHasReturnTwoParam {
int test(int a, int b);
}
运行结果: 
