第一节 非静态内部类

第一节 非静态内部类

一个类在一个类的内部称为内部类，包含内部类的类称为外部类

非静态内部类的基本语法

class < 外部类类名 >{
    // 外部类其他成员
    
    [ 成员访问限制修饰符号 ] class < 内部类名 > {
        // 内部类成员
    }
    
    // 外部类其他成员
}

在外部类中创建内部类实例

public class CreateInnerClass {
	public static void main(String[] args) {
		Outter outter = new Outter();
		outter.createInnerInstance();
	}
}

class Outter{
	public class Inner{
		public Inner() {
			System.out.println("Inner 实例创建成功！");
		}
	}
	
    // 通过外部类方法创建内部类实例
    // 与创建普通类实例一致
	public void createInnerInstance() {
		Inner i = new Inner();
	}
}

/*
 * 执行结果
 * Inner 实例创建成功
 */

在外部类以外创建内部类实例

< 外部类名 >.< 内部类名 > 引用变量 = < 外部变量对象引用 >.new < 内部类构造器 >;

< 外部类名 >.< 内部类名 > 引用变量 = new < 外部类构造器 >.new < 内部类构造器 >;

public class CreateInnerClass {
	public static void main(String[] args) {
        // 通过外部类实例调用内部类构造方法创建内部类实例
        Outter outter = new Outter();
		Outter.Inner inner0 = outter.new Inner();
		Outter.Inner inner1 = new Outter().new Inner();
	}
}

class Outter{
	public class Inner{
		public Inner() {
			System.out.println("Inner 实例创建成功！");
		}
	}
}

/*
 * 执行结果
 * Inner 实例创建成功
 * Inner 实例创建成功
 */

1. 创建的类型为 `Outter.Inner` 类型
2. 返回的对象为**外部类对内部类的一个引用**

外部类与内部类之间的成员互访

内部类可以访问外部类私有字段

内部类可以访问外部类私有方法

public class TestInnerClass {
	public static void main(String[] args) {
		Outter.Inner o = new Outter().new Inner();
		o.callingOutterMethod();
		System.out.println(o.getOutterFiled());
	}
}

class Outter{
	private int outterFiled = 520;
	
	private void outterMethod() {
		System.out.println("Calling outterMethod() successfully!");
	}
	
	public class Inner{
        // 内部类访问外部类私有字段
		public int getOutterFiled() {
			return outterFiled;
		}
		
        /// 内部类访问外部类私有方法
		public void callingOutterMethod() {
			outterMethod();
		}
	}
}

/*
 * 执行结果
 * Calling outterMethod() successfully!
 * 520
 */

外部类可以访问内部类私有字段

外部类可以访问内部类私有方法

public class TestInnerClass {
	public static void main(String[] args) {
		Outter o = new Outter();
		o.callingInnerMethod();
		System.out.println(o.getInnerFiled());
	}
}

class Outter{
	public class Inner{
		private int innerFiled = 1314;
		
		private void innerMethod() {
			System.out.println("Calling innerMethod() successfully!");
		}
	}
	
    // 访问内部类私有字段
	public void callingInnerMethod() {
		new Inner().innerMethod();
	}
	
    // 访问内部类私有方法
	public int getInnerFiled() {
		return new Inner().innerFiled;
	}
}

/*
 * 执行结果
 * Calling innerMethod() successfully!
 * 1314
 */

预定义对象引用 this

当内部类有字段与外部类重名，可以通过预定义对象引用访问外部类字段

< 外部类名 >.this.< 外部类字段 >

public class TestInnerClass {
	public static void main(String[] args) {
		Outter.Inner o = new Outter().new Inner();
		System.out.println(o.getOutterX());
	}
}

class Outter{
	int x = 520;
	
	public class Inner{
        // 与外部类重名字段x
		int x = 1314;
		
		public int getOutterX() {
            // 预定义对象引用外部类字段x
			return Outter.this.x;
		}
	}
}

/*
 * 执行结果
 * 520
 */