这几天正在看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方法没有必要实现，由于子类必需要进行重写。父类写了还有点多余，所以就用到了抽象。
抽象：用abstractkeyword修饰。以下举例：
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();
}
}
解释：能够看出来带有abstractkeyword的类被定义为了抽象类。方法被定义为了抽象方法。仅仅有定义没有实现。在子类中实现。
所以。抽象类必须被继承。抽象方法必须被重写。
上面讲了继承，重写。抽象，多态。用这几个的结合体能够实现非常完美的编程，可是美中不足的是Java里不能实现多继承，这里我们就用到了接口。接口：是一种特殊的抽象类。仅仅包括常量和方法的定义。没有变量和方法的实现。
。几个不相关的类能够实现同一个接口。一个类能够实现多个接口。相当于多继承。
举例：
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();
}
}
显示结果：
解释：在接口类中没有写方法的实现。可是普通类必须对接口全部的方法进行重写。
总结：重写必需要有继承。
多态必需要有继承和重写。
抽象必需要有继承和重写。
用抽象来实现多态。
接口必需要有实现。
这样总结一遍，思路一下子清晰多了。
多多总结没有坏处。