这几天正在看HeadFirst的时候，突然觉得面向对象的几个特点，有点理解模糊不清，所以在这再次回顾一下，加深印象。

    上篇博客（http://blog.csdn.net/u010539352/article/details/39500455）中已经讲解了3个面向对象的特点，下面讲解剩下的。

    多态：如果一个人想养一个宠物，想养狗就养一条狗，想养一只猫就养一只猫，该怎么实现？那就用到了多态，可以随机切换，不改动“人”这个类中的代码，具有动态和灵活性。下面举例：

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

 class Cat extends Animal {
  private String eyesColor;
  Cat(String n,String c) {super(n); eyesColor = c;}

  public void enjoy() {
    System.out.println("猫叫声......");
  }
}

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


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");
        Lady l1 = new Lady("l1",c);
        Lady l2 = new Lady("l2",d);
        l1.myPetEnjoy();           //多态，实际New出来的对象的方法，所以是猫的enjoy()方法
        l2.myPetEnjoy();           //狗的enjoy()方法
    }
}

    解释：运行期间New出来那个对象，我们就调用谁的方法。运行期间我们New出来的是狗和猫的enjoy方法，所以调用的是猫和狗的enjoy方法。具有动态性。所以运行出来就是女孩养的猫高兴了，所以猫的enjoy方法就运行了，结果：猫叫声…..女孩养的狗高兴了，所以猫的enjoy方法就运行了，结果：狗叫声…..现在如果再加一个鸟，不用改变原来的代码，直接添加一个类就可以，可扩展性。

    总结如下：当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有则编译错误，如果有再去调用子类的该同名的方法。所以多态必须具备3个条件：要有继承，要有重写，父类引用指向子类对象。

   从多态例子可以看出，父类的enjoy方法没有必要实现，因为子类必须要进行重写，父类写了还有点多余，所以就用到了抽象。

   抽象：用abstract关键字修饰。下面举例：

abstract class Animal {                //抽象类
  private String name;
  Animal(String name) {this.name = name;}
  
	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("猫叫声......");
  }
}

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


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");
        Lady l1 = new Lady("l1",c);
        Lady l2 = new Lady("l2",d);
        l1.myPetEnjoy();           
        l2.myPetEnjoy();           
    }
}

    解释：可以看出来带有abstract关键字的类被定义为了抽象类，方法被定义为了抽象方法。只有定义没有实现。在子类中实现。

    所以，抽象类必须被继承，抽象方法必须被重写。

    接口：是一种特殊的抽象类，只包含常量和方法的定义，没有变量和方法的实现。。几个不相关的类可以实现同一个接口。一个类可以实现多个接口。相当于多继承。举例：

interface Animal {            //接口类
	public void call(); 
}

interface Animal1 {            //接口类
	public void run();
}


class Dog implements Animal {     //狗类实现接口
	private String name;
	Dog(String name) 
	{this.name = name;}
	
	public void call() {             //实现了接口方法
		System.out.println("狗叫声......");
	}
	
	public String getName() {
		return name;
	}
	
	public void run() {               //实现了接口方法
		System.out.println("狗跑......");
	}
}

class Cat implements Animal {        //猫类实现接口
	private String name;
	Cat(String name) {this.name = name;}
	

	public void call() {               //实现了接口方法
		System.out.println("猫叫声......");
	}
	
	public String getName() {
		return name;
	}
	
	public void run() {                 //实现了接口方法
		System.out.println("猫跑......");
	}
}

public class Interface {
    public static void main(String args[]){
        Cat c = new Cat("cat");
        Dog d = new Dog("dog");
        c.call();
        c.run();
        d.call();
        d.run();                    
    }
}

    解释：在接口类中没有写方法的实现，但是普通类必须对接口所有的方法进行重写。

    总结：重写必须要有继承。

                        多态必须要有继承和重写。

                        抽象必须要有继承和重写。用抽象来实现多态。

                        接口必须要有实现。

    这样总结一遍，思路一下子清晰多了。多多总结没有坏处。

java-面向对象（二）