Java之成员及静态内部类

内部类

在一个类的内部再定义另外的一个类，这就是内部类。

正常类形式，也称为外部类或顶级类：

public class Test {
      
}

class A {
    
}

内部类形式：

//外部类
public class Outer {
    //内部类
    public class Inner {
        
    } 	
}

内部类一共分为四种：

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

1 成员内部类

在类中，除了可以定义成员方法、成员变量，还可以定义成员内部类。

成员内部类定义格式：

//外部类
[修饰符] class 外部类 {
    //省略...
        
    //内部类
    [权限修饰符] class 内部类 {
        0或多个数据成员
        0或多个构造方法
        0或多个成员方法
        
        //注意，不可以包含static成员或方法
    } 	
}

内部类对象实例化格式：

​ 外部类名.内部类名 对象名 = 外部类对象.new 内部类(实际参数列表);

​ 例：Outer.Inner oi = new Outer().new Inner();

内部类中访问外部类中同名成员：

​ 外部类名.this.成员名

​ 例：int v = Outer.this.o_num;

注意事项：

• 成员内部类中可以直接访问外部类中所有成员和方法（含private）
• 在外部类中可以直接访问内部类所有的成员和方法（含private），但必须借助内部类对象
• 成员内部类内部不能定义static成员或方法

案例展示：

​ 定义外部类Outer，包含数据成员num，其内部定义内部类Inner，也包含数据成员num，测试内部类基本用法。

package com.briup.chap07.test;

//1.定义外部类
class Outer {
	private int o_num = 10;
	private int num = 20;
	
	//2.定义成员内部类
	class Inner {
		private int i_num = 30;
		//关键点：包含数据成员与外部类中成员同名
		private int num = 40;
		
		//3.成员内部类 不能定义static 成员或方法
		//public static int s_num = 50;   	error
		//public static void s_test() {} 	error
		
		//4.定义内部类方法，测试对外部类成员的访问
		void show() {
			//内部类中可以直接访问外部类所有成员
			System.out.println("in Inner,o_num: " + o_num);
			
			//局部变量
			int num = 50;
			System.out.println("in Inner,num: " + num);				//50
            //访问内部类中数据成员num
			System.out.println("in Inner,num: " + this.num);		//40
			//访问外部类中同名成员num,固定格式：外部类名.this.成员名
			System.out.println("in Inner,num: " + Outer.this.num);	//20
		}
	}
	
    //5.定义外部类方法，测试访问内部类成员
    //	注意：外部类中可以访问内部类所有成员(含private)，但必须借助内部类对象
	public void disp() {
		//实例化内部类对象格式：
		//	外部类.内部类 引用 = 外部类对象.new 内部类(实参);
		Outer.Inner inn = this.new Inner();
		System.out.println("in Outer, i_num: " + inn.i_num);

		//简化格式：
		//	内部类 引用名 = new 内部类(实参列表);
		//解析：
		//	在外部类方法中，Inner类名前默认加'Outer.'，new Inner()前默认加'this.'
		Inner inn2 = new Inner();
		System.out.println("inn2.i_num: " + inn2.i_num);
	}
}

//测试类
public class Test031_Member {
	public static void main(String[] args) {
		//实例化成员内部类对象
		// 外部类.内部类 引用 = 外部类对象.new 内部类(实参);
		Outer out = new Outer();
		Outer.Inner inn = out.new Inner();
		inn.show();

		System.out.println("-------------");
		
		Outer.Inner inn2 = new Outer().new Inner();
		inn2.show();
	}
}

注意，上述代码编译成功后，外部类和内部类都会生成对应的class文件

运行效果：

思考，什么情况下会使用内部类？

在对事物进行抽象的时候，若一个事物内部还包含其他事物，就可以考虑使用内部类这种结构。

例如，汽车（Car）中包含发动机（Engine） ，这时， Engine 类就可以考虑（非必须）使用内部类来描述，定义在Car类中的成员位置。

这样设计，既可以表示Car和Engine的紧密联系的程度，也可以在Engine类中很方便的使用到Car里面的属性和方法。

注意，这是从程序中，类和类之间的关系和意义进行考虑而设计的。其实这里即使不使用内部类的结构，使用普通的俩个类也能完成功能，但是内部类的结构设计会加符合实际意义，也能够好的完成功能，因为内部类访问外部的属性和方法会更加容易。

2 静态内部类

静态内部类属于成员内部类中的一种，其需要static关键字进行修饰。

静态内部类定义格式：

//外部类
[修饰符] class 外部类 {
    //省略...
      
    //静态内部类
    [权限修饰符] static class 内部类 {
        0或多个数据成员
        0或多个构造方法
        0或多个成员方法
        
        //注意：静态内部类成员方法内，只能访问外部类static成员或方法
    }
}

对象定义格式：

​ 外部类名.内部类名 对象名 = new 外部类名.内部类名();

静态方法访问格式：

​ 外部类名.内部类名.方法名();

​ 如果在外部类的成员方法中，可以省略外部类名.。

注意事项：

• 相对于成员内部类，静态内部类中可以定义static成员和方法

• 静态内部类成员方法内，只能访问外部类static成员或方法【静态只能访问静态】

• 外部类方法可以访问静态内部类所有成员及方法

案例如下：

package com.briup.chap07.test;

class Outer2 {
	private int o_num = 10;
	private static int s_num = 20;
	
	//定义static内部类
	static class Inner {
		private int i_num = 30;
		
		//静态内部类中可以定义static成员
		private static int is_num = 40;
		
		//static成员方法只能访问外部类static成员【静态只能访问静态】
		public static void sFun() {
			//编译报错
			//System.out.println("Outer2 o_num: " + o_num);
			
			System.out.println("Outer2 s_num: " + Outer2.s_num);
			System.out.println("Outer2 s_num: " + s_num);
		}
		
		//普通成员方法
		void show() {
			//1.访问内部类中数据成员
			System.out.println("in Inner, num: " + this.i_num);		//30
			System.out.println("in Inner, is_num: " + Inner.is_num);	//40
			
			//2.静态内部类方法中只能访问外部类的static成员
			//编译报错
			//System.out.println("in Inner,o_num: " + o_num);
			
			//3.访问外部类static成员，下面两行效果相同
			System.out.println("in Inner, s_num: " + s_num);		//20
			System.out.println("in Inner, s_num: " + Outer2.s_num);	//20
		}
	}
	
	//外部类方法可以访问 静态内部类所有成员及方法
	public void disp() {
		//Outer2.Inner inn = new Inner();
		Outer2.Inner inn = new Outer2.Inner();
		System.out.println("in Outer, i_num: " + inn.i_num);
		System.out.println("in Outer, is_num: " + Inner.is_num);
		System.out.println("in Outer, is_num: " + inn.is_num);
	}
}

public class Test032_Static {
	public static void main(String[] args) {
		//1.静态内部类调用static方法		
		//编译报错，不识别Inner，会把Inner当成外部类去查找
		//Inner.sFun();
		
		//正确写发
		Outer2.Inner.sFun();
		
		System.out.println("---------------");
		
		//2.静态内部类普通方法调用
		//内部类对象 固定定义格式
		Outer2.Inner inn = new Outer2.Inner();
		inn.show();
		
		System.out.println("----------------");
		
		//3.外部类对象访问内部类成员
		Outer2 outer = new Outer2();
		outer.disp();
	}
}

运行效果：

注意：在静态内部类中不可以访问外部类中的非静态属性和方法！

JavaAPI中静态内部类案例：

​ java.lang.Integer类中，就定义了一个静态内部类，并且还是private修饰的