内部类的基本使用

内部类概念

在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类
我们把一个类放在另一个类的内部定义，称为内部类(inner class)。

内部类的两个要点：

内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包中的其他类直接访问。
内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。但外部类不能访问内部类的内部属性。

/*
    内部类访问特点：
        内部类可以直接访问外部类的成员，包括私有
        外部类要访问内部类的成员，必须创建对象
 */
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 的内部类。编译完成后会出现 Outer.class和 Outer$Inner.class 两个类的字节码文件。所以内部类是相对独立的一种存在，其成员变量 / 方法名可以和外部类的相同。

内部类的访问特点

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

内部类的分类

成员内部类（理解）

成员内部类的定义位置
- 在类中方法，跟成员变量是一个位置
外界创建成员内部类格式
- 格式：外部类名.内部类名对象名 = 外部类对象.内部类对象;
- 举例：Outer.Inner oi = new Outer().new Inner();
私有成员内部类
- 将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。

非静态内部类

非静态内部类（外部类里使用非静态内部类和平时使用其他类没什么不同）

1. 非静态内部类对象必须寄存在一个外部类对象里。因此，如果有一个非静态内部类对象那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象。

2. 非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问非静态内部类成员。

3. 非静态内部类不能有静态方法、静态属性和静态初始化块。

4. 成员变量访问要点：

1. 内部类属性：this.变量名。

2. 外部类属性：外部类名.this.变量名。

内部类的访问：

1. 外部类中定义内部类：new Inner()。

2. 外部类以外的地方使用非静态内部类：
Outer.Inner varname = new Outer().new Inner()。

        Outer sw = new Outer();
//        通过method方法调用内部类方法，到达调用内部类
        sw.method();
//        访问内部类的格式
        Outer.Inner inc = new Outer().new Inner();
        inc.show();

静态内部类

static class ClassName {
//类体
}

使用要点：

1. 静态内部类可以访问外部类的静态成员，不能访问外部类的普通成员。

2. 静态内部类看做外部类的一个静态成员。

package static_innerclass;

class Outer2 {
    private static int b = 20;
    private int a = 10;

    //相当于外部类的一个静态成员
    static class Inner2 {
        public void test() {
//            System.out.println(a);           //静态内部类不能访问外部类的普通属性
            System.out.println(b); //静态内部类可以访问外部类的静态属性
        }
    }
}

public class static_inner {
    public static void main(String[] args) {
        //通过 new 外部类名.内部类名() 来创建内部类对象
        Outer2.Inner2 inner = new Outer2.Inner2();
        inner.test();
    }
}

匿名内部类

匿名内部类的前提
- 存在一个类或者接口，这里的类可以是具体类也可以是抽象类
- 匿名内部类没有访问修饰符。

- 匿名内部类没有构造方法。因为它连名字都没有那又何来构造方法呢。

匿名内部类的格式
- 格式：new 类名 ( ) { 重写方法 }
- new 接口名 ( ) { 重写方法 }

匿名内部类的本质
- 本质：是一个继承了该类或者实现了该接口的子类匿名对象
匿名内部类的细节
- 匿名内部类可以通过多态的形式接受

package anonymity_class;

//定义一个接口，里面有个show方法
interface Inter {
    void show();
}

interface Inter2 {
    void show1();

    void show2();
}

//实现类：创建接口的实现类对象使用
class InterImpl implements Inter {
    //重写接口里面的方法
    @Override
    public void show() {
        System.out.println("InterImpl  重写的show方法");
    }
}
public class anonymity {
    /*
        1. 创建实现类, 通过implements关键字去实现接口
        2. 重写方法
        3. 创建实现类对象
        4. 调用重写后的方法.

        匿名内部类:
            前提: 需要存在类\接口
            格式:
                   new 类名 \ 接口名 (){
                        重写方法
                    }
     */
    public static void main(String[] args) {

        InterImpl ii = new InterImpl();
        ii.show();

        // 匿名内部类的理解: 将继承\实现, 方法重写, 创建对象, 放在了一步进行.
        // 解释: 实现了Inter接口的, 一个实现类对象.
        new Inter() {
            @Override
            public void show() {
                System.out.println("我是匿名内部类中的show方法");
            }
        }.show(); // .show() 直接调用内部类的show方法

        // 情况: 接口中存在多个方法
//        实例化接口实现类 打个花括号在里面重写方法
        Inter2 i = new Inter2() {

            @Override
            public void show1() {
                System.out.println("show1...");
            }

            @Override
            public void show2() {
                System.out.println("show2...");
            }
        };
//调用内部类的方法
        i.show1();
        i.show2();
    }
}

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

Lambda表达式

Lambda表达式的使用前提

使用Lambda必须要有接口
并且要求接口中有且仅有一个抽象方法

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

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

体验Lambda表达式

组成Lambda表达式的三要素：

形式参数，箭头，代码块

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

形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可 ->：由英文中画线和大于符号组成，固定写法。代表指向动作

代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

匿名内部类的格式是 new 类名/接口名(){ // 重写方法 }

抽象方法带参无返回值的Lambda写法

Lambda表达式的简化写法

省略规则

参数类型可以省略。但是有多个参数的情况下，不能只省略一个

如果参数有且仅有一个，那么小括号可以省略

如果代码块的语句只有一条，可以省略大括号，分号，return

package LambdaDemo;

/*
    游泳接口
 */
interface Swimming {
    void swim();
}

public class Swimmingdemo {
    public static void main(String[] args) {
        // 通过匿名内部类实现
        goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("铁汁, 我们去游泳吧");
            }
        });

        /*  通过Lambda表达式实现
            理解: 对于Lambda表达式, 对匿名内部类进行了优化
            省略了类型名，没传入参数则小括号没有省略，由于这里代码只有一句，省略了大括号、分号、return
         */
        goSwimming(() -> System.out.println("铁汁, 我们去游泳吧"));
    }

    /*
     * 使用接口的方法
     */
    public static void goSwimming(Swimming swimming) {
        swimming.swim();
    }
}

Lambda表达式练习

Lambda表达式的使用前提
- 有一个接口
- 接口中有且仅有一个抽象方法
练习描述

无参无返回值抽象方法的练习
操作步骤
- 定义一个接口(Eatable)，里面定义一个抽象方法：void eat();
- 定义一个测试类(EatableDemo)，在测试类中提供两个方法
  - 一个方法是：useEatable(Eatable e)
  - 一个方法是主方法，在主方法中调用useEatable方法

package LambdaDmeo2;

//接口
interface Eatable {
    void eat();
}
//实现类
class EatableImpl implements Eatable {
    @Override
    public void eat() {
        System.out.println("一天一苹果，医生远离我，实现类调用");
    }
}
//测试类
public class EatableDemo {
    public static void main(String[] args) {
        //在主方法中调用useEatable方法
        Eatable e = new EatableImpl();
        useEatable(e);

        //匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("一天一苹果，医生远离我，匿名类调用");
            }
        });

        //Lambda表达式，
        useEatable(() -> {
            System.out.println("一天一苹果，医生远离我，Lambda表达式调用");
        });
    }
//定义了一个函数，形式参数为一个接口，接口不能实例化所以就会用到匿名类、Lambda表达式了
    private static void useEatable(Eatable e) {
        e.eat();
    }
}

标签：部类,java,内部,void,接口,new,public
From： https://www.cnblogs.com/e-link/p/16754808.html

java-内部类