设计原则之面向接口编程

面向对象设计中有这样一个原则：
针对接口编程，而不是针对实现编程，也就是针对抽象编程。

我是这样理解它的，举个例子：

假设，现在要实现一个装动物的笼子，里面要放置一个狗。那么我们可以这样写代码：
狗的实现类 Dog.java

public class Dog{
    public void talk(){
        System.out.println("Dog talk");
    }
}

笼子的实现类 Cage.java

public class Cage{
    private Dog dog;

    public Cage(Dog dog){
        this.dog = dog;
    }

    public void talk(){
        this.dog.talk();
    } 
}

客户端代码 Client.java

public class Client{

     public static void main(String[] args){
            Dog dog = new Dog();
            //向笼子里加入狗
            Cage cage = new Cage(dog);

            //笼子里的动物说话
            cage.talk();
     }

}

这样的话，针对这个需求，我们很完美的完工了！实现了所需要的功能。
但是如果现在需求变了呢，想向笼子里加上一只猫，而不是一只狗。
从直观的角度考虑，我们就是更改Cage类中定义的Dog对象，将其全都换成Cat对象。
换个角度，将Dog 和 Cat 抽象出共用的接口，用于复用。

新改变的代码如下：
新定义的 动物接口 Animal.java

public interface Animal{

      public void talk();
}

定义Cat类，实现此接口   Cat.java

public class Cat implements Animal{
    
     public void talk(){
         System.out.println("Cat talk");
     }

}

Dog类也改为实现Animal接口，这里就不再写出了
Cage类更改如下

public class Cage{
    private Animal animal;

    public Cage(Animal animal){
        this.animal = animal;
    }

    public void talk(){
        this.animal.talk();
    } 
}

这样，就可以在客户端实现将Cat或Dog加入到笼子里了

public class Client{

     public static void main(String[] args){
            Dog dog = new Dog();
            Cat cat = new Cat();
            //向笼子里加入狗
            //Cage cage = new Cage(dog);
            //或向笼子里加入猫
            Cage cage = new Cage(cat);
            
            //笼子里的动物说话
            cage.talk();
     }
}

这样就可以实现了代码的复用，以后再改需求，加入别的动物，对于Cage也可以不需要进行改变。

• 利用第一种形式定义Cage，即是面向实现编程，是在编译时确定笼子与具体动物的关系。
• 利用第二种形式定义Cage，抽象出Animal，即是面向接口编程，是在运行时确定笼子与具体动物的关系。当在客户端运行时加入Dog，则笼子里放入的是Dog，当在客户端运行时加入Cat，则笼子里放入的是Cat。

算是自己对面向接口编程的一点体会吧~