多态性是继数据抽象和继承之后，面向对象语言的第三个特征。
它提供了另一个层面的接品与实现分离，也就是说把  做什么  和  怎么做分离开来。
 多态性是一项很重要的技术，它能够将会变的和不会变的东西分隔开来

一些代码

import java.util.*;

class Note
{
    private String noteName;
    private Note(String noteName)
    {
        this.noteName = noteName;
    }
    public String toString()
    {
        return noteName;
    }
    public static final Note
        A = new Note("A"),
        B = new Note("B"),
        C = new Note("C");    
}
class Instrument
{
    void play(Note note)
    {
        System.out.println("Instrument.play()"+note);
    }
    String what()
    {
        return "Instrument";
    }
    void adjust(){}
}
class Wind extends Instrument
{
    void play(Note n)
    {
        System.out.println("Wind.play()" + n);
    }
    String what()
    {
        return "Wind";
    }
    void adjust(){}
}

class Percussion extends Instrument
{
    void play(Note n)
    {
        System.out.println("Percussion.play()"+n);        
    }
    String what()
    {
        return "Percussion";
    }
    void adjust(){}
}

class Stringed extends Instrument
{
    void play(Note n)
    {
        System.out.println("Stringed.play()"+n);
    }
    String what()
    {
        return "Stringed";
    }
    void adjust(){}
}

class Brass extends Wind
{
    void play(Note n)
    {
        System.out.println("Brass.play()"+n);
    }
    void adjust()
    {
        System.out.println("Brass.adjust()");
    }
}
class Woodwind extends Wind
{
    void play(Note n)
    {
        System.out.println("Woodwind.play()"+n);
    }
    String what()
    {
        return "Woodwind";
    }
}

public class HelloWord
{
    public static void tune(Instrument i)
    {
        i.play(Note.C);
    }
    public static void tuneAll(Instrument[] e)
    {
        for(int i = 0; i < e.length; i++)
        {
            tune(e[i]);
        }
    }
    public static void main(String[] args)
    {
        Instrument[] orchestra = {
                new Wind(),
                new Percussion(),
                new Stringed(),
                new Brass(),
                new Woodwind()
        };        
        tuneAll(orchestra);
        
    }
}

1.当你想要通过一个公共的接口来控制一组类的时候，就可以使用抽象类.
2.如果构造函数调用了一个动态绑定的方法，且那个方法又属于那个正在创建中的对象，那么它会使用那个覆写后的版本。===》一个好的构造函数应该用尽可能少的工作量去把属性初始化并尽量少的调用方法.