浅谈附属类，内部类，匿名内部类，静态内部类

一、附属类
附属类只能用默认的访问修饰符，没有静态附属类
二、内部类
1、内部类一般定义成private，直接在类中其他方法中调用；
2、内部类地位可以想象成类中的方法，内部类可以随意使用外部类的成员变量；

public class A {
    private String name = "张三";
    private static int num = 001;
    public float score = 90.0f;

    public void study() {
        System.out.println("学生学习");
    }

//内部类，随意访问外部类的成员变量,局部变量访问不到
    private class B {
        public void learn() {
            System.out.println(name + num + score);
        }
    }
}

3、内部类中与外部类有同名变量的情况下，内部类中变量会覆盖外部类的成员变量，访问外部类的成员变量需要使用“外部类名.this.属性名”

public class A {
    private String name = "张三";
    private static int num = 001;
    public float score = 90.0f;

    public void study() {
        System.out.println("学生学习");
    }

    private class B {
        private String name = "李四";
        public void learn() {
        //name = this.name = "李四"；---内部类中的成员属性
        //A.this.name = " 张三" ---外部内中的成员属性
            System.out.println(name + num + score + A.this.name);
        }
    }
}

4、若内部类想在外部类中访问，需要先创建外部类对象，再创建内部类对象，通过外部类new一个内部类引用地址，最后通过内部类对象调用方法

public class A {
    private String name = "张三";
    private static int num = 1;
    public float score = 90.0f;

    public void study() {
        System.out.println("学生学习");
    }

    public class B {
        public void learn() {
            System.out.println(name + num + score );
        }
    }
}

public class Main {

    public static void main(String[] args) {
    // 先创建外部类对象
        A a = new A();
    //通过外部类对象new一个内部类的引用地址
        B b = a.new B();
    //通过内部类对象调用内部类中的方法
        b.learn();

    }

}

输入结果：张三190.0

5、内部类若调用外部类的方法，直接用外部方法名（）；

public class A {
    public String name = "张三";

    public void study() {
        System.out.println(name + "在学习");
    }

    public class B1 {
        public void exam() {
         //调用外部类的study（）方法
            study();
            System.out.println(name + "在考试");
        }
    }
}

public class Main {

    public static void main(String[] args) {
        A a = new A();
        B1 b = a.new B1();
        b.exam();
    }
}

三、匿名内部类
1、匿名内部类是放在方法里面的，匿名内部类是new类型的子类，在创建对象的时候继承父类或者实现一个接口，用创建对象调用方法是调用的匿名内部类中重写的方法，若不是重写的方法，调用的则是创建对象时的里面自己本身的方法

public class A {
    private String name = "张三";
    public void study() {
        System.out.println(name + "在学习");
    }

}

public class Main {

    public static void main(String[] args) {
        A a = new A() {
        //匿名内部类
            public void study() {
                System.out.println("匿名内部类重写的方法");
            }
        };
        //调用的匿名内部类中重写的方法
        a.study();
        }
        //再创建一个A类对象a1，里面写一个A子类中独有的方法
        A a1 = new A() {
            public void study1() {
                System.out.println("匿名内部类独有的方法");
            }
        };
        //调用study的方法是调用的A类中的study方法，若使用a1.study();会报错，我也不知道怎么调用匿名内部类中独有的方法，求大神
        a1.study();

    }

输入结果：1、匿名内部类重写的方法
2、张三在学习

2、在匿名内部类调用外部类的变量，这个变量要么是属性，要么是final修饰的常量

3、在匿名内部类调用外部类的方法，用super关键字

4、匿名内部类因为没有名字，因此没有构造函数

四、静态内部类
1、相当于外部类的静态方法的地位，可以用到外部类中的静态属性和静态方法，若想调用外部类的非静态方法和属性，则需要创建外部类的对象，通过对象名. 方法名/属性名 调用

public class A {
    public static String name = "张三";
    public void study() {
        // 外部类方法调用静态内部类的方法，创建静态内部类对象，通过对象调用方法
        // 或者将静态内部类的方法写成static方法，通过类名.方法名调用
        B1 b = new B1();
        b.exam();
        System.out.println(name + "在学习");
    }
    //外部类的静态方法
    public static void study1() {
        System.out.println("外部类的静态方法");
    }
    //静态内部类
    public static class B1 {
        public void exam() {
            //调用外部类的非静态方法，创建外部类的对象，通过对象调用方法
            A a = new A();
            a.study();
            //调用外部类的静态方法，不需要创建对象，直接调用静态方法名
            study1();
            //直接调用外部类的中静态属性
            System.out.println(name + "在考试");
        }
    }
}

2、静态内部类调用内部类的方法（内部类和内部类的方法访问修饰符可以是private)，通过外部类创建外部类对象，再通过外部类对象new一个内部类引用对象，通过内部类对象调用方法和属性；
内部类调用静态内部类的方法（内部类和内部类的方法访问修饰符可以是private),直接创建静态内部类对象，通过对象调用方法和属性

public class A {
    public static String name = "张三";

    public void study() {
        System.out.println(name + "在学习");
    }

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

    private static class B1 {
        private void exam() {
            /*
             * 静态内部类调用内部类的方法，创建一个外部类的对象，
             * 用该对象new一个 内部类的引用地址，通过内部类对象调用内部类中的方法
             */
            A a = new A();
            B2 b2 = a.new B2();
            b2.exam();
            System.out.println(name + "在考试");
        }
    }

    private class B2 {
        private void exam() {
            /*
             * 内部类调用静态内部类的方法直接只用创建静态内部类的对象，
             *  通过对象调用静态内部类的方法
             */
            B1 b1 = new B1();
            b1.exam();
            System.out.println("内部类的考试方法");
        }
    }
}

3、在main函数中调用静态内部类和内部类的方法,首先静态内部类和内部类及其方法的类访问限定修饰符不能是private，其他与上面一致

public class Main {

    public static void main(String[] args) {
        A a = new A();
        //调用静态内部类的方法
        B1 b1 = new B1();
        b1.exam();
        //调用内部类的方法
        B2 b2 = a.new B2();
        b2.exam();


}
}