Java-内部类和Lambda表达式

女爷i 2022-12-23 03:21 103阅读 0赞

### 文章目录 ###

*  一、内部类的基本使用
 *  二、成员内部类
 *  三、局部内部类
 *  四、匿名内部类
 *  五、Lambda表达式
 *  六、Lambda表达式和匿名内部类的区别

--------------------

# 一、内部类的基本使用 #

在一个类中定义一个类。

*  格式：

class 外部类名{
        
        修饰符 class 内部类名{
        
    
        }
    }

*  实例：

class Outer {
        
        public class Inner {
        
    
        }
    }

内部类的访问特点

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

public class Outer {
        
        private int num = 10;
        public class Inner {
        
            public void show() {
        
                System.out.println(num);
            }
        }
        public void method() {
        
            Inner i = new Inner();
            i.show();
        }
    }

# 二、成员内部类 #

成员内部类的定义位置

*  在类中方法，跟成员变量是一个位置

外界创建成员内部类格式

*  格式：

外部类.内部类名 对象名 = 外部类对象.内部类对象;

*  实例

Outer.Inner oi = new Outer().new Inner();

私有成员内部类

*  将一个类，设计为内部类的目的，大多是都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。

实例：

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

静态成员内部类

*  访问格式：

外部类名.内部类名 对象名 = new 外部类名.内部类名();

*  静态成员内部类中的静态方法：

外部类名.内部类名.方法名();

*  实例：

class Outer {
        
        static class Inner {
        
            public void show(){
        
                System.out.println("inner..show");
            }
    
            public static void method(){
        
                System.out.println("inner..method");
            }
        }
    }
    
    public class Test3Innerclass {
        
        /*
            静态成员内部类演示
         */
        public static void main(String[] args) {
        
            // 外部类名.内部类名 对象名 = new 外部类名.内部类名();
            Outer.Inner oi = new Outer.Inner();
            oi.show();
    
            Outer.Inner.method();
        }
    }

# 三、局部内部类 #

局部内部类定义位置

*  局部内部类实在方法中定义的类

局部内部类发访问方式

*  局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
 *  该类可以直接访问外部类的成员，也可以访问方法内的局部变量

实例：

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();
        }
    }

# 四、匿名内部类 #

匿名内部类的前提

*  存在一个类或者接口，这里的类可以是具体的类也可以是抽象类

匿名内部类的格式

*  格式：

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

*  实例：

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

匿名内部类的本质是一个继承了该类或者实现了该接口的子类匿名对象。

匿名内部类的细节：

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

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();	// 直接调用方法
        }
    }

匿名内部类在开发中的使用

*  当发现某个方法需要接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码。

实例：

/*
        游泳接口
     */
    interface Swimming {
        
        void swim();
    }
    
    public class TestSwimming {
        
        public static void main(String[] args) {
        
            goSwimming(new Swimming() {
        
                @Override
                public void swim() {
        
                    System.out.println("铁汁, 我们去游泳吧");
                }
            });
        }
    
        /**
         * 使用接口的方法
         */
        public static void goSwimming(Swimming swimming){
        
            /*
                Swimming swim = new Swimming() {
                    @Override
                    public void swim() {
                        System.out.println("铁汁, 我们去游泳吧");
                    }
                }
             */
            swimming.swim();
        }
    }

# 五、Lambda表达式 #

格式：

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

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

组成Lambda表达式的三要素：

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

Lambda表达式的省略模式

规则：

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

通过匿名内部类实现：

goSwimming(new Swimming() {
        
        @Override
        public void swim() {
        
            System.out.println("铁汁, 我们去游泳吧");
        }
    });

通过Lambda表达式实现：

goSwimming(() -> System.out.println("铁汁, 我们去游泳吧"));

# 六、Lambda表达式和匿名内部类的区别 #

所需类型不同

*  匿名内部类：可以是借口，也可以是抽象类，还可以是具体类
 *  Lambda表达式：只能是接口

使用限制不同

*  如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
 *  如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式

实现原理不同

*  匿名内部类：编译之后，产生一个单独的.class字节码文件
 *  Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

--------------------