匿名内部类

1.引入定义测试类，定义接口

public class AddableDemo {
     public static void main(String[] args) {
           }
    }
interface Addable{
    public abstract int add(int x,int y);
    }

1.1现在我们要调用接口中的方法应该怎么办呢？
定义一个Addable的实现类，实例化，然后调用。

public class AddableDemo {
     public static void main(String[] args) {
     Caddable  cc=new Caddable();
     int sum=cc.add(5,6);
     System.out.println(sum);
           }
    }
interface Addable{
    public abstract int add(int x,int y);
    }
//正常情况
class Caddable implements Addable{
    @Override
    public int add(int x, int y) {
        return x+y;
    }
}

1.2我们知道我们肯定能找到Addable的实现类，实例化，然后调用add();方法，既然肯定能找到这个实现类，那么能不能将其省略呢？这就是匿名内部类。我们来改进一下这个代码。

public class AddableDemo {
     public static void main(String[] args) {
     //3.我们来看一下这个参数，里面重写了add方法，前面有个new关键字
     //那我们就知道了接口没有构造方法不能new对象,
     //有重写 有new,有重写 所有这个一定是接口的实现类的对象
     //那么改进1处的参数若有参数则是 Addable a=子类对象
     //这是啥这就是多态呗
     int sum=useAddable(new Addable() {
            @Override
            public int add(int x, int y) {
                return x+y;
            }
        });
     System.out.println(sum);
           }
     //改进1.定义了一个方法参数为接口类型的变量
     public static int useAddable(Addable a){
       return a.add(4,2);//2.但是这里面的逻辑是啥呢
    }
}
interface Addable{
    public abstract int add(int x,int y);
    }
}

1.3我们来看一下改进方法里面这个参数，里面重写了add方法，前面有个new关键字，那我们就知道了接口没有构造方法不能new对象,有重写还有new 所有这个一定是接口的实现类的对象
那么改进1处的参数若有参数传过来则是 Addable a=子类对象
这是啥这就是多态呗
1.4再探究
既然是多态，那我们把1.1中的对象传入useAddable(Addable a)那应该也是可以的咯。

public class AddableDemo {
     public static void main(String[] args) {
     Caddable  cc=new Caddable();
     int sum= useAddable(cc);
     System.out.println(sum);
           }
      public static int useAddable(Addable a){
       return a.add(4,2);//2.但是这里面的逻辑是啥呢
    }
    }
interface Addable{
    public abstract int add(int x,int y);
    }
//正常情况
class Caddable implements Addable{
    @Override
    public int add(int x, int y) {
        return x+y;
    }
}

运行结果 --这是正儿八经的多态这里的cc 就相当于匿名类对象中的一个，重写方法的逻辑也是对应着的可以对应前三个实验代码看看帮助理解。

6

Process finished with exit code 0

2.我们看到下面这个地方emmm是不是看着很难受能不能再改进一下----接下来使用Lambda表达式来改进一下。

 int sum=useAddable(new Addable() {
            @Override
            public int add(int x, int y) {
                return x+y;
            }
        });

2.1但是Lambda的使用是有
前提

• 有一个接口
• 接口中有且仅有一个抽象方法
  格式
  (形式参数) -> {代码块}
  2.2开始改进

int sum=useAddable((int x, int y)->{ return x+y;});

你觉的咋样----是不是简洁了很多🐕
2.3那还能不能再简化一下呢？

Lambda表达式省略的规则

• 参数类型可以省略。但是有多个参数的情况下，不能只省略一个
• 如果参数有且仅有一个，那么小括号可以省略
• 如果代码块的语句只有一条，可以省略大括号和分号，和return关键字

public class AddableDemo {
    public static void main(String[] args) {
        int sum= useAddable((x,y)->x+y);
        System.out.println(sum);
    }
    public static int useAddable(Addable a){
        return a.add(4,2);//2.但是这里面的逻辑是啥呢
    }
}
interface Addable{
    public abstract int add(int x,int y);
}

运行结果 对着的

6

Process finished with exit code 0