java—（内部类，匿名内部类）

内部类

定义：就是在一类中在定义一个类。
特点：内部类可以直接访问外部类成员，包括私有
外部类要访问内部类的成员，必须创建对象。

package neibulei;

public class Outer {//创建外面类
    
    private int m;
    public int n;

    public void eat() {
        System.out.println("吃");
    }

    public class Inter {//内部类
        int s = 20;

        //内部类可以直接访问外部类成员，包括私有
        public void show() {
            m = 10;//直接调用外部变量
            System.out.println(m);
            eat();//直接调用外部方法
        }
    }
        // 外部类要访问内部类的成员，必须创建对象。
        public void play() {
            Inter I = new Inter();
            I.show();//通过创建对象调用内部方法
            System.out.println(I.s);

    }
}

【没有创建内部类对象就调用内部方法，系统报错

】

成员内部类的：

在类的成员位置：和类方法一样的位置
格式：外部类名.内部类名 对象名 =new 外部类对象. new内部类对象

  Outer.Inter a =new Outer().new Inter();

测试类：
在测试类中调用内部类的方法

package neibulei;

public class Test {
    public static void main(String[] args) {
//成员类部类的调用方法：这里面要求内部类不能是私有的
        Outer.Inter a =new Outer().new Inter();
        a.show();
    }
}

【如果将内部设为私有类，则需要在外部类创建一个方法，然后实例化对象，调用内部类方法

 public void getMethod(){
         Inter i =new Inter();
         i.show();
            }

】
然后在测试类创建外部类对象，外部类对象调用方法从而间接调用了内部类方法；就行构造器中getge方法一样，通过函数访问私有变量，然后其他类创建对象，调用该方法即可。

package neibulei;

public class Test {
    public static void main(String[] args) {
//成员类部类的调用方法：这里面要求内部类不能是私有的
      //  Outer.Inter a =new Outer().new Inter();
       // a.show();
        Outer o =new Outer();
        o.getMethod();
    }
}

局部内部类：

在类方法里面有一个类
特点：局部内部类可以直接访问外部类成员，包括私有
外部类要访问局部内部类的成员，必须创建对象，然后在调用

package neibulei;

public class Outer1 {
    private  int n =10;
    public  void  get(){
        class Inter {
            public void show() {
                //内部类可以直接访问外部类成员，包括私有
                System.out.println(n);
            }
        }
            Inter i =new Inter();
            i.show();
        }
    }

package neibulei;

public class Test {
    public static void main(String[] args) {
//成员类部类的调用方法：这里面要求内部类不能是私有的
      //  Outer.Inter a =new Outer().new Inter();
       // a.show();
        Outer1 o =new Outer1();
        o.get();
    }
}

匿名类部类

存在一个类或接口，在里面类可以是抽象或者具体的类
本质是继承了该类或者实现了该接口的子类匿名对象
格式：

new 类名或接口（）{
	重写方法；
}

package neibulei;

public interface Inter1 {
    void show();
}

package neibulei;

public class Outer2 {
    public  void getMethod(){
       /* new Inter1(){//本质是一个对象.结尾可以调用该内部类成员方法
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }.show();
        */
      Inter1 i = new Inter1(){//或者直接创建一个对象
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
      
    };
    i.show();

}
}

package neibulei;

public class Test {
    public static void main(String[] args) {
//成员类部类的调用方法：这里面要求内部类不能是私有的
      //  Outer.Inter a =new Outer().new Inter();
       // a.show();
        Outer2 o =new Outer2();
        o.getMethod();
    }
}

匿名类部类应用

接口知识点：https://blog.csdn.net/gun_wqy/article/details/123589004

接口类：

package neibulei;

public interface Inter1 {
    void show();
}

接口操作类：

package neibulei;

public class OuterOperation {
    public void method(Inter1 i){//本质是Inter1 i =new 传进来的类
        //Inter1 i创建了一个对象，就可以调用其方法
        //Inter1 i =new Student()表示实现接口Inter ,调用右边方法
        i.show();
    }
}

学生类：

package neibulei;

public class Student implements Inter1{
    @Override//重写方法，接口的知识点
    public void show(){
        System.out.println("学生在学习");
    }
}

测试类：

package neibulei;

import javafx.concurrent.Worker;

public class Test {
    public static void main(String[] args) {
//成员类部类的调用方法：这里面要求内部类不能是私有的
      //  Outer.Inter a =new Outer().new Inter();
       // a.show();
        OuterOperation O =new OuterOperation();
        Inter1 i =new Student();
        o.method(i);

            }
        }

应用：
这里使用了匿名内部类的应用，好处就是可以实现接口的方法，且不需要再次创建一个类去实现接口方法，然后主函数在调用等操作；
分析：
通过method()传进去new Inter1()， OuterOperation（）相当于创建Inter1 i =new Inter1()，
new Inter1()就相当于new Student()一样，也可以理解为new Worker()等等；
之前就重写了方法，和Student重写方法一样。

package neibulei;

import javafx.concurrent.Worker;

public class Test {
    public static void main(String[] args) {
//成员类部类的调用方法：这里面要求内部类不能是私有的
      //  Outer.Inter a =new Outer().new Inter();
       // a.show();
        OuterOperation O =new OuterOperation();
        Inter1 i =new Student();
        O.method(i);
        O.method(new Inter1() {
            @Override
            public void show() {
                System.out.println("老师在学习");
            }
        });
        
        }
            }