黑马程序员————面向对象之多态
------- android培训、java培训、期待与您交流！ ----------
众所周知，面向对象思想有三大特征：封装，继承，多态。
下面详细说说多态。
举个例子，猫对应的类型是猫类型，同时也是动物类型，很明显动物是猫的父类。我们在创建猫对象的时候，可以用：
猫 cat = new 猫（）；也可以用：动物cat = new 猫（）；第二种方法就是父类型引用指向了子类对象。这种现象就是多态。
由此可见，多态就是同一事物在不同时刻体现出来的不同状态。
多态的体现：父类或者接口的引用指向或者接收自己的子类对象。
多态的前提：
1、 必须类与类之间有关系，要么是继承关系，要么是实现关系
2、 要有方法的覆盖
举例：class Fu {
public int num = 100;
public void show() {
System.out.println("show Fu");
}
public static void function() {
System.out.println("functionFu");
}
}
//继承关系
class Ziextends Fu {
public int num = 1000;
public int num2 = 200;
//覆盖操作
public void show() {
System.out.println("showZi");
}
public void method() {
System.out.println("methodzi");
}
public static void function() {
System.out.println("functionZi");
}
}
class DuoTaiDemo {
public static void main(String[] args) {
//父类引用指向子类对象。
Fuf = new Zi();
}
}
多态中成员访问的特点：
1、 成员变量：
编译看左边，运行也看左边。
2、 成员函数：
编译看左边，运行看右边。
3、 构造函数：
创建子类的对象的时候，访问父类的构造方法，对父类的数据进行初始化。
4、 静态函数：
编译看左边，运行也看左边。（静态是和类相关的）
举例：
class Fu {
public int num = 100;
public void show() {
System.out.println("showFu");
}
public static void function() {
System.out.println("functionFu");
}
}
class Zi extends Fu {
public int num = 1000;
public int num2 = 200;
public void show() {
System.out.println("showZi");
}
publicvoid method() {
System.out.println("methodzi");
}
public static void function() {
System.out.println("functionZi");
}
}
class DuoTaiDemo {
public static void main(String[] args) {
//父类引用指向子类对象。
Fu f = new Zi();
System.out.println(f.num);//结果为1000
//System.out.println(f.num2);//编译时就找不到符号
f.show();//编译看父类有show方法，编译通过，运行时看子类有show方法，输出show Zi
//f.method();//编译时看父类没有method方法，编译不通过
f.function();//编译看父类有method方法，编译通过，运行时看子类有method方法，输出function Zi
}
}
多态的好处：
1、 提高了代码的可维护性（由继承保证）；
2、 提高了代码的可扩展性（由多态保证）
举例：
现在有父类：Animal 和两个子类：Cat和Dog；对这两个子类的对象进行维护
//父类
abstract class Animal
{
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 watchHome()
{
System.out.println("看家");
}
}
class DuoTaiDemo
{
publics tatic void main(String[] args)
{
Catc = new Cat();//创建一个Cat对象
c.eat();//调用Cat类中的方法
Dogd = new Dog();//创建一个Dog对象
d.eat();//调用Dog类中的方法
}
}
在此基础上，如果又增加了Pig对象，那我们可以直接创建Pig类继承Animal类，并在主函数中创建Pig对象和调用Pig类中的方 法。可见多态的出现使程序的维护和扩展变得容易。
但是发现多态有个弊端：虽然提高了扩展性，但是使用父类的引用只能访问父类中的成员，不能使用子类的特有功能。
如果要使用子类的特有功能呢？当然可以如上面的例子中这样创建子类对象然后调用方法，但是很多时候会不合理，占内存， 也是代码的重复性很高。对此java提供了另外一种方式：向下转型，即将父类的引用强制转换为子类的引用，
格式：子类名子类对象名 = （子类名）父类对象名；
那么，我们如果要在上例中加入Pig对象，可以将创建对象和调用方法功能封装起来，并用父类引用强转为子类引用，改进的 代码如下：
abstract class Animal
{
abstrac tvoid 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 watchHome()
{
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){
function(newCat());
function(newDog());
function(newPig());
}
//定义一个方法将建立对象和调用方法封装
public static void function(Animal a)//形参是用父类引用接收子类对象
{
a.eat();
if(a instanceof Cat)
{
//判断a的类型，然后强转
Catc = (Cat)a;
c.catchMouse();
}
elseif (a instanceof Dog)
{
Dogd = (Dog)a;
d.watchHome();
}
elseif (a instanceof Pig)
{
Pigp = (Pig)a;
p.gongDi();
}
}
}
千万不能有这样的操作：Animal a = new Animal(); Catc = (Cat)a; 这样是将父类的对象转换成子类类型。我们所能转换 的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强转。多态自始至终都是子类对象再做着变化。