java面向对象 成员内部类、静态内部类、匿名内部类、成员内部类总结

Java类的一般组成是类中包含成员属性和成员方法，但是，在特殊情况下，一个类的内部也会有另一个类的存在，这种类就叫内部类，之前一直搞不太清内部类的用法，看到一些教程自己也操作一遍终于能弄懂它们之间的区别了。
一、静态内部类
特点：
1、静态内部类可以等同看作静态变量
2、内部类可以访问外部类中私有的数据
3、静态内部类可以用访问控制权限的修饰符
4、静态内部类可以访问外部类中的静态数据（变量，方法），无法直接访问成员数据

/*
1、静态内部类可以等同看作静态变量
2、内部类可以访问外部类中私有的数据
3、静态内部类可以用访问控制权限的修饰符
4、静态内部类可以访问外部类中的静态数据（变量，方法），无法直接访问成员数据
*/

public class OuterClass {
    // 静态变量
    private static String s1 = "a";

    //成员变量
    private String s2="b";
    //静态方法
    private static void m1(){
       System.out.println("静态方法");
    }
    //成员方法
    private void m2(){
        System.out.println("成员方法");
    }
    //静态内部类
    static class InnerClass {
        //静态方法
        public static void m3(){
            System.out.println(s1);
            m1();
        }

        //成员方法
        public void m4(){
            System.out.println(s1);
           m1();
        }
    }
    public static void main(String[] args) {
        //静态方法通过类名直接访问
        OuterClass.InnerClass.m3();
        //成员方法实例化后通过对象进行访问
        InnerClass inner=new OuterClass.InnerClass();
        inner.m4();
    }
}

二、成员内部类
特点：
1、成员内部类可以等同看做成员变量
2、成员内部类中不能有静态声明
3、可以用访问控制权限的修饰符修饰
4、成员内部类可以访问外部类中所有的数据
5、创建成员内部类对象时，先创建外部类对象，再通过那个对象创建出来。

/*
1、成员内部类可以等同看做成员变量
2、成员内部类中不能有静态声明
3、可以用访问控制权限的修饰符修饰
4、成员内部类可以访问外部类中所有的数据
5、创建成员内部类对象时，先创建外部类对象，再通过那个对象创建出来。
*/

public class OuterClass2 {
    // 静态变量
    private static String s1 = "a";

    // 成员变量
    private String s2 = "b";

    // 静态方法
    private static void m1() {
        System.out.println("静态方法");
    }

    // 成员方法
    private void m2() {
        System.out.println("成员方法");
    }

    // 成员内部类
    class InnerClass {
        // 静态方法

        // 成员方法
        public void m4() {
            System.out.println(s1);
            m1();
            System.out.println(s2);
            m2();
        }
    }
    public static void main(String[] args) {

        //创建外部类对象
        OuterClass2 oc = new OuterClass2();
     
        InnerClass inner = oc.new InnerClass();
        inner.m4();
}
}

三、成员内部类
特点：
1、局部内部类等同于局部变量，不能用修饰符修饰。
2、局部内部类在访问局部变量时，局部变量必须用final修饰
3、局部内部类只在方法内有效，所以只能在方法内调用

/*
1、局部内部类等同于局部变量，不能用修饰符修饰。
2、局部内部类在访问局部变量时，局部变量必须用final修饰
3、局部内部类只在方法内有效，所以只能在方法内调用
*/
public class OuterClass3 {
    //方法
    public void m1(){
        //局部变量
        final int i=10;
        //局部内部类
        //局部内部类不能用访问控制权限修饰符修饰
        class Innerclass{
            //内部类不能有静态声明
            //public static void m1(){}
            public void m2(){
                System.out.println(i);
            }
        }
        //调用m2
        Innerclass inner=new Innerclass();
        inner.m2();
    }
    public static void main(String[] args) {
        OuterClass3 outer=new OuterClass3();
        outer.m1();
    }

}

四、匿名内部类
特点：1、匿名内部类，指的是类没有名字
2、整个“new customerservice就是个匿名内部类，为了减少接口的实现类，直接实现该接口

/*
匿名内部类，指的是类没有名字
*/
public class OuterClass4 {
    public static void  t(CustomerService cs){
    cs.logout();
}
public static void main(String[] args) {
    //使用匿名内部类执行t方法
    //整个“new customerservice就是个匿名内部类，为了减少接口的实现类，直接实现该接口
    t(new CustomerService(){
    
        @Override
        public void logout() {
            System.out.println("exit");
        }
    });
}
}
interface CustomerService{

    void logout();
}