java-面向对象（二）
这几天正在看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关键字的类被定义为了抽象类，方法被定义为了抽象方法。只有定义没有实现。在子类中实现。
所以，抽象类必须被继承，抽象方法必须被重写。
上面讲了继承，重写，抽象，多态，用这几个的结合体可以实现很完美的编程，但是美中不足的是 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();
}
}
显示结果：
解释：在接口类中没有写方法的实现，但是普通类必须对接口所有的方法进行重写。
总结：重写必须要有继承。
多态必须要有继承和重写。
抽象必须要有继承和重写。用抽象来实现多态。
接口必须要有实现。
这样总结一遍，思路一下子清晰多了。多多总结没有坏处。