JAVA视频笔记（day10）

对象的多态性。
class 动物
{}
class 猫 extends 动物
{}
class 狗 extends 动物
{}
猫 x = new 猫();

动物 x = new 猫();//一个对象，两种形态。

猫这类事物即具备者猫的形态，又具备着动物的形态。
这就是对象的多态性。 
简单说：就是一个对象对应着不同类型. 

多态在代码中的体现：

父类或者接口的引用指向其子类的对象。

多态的好处：
提高了代码的扩展性，前期定义的代码可以使用后期的内容。

多态的弊端：
前期定义的内容不能使用(调用)后期子类的特有内容。

多态的前提：
1，必须有关系，继承，实现。

2，要有覆盖。 

abstract class Animal
{
	abstract void eat();

}

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

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

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



class DuoTaiDemo 
{
	public static void main(String[] args) 
	{
		
//		Cat c = new Cat();
//		c.eat();
//		c.catchMouse();

		Animal a = new Cat(); //自动类型提升，猫对象提升了动物类型。但是特有功能无法s访问。
							//作用就是限制对特有功能的访问。
							//专业讲：向上转型。将子类型隐藏。就不用使用子类的特有方法。


//		a.eat();

		//如果还想用具体动物猫的特有功能。 
		//你可以将该对象进行向下转型。
//		Cat c = (Cat)a;//向下转型的目的是为了使用子类中的特有方法。
//		c.eat();
//		c.catchMouse();

//		注意：对于转型，自始自终都是子类对象在做着类型的变化。
//		Animal a1 = new Dog();
//		Cat c1 = (Cat)a1;//ClassCastException


		/*
		Cat c = new Cat();

//		Dog d = new Dog();

//		c.eat();
		method(c);
//		method(d);
//		method(new Pig());
		*/

		method(new  Dog());

	}

	public static void method(Animal a)//Animal a = new Dog();
	{
		a.eat();

		if(a instanceof Cat)//instanceof：用于判断对象的具体类型。只能用于引用数据类型判断
//						//通常在向下转型前用于健壮性的判断。

		{
			Cat c = (Cat)a;
			c.catchMouse();
		}
		else if(a instanceof Dog)
		{
			Dog d = (Dog)a;
			d.lookHome();
		}
		else
		{
		
		}
		
	}
	/*
	public static void method(Cat c)
	{
		c.eat();
	}
	public static void method(Dog d)
	{	
		
	}
	*/	
}

多态时，成员的特点：
1，成员变量。
编译时：参考引用型变量所属的类中的是否有调用的成员变量，有，编译通过，没有，编译失败。
运行时：参考引用型变量所属的类中的是否有调用的成员变量，并运行该所属类中的成员变量。
简单说：编译和运行都参考等号的左边。哦了。
作为了解。
2，成员函数(非静态)。
编译时：参考引用型变量所属的类中的是否有调用的函数。有，编译通过，没有，编译失败。
运行时：参考的是对象所属的类中是否有调用的函数。
简单说：编译看左边，运行看右边。
因为成员函数存在覆盖特性。
3，静态函数。
编译时：参考引用型变量所属的类中的是否有调用的静态方法。
运行时：参考引用型变量所属的类中的是否有调用的静态方法。
简单说，编译和运行都看左边。
其实对于静态方法，是不需要对象的。直接用类名调用即可。

内部类访问特点：
1，内部类可以直接访问外部类中的成员。
2，外部类要访问内部类，必须建立内部类的对象。

一把用于类的设计。
分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容。
这时就是还有的事物定义成内部类来描述。

为什么内部类能直接访问外部类中成员呢？
那是因为内部类持有了外部类的引用。  外部类名.this

内部类可以存放在局部位置上。 
内部类在局部位置上只能访问局部中被final修饰的局部变量。

匿名内部类。就是内部类的简写格式。
必须有前提：
内部类必须继承或者实现一个外部类或者接口。

匿名内部类：其实就是一个匿名子类对象。 
格式：new 父类or接口(){子类内容}

通常的使用场景之一：
当函数参数是接口类型时，而且接口中的方法不超过三个。
可以用匿名内部类作为实际参数进行传递