内部类&Lambda

内部类

在一个类中定义一个类

内部类的访问特点：

• 内部类可以直接访问外部类的成员，包括私有
• 外部类要访问内部类成员，必须创建对象

1. 成员内部类

1. 举例：

   public class Test {
       public static void main(String[] args) {
           //内部类对象创建格式：
           Outer.Inner oi = new Outer().new Inner();
           oi.show();
           System.out.println(oi.a);
       }
   }
   
   class Outer{
       private int a = 20;
       class Inner{
           //成员内部类里面不能包含静态的属性和方法
           int a = 10;
           public void show(){
               System.out.println("内部类的show方法");
               System.out.println(a);
               System.out.println("外部类.this.变量名="+Outer.this.a);//访问外部类的私有变量
           }
       }
   }
   

2. 概览：

   • 定义位置：
     • 在类中方法外，跟成员变量是一个位置
   • 外界创建成员内部类格式：
     • 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
     • Outer.Inner oi = new Outer().new Inner();

3. 注意：

   • 内部类可以使用任意权限修饰符，如：public、private、protected等。
   • 内部类可以直接访问外部类的数据，不受权限修饰符的影响
   • 如果外部类和内部类具有相同的成员变量或方法，如果内部类访问外部类的成员变量或者方法时，需要使用this关键字

2.静态内部类

1. 举例：

   public class Test1 {
       public static void main(String[] args) {
           //用static 修饰的内部类
           StaticOuter.Inner so = new StaticOuter.Inner();
           so.show();//静态类的非静态方法
           StaticOuter.Inner.show1();//静态的静态方法
       }
   }
   
   class StaticOuter{
       int a = 10;
       static int s = 33;
       static class Inner{
           static int s = 22;
           public void show(){
               System.out.println("静态中非静态方法");
               System.out.println("外部类的静态成员S="+StaticOuter.s);
               System.out.println("内部类的静态成员S="+s);
           }
           public static void show1(){
               System.out.println("静态中的静态方法");
               System.out.println("访问外部类非静态成员："+new StaticOuter().a);
           }
       }
   }
   

2. 概览：

   • 用static修饰的内部类

3. 注意：

   • 不能直接访问外部类的非静态成员(可以通过 new 外部类().成员名 的方式访问)
   • 如果外部类的静态成员与内部类的静态成员相同，可以通过 类名.静态成员 来访问，如果不同就直接调用
   • 内部类中的静态方法也可以使用类名点调用*(StaticOuter.Inner.show1()😉*

3.局部内部类

1. 举例：

   class Outer {
       private int num = 10;
       public void method() {
           int num2 = 20;
           class Inner {
               public void show() {
                   System.out.println(num);
                   System.out.println(num2);
               }
           }
           Inner i = new Inner();
           i.show();
       }
   }
   public class OuterDemo {
       public static void main(String[] args) {
           Outer o = new Outer();
           o.method();
       }
   }
   

2. 概览：

   • 定义位置：
     • 在方法中定义
   • 调用方式：
     • 外界无法直接使用局部内部类，需要在方法内部创建对象并使用
     • 局部内部类可以直接访问外部类的成员，也可以访问方法内的局部变量

4.匿名内部类

1. 概览：

   • 前提

     • 存在一个类或者接口，可以是具体类也可以是抽象类

   • 格式

     • new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }

     • 举例

       new Inter(){
           @Override
           public void method(){}
       } 
       

   • 匿名内部类的本质

     • 是一个继承了该类或者实现了该接口的子类匿名对象

2. 细节：

   • 匿名内部类可以通过多态的形式接受

     Inter i = new Inter(){
       @Override
         public void method(){
             
         }
     }
     

   • 匿名内部类直接调用方式

     interface Inter{
         void method();
     }
     
     class Test{
         public static void main(String[] args){
             new Inter(){
                 @Override
                 public void method(){
                     System.out.println("我是匿名内部类");
                 }
             }.method();	// 直接调用方法
         }
     }
     

Lambda表达式

1. 代码演示

   /*
       游泳接口
    */
   interface Swimming {
       void swim();
   }
   
   public class TestSwimming {
       public static void main(String[] args) {
           // 通过匿名内部类实现
           goSwimming(new Swimming() {
               @Override
               public void swim() {
                   System.out.println("铁汁, 我们去游泳吧");
               }
           });
   
           /*  通过Lambda表达式实现
               理解: 对于Lambda表达式, 对匿名内部类进行了优化
            */
           goSwimming(() -> System.out.println("铁汁, 我们去游泳吧"));
       }
   
       /**
        * 使用接口的方法
        */
       public static void goSwimming(Swimming swimming) {
           swimming.swim();
       }
   }
   

2. 格式：

   • 格式：

     ​ (形式参数) -> {代码块}

     • 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
     • ->：由英文中画线和大于符号组成，固定写法。代表指向动作
     • 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

   • 组成Lambda表达式的三要素：

     • 形式参数，箭头，代码块

3. 省略模式

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

   代码演示：

   public interface Addable {
       int add(int x, int y);
   }
   
   public interface Flyable {
       void fly(String s);
   }
   
   public class LambdaDemo {
       public static void main(String[] args) {
   //        useAddable((int x,int y) -> {
   //            return x + y;
   //        });
           //参数的类型可以省略
           useAddable((x, y) -> {
               return x + y;
           });
   
   //        useFlyable((String s) -> {
   //            System.out.println(s);
   //        });
           //如果参数有且仅有一个，那么小括号可以省略
   //        useFlyable(s -> {
   //            System.out.println(s);
   //        });
   
           //如果代码块的语句只有一条，可以省略大括号和分号
           useFlyable(s -> System.out.println(s));
   
           //如果代码块的语句只有一条，可以省略大括号和分号，如果有return，return也要省略掉
           useAddable((x, y) -> x + y);
       }
   
       private static void useFlyable(Flyable f) {
           f.fly("风和日丽，晴空万里");
       }
   
       private static void useAddable(Addable a) {
           int sum = a.add(10, 20);
           System.out.println(sum);
       }
   }
   

4. Lambda表达式和匿名内部类的区别

   • 所需类型不同
     • 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
     • Lambda表达式：只能是接口
   • 使用限制不同
     • 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
     • 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式
   • 实现原理不同
     • 匿名内部类：编译之后，产生一个单独的.class字节码文件
     • Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成