JAVA中内部类和外部类的相关关系

内部类

注意⚠️写在外部类的 {} 中的类才是内部类
总结几点：
1、静态内部类只能访问外部类的静态属性，要访问外部类的其他属性需要通过创建对象
2、成员内部类可以访问外部类的所有属性

3、外部类可以通过(静态内部类)内部类的对象，去访问内部类的所有属性（包括private私有属性），
对于静态内部类：【外部类中】也可以直接通过 【 类名.静态属性名】的方式——> 访问静态内部类的静态属性，
但【其他类不能直接通过类名.属性名】访问静态内部类的属性。
需要【外部类.静态内部类.属性名】new Outer.StaticInner().静态属性

4、成员内部类不能拥有static属性，静态内部类可以拥有所有修饰符的属性

5、其他类可以直接new静态内部类，但不能直接new成员内部类，

成员内部类——>在家娇生惯养的小儿子

他是小儿子，还没长大，不具有一个类的所有功能（不能有static）
他被外部类（他爸爸）保护，是亲亲的自家人（可以访问外部类的所有属性）
想要拿到小儿子，需要过他爸爸这一关（先经过他爹同意，先new他爹）
成员内部类：可以视为是外部类的一个成员
它就相当于是外部类的一个 int a;
其他类要获取该外部类的成员变量a时，必须通过get方法。
类比成员内部类，它是外部类的一个成员类，不像成员变量有get方法
成员内部类的get方法，就是它的构造方法。
成员内部类，作为外部类的成员，完全是外部类的自家人
所以！
总结：
1、成员内部类可以随意访问外部类的任何东西
2、其他类要访问成员内部类，必须通过外部类的对象new出来（相当于getA）
Outer outer = new Outer();
Inner inner = outer.new Inner(); 即，成员内部类受外部类保护而隐藏
3、外部类可以直接new成员内部类
4、成员内部类不能持有static修饰的任何东西
5、外部类可以【通过】（静态）内部类的【对象】 访问（静态）内部类中的 任意属性，
包括私有的属性，因为私有属性对于其他类来说，是需要get方法来访问的。但对于
外部类来说，可以直接通过 对象.属性名 来访问，而不需要get方法

public class Outer {
    private int outerAge = 1;
    public String outerName = "innerName";
    public static String outerTall = "外部类的静态成员";

    public static void outerStaticMethod() {
        System.out.println("外部类的静态方法");
    }

    private void outerStaticMethod1(Inner inner) {
    // 外部类可以【通过】（静态 / 成员）内部类的【对象】
        //           访问（静态）内部类中的 任意属性
        System.out.println(inner.innerAge);
        System.out.println(inner.innerName);
        System.out.println("外部类的普通方法");
    }

	public Inner outerMethod() {
	//  外部类可以直接new一个成员内部类，
//但其他类不行直接new成员内部类，因为它受外部类保护了
        Inner inner = new Inner();
外部类可以【通过】（静态）内部类的【对象】 访问（静态）内部类中的 任意属性，
        int age = inner.innerAge;
        String name = inner.innerName;
        return inner;
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        // 注意：外部类的 psvm main方法中，也不能直接new出 成员内部类
        Inner inner = outer.new Inner();
    }

    class Inner {
        private int innerAge = 1;
        public String innerName = "innerName";

        public Inner() {
            System.out.println("成员内部类的构造方法");
        }

        public void innerMethod() {
            System.out.println("成员内部类的方法");
            System.out.println(outerAge);
            System.out.println(outerName);
            System.out.println(outerTall);
            outerStaticMethod();
            System.out.println("成员内部类可以访问外部类的任何东西");
        }

    }
}

静态内部类——>放养在外的成年大儿子

成年大儿子放养在外，相当于可以视为完全正常的一个外部类
只不过静态内部类写在外部类中而已。它拥有一个类所有的正常功能
它完全可以视为是一个独立的类，只不过它和外部类挂钩了而已
相当于是外部类中的一个 static int b; 即静态成员
他是养子，不够亲，不受外部类保护，可以完全视为一个独立的类。
但为了代码深度不要太深，它只是写在这个外部类里面而已
它是一个健全的类，只不过是写在外部类中。

即使没有外部类对象，也可以创建静态内部类对象，而外部类的非static成员必须依赖于对象的调用，静态成员则可以直接使用类调用，不必依赖于外部类的对象，所以静态内部类只能访问静态的外部属性和方法

因此
1、静态内部类可以直接new出来，不用通过它的外部类去new
2、静态内部类【只能访问外部类的静态成员和方法】（相对于其他独立的类而言，
其他独立的类也可以直接通过类名访问外部类的静态成员和方法，所以
这个静态内部类就相当于是其他独立的类一样）
静态内部类想要访问外部类的非静态方法，需要先new出一个外部类对象
3、静态内部类和其他独立的类一样，可以正常的拥有静态属性和非静态的属性
4、外部类可以【通过】（静态）内部类的【对象】 访问（静态）内部类中的 任意属性，
包括私有的属性，因为私有属性对于其他类来说，是需要get方法来访问的。但对于
外部类来说，可以直接通过 对象.属性名 来访问，而不需要get方法

public class Outer {
    private int outerAge = 1;
    public String outerName = "innerName";
    public static String outerTall = "外部类的静态成员";

    public static void outerStaticMethod() {
        System.out.println("外部类的静态方法");
    }

    private void outerStaticMethod1(StaticInner staticInner) {
        // 外部类可以【通过】（静态）内部类的【对象】
        //           访问（静态）内部类中的 任意属性
        System.out.println(staticInner.innerAge);
        System.out.println(staticInner.innerName);
        System.out.println("外部类的普通方法");
    }

    private StaticInner outerStaticMethod2() {
    // 在外部类中可以直接new出来静态内部类，
        // 同时，其他类也可以直接new出来静态内部类
        StaticInner staticInner = new StaticInner();
        // 外部类可以【通过】（静态）内部类的【对象】
        //           访问（静态）内部类中的 任意属性
    //  ！ 如果是静态内部类，可以直接【通过类名访问静态属性】
        System.out.println(staticInner.innerAge);
        System.out.println(staticInner.innerName);
        return staticInner;
    }


    public static void main(String[] args) {
    //  在外面直接new出来静态内部类
        StaticInner staticInner = new StaticInner();
    }

    static class StaticInner {
        private int innerAge = 1;
        public String innerName = "innerName";

        public StaticInner() {
            System.out.println("静态内部类的构造方法");
        }

        public static void main(String[] args) {
            System.out.println("静态内部类！都可以创建一个主线程（跟独立的外部类一样）");
        }

        public void innerMethod() {
            System.out.println("静态内部类的普通方法");
            System.out.println(outerTall);
            outerStaticMethod();
        }

        public static void innerMethod2() {
            System.out.println("静态内部类的静态方法");
        }

    }
}

局部内部类——>在家娇生惯养的小小儿子(权限更低些)

1、定义：定义在方法中或者一个作用域里面的类，
它和成员内部类的区别在于
局部内部类的访问仅限于方法内或者该作用域内。
局部内部类就像是方法里面的一个局部变量一样，
**********是【不能有public、protected、private以及static修饰符】的。

class People{
    public People() {
         
    }
}
    public People getWoman(){
        class Woman extends People{   //局部内部类
            int age =0;
        }
        return new Woman();
    }
}

匿名内部类

1、匿名内部类不能有构造器（构造方法）——> 他都没有类名
2、匿名内部类不可以是抽象类

abstract class Outer {
    abstract void method();
}

public class demo {
    public static void main(String[] args) {
        Outer outer = new Outer() {   //{}里就是个匿名内部类
            @Override
            void method() {

            }
        };
    }

    //可以看到，我们直接将抽象类的方法在大括号中实现了。这样便可以省略一个类的书写。
    //并且，匿名内部类还能用于接口上
}