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方法没有必要实现，由于子类必需要进行重写。父类写了还有点多余，所以就用到了抽象。

   抽象：用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();                    
    }
}

显示结果：

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

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

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

                        抽象必需要有继承和重写。

用抽象来实现多态。

                        接口必需要有实现。

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

多多总结没有坏处。