Java学习（69）Java多态——内部类概述、成员内部类

内部类概述

1. 概念

(1) 在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类成为内部类；
(2) 与之对应，包含内部类的类被成为外部类。

2. 案例

//外部类：人
public class Person {
	int age;//年龄

	public Heart getHeart() {
	      return new Heart();
	}
	
	//内部类：心脏
	class Heart{
		public String beat() {
			return "心脏在跳动";
		}
	}
}

3. 内部类的作用

为什么要将一个类定义在另一个类里面呢？
答：内部类隐藏在外部类之内，更好地实现了信息隐藏。

4. 内部类的分类

(1) 成员内部类
(2) 静态内部类
(3) 方法内部类
(4) 匿名内部类

成员内部类

1. 简介

内部类中最常见的就是成员内部类，也称为普通内部类（上面案例中的心脏类就是内部成员类）；

2. 获取内部类对象实例方式1

new 外部类.new内部类

//外部类：人
public class Person {
	int age;//年龄

	public Heart getHeart() {
	      return new Heart();
	}
	
	//成员内部类：心脏
	class Heart{
		public String beat() {
			return "心脏在跳动";
		}
	}
}

public class PeopleTest {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Person lili = new Person();
		lili.age = 12;
		
		//获取内部类对象实例，方式1：new 外部类.new 内部类
		Person.Heart myHeart = new Person.new Heart（）;
		System.out.println(myHeart.beat());
	}
}

运行结果：

心脏在跳动

3. 获取内部类对象实例方式2

外部类对象.new内部类

		//获取内部类对象实例，方式2：外部类对象.new 内部类
		myHeart = lili.new Heart（）;
		System.out.println(myHeart.beat());

4. 获取内部类对象实例方式3

外部类对象.获取方法

		//获取内部类对象实例，方式3：外部类对象.获取方法
		myHeart = lili.getHeart();
		System.out.println(myHeart.beat());

这里我们发现：内部类在外部使用时，无法直接实例化没需要借由外部类信息才能完成实例化。

5. 内部类的访问修饰符

内部类的访问修饰符，可以任意，但是访问范围会受影响。

6. 外部类与内部类的相互使用关系

(1) 案例：内部类可以直接访问外部类的成员

public class Person01 {
	public int age;
	
	public Heart getHeart() {
		return new Heart();
	}

	public void eat() {
		System.out.println("人会吃东西");
	}

	public class Heart{
		public String beat() {
			eat();
			return age+"岁的心脏在跳动";
		}
	}
}

public class PeopleTest {
	public static void main(String[] args) {
		Person01 lili = new Person01();
		lili.age = 12;
		
		//获取内部类对象实例，方式1：new 外部类.new 内部类
		Person01.Heart myHeart = new Person01().new Heart();
		System.out.println(myHeart.beat());
		
		//获取内部类对象实例，方式2：外部类对象.new 内部类
		myHeart = lili.new Heart();
		System.out.println(myHeart.beat());
		
		//获取内部类对象实例，方式3：外部类对象.获取方法
		myHeart = lili.getHeart();
		System.out.println(myHeart.beat());

	}
}

运行结果：

人会吃东西
0岁的心脏在跳动
人会吃东西
12岁的心脏在跳动
人会吃东西
12岁的心脏在跳动

(2) 案例：如果出现同名属性，则优先访问内部类中定义的

public class Person01 {
	public int age;
	public class Heart{
		int age = 13;
		public String beat() {
			eat();
			return age+"岁的心脏在跳动";
		}
	}
}

则运行结果为：

人会吃东西
13岁的心脏在跳动
人会吃东西
13岁的心脏在跳动
人会吃东西
13岁的心脏在跳动

(3) 案例：可以使用外部类.this.成员的方式，访问外部类中同名的信息

public class Person01 {
	public int age;
	public class Heart{
		int age = 13;
		public String beat() {
			eat();
			return Person01.this.age+"岁的心脏在跳动";
		}
	}
}

则运行结果为：

人会吃东西
0岁的心脏在跳动
人会吃东西
12岁的心脏在跳动
人会吃东西
12岁的心脏在跳动

注：src文件为源码文件，bin文件为编译文件。
(4) 案例：外部类访问内部类信息，需要通过内部类实例，无法直接访问

public class Person01 {
	public Heart getHeart() {
		new Heart().temp = 12;
//		temp = 33;//外部类无法直接访问内部类成员属性
		return new Heart();
	
	public class Heart{
		int age = 13;
		int temp = 22;
		public String beat() {
			eat();
			return Person01.this.age+"岁的心脏在跳动";
		}
	}
}

(5) 内部类编译后.class文件命名：外部类$内部类.class

7. 外部类与内部类的相互使用关系小结

(1) 内部类在外部使用时，无法直接实例化，需要借由外部类信息才能完成实例化；
(2) 内部类的访问修饰符，可以任意，但是访问范围会受到影响；
(3) 内部类可以直接访问外部类的成员；如果出现同名属性，优先访问内部类中定义的；
(4) 可以使用外部类.this.成员的方式，访问外部类中同名的信息；
(5) 外部类访问内部类信息，需要通过内部类实例，无法直接访问；
(6) 内部类编译后.class文件命名：外部类$内部类.class；
(7) 提出问题：内部类中是否可以包含与外部类相同方法签名的方法？以及如何调用？