23.内部类

上一篇：22.多态

---

---

一.概述

在一个类的内部定义的类称为内部类，其实就是类定义的位置发生了变化。在类中定义的内部类叫成员内部类，在函数中定义的内部类叫局部内部类，使用static修饰的成员内部类叫静态内部类。静态内部类使用很少，用的最多的是成员内部类。
注意：内部类生成的文件为 “外部类$内部类” ，它表明该内部类是属于哪个外部类的。

---

二.成员内部类

（一）.定义成员内部类

1.成员内部类也是一个类，可以有自己的成员属性、成员方法；
2.成员内部类可以访问外部类的成员方法和成员属性。
3.在内部类中，this.name中的this表示内部类。

小结：
1.内部类访问外部类的字段：外部类类名.this.字段
2.内部类访问外部类的方法：外部类类名.this.方法
3.内部类访问内部类字段：this.字段
4.内部类访问内部类方法：this.方法

例子：

// 外部类
public class Forest {
	private int treeType = 100;
	public int getTreeType() {
		return treeType;
	}
	
	// 内部类
	class Animal{
		private  String name;
		
		public String getName() {
			// 访问内部类字段
			return this.name;
		}

		public void setName(String name) {
			this.name = name;
		}
		
		// 访问外部类属性
		public int getTreeNumber() {
			return Forest.this.treeType;
		}
		
	}	
}

（二）.成员内部类的使用

成员内部类必须依赖于外部类的对象。
所以，首先创建外部类，然后再使用外部类的实例创建普通内部类。
示例如下：
写法一：

public class Test {

	public static void main(String[] args) {
		// 创建外部类对象
		Forest forest = new Forest();
		// 创建内部类对象
		Forest.Animal animal = forest.new Animal();
		// 内部类对象调用方法
		int treeNumber = animal.getTreeNumber();
		System.out.println(treeNumber);

	}

}

写法二：

public class Test1 {

	public static void main(String[] args) {
		// 直接创建外部类对象的同时创建内部类对象
		Forest.Animal animal = new Forest().new Animal();
		// 内部类对象调用方法
		int treeNumber = animal.getTreeNumber();
		 // getTreeNumber是外部类方法
		System.out.println(treeNumber);

	}

}

小结：
1.内部类可以直接访问外部类的成员，包括外部类的私有对象。
2.外部类要访问内部类的成员，必须创建对象。

---

三.静态内部类

（一）.静态内部类的定义

静态内部类就是一个Java类，他可以访问外部类的静态成员和静态方法，不能访问外部类的实例成员和实例方法。
示例：

// 外部类
public class Forest {
	private int treeType = 100;  // 树的类型
	public int getTreeType() {   // 成员方法
		return treeType;
	}
	
	
	private static int treeSum = 1000;  // 静态变量
	public static int getTreeSum() {    // 静态方法
		return treeSum;
	}

	
	// 静态内部类
	static class A{
		// 内部类的属性和方法
		private int number = 10;
		public int getNumber() {
			return number;
		}
		
		
		/*
		public int getTreeSum() {
			return Forest.this.treeType;
			// 静态类不能访问外部类的成员变量
			// No enclosing instance of the type Forest is accessible in scope
		}
		*/
		
		/*
		public int getTreeSum() {
			return Forest.this.getTreeType();
			// 静态类不能访问外部类的成员方法
			// No enclosing instance of the type Forest is accessible in scope
		}
		*/
		
		public int  getStaticValue() {
			return Forest.treeSum;
			// 静态类能访问外部类的静态变量
		}
		
		public int getTreeSum() {
			return Forest.getTreeSum();
			// 静态类能访问外部类的静态方法
		}
	}
}

（二）.静态内部类的使用

创建静态内部类时，不需要先创建外部类的实例，直接使用 new Forest.A() 语法就可以创建一个实例。
如果静态内部类中有静态成员和静态方法，那么调用方式： Forest.A.方法名（）；
示例：

// 外部类
public class Forest {
	private static int treeType = 100;  // 外部类静态变量

	
	// 静态内部类
	static class A{
		// 内部类的属性和方法
		private int number = 10;
		public int getNumber() {
			return number;
		}
		
		public static int getTreeType() {
			return Forest.treeType;
		}
		

	}
}

public class Test {
	public static void main(String[] args) {
		Forest.A a = new Forest.A();  //不需要外部类的实例
		System.out.println(a.getNumber());  // 静态类的成员变量
		System.out.println(Forest.A.getTreeType()); // 静态类的静态方法
	}

}

---

四.局部内部类

包含在外部类的函数中的内部类称之为局部内部类，这种类一般不用，仅供了解。
局部内部类只能访问所在函数的final属性。
示例：

public class Outer {
	String name = "外部类的name";
	public void test() {
		final int y = 1000;
		// 只有声明为final，才能被局部内部类访问
		
		
		// 局部内部类Inner
		class Inner{
			int x  = 10;
			
			public void print() {
				System.out.println("这是局部内部类的print方法 "+y);
			}
		}
		
		// 创建对象
		Inner inner = new Inner();
		inner.print();
	}
}

public class Test {

	public static void main(String[] args) {
		Outer outer = new Outer();
		outer.test();// 这是局部内部类的print方法 1000
	}

}

---

五.匿名对象

1.没有名字；
2.仅能使用一次

---

六 .匿名内部类

匿名内部类是一种特殊的内部类，它在语句内部定义，没有类名。
匿名内部类必须继承一个父类或者是实现一个接口。语法：

new 父类或接口(){
	代码块;
}

每次创建匿名内部类的对象时，必须先定义匿名内部类，然后使用new创建对象。如果希望再次创建这个匿名内部类的对象，必须重新定义匿名内部类，即每个匿名内部类的定义只能使用一次。

（一）.基于接口实现匿名内部类

// 定义接口
public interface Product {
	public double getPrice();
	public String getName();

}

public class Test {

	public static void main(String[] args) {
		Test test = new Test();
		test.printProduct(new Product() {

			@Override
			public double getPrice() {
				double price = 9.9;
				return price;
			}

			@Override
			public String getName() {
				String name = "棒棒糖";
				return name;
			}
		});
	}

	// 打印商品信息
	public void printProduct(Product product) {
		System.out.println(product.getName());
		System.out.println(product.getPrice());

	}
}

（二）.基于类实现匿名内部类

public abstract class Animal {
	public abstract void run();
	public abstract void sleep();

}

public class Demo {

	public static void main(String[] args) {
		Demo demo = new Demo();
		// 匿名对象
		demo.printAnimal(new Animal() {
			
			@Override
			public void sleep() {
				System.out.println("小狗在睡觉");
				
			}
			
			@Override
			public void run() {
				System.out.println("小狗在奔跑");
				
			}
		});
	
		

	}
	
	public void printAnimal(Animal animal) {
		animal.sleep();
		animal.run();
	}

}

---

下一篇：24.传值和传引用