012Java基础之内部类

一个类内部又嵌套了一个完整的类结构。被嵌套的类称为内部类（inner class），嵌套其他类的类称为外部类（outer class），是类的五大成员（属性、方法、构造器、代码块、内部类）之一，内部类最大的特点就是可以直接访问私有属性，并且可以提现类与类之间的包含关系。
基本语法

class Outer{
class Inner{

	}
}

class Other{

}

1、内部类的分类

1、定义在外部类局部位置上（比如方法体内）

1、局部内部类（有类名）

（1）可以直接访问外部类的成员，包括私有的
（2）不能添加访问修饰符，因为它的地位就是我一个局部变量，局部变量是不能使用修饰符的，但是可以使用final来修饰，因为局部变量也可以使用final修饰，表示该内部类不能被继承
（3）作用域：仅仅在定义它的方法或代码块中
（4）局部内部类访问外部类的成员：直接访问！
（5）外部类范围局部类的成员：先创建对象，再访问（必须在其作用域内）
（6）外部其他类不能访问内部类成员
（7）如果外部类和内部类的成员重名，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类.this.成员）去访问

/**
 * @author Francis
 * @create 2021-07-03 18:28
 */
public class LocalClass01 {
    public static void main(String[] args) {
//演示一遍
        Outer02 outer02 = new Outer02();
        outer02.m1();
        System.out.println("outer02 的 hashcode=" + outer02);
    }
}
class Outer02 {//外部类
    private int n1 = 100;

    private void m2() {
        System.out.println("Outer02 m2()");
    }//私有方法
    public void m1() {//方法
//1.局部内部类是定义在外部类的局部位置,通常在方法
//3.不能添加访问修饰符,但是可以使用 final 修饰
//4.作用域 : 仅仅在定义它的方法或代码块中
        final class Inner02 {//局部内部类(本质仍然是一个类)
            //2.可以直接访问外部类的所有成员，包含私有的
            private int n1 = 800;
            public void f1() {
//5. 局部内部类可以直接访问外部类的成员，比如下面 外部类 n1 和 m2()
//7. 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，
// 使用 外部类名.this.成员）去访问
//  Outer02.this 本质就是外部类的对象, 即哪个对象调用了 m1, Outer02.this 就是哪个对象
                System.out.println("n1=" + n1 + " 外部类的 n1=" + Outer02.this.n1);
                System.out.println("Outer02.this hashcode=" + Outer02.this);
                m2();
            }
        }
//6. 外部类在方法中，可以创建 Inner02 对象，然后调用方法即可
        Inner02 inner02 = new Inner02();
        inner02.f1();
    }
}

2、匿名内部类（没有类名，这是学习的重点）

（1）本质是一个类
（2）是一个局部内部类
（3）该类没有名字
（4）同时还是一个对象
基本语法

new 类或接口(参数列表){
    类成员
};

这里的;不能少，切记切记！！！！

基于接口的匿名内部类
传统方式中，想要使用一个接口的功能，就得写一个类去实现该接口，并在需要的地方创建一个实现了该接口的对象，再调用方法实现功能

但这样做比较繁琐，当我们想使用接口的功能，但只会使用一次，以后就不会再用了，这样是写一个类实现接口就很不划算，这时可以用匿名内部类来实现。即在定义类的同时创建了对象，然后直接调用方法，实现功能。

基于类的匿名内部类
与基于接口的场景类似，当一个类想要继承于一个父类，但该类的对象也只会使用一次就不用了，可以使用匿名内部类来简化开发。

/**
 * @author Francis
 * @create 2021-07-03 19:03
 */
public class AnonymousInner {

    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}

class Outer04 { //外部类
    private int n1 = 10;//属性

    public void method() {//方法
//基于接口的匿名内部类
//1.需求： 想使用 IA 接口,并创建对象
//2.传统方式，是写一个类，实现该接口，并创建对象
//3.老Tiger/Dog 类只是使用一次，后面再不使用
//4. 可以使用匿名内部类来简化开发
//5. tiger 的编译类型 ? IA
//6. tiger 的运行类型 ? 就是匿名内部类 Outer04$1
/*
我们看底层会分配 类名 Outer04$1
class Outer04$1 implements IA {
@Override
public void cry() {
System.out.println("老虎叫唤...");
}
}
*/
//7. jdk 底层在创建匿名内部类 Outer04$1,立即马上就创建了 Outer04$1 实例，并且把地址
// 返回给 tiger
//8. 匿名内部类使用一次，就不能再使用
        IA tiger = new IA() {
            @Override
            public void cry() {
                System.out.println("老虎叫唤...");
            }
        };
        System.out.println("tiger 的运行类型=" + tiger.getClass());
        tiger.cry();
        tiger.cry();
        tiger.cry();
// IA tiger = new Tiger();
// tiger.cry();
//演示基于类的匿名内部类
//分析

//1. father 编译类型 Father
//2. father 运行类型 Outer04$2
//3. 底层会创建匿名内部类
/*
class Outer04$2 extends Father{
@Override
public void test() {
System.out.println("匿名内部类重写了 test 方法");
}
}
*/
//4. 同时也直接返回了 匿名内部类 Outer04$2 的对象
//5. 注意("jack") 参数列表会传递给 构造器
        Father father = new Father("jack") {
            @Override
            public void test() {
                System.out.println("匿名内部类重写了 test 方法");
            }
        };
        System.out.println("father 对象的运行类型=" + father.getClass());//Outer04$2
        father.test();
//基于抽象类的匿名内部类
        Animal animal = new Animal() {
            @Override
            void eat() {
                System.out.println("小狗吃骨头...");
            }
        };
        animal.eat();
    }
}

interface IA {//接口

    public void cry();
}

//class Tiger implements IA {
//
// @Override
// public void cry() {
// System.out.println("老虎叫唤...");
// }
//}
//class Dog implements IA{
// @Override
// public void cry() {
// System.out.println("小狗汪汪...");
// }
//}
class Father {//类

    public Father(String name) {//构造器
        System.out.println("接收到 name=" + name);
    }

    public void test() {//方法
    }
}

abstract class Animal { //抽象类
    abstract void eat();

}

其特性与局部内部类一致
匿名内部类的金典使用场景
（1）当做实参直接传递，简洁高效

/**
 * @author Francis
 * @create 2021-07-03 22:52
 */
public class AnonymousClassExercise01 {

    public static void main(String[] args) {
//当做实参直接传递，简洁高效
        f1(new IL() {
            @Override
            public void show() {
                System.out.println("这是一副名画~~...");
            }
        });
//传统方法
        f1(new Picture());
    }
    //静态方法,形参是接口类型
    public static void f1(IL il) {
        il.show();
    }
}
//接口
interface IL {
    void show();
}
//类->实现 IL => 编程领域 (硬编码)
class Picture implements IL {
    @Override
    public void show() {
        System.out.println("这是一副名画 XX...");
    }
}

2、定义在外部类的成员位置上

1、成员内部类（没有static修饰）

（1）可以访问外部类的所有成员，包括私有的。
（2）可以添加任意访问修饰符（public、protected、默认的、private），因为它的地位就是一个成员
（3）作用域：和外部类的其他成员一样，为整个类
（4）成员内部类范围外部类的成员：直接访问
（5）外部类访问成员内部类：创建内部类对象，通过一个方法返回
（6）外部其他类访问内部类，三种方法，代码说明
（7）如果外部类与内部类属性重名时，访问时遵循就近原则，如果想访问外部类的成员，还是使用（外部类名.this.属性）

/**
 * @author Francis
 * @create 2021-07-04 0:29
 */
public class MenberInnerClass01 {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();
//外部其他类，使用成员内部类的三种方式
//老韩解读
// 第一种方式
// outer08.new Inner08(); 相当于把 new Inner08()当做是 outer08 成员
// 这就是一个语法，不要特别的纠结.
        Outer08.Inner08 inner08 = outer08.new Inner08();
        inner08.say();
// 第二方式 在外部类中，编写一个方法，可以返回 Inner08 对象
        Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
        inner08Instance.say();
    }
}

class Outer08 { //外部类
    private int n1 = 10;
    public String name = "张三";

    private void hi() {
        System.out.println("hi()方法...");
    }

    //1.注意: 成员内部类，是定义在外部内的成员位置上
//2.可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    public class Inner08 {//成员内部类
        private double sal = 99.8;
        private int n1 = 66;

        public void say() {
//可以直接访问外部类的所有成员，包含私有的
//如果成员内部类的成员和外部类的成员重名，会遵守就近原则. //，可以通过 外部类名.this.属性 来访问外部类的成员
            System.out.println("n1 = " + n1 + " name = " + name + " 外部类的 n1=" + Outer08.this.n1);
            hi();
        }
    }

    //方法，返回一个 Inner08 实例
    public Inner08 getInner08Instance() {
        return new Inner08();
    }

    //写方法
    public void t1() {
//使用成员内部类
//创建成员内部类的对象，然后使用相关的方法
        Inner08 inner08 = new Inner08();
        inner08.say();
        System.out.println(inner08.sal);
    }

}

2、静态内部类（使用static修饰 ）

静态内部类是定义在外部类的成员位置，并且有static修饰
（1） 可以访问外部类的所有静态成员，包括私有的，但不能访问非静态成员
（2）可以添加任意访问修饰符，因为它的地位就是一个成员
（3）作用域：同其他成员一样，为整个类体
（4）静态内部类访问外部类成员（静态成员）：直接访问
（5）外部类访问内部类：创建对象，或者使用方法来创建对象，然后再返回
（6）外部其他类访问静态内部类：与外部类访问类似
（7）外部类与静态内部类属性重名的问题，还是遵循就近原则，如果想要访问外部类的静态成员，用==（外部类.静态成员名）==

/**
 * @author Francis
 * @create 2021-07-04 10:39
 */
public class StaticInnerClass01 {

        public static void main(String[] args) {
            Outer10 outer10 = new Outer10();
            outer10.m1();
//外部其他类 使用静态内部类
//方式 1
//因为静态内部类，是可以通过类名直接访问(前提是满足访问权限)
            Outer10.Inner10 inner10 = new Outer10.Inner10();
            inner10.say();
//方式 2
//编写一个方法，可以返回静态内部类的对象实例.
 Outer10.Inner10 inner101 = outer10.getInner10();
            System.out.println("============");
            inner101.say();
            Outer10.Inner10 inner10_ = Outer10.getInner10_();
            System.out.println("************");
            inner10_.say();
        }
    }
    class Outer10 { //外部类
        private int n1 = 10;
        private static String name = "张三";
        private static void cry() {}
        //Inner10 就是静态内部类
//1. 放在外部类的成员位置
//2. 使用 static 修饰
//3. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
//4. 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
//5. 作用域 ：同其他的成员，为整个类体

        static class Inner10 {
            private static String name = "法外狂徒张三";
            public void say() {
//如果外部类和静态内部类的成员重名时，静态内部类访问的时，
//默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.成员）
                System.out.println(name + " 外部类 name= " + Outer10.name);
                cry();
            }
        }
        public void m1() { //外部类---访问------>静态内部类 访问方式：创建对象，再访问
            Inner10 inner10 = new Inner10();
            inner10.say();
        }
        public Inner10 getInner10() {
            return new Inner10();
        }
        public static Inner10 getInner10_() {
            return new Inner10();
        }

}