java内部类

什么是内部类

一个类A内部定义一个内部类B，那么B就是A的内部类，A可以称为外部类。

成员内部类如何实例化对象

外部类名.内部类名 对象名 = new 外部类构造方法().new 内部类构造方法()

成员内部类方法中局部变量，成员变量，外部类成员变量名字冲突了，如何访问

局部变量：直接访问
内部类成员变量： this 访问
外部类成员变量：外部类名.this 访问

public class Test {
    public static void main(String[] args) {
        Person.Heart heart = new Person().new Heart();

        heart.beats();
        heart.show();

        Person person = new Person();
        person.show();
    }
}

//外部类
class Person{

    private int age = 10;

    public void show(){
        Heart heart = new Heart();
        System.out.println(heart.rate);
    }

    //内部类
    class Heart{
        private int age = 20;
        private int rate = 80;

        public void beats(){
            System.out.println("咚咚咚~~");
        }

        public void show(){
            int age = 30;
            System.out.println(age);//30
            System.out.println(this.age);//20
            //外部类名.this
            System.out.println(Person.this.age);//10
        }
    }
}

匿名内部类

	1.匿名内部类是一个非常特殊的内部类，从命名可以看出，匿名内部类是
没有类名，因此这个内部类只能用一次。
	2.有什么场景可以使用呢？匿名内部类一般用来简化代码，当要快速实
现一个抽象类或者接口的抽象方法时，我们就可以使用匿名内部类来简化，
可以不用专门定义一个有名类来操作。
	3.要使用匿名内部类，必须要有一个父类或者接口。

匿名内部类格式：

new 抽象类名/接口名(){
            需要重写抽象类或者接口中的抽象方法
        }

public class Test {
    public static void main(String[] args) {
        useSwimming(new SwimmingImpl());

        useSwimming(new SwimmingImpl(){
            @Override
            public void swim(){
                System.out.println("游泳");
            }
        });

        //匿名内部类
        useSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("游泳");
            }
        });
    }


    public static void useSwimming(Swimming swimming){
        swimming.swim();
    }
}

interface Swimming{
    public abstract void swim();
}

class SwimmingImpl implements Swimming{

    @Override
    public void swim() {
        System.out.println("我们去游泳");
    }
}

匿名内部类的使用

1.使用父类型变量多态接受该匿名子类对象
2.以匿名对象的方式使用
	直接调用的方式使用
	当做方法的参数传递
	当做方法的返回值使用

public class Test1 {
    public static void main(String[] args) {
        //1.使用父类型变量多态接受该匿名子类对象
        Flyable flyable = new Flyable() {
            @Override
            public void fly() {
                System.out.println("飞");
            }
        };
        flyable.fly();

        //2.以匿名对象的方式使用
        //    1）直接调用方法使用
        new Flyable() {
            @Override
            public void fly() {
                System.out.println("飞2");
            }
        }.fly();

        //     2）当作方法的参数传递
        useFlyable(new Flyable() {
            @Override
            public void fly() {
                System.out.println("飞3");
            }
        });


    }

    //当作方法的返回值类型
    public static Flyable getFlyable(){
        return new Flyable() {
            @Override
            public void fly() {
                System.out.println("飞~~~");
            }
        };
    }

    public static void useFlyable(Flyable flyable){
        flyable.fly();
    }

}

interface Flyable{
    public abstract void fly();
}

学的不是技术，更是梦想！！！