四种内部类

内部类

基本介绍

  一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class)，嵌套其他类的类称为外部类(outer class)。是我们类的第五大成员【其他四类为：属性、方法、构造器、代码块】，内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系。

// 基本语法
class Outer{	// 外部类
	class Inner{	// 内部类

	}
}

class Other{	// 外部其他类
}

如图所示：

内部类的分类

定义在外部类局部位置上（比如方法内）：
   1）局部内部类（有类名）
   2）匿名内部类（没有类名，重点！）

定义在外部类的成员位置上：
   1）成员内部类（没用static修饰）
   2）静态内部类（使用static修饰）

局部内部类

说明： 局部内部类是定义在外部类的局部位置，比如方法中，并且有类名。

   1）可以直接访问外部类的所有成员，包含私有的；

   2）不能添加访问修饰符，因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final修饰，因为局部变量也可以使用final；

   3）作用域： 仅仅在定义它的方法或代码块中；

   4）局部内部类 — 访问 —> 外部类的成员 [访问方式： 直接访问]

   5）外部类 — 访问 —> 局部内部类的成员 [访问方式： 创建对象，再访问]
   （注意： 必须在作用域内）

   6）外部其他类 — 不能访 —> 局部内部类（因为 局部内部类地位是一个局部变量）；

   7）如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名this.成员）；

System.out.println("外部类的 n1 = " + 外部类名.this.n1)

匿名内部类

匿名内部类的使用（重点！！！）

  
1、 匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名。

   1）本质是类；2）内部类；3）该类没有名字；4）同时还是一个对象。

// 匿名内部类的基本语法
new 类/接口(参数列表){
	类体
}

// 基于接口的匿名内部类
public class Inner {
    public static void main(String[] args) {
        Outer01 outer01 = new Outer01();
        outer01.method();
    }
}


class Outer01{
    private int n1 = 10;    // 属性
    
    // 1.使用IA接口，并创建对象
    // 2.传统方式，写一个类，实现该接口，并创建对象
    // 3.需求是student类只使用一次，后面不再使用
    /*
        底层代码 会分配类名 Outer01$1
        class XXX implements IA {
            @Override
            public void study() {
                System.out.println("学生正在学习...");
            }
        }
    */
    // 4.jdk底层在创建匿名内部类0uter01$1, 立即马上就创建了0uter01$1实例
    //   并且把地址返回给了 student
    // 5.匿名内部类使用一次，就不能再使用了
    public void method(){   // 方法
        IA student = new IA() {
            // student的编译类型？ IA
            // student的运行类型？ 匿名内部类 XXX => Outer04$1
            @Override
            public void study() {
                System.out.println("学生正在学习...");
            }
        };

        System.out.println("student的运行类型 = " + student.getClass());
        student.study();

		// 基于类的匿名内部类
        // teacher的编译类型？ Teacher
        // teacher的运行类型？ Outer04$2
        Teacher teacher = new Teacher("tom"){
        };
    }
}


interface IA{    // 接口
    public void study();
}

class Teacher{
    public Teacher(String name){
    }
}

运行结果：

匿名内部类细节

  
2、 匿名内部类的语法比较奇特，因为匿名内部类既是一个类的定义，同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，因此可以调用匿名内部类方法。

3、 可以直接访问外部类的所有成员，包含私有的；

4、 不能添加访问修饰符，因为它的地位就是一个局部变量；

5、 作用域：仅仅在定义它的方法或代码块中；

6、 匿名内部类 — 访向 —> 外部类成员；[ 访问方式：直接访问 ]

7、 外部其他类 — 不能访问 —> 匿名内部类（因为 匿名内部类地位是一个局部变量）

8、 如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员) 去访问

public class InnerClassDetail {
    public static void main(String[] args) {

        Outer05 outer05 = new Outer05();
        outer05.f1();
    }
}

// 外部类
class Outer05{
    private int n1 = 99;
    public void f1(){
        // 创建一个基于类的匿名内部类
        // 不能添加访问修饰符，因为它的地位就是一个局部变量
        // 作用域：仅仅在定义它的方法或代码块中
        Person p = new Person(){
                    @Override
            public void hi() {
            
            	// 可以直接访问外部类的所有成员，包含私有的
            	// 如果外部类和内部类的成员重名时，内部类访问的话
            	// 默认遵循就近原则
            	// 如果想访问外部类的成员，则可以使用(外部类名.this.成员) 去访问
            	
                System.out.println("匿名内部类重写 hi方法的n1 = " + n1 + 
                        " 外部类的n1 = " + Outer05.this.n1 );
                        
                // Outer05.this 就是调用 f1的 对象
                
        };
        p.hi(); // 动态绑定，运行类型是 Outer05$1
        
        // 也可以直接调用，匿名内部类本身也是返回对象
        /*
        
        Person p = new Person(){
                    @Override
            public void hi() {
                System.out.println("匿名内部类重写 hi方法...");
            }
        };.hi();
        
        */

    }
}

class Person{   // 类
    public void hi(){
        System.out.println("Person hi()...");
    }
}

运行结果：

匿名内部类实践

public class InnerClassExercise01 {
    public static void main(String[] args) {

        // 匿名内部类当作实参直接传递，简洁高效
        f1(new AA1() {
            @Override
            public void show() {
                System.out.println("这是一副名画...");
            }
        });

        // 传统方法
        f1(new Picture());
    }

    // 静态方法，形参是接口类型
    public static void f1(AA1 aa1){
        aa1.show();
    }
}

// 接口
interface AA1{
    void show();
}

// 传统方法 类->实现AA1 => 编程领域（硬编码）
class Picture implements AA1{

    @Override
    public void show() {
        System.out.println("这是一副名画...");
    }
}

运行结果：

成员内部类

成员内部类的使用

 
说明： 成员内部类是定义在外部类的成员位置，并且没有static修饰。

1、 可以直接访问外部类的所有成员，包含私有的；

2、 可以添加任意访问修饰符(public、protected 、默认、private)，因为它的地位就是一个成员；

3、 作用域：和外部类的其他成员一样，为整个类体比如前面案例，在外部类的成员方法中创建成员内部类对象，再调用方法；

4、 成员内部类 — 访问 —> 外部类(比如：属性) [访问方式:直接访问]

5、 外部类 — 访问 —> 内部类，访问方式：创建对象， 再访问；

6、 外部其他类 — 访问 —> 成员内部类

public class MemberInnerClass {
    public static void main(String[] args) {
        Outer03 outer03 = new Outer03();
        outer03.test1();

        // 外部其他类，使用成员内部类的三种方式
        // 方式1
        // outer03.new Inner03(); 相当与把 new Inner03() 当作是 outer03的成员
        // 这就是一个语法，不要特别纠结
        Outer03.Inner03 inner03 = outer03.new Inner03();
        inner03.say();

        // 方式2 在外部类中，编写一个方法，可以返回 Inner03 对象
        Outer03.Inner03 inner03Instance = outer03.getInner03Instance();
        inner03Instance.say();

        // 方式3
        new Outer03().new Inner03();


    }
}

class Outer03{  // 外部类
    private int n1 = 10;

    public String name = "Raze";

    private void hi(){
        System.out.println("hi()方法...");
    }

    // 注意:成员内部类，是定义在外部类的成员位置
    public class Inner03{  // 成员内部类欧员内部类，规定义在外部内的成员位置上
        private double sal = 95.8;
        public void say(){
            // 可以直接访问外部类的所有成员，包含私有的
            System.out.println("n1 = " + n1 + " name = " + name);
            hi();
        }
    }

    // 方法，返回一个Inner03实例
    public Inner03 getInner03Instance(){
        return new Inner03();
    }

    // 方法
    public void test1(){
        // 使用了成员内部类
        Inner03 inner03 = new Inner03();
        inner03.say();
        System.out.println(inner03.sal);
    }
}

7、 如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员) 去访问；

静态内部类

静态内部类的使用

说明： 静态内部类是定义在外部类的成员位置，并且有static修饰

1、 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员；

2、 可以添加任意访问修饰符(public、protected 、默认、private)，因为它的地位就是个成员；

3、 作用域：同其他的成员，为整个类体；

4、 静态内部类 — 访问 —> 外部类(比如：静态属性) [ 访问方式：直接访问所有静态成员 ]；

5、 外部类 — 访问 —> 静态内部类 [ 访问方式：创建对象，再访问 ]；

6、 外部其他类 — 访问 —> 静态内部类；

7、 如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.成员) 去访问；

public class StaticInnerClas01 {
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.m();

        // 外部其他类 使用静态内部类
        // 方式1
        // 因为静态内部类，是可以通过类名直接访问（前提是满足访问权限）
        Outer04.Inner04 inner04 = new Outer04.Inner04();
        inner04.say();

        System.out.println("===============");
        // 方式2
        // 编写一个方法，可以返回静态内部类的对象实例
        Outer04.Inner04 inner041 = outer04.getInner04();
        inner041.say();

        System.out.println("****************");

        // 方式3
        // 直接使用外部类
        Outer04.Inner04 inner04_ = Outer04.getInner04_();
        inner04_.say();

    }
}

class Outer04{  // 外部类
    private int n1 = 10;
    private static String name = "Reyna";

    // Inner04 就是静态内部类
    // 1. 放在外部类的成员位置
    // 2. 使用 static 修饰
    static class Inner04{

        // 3. 可以直接访问外部类的所有静态成员，包含私有的
        // 但不能直接访问非静态成员

        // 4. 可以添加任意访问修饰符(public、protected 、默认、private)
        // 因为它的地位就是个成员
        public void say(){
            System.out.println(name);
        }
    }

    public void m(){
        Inner04 inner04 = new Inner04();
        inner04.say();
    }

    public Inner04 getInner04(){
        return new Inner04();
    }

    public static Inner04 getInner04_(){
        return new Inner04();
    }
}

小结

   1）内部类有四种：局部内部类，匿名内部类，成员内部类，静态内部类；

   2）重点还是掌握，匿名内部类的使用；

new 类/接口(参数列表){
	//...
};

   3）感员内部类，静态内部类，是放在外部类的成员位置，本质就是一个成员。