Java的内部类

1、定义：将一个类放在另一个类的内部定义，这个定义在内部的类就称为内部类。（包含这个内部类的类叫外部类）

2、作用：

（1）内部类可以提供更好的封装，将内部信息隐藏在外部类之内，使得同一个包中的其他类不可访问。也就说这个内部类只让外部类访问，不让其他的类访问

（2）内部类可以访问外部类的数据，即使这个外部类的数据是用private修饰的都可以。但是外部类无法访问用private修饰的内部类的成员

（3）匿名内部类用于创建只需要使用一次的类

3、注意点：

（1）内部类的修饰符可以是：public （公共访问）、private （同一个类）、protected（父子类） 、default（同一个包）、static

（2）没有static修饰的内部类中不能出现任何有static修饰的成员变量

4、内部类与外部类的区别

（1）外部类的上一级是包，因此它只有两个作用域：同一个包（修饰符为：default）、全部位置（修饰符为public）; 内部类的上一级是外部类，因为它有四个作用域：同一个包、全部位置、同一个类、父子类

（2）内部类可以访问外部类所有的成员变量，即使是private修饰的也可以

5、非静态内部类：没有static修饰的内部类

该内部类属于外部类的对象，因此必须使用外部类的对象才能调用到这个类。

//定义一个Cow外部类
class Cow{
	private double weight;
	public void setWeight(double weight) {
		if(weight<=0 || weight>100) {
			System.out.println("非法牛重");
		}
		else {
			this.weight=weight;
		}
	}
	public double getWeight() {
		return this.weight;
	}
	//构造器
	public Cow() {}
	public Cow(double weight) {
		this.setWeight(weight);
	}
	//private修饰的内部类CowLeg，此时外部类Cow不可访问其内部成员，并且该类没有static修饰，属于非静态内部类
	private class CowLeg{
		private double length;
		private String color;
		public void setLength(double length) {
			this.length=length;
		}
		public double getLength() {
			return this.length;
		}
		public void setColor(String color) {
			this.color=color;
		}
		public String getColor() {
			return this.color;
		}
		//构造器
		public CowLeg() {}
		public CowLeg(double length,String color) {
			this.setLength(length);
			this.setColor(color);
		}
		public void info() {
			System.out.print("当前牛腿的颜色是："+color+"，长度是："+length);
			//直接访问外部类private修饰的成员变量
			System.out.println("，该牛腿所在的牛重量是："+weight);
		}
	}
	//对于含有非静态内部类的类，该类中必须含有用来产生内部类实例的方法
	public void test() {
		CowLeg c1=new CowLeg(7.8,"黑色");
		c1.info(); //输出这个牛腿的信息  
	}
    public static void main(String[] args) {
		Cow cow=new Cow(88.9);
		cow.test();//非静态内部类属于外部类的实例，如果想要创建这个内部类的对象，那么首先需要创建外部类的对象，然后通过该对象来访问内部类。
    //  cow.info();  //编译错误，由于CowLeg是非静态内部类，而main函数是有static修饰的，因为无法直接访问
	}
}
//输出结果：当前牛腿的颜色是：黑色，长度是：7.8，该牛腿所在的牛重量是：88.9

整个底层的运行机制如下图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kb0s2OLt-1590400404772)(C:\Users\24973\AppData\Roaming\Typora\typora-user-images\image-20200522160242644.png)]

如果内部类与外部类有变量重名，那么应该使用this表示内部类的变量、使用外部类类名.this表示外部类的变量。

class A{
	private int a=9;  //外部类的非静态变量
	//内部类
	private class B{
		private int a=1;  //内部类的非静态变量
		public void info() {
			int a=5;  //方法中的局部变量
			System.out.println("外部类的实例变量值："+A.this.a);
			System.out.println("内部类的实例变量值："+this.a);
			System.out.println("方法中的实例变量值："+a);
		}
	}
	public void test() {
		B b=new B();
		b.info();
	}
}
public class test{
	public static void main(String[] args) {
		A a=new A();
		a.test();
	}
}

总结：非静态内部类对象必须寄生在外部类对象里，即一定要先创建一个外部类的对象，然后通过这个对象来生成内部类的对象。

6、静态内部类：有static修饰的内部类

（1）静态内部类里可以包含静态成员，也可以包含非静态成员

（2）可以访问外部类的类成员（静态成员），不可以访问外部类的实例成员（非静态成员）

（3）外部类不能直接访问内部类的成员变量，但是可以通过内部类的类名来访问静态内部类的类成员，通过内部类的对象来访问静态内部类的实例成员。

（4）接口中创建内部类时，默认修饰符为public static，所以接口中的内部类只能是静态内部类

静态内部类属于外部类，因为不需要创建外部类的实例即可使用这个类。

class test{
	private int a=9;  //外部类的非静态变量
	private static int b=10;  //外部类的静态变量
	//内部类
	static class P{
		private static int age=23;;  //可以包含静态变量
		private String name="张三";  //可以包含非静态变量
		public void info() {
			//System.out.println("方法中的实例变量值："+a);  //错误。不能访问非静态成员
			System.out.println(b);
		}
	}
	public static void main(String[] args) {
		P b=new P();  //直接创建静态内部类的对象，不需要先创建外部类实例
		b.info();
		System.out.println(P.age);  //通过类名访问静态变量
		System.out.println(b.name);  //通过实例对象访问非静态变量
	}
}

7、使用方式：在外部类中使用内部类、在外部类以外使用内部类

（1）非静态内部类

//访问方式一：在外部类中访问
class Out{
	//非静态内部类
	private class In{
		int age;
		public In(int age){
			this.age=age;
		}
		private void info() {
			System.out.println("年龄是："+age);
		}
	}
	public void test(int age) {
		In in=new In(age);
		in.info();
	}
	public static void main(String[] args) {
		//In in=new In();   //main方法是static修饰的，因此这里无法直接创建In实例
		Out out=new Out();   //只能先创建外部类的实例，然后在通过该实例创建In实例
		out.test(23);   
	}
}
//访问方式二：在外部类外面访问
class Out{
	//非静态内部类
	public class In{  //此处不能再使用private修饰
		int age;
		public In(int age){
			this.age=age;
		}
		public void info() {  //改为public 
			System.out.println("年龄是："+age);
		}
	}
	public void test(int age) {
		In in=new In(age);
		in.info();
	}
}
public class test{
	public static void main(String[] args) {
		//非静态内部类的构造器必须采用外部类的实例来调用，因此需要先new一个外部类的实例，然后通过该实例来new一个in对象
		Out.In in=new Out().new In(23);
		in.info();
	}
}
/*
可以将Out.In in=new Out().new In(23); 语句改为：
Out out=new Out();
Out.In in=out.new In(23);
*/

（2）静态内部类

//访问方式一：在外部类中访问
class Out{
	//静态内部类
	private static class In{
		int age;
		public In(int age){
			this.age=age;
		}
		private void info() {
			System.out.println("年龄是："+age);
		}
	}
	public static void main(String[] args) {
		In in=new In(23);  //直接创建In对象，而不需要提前创建外部类实例
		in.info();
	}
}
//访问方式二：在外部类外面访问
class Out{
	//静态内部类
	public static class In{  //使用public修饰或default
		int age;
		public In(int age){
			this.age=age;
		}
		public void info() {  //改为public 
			System.out.println("年龄是："+age);
		}
	}
	public void test(int age) {
		In in=new In(age);
		in.info();
	}
}
public class test{
	public static void main(String[] args) {
		//直接使用 new 外部类类名.内部类类名()  即可创建
		Out.In in=new Out.In(23);
		in.info();
	}
}