内部类总结(20)

内部类总结

静态内部类

1. 概述：

   • 静态内部类可以等同看作静态方法/变量

2. 作用：

   • 静态内部类可以访问它的外部类中的私有属性和方法

3. 总结:

   • 静态内部类里面可以直接访问外部类的静态数据，但无法直接访问成员变量及方法
   • 静态内部类可以添加修饰符public、protected、缺省

   // 静态内部类
   public class StaticClass {
       // 成员变量
       String name = "我是一个成员变量";
       //  静态变量
       private static String a1 = "我是一个静态常量";
       // 静态方法
       public static void b1() {
           System.out.println("我是一个静态方法");
       }
       // 成员方法
       public int sum(int a,int b) {
           int result = a + b;
           return result;
       }
   
       // 声名一个静态内部类
       public static class static1{
           String c;   // 成员变量
           public static int num = 10; // 静态变量
   
           public static void c1() {
               System.out.println("这是一个静态内部类里面的静态方法");
           }
   
           public void  c2() {
               System.out.println("这是一个静态内部类里面的成员方法");
           }
           public static void test() {
               System.out.println(a1);   // 静态变量
               // System.out.println(name);   // 成员变量编译报错 --------> java: 无法从静态上下文中引用非静态 变量 name
               b1();   // 静态方法
               // sum(1,2); // 成员方法编译报错 --------> java: 无法从静态上下文中引用非静态 方法 sum(int,int)
   
               System.out.println("---------------------------");
           }
       }
   
   }
   class a {
       public static void main(String[] args) {
           StaticClass.static1.c1();   // 静态方法
           // StaticClass.static1.c2();   // 静态方法 --------> java: 无法从静态上下文中引用非静态 方法 c2()
           StaticClass.static1.test();   // 静态内部类方法测试
   
           // 创建静态内部类
           StaticClass.static1 e = new StaticClass.static1();
           e.c2();
           e.c1();
       }
   }
   

成员内部类

概述：

• 成员内部类可以等同看作成员方法/变量

作用：

• 成员内部类可以访问它的外部类中的私有属性和方法

总结：

• 成员内部类可以直接访问外部类的所有属性和方法
• 成员内部类不可以有静态声名(包括所有含有static的关键字)
• 成员内部类可以添加修饰符public、protected、缺省

public class MembersClass {
    // 成员变量
    String name = "我是一个成员变量";
    //  静态变量
    private static String a1 = "我是一个静态常量";
    // 静态方法
    public static void b1() {
        System.out.println("我是一个静态方法");
    }
    // 成员方法
    public int sum(int a,int b) {
        int result = a + b;
        return result;
    }

    // 声名一个成员内部类
    public class static1{
        // public static int num = 10; // 静态变量编译报错： ---> 'static' 仅允许在常量变量声明中使用
        String c;   // 成员变量
        // 成员方法
        public void  c2() {
            System.out.println("这是一个成员内部类的成员方法");
        }
        public void test() {
            System.out.println(name);   // 成员变量
            System.out.println(a1); // 静态变量
            b1();   // 静态方法
            sum(1,2);   // 成员方法
            System.out.println("---------------------------");
        }
    }

}

class b {
    public static void main(String[] args) {
        // 创建外部类对象
        MembersClass e1 = new MembersClass();
        MembersClass.static1 e2 = e1.new static1();
        e2.test(); // 测试

        e2.c = "这是一个成员内部类的成员变量";
        System.out.println(e2.c);
        e2.c2();
    }
}

局部内部类

作用：

• 局部内部类的使用保证全局方法和变量不会被污染从而运行出错

总结：

• 局部内部类只在当前方法中有效
• 在JDK8及以上版本中，可以不使用final修饰，但是也不可以二次赋值，如果局部变量被内部类访问，那么该局部变量相当于自动使用了final修饰
• 局部内部类中不能定义 static 成员
• 局部内部类中还可以包含内部类，但是这些内部类也不能使用访问控制修饰符（public、private 和 protected）和 static 修饰符修饰
• 在局部内部类中可以访问外部类的所有成员

public class LocalClass {
    int n = 11000;
    public int sum(int a,int b) {
        return a+b;
    }
    public void a1() {
        int a = 10;
        // 声名一个局部内部类
        class b1{
            public void c() {
                System.out.println(a);
                System.out.println(n);  // 外部方法
                System.out.println(sum(10,10)); // 外部方法
            }
        }
        // a = 100; // 编译报错 ----> java: 从内部类引用的本地变量必须是最终变量或实际上的最终变量
        b1 local = new b1();
        local.c();
    }
}
class d {
    public static void main(String[] args) {
        LocalClass localClass = new LocalClass();
        localClass.a1();
    }
}

匿名内部类

概述：

• 匿名内部类：其实就是一个匿名子类对象
• 格式：new 父类or接口（）{子类内容}

总结：

• 匿名内部类优点：可以少定义一个类

• 匿名内部类缺点：无法重复利用

public class AnonymousClass {
    public static void i(a1 a) {
        a.m1();
    }

    public static void main(String[] args) {
        // 第一种方法：调用a2接口
        i(new a2());

        // 第二种方法：调用m1方法,可以使用匿名内部类
        i(new a1() {
            @Override
            public void m1() {
                System.out.println("执行了");
            }
        });
    }
}
// 接口
interface a1 {
    public void m1();
}

// 第一种方法：实现a1接口
class a2 implements a1 {
    public void m1() {
        System.out.println("执行力");
    }
}