Quartz 4

Inner Class

9 min read

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class), 嵌套其他类的类称为外部类(outer class)。

是我们类的第五大成员类的五大成员是哪些? 属性、方法、构造器、代码块、内部类。内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系。

如果定义类在局部位置 (方法中/代码块):

  1. 局部内部类（有类名）
  2. 匿名内部类（没有类名，重点）

定义在外部类的成员位置上：

  1. 成员内部类（没用static修饰）
  2. 静态内部类（使用static修饰）

局部内部类

public class LocalInnerClass {
    public static void main(String[] args) {
        //演示一遍
        Outer02 outer02 = new Outer02();
        outer02.m1();
        System.out.println("outer02的hashcode=" + outer02);
    }
}
 
 
class Outer02 {//外部类
    private int n1 = 100;
    private void m2() { //私有方法
        System.out.println("Outer02 m2()");
    }
    public void m1() { // 方法里面
        //1. 局部内部类是定义在外部类的局部位置,通常在方法
        //3. 不能添加访问修饰符,但是可以使用final 修饰
        //4. 作用域 : 仅仅在定义它的方法或代码块中
        final class Inner02 {// 局部内部类(本质仍然是一个类)
            //2. 可以直接访问外部类的所有成员，包含私有的
            private int n1 = 800;
            public void f1() {
                //5. 局部内部类可以直接访问外部类的成员，比如下面 外部类n1 和 m2()
                //7. 如果外部类和局部内部类的成员重名时，默认遵循**就近原则**，如果想访问外部类的成员，
                //   使用 外部类名.this.成员 去访问
                //   解读 Outer02.this 本质就是**外部类的对象**, 即哪个对象调用了m1, Outer02.this就是哪个对象
                System.out.println("n1=" + n1 + " 外部类的n1=" + Outer02.this.n1); // 注意：要加 this
                System.out.println("Outer02.this hashcode=" + Outer02.this);
                m2();
            }
        }
        //6. 外部类在方法中，可以创建Inner02对象，然后调用方法即可
        Inner02 inner02 = new Inner02();
        inner02.f1();
    }
 
}

匿名内部类

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

说明：匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名 匿名内部类的基本语法:

new 类或接口（参数列表）{
类体
};

传统方式

public class AnonymousInnerClass {
    public static void main(String[] args) {
        new Outer04().method();
    }
}
 
class Outer {
	private int n1 = 10; // 属性
	public void method(){}//方法
	 // 基于接口的匿名内部类
	 // 实现并使用 IA 接口
	 // 传统方式，是写一个类，实现该接口，并创建对象
	 IA tiger = new Tiger();
	 tiger.cry();
}
 
class Tiger implements IA{
	@Override
	public void cry(){
			// 实现了方法
	}
}
 
interface IA {
     public void cry();
}
 
class Father {
		public void test(){}
		public Father(String name){}
}

使用匿名内部类

IA tiger = new IA(){ // tiger 的编译类型 IA;运行类型为 匿名内部类
	@Override
	public void cry(){System.out.println("老虎叫唤...");}
};

底层实现

class Outer$1 implements IA {
	@Override
	public void cry() {
			System.out.println("老虎叫唤...");
	}
}

成员内部类

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

public class MemberInnerClass01 {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();
 
        //外部其他类，使用成员内部类的三种方式
       
        // 第一种方式
        // outer08.new Inner08(); 相当于把 new Inner08()当做是outer08成员
        // 这就是一个语法，不要特别的纠结.
        Outer08.Inner08 inner08 = outer08.new Inner08();
        inner08.say();
        // 第二种方式 在外部类中，编写一个方法，可以返回 Inner08对象
        Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
        inner08Instance.say();
 
				//第三种方式，就是第一种方式的简化写法
				Outer08.Inner08 inner = new Outer08().new Inner08();
    }
}
 
class Outer08 { //外部类
    private int n1 = 10;
    public String name = "张三";
 
    private void hi() {
        System.out.println("hi()方法...");
    }
 
    //1.注意: 成员内部类，是定义在外部内的成员位置上
    //2.可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    public class Inner08 {//成员内部类
        private double sal = 99.8;
        private int n1 = 66;
        public void say() {
            //可以直接访问外部类的所有成员，包含私有的
            //如果成员内部类的成员和外部类的成员重名，会遵守就近原则.
            //，可以通过  外部类名.this.属性 来访问外部类的成员
            System.out.println("n1 = " + n1 + " name = " + name + " 外部类的n1=" + Outer08.this.n1);
            hi();
        }
    }
    //方法，返回一个Inner08实例
    public Inner08 getInner08Instance(){
        return new Inner08();
    }
 
 
    //写方法
    public void t1() {
        //使用成员内部类
        //创建成员内部类的对象，然后使用相关的方法
        Inner08 inner08 = new Inner08();
        inner08.say();
        System.out.println(inner08.sal);
    }
}

静态内部类

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

  1. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
  2. 可以添加任意访问修饰符(public、protected、默认、private)),因为它的地位就是一个成员。
  3. 作用域：同其他的成员，为整个类体
  4. 静态内部类 访问⇒ 外部类（比如：静态属性）访问方式：直接访问所有静态成员
  5. 外部类 访问-⇒ 静态内部类访问方式：创建对象，再访问
  6. 外部其他类—访问-⇒ 静态内部类
  7. 如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名成员）去访问
public class StaticInnerClass01 {
    public static void main(String[] args) {
        Outer10 outer10 = new Outer10();
        outer10.m1();
 
        //外部其他类 使用静态内部类
        //方式 1
        //因为静态内部类，是可以通过类名直接访问(前提是满足访问权限)
        Outer10.Inner10 inner10 = new Outer10.Inner10();
        inner10.say();
        //方式 2
        //编写一个方法，可以返回静态内部类的对象实例.
        Outer10.Inner10 inner101 = outer10.getInner10();
        System.out.println("============");
        inner101.say();
			// 方式 2.1
        Outer10.Inner10 inner10_ = Outer10.getInner10_(); // 这种方法不用创建对象了
        System.out.println("************");
        inner10_.say();
    }
}
 
class Outer10 { //外部类
    private int n1 = 10;
    private static String name = "张三";
    private static void cry() {}
    //Inner10就是静态内部类
    //1. 放在外部类的成员位置
    //2. 使用static 修饰
    //3. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
    //4. 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    //5. 作用域 ：同其他的成员，为整个类体
    static class Inner10 {
        private static String name = "韩顺平教育";
        public void say() {
            //如果外部类和静态内部类的成员重名时，静态内部类访问的时，
            //默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.成员）
            System.out.println(name + " 外部类name= " + Outer10.name);
            cry();
        }
    }
 
    public void m1() { //外部类---访问------>静态内部类 访问方式：创建对象，再访问
        Inner10 inner10 = new Inner10();
        inner10.say();
    }
 
    public Inner10 getInner10() {
        return new Inner10();
    }
 
    public static Inner10 getInner10_() {
        return new Inner10();
    }
}

Graph View