内部类、匿名内部类

内部类

把类定义在其他类的内部，这个类就叫内部类。
内部类分为：成员内部类、局部内部类。

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

局部内部类

局部内部类是定义在一个方法或者一个作用域里面的类。

public class Outer {

    public void function() {
        //局部内部类Inner
        class Inner {
            public void print() {
                System.out.println("局部内部类");
            }
        }
        //在局部位置创建内部类对象，调内部类方法，来使用局部内部类功能
        Inner in= new Inner();
        in.print();

    }
}

public class InnerDemo {
    public static void main(String[] args){
        Outer out= new Outer();
        out.function();
    }
}

//输出：局部内部类

什么时候使用局部内部类：
假设Inner这个类只在方法function中创建这个类对象时被使用了一次。（即只在某个方法中需要用那么一下）
当遇到这种情况时，可以在一个方法中定义局部类。

匿名内部类

匿名内部类将局部内部类的使用再深入一步。假如只创建这个类的一个对象，就不必命名了。

前提：存在一个类（抽象类或具体类都可以）或者接口。
格式：

new 类名或者接口名(){
	重写方法；
};//有个分号哦，这句其实是一个对象

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

接口式匿名内部类：

code V1:

//接口
interface Inter {
    public abstract void show();
}

//采用匿名内部类实现接口
public class OuterInner {

    public void method(){
        new Inter(){
            public void show(){
                System.out.println("我是匿名内部类");
            }
        }.show();  //Note！！分号  这句是一个匿名对象  它实现了Inner接口（重写了show方法）  它是一个实现了接口的子类匿名对象，对象调方法
    }
}

//测试类
public class AnonymousInnerDemo {
    public static void main(String[] args){

        OuterInner o= new OuterInner();
        o.method();
    }
}

//输出结果：我是匿名内部类

code V2：

//采用匿名内部类实现接口   V2
public class OuterInner {

    public void method(){
    
        Inter i= new Inter(){  //其实是多态Fu f= new Zi();  右边new Inter(){}这一堆是子
            public void show(){
                System.out.println("我是匿名内部类");
            }
        };//注意分号哦
        i.show();
    }

}

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

参数式的匿名内部类：使用比较器排序的TreeSet、TreeMap
https://blog.csdn.net/u013317445/article/details/82228746 TreeMap比较器排序中用到。采用了匿名内部类重写Comparator的compare方法，也就是实现Comparator接口。

interface Person {
    public abstract void study();
}

public class PersonDemo {

    //method的形参是个接口
    //需要的实参是一个该接口的实现类对象 其实我们在给实参时，就可以用匿名内部类
    public void method(Person p){
        p.study();
    }
}

public class AnonymousInnerDemo {
    public static void main(String[] args){
        PersonDemo pd= new PersonDemo();


        //整个操作中只使用一次，且只需要创建一个实例，就可以将其定义为匿名内部类
        //参数式匿名内部类
        //最原始的方式是单独写一个类实现Person接口，在这个类中重写方法。然后创建该类的对象，然后调用方法
        pd.method(new Person() {
            @Override
            public void study() {
                System.out.println("好好学习");
            }
        });
    }
}

一道题引发的思考

interface Inter{
    void show();
}

class Outer{
    //补齐该类的代码 令测试类输出为HelloWorld.
    public static Inter method(){
        return new Inter(){  //return了一个这样的匿名对象
            @Override
            public void show(){
                System.out.println("HelloWorld.");

          }
        };
    }
}

public class Prictice {
    public static void main(String[] args){
        Outer.method().show();
        //Outer.method()：类调用方法，说明method是static的
        //.show()：说明点前面有对象——>method有返回值，且返回值为一个对象，且这个对象的类型里面定义了show方法
    }
}

Outer.method().show(); 这一句代码：
Outer.method()：类调用方法，说明method是static的
.show()：说明点前面有对象——>method有返回值，且返回值为一个对象，且这个对象的类型里面定义了show方法