黑马程序员——Java语言基础：多态、内部类

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、多态

1.概念：可以理解为事物存在的多种体现形式。

   例：动物：猫、狗

 创建对象可：动物 x = new 猫();

2.多态的体现：父类的引用指向了自己的子类对象；父类的引用也可以接受自己的子类对象

3.多态的前提：必须是类与类之间有关系：继承或实现（存在覆盖）

4.多态的好处：大大的提高了程序的扩展性

5.多态的弊端：只能使用父类的引用访问父类的成员

6.多态中成员函数的特点：（多用于非静态，因为非静态有重写特性）

（1）在编译时期：参阅引用性变量所属类中是否有调用的方法
（2）在运行时期：参阅对象所属的类中是否有调用的方法

※ 成员函数在多态调用时，编译看左边，运行看右边

※成员变量在多态中，无论编译和运行，都参考左边（引用型变量所属的类）

（3）多态中，静态成员函数的特点：无论编译还是运行，都参考左边

例：

abstract class Animal
{
	public abstract void eat(); //必须定义的，子类都必须执行
	
}

class Cat extends Animal
{
	public void eat()
	{
		System.out.println("吃鱼");
	}
	public void catchMouse()
	{
		System.out.println("抓老鼠");
	}	
}

class Dog extends Animal
{
	public void eat()
	{
		System.out.println("吃骨头");
	}
	public void kanJia()
	{
		System.out.println("看家");
	}
}

class Pig extends Animal
{
	public void eat()
	{
		System.out.println("吃饲料");
	}
	public void gongDi()
	{
		System.out.println("拱地");
	}
}

class DuoTaiDemo
{
	
	public static void main(String[] args)
	{

		Animal c = new Cat();   //多态，既是Cat也是Animal
		function(new Cat());
		function(new Dog());
		function(new Pig());

		/*
		不要出现以下操作：将父类对象转成子类类型
		可以转换的是父类应用指向了自己的子类对象时
		多态自始至终都是子类对象在做着变化
		Animal a = new Animal();
		Cat c = (Cat)a;
		*/	
	}

	//提高了代码的扩展性	
	public static void function(Animal a)
	{
		a.eat();

		//想要调用特有方式的操作
		//强制将父类的引用，转成子类类型
		
		if(a instanceof Cat)  //a是否指向Cat类型
		{
			Cat c = (Cat)a;//称为类型提升或向上转型
				       //猫提升为动物
			c.catchMouse();
		}
		else if(a instanceof Dog)  //a是否指向Dog类型
		{
			Dog d = (Dog)a;
			d.kanJia();
		}
		else if(a instanceof Pig)  //a是否指向Pig类型
		{
			Pig p = (Pig)a;
			p.gongDi();
		}
	}		
}

二、内部类

1.概念：将一个类定义在另一个类的里面，对里面那个类就成为内部类（内置类、嵌套类）。

2.访问特点：

（1）内部类可以直接访问外部类中的成员（方法），包括私有
  原因：内部类中持有了一个外部类的引用，该引用写法是，外部类名.this.变量名

（2）外部类要访问内部类，必须建立内部类对象

3.访问格式：

（1）当内部类定义在外部类的成员位置上，而且非私有，可以在外部类其他类中直接建立内部对象
  格式：外部类名.内部类名 变量名 = 外部类对象.内部类对象
    Outer.Inner in  = new Outer.new Inner();

（2）当内部类在成员位置上，就可以被成员修饰符所修饰，比如private，将内部类在外部类中进行封装
  当内部类被静态修饰后，只能直接访问外部类中的静态成员。（访问局限）

（3）在外部其他类中，如何直接访问static内部类的非静态成员：new Outer.Inner().function();
在外部其他类中，如何直接访问static内部类的静态成员 ：Outer.Inner.function();

（4）内部类定义在局部时：不可以被成员修饰符修饰；可以直接访问外部类中的成员；

不可以访问它所在的局部中除被final修饰的变量。

※ 当内部类中定义了静态成员，该内部类必须是静态的。
※ 当外部类中的static方法访问内部类时，内部类也必须是static的

例：

class Outer
{
	private int x = 3;

	static class Inner  //静态内部类
	{
		int x = 4;
		static void function()
		{
			int x = 6;
			System.out.println("inner: "+x);
			//x打印6；this.x打印4；Outer.this.x打印3；(一般省略Outer.this.)
		}
	}
	
	class Inner2//内部类
	{
		void show()
		{
			System.out.println("inner2 show");
		}
	}

	void method()
	{
		Inner in = new Inner();
		in.function();
	}
}

class InnerClassDemo
{
	
	public static void main(String[] args)
	{
		Outer out = new Outer();
		out.method();
	
//		直接访问内部类中的成员,但当内部类为private时，不能用
		Outer.Inner in = new Outer.new Inner();
		in.function();
	}
	
}

4.匿名内部类：
（1）匿名内部类其实就是内部类的简写格式
（2）定义匿名内部类的前提：内部类必须继承一个类或者实现接口
（3）匿名内部类的格式：  new 父类或者接口(){定义子类的内容}
（4）其实匿名内部类就是一个匿名子类对象，而且这个对象有点胖(内容多)， 也可理解为带内容的对象
（5）匿名内部类中定义的方法最好不要超过3个，最好2或1

例：

abstract class AbsDemo
{
	abstract void show();
}
class Outer
{
	int x = 3;
	public void function()
	{
//		new Inner().show();
//		匿名内部类
		new AbsDemo()
		{
			void show()
			{
				System.out.println("x = "+x);
			}
		}.show();

		new AbsDemo()
		{
			void show()
			{
				System.out.println("x = "+x);
			}
			void abc()
			{
				System.out.println("ahaa");
			}
		}.abc();
	}
	
}