面向对象编程（七）接口，面向接口编程

接口

接口语法：

interface 接口名{

           //静态常量、抽象方法

}

 

接口的特点：

①   接口中只能存放静态常量和抽象方法;

②   Java接口是对功能的扩展;

③   通过实现接口，java类可以实现多实现;

④   一个人可以同时继承（extends）一个父类并且实现（implements）多个接口;

⑤   接口与接口之间可以通过使用extends来产生继承关系;

 

接口与抽象类的区别

①   抽象类和具体实现类之间是一种继承关系，也就是说如果采用抽象类的方式，则父类和子类在概念上应该是相同的;

②   接口和实现类在概念上不要求相同，接口只是抽取互相之间没有关系的类的共同特征，而不去关注类之间的关系，它可以使没有层次关系的类具有相同的行为;

③   抽象类是对一组具有相同属性和行为的逻辑上有关系的事物的一种抽象，而接口则是对一组具有相同属性和行为的逻辑上不相关的事物的一种抽象;

④   对于接口和抽象类的选择，反映出设计人员看待问题的不同角度。抽象类用于一组相关的事物，表示的事“is-a”的关系；而接口用于一组不相关的事物，表示的是“like-a”的关系;

不使用接口code

public class InterfaceDemo{
    public static void main(String []args){
        Person p=new Person();
        Child child=new Child();
        Dog dog=new Dog();
        p.feed(child);
        p.feed(dog);
    }
}

class Person{
    public void feed(Child child){
        child.eat();
    }
    public void feed(Dog dog){
        dog.eat();
    }
    
}

interface IAbility{
    //接口中只能放共有的静态常量和抽象方法
    //接口中会默认public static final
    /*public static final*/ /*int number=1;*/
    
    //方法中会默认加上public abstract
    /*public abstract*/ /*void show();*/
}

class Child{
    public void eat(){
        System.out.println("吃米饭");
    }
}

class Dog{
    public void eat(){
        System.out.println("啃骨头");
    }
}

使用接口code

public class InterfaceDemo{
    public static void main(String []args){
        Person p=new Person();
        Child child=new Child();
        Dog dog=new Dog();
        p.feed(child);
        p.feed(dog);
    }
}

class Person{
    /*public void feed(Child child){
        child.eat();
    }
    public void feed(Dog dog){
        dog.eat();
    }*/
    //接口的引用变量可以引用其实现类的对象
    //接口实现了多态
    public void feed(IAbility ability){
        ability.eat();//动态绑定
    }
    
}

interface IAbility{
    //接口中只能放共有的静态常量和抽象方法
    //接口中会默认public static final
    /*public static final*/ /*int number=1;*/
    
    //方法中会默认加上public abstract
    /*public abstract*/ /*void show();*/
    
    void eat();
}

class Child implements IAbility{
    public void eat(){
        System.out.println("吃米饭");
    }
}

class Dog implements IAbility{
    public void eat(){
        System.out.println("啃骨头");
    }
}

 

面向接口编程

开发系统时，主体架构使用接口，接口构成系统的骨架;

这样就可以通过更换接口的实现类更换系统的实现;

 

示例：

需求：学习内部安装了彩色打印机或黑白打印机，通过其所安装的打印机可以用来打印教员的详细信息，也可以打印学校其自身的详细信息;

改写以前编写过的一个程序（打印机打印的程序）

public class PrinterDemo{
    public static void main(String []args){
        ColorPrinter cp=new ColorPrinter("惠普");
        BlackPrinter bp=new BlackPrinter("戴尔");
        ZhenPrinter zp=new ZhenPrinter("戴尔");
        School school=new School();
        
        school.setPrinter(zp);//这里的参数可以调用较灵活，使用cp，bp，zp都可以，而不用改school类中的方法
        
        Teacher t=new Teacher("张三",30);
        school.print(t);
        school.print(school); 
    }
}

interface IInfo{
    String detail();
}

abstract class Printer{
    private String brand;
    
    public Printer(String brand){
        this.brand=brand;
    }
    
    public String getBrand()
    {
        return brand;
    }
    
    //打印方法应该由其子类来具体的实现
    public abstract void print(String content);
}

//开原原则：对修改是封闭的，对扩展是开放的，不要违反开闭原则
//可以使用多态解决这个问题，父类的引用变量可以引用其子类的对象
class School implements IInfo{
    private Printer p=null;//安装打印机
    
    //拿父类的引用变量作为参数，好处就是可以接受任何其子类的对象
    //越是抽象的东西就是越稳定的
    public void setPrinter(Printer p){
        this.p=p;
    }
    //多态，程序设计时主体框架使用接口或抽象类，是程序具有很好的维护性和扩展性
    public void print(IInfo info){
        //交给中心所安装的打印机来打印
        p.print(info.detail());
    }
    
    public String detail(){
        return "hello,我是学校";
    }
}

class ColorPrinter extends Printer{
    public ColorPrinter(String brand){
        super(brand);
    }
    //对父类的方法进行重写
    public void print(String content){
        System.out.println(getBrand()+"彩色打印:"+content);
    }
}

class BlackPrinter extends Printer{
    public BlackPrinter(String brand){
        super(brand);
    }
    //对父类的方法进行重写
    public void print(String content){
        System.out.println(getBrand()+"黑白打印:"+content);
    }
}

class ZhenPrinter extends Printer{
    public ZhenPrinter(String brand){
        super(brand);
    }
    //对父类的方法进行重写
    public void print(String content){
        System.out.println(getBrand()+"针式打印:"+content);
    }
}

class Teacher implements IInfo{
    private String name;
    private int age;
    public Teacher(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String detail(){
        return "我的名字叫："+name+"，今年："+age+"岁";
    }
}