【java初学笔记5】马士兵-java-面向对象-39->41多态、abstract关键字

1.多态机制是面向对象语言中最为核心的机制，它大大增加了程序的可扩展性；

2.多态的定义：【互动百科】多态是函数的一类，它允许将父对象设置成为和一个或更多的他的子对象相等的技术。赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。

                            【马士兵课件】在执行期间(非编译期)判断所引用对象实际类型，根据其实的类型调用其相应的方法

3.多态的必要条件：

   (1)有继承;

   (2)有重写;

   (3)父类引用指向子类对象。

    一旦满足上述，当父类里被重写的方法时，实际new的哪个子类对象，就调用子类对象方法。

4.例子，这里面，首先定义了父类Animal类，及其方法enjoy方法{System.out.println("wow(叫声)")}，Cat,Dog和Bird类都是其子类。这些子类都对enjoy进行了重写。重写以后，如果在后面的过程中创造出父类对象引用，在使用父类的被重写的方法的时候，会根据实际情况使用子类对象重写的方法。

class Animal {
  private String name;
  Animal(String name) {this.name = name;}
  
  public void enjoy(){
    System.out.println("wow......");
  }
  
  //public abstract void enjoy();
}


class Cat extends Animal {
  private String eyesColor;
  Cat(String n,String c) {super(n); eyesColor = c;}
  
  public void enjoy() {
    System.out.println("meow......");
  }
  
  //public abstract void enjoy();
}


class Dog extends Animal {
  private String furColor;
  Dog(String n,String c) {super(n); furColor = c;}
 
  public void enjoy() {
    System.out.println("bark.....");
  }
}


class Bird extends Animal {
	 Bird() {
	 	 super("bird");
	 }
	 public void enjoy() {
    System.out.println("tweet......");
  }
}


class Lady {
    private String name;
    private Animal pet;
    Lady(String name,Animal pet) {
        this.name = name; this.pet = pet;
    }
    public void myPetEnjoy(){pet.enjoy();}
}


public class Test {
    public static void main(String args[]){
        Cat c = new Cat("catname","blue");
        Dog d = new Dog("dogname","black");
        Bird b = new Bird();
        Lady l1 = new Lady("l1",c);
        Lady l2 = new Lady("l2",d);
        Lady l3 = new Lady("l3",b);
        l1.myPetEnjoy();
        l2.myPetEnjoy();
        l3.myPetEnjoy();
    }
}

5.abstract 关键字适用于多态的情况，在继承关系中，当父类里面的方法一定会被子类重写，并且本身没有任何使用的必要的时候，我们会对这个方法用abstract关键字修饰修饰。

6.修饰abstract关键字有如下几个条件：

    1) 含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须重写；
    2) 抽象类不能被实例化；
    3) 抽象方法只需声明而不需实现。(后面没有大括号“{}”)

7.如果abstract 方法在子类里面没有被重写，则需要把该abstract方法在子类里重新声明一次，而且必须被它的子类重写，同时，自己的类前面要加abstract关键字。