JAVA内部类

一.内部类分类

1.成员内部类（可以理解为成员变量）
2.静态内部类 （可可以理解为静态变量）
3.局部内部类 （可以理解为局部变量）
4.匿名内部类

二.成员内部类

1.成员内部类相当于类的成员变量，可以用访问修饰符修饰(private,public,protected,默认修饰符)
2.成员内部类不能有静态变量和静态方法
3.成员内部类可以访问外部类的所有资源（静态变量方法，成员变量方法）
4.内部使用： InnerClass inner = new InnerClass(); inner.调用
5.外部使用： OuterClass.InnerClass innerClass = new OuterClass().new InnerClass(); innerClass.调用

package com.test;

public class OuterClass {
    private String outmenber = "外部类成员变量";
    public static String outstatic = "外部类静态变量";

    public void outmethor(){
        System.out.println("外部类成员方法");
    }

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

    /**
     * 1.成员内部类相当于类的成员变量，可以用访问修饰符修饰(private,public,protected,默认修饰符)
     * 2.成员内部类不能有静态变量和静态方法
     * 3.成员内部类可以访问外部类的所有资源（静态变量方法，成员变量方法）
     * 4.内部使用： InnerClass inner = new InnerClass();  inner.调用
     * 5.外部使用： OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();  innerClass.调用
     */
    class InnerClass{
        private String innermenber = "内部类成员属性";
        //public static String innerStaticMember = "内部类静态变量";  成员内部类不允许有静态变量和方法
        private void innerMethor(){
            System.out.println("内部类方法");
            System.out.println("访问外部类成员变量："+outmenber);
            System.out.println(outstatic);
            outmethor();
            outStaticMethor();
        }
        public void innerMethor2(){
            System.out.println("内部类========");
        }
    }

    public void useInner(){
        InnerClass innerClass = new InnerClass();
        innerClass.innerMethor();
        System.out.println(innerClass.innermenber);
    }

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.useInner();
    }
}

class OutTest{
    public static void main(String[] args) {
        OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();
        innerClass.innerMethor2();
    }
}

三.静态内部类

1.静态内部类相当于外部类的静态变量，可以用任意访问修饰符修饰
2.静态内部类可以有静态变量及方法，成员变量及方法
3.静态内部类只能访问外部类的静态变量和方法
4.外部类内部使用： 分为访问静态变量/方法（类名.直接调用给）和访问成员变量及方法（通过对象调用）
5.类外部访问：
OuterClass2.InnerClass2.inStaticMethor(); //调用静态变量及方法
OuterClass2.InnerClass2 innerClass2 = new OuterClass2.InnerClass2(); //创建对象调用成员变量及方法

package com.test;

public class OuterClass2 {
    private String str1 ="str1";
    private static String str2 ="static menber";
    public void outMethor(){
        System.out.println("outMethor");
    }
    public static void outStaticMethor(){
        System.out.println("outStaticMethor");
    }

    /**
     * 静态内部类
     * 1.静态内部类相当于外部类的静态变量，可以用任意访问修饰符修饰
     * 2.静态内部类可以有静态变量及方法，成员变量及方法
     * 3.静态内部类只能访问外部类的静态变量和方法
     * 4.外部类内部使用： 分为访问静态变量/方法（类名.直接调用给）和访问成员变量及方法（通过对象调用）
     * 5.类外部访问：
     * OuterClass2.InnerClass2.inStaticMethor();  //调用静态变量及方法
     * OuterClass2.InnerClass2 innerClass2 = new OuterClass2.InnerClass2();  //创建对象调用成员变量及方法
     */
    static class InnerClass2{
        private String instr = "instr";
        private static String inStaticStr = "inStaticStr";
        public void inmethor(){
            System.out.println("this is inmethor");
            System.out.println(str2);  //只能访问静态变量及方法
            outStaticMethor();
        }
        public static void inStaticMethor(){
            System.out.println("this is inStaticMethor");
            System.out.println(str2);
            outStaticMethor();
        }
    }

    public void userStaticInnerClass(){
        InnerClass2.inStaticMethor();
        System.out.println(InnerClass2.inStaticStr);
        InnerClass2 innerClass2 = new InnerClass2();
        innerClass2.inmethor();
        System.out.println(innerClass2.instr);
        System.out.println(innerClass2.inStaticStr);
        innerClass2.inStaticMethor();
    }
}

class OutTest2{
    public static void main(String[] args) {
        OuterClass2.InnerClass2.inStaticMethor();  //调用静态变量及方法
        OuterClass2.InnerClass2 innerClass2 = new OuterClass2.InnerClass2();  //创建对象
        innerClass2.inmethor();  //调用成员变量及方法
    }
}

三.局部内部类

局部内部类
1.局部内部类相当于局部变量，不能用访问修饰符修饰
2.不能拥有静态变量及方法，和成员内部类一样
3.静态方法里的局部内部类只能方位外部类的静态变量及方法，成员方法的局部内部类访问外部类的所有资源
4.只能在定义局部内部类的方法里创建局部内部类对象调用
5.不能修改方法里的局部变量，但可以修改外部类的静态变量，成员变量

package com.test;

public class OuterClass3 {
    private static int x = 100;
    private String str1 ="str1";
    private static String str2 ="static menber";
    public void outMethor(){
        System.out.println("outMethor");
    }
    public static void outStaticMethor(){
        System.out.println("outStaticMethor");
    }
    public static void outStaticMethor2(){
        int k = 10;
        System.out.println("outStaticMethor");
        /**
         * 局部内部类
         * 1.局部内部类相当于局部变量，不能用访问修饰符修饰
         * 2.不能拥有静态变量及方法，和成员内部类一样
         * 3.静态方法里的局部内部类只能方位外部类的静态变量及方法，成员方法的局部内部类访问外部类的所有资源
         * 4.只能在定义局部内部类的方法里创建局部内部类对象调用，作用域在定义它的方法里
         * 5.不能修改方法里的局部变量，但可以修改外部类的静态变量，成员变量
         */
        class InnerClass3{
            private int a = 10;
            public void innerMethor(){
                System.out.println(a);
                System.out.println(str2);
                x++;
            }
        }
        InnerClass3 innerClass3 = new InnerClass3();
        innerClass3.innerMethor();
    }

    public static void main(String[] args) {

        outStaticMethor2();
    }
}

四.匿名内部类

1.匿名内部类只使用一次，没有名字，通过 new 类名(){} 创建，和局部内部类一样不能修改方法里的局部变量，可以和局部内部类一样去理解匿名内部类

package com.test;

public class NiClass {
    static int k = 300;
    public static void main(String[] args) {
        int t = 200;
        //相当于创建类A的子类，通过向上造型父类引用了子类
        A a = new A(){
            //重写方法a1
            public void a1(){
                System.out.println("我是匿名内部类，重写了a1方法");
            }
            //重写方法a2
            public int a2(int a,int b){
                return a*b;
            }
            
            public void a3(){
                k++;  //可以修改外部类的资源，由于是在静态方法定义的所以只能访问静态资源
            }
        };
        a.a1();
        int sum = a.a2(5,4);
        System.out.println(sum);
    }
}

class A{
    public void a1(){
        System.out.println("methor a1");
    }

    public int a2(int a,int b){
        return a+b;
    }
}