Java day11【第二十章】接口的定义与使用

【第二十章】接口的定义与使用

二.接口定义加强：

　　接口最早的主要特点是全部由抽象方法和全局常量所组成，但是如果项目设计不当，就有可能出现问题：

 

　　一直强调该操作是属于结构设计不当，在这样的情况下往往不会让子类直接实现接口，而是在中间追加一个过度的抽象类。

　　但是从JDK1.8之后，为了解决接口设计的缺陷，所以在接口中允许开发者定义普通方法。

interface IMessage
{
    public String Message();
    public default boolean Connect(){
        return true;                        //default定义一个普通方法
    };        
}
class MessageImp implements IMessage
{
    public String Message(){
        return "WWW.MLDN.COM";
    }
}

public class tsy
{
    public static void main(String[] args) 
    {
        IMessage msg = new MessageImp();
        if(msg.Connect()){
            System.out.println(msg.Message());
        }
    }
}

　　接口中default定义一个普通方法，但是该操作是一个挽救功能，不应该作为设计首选。

 

三.使用接口定义标准：

　　对于接口而言在开发之中最为重要的应用就是进行标准的制定，实际上在日常的生活之中也会听见许多关于接口的名词：USB接口，PCI接口等等，这些实际上都属于标准的应用。

　　下面我们定义简单的USB接口标准

interface IUSB{
    public boolean check();
    public void work();
}
class Computer
{    
    public void plugin(IUSB iusb){
        if(iusb.check()){
            iusb.work();
        }else {
            System.out.println("硬件设备出错");
        }
    }
}
class Keyboard implements IUSB
{
    public boolean check(){
        return true;
    }
    public void work(){
        System.out.println("硬件设备开始工作");
    }
}
class Print implements IUSB
{
    public boolean check(){
        return false;
    }
    public void work(){
        System.out.println("硬件设备开始工作");
    }
}

public class tsy
{
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.plugin(new Keyboard());
        computer.plugin(new Print());
    }
}

 

四.工厂设计模式（Factory）：

　　接口通过子类的向上转型来实现实例化，但是在对象实例化的过程之中也可能存在有设计问题。

interface IFood
{
    public void eat();
}
class Milk implements IFood
{
    public void eat(){
        System.out.println("喝酒奶");
    }
}
class Bread implements IFood
{
    public void eat(){
        System.out.println("吃面包");
    }
}
public class tsy
{
    public static void main(String[] args) {
        IFood eat = new Milk();
        eat.eat();
    }
}

　　红色代码部分表示，用户需要吃面包，则需要修改客户端，用户需要喝牛奶，也需要修改客户端。

　　所以此时的程序就表示出现有耦合问题，而造成耦合最直接的元凶：关键字 new， 关键字new。

　　我们以JVM设计为例，Java实现可移植性的关键在于JVM，而JVM的核心原理：利用一个虚拟机来运行Java程序，所有的程序并不与具体的操作系统有任何的关联，而是由JVM来匹配。

　　所以我们得出的结论是：良好的设计应该避免耦合

范例：工厂设计实现:

interface IFood
{
    public void eat();
}
class Factory
{
    public static IFood getInstance(String className){
        if("Bread".equals(className)){
            return new Bread();
        }else if("Milk".equals(className)){
            return new Milk();
        }else{
            return null;
        }
    }
}
class Milk implements IFood
{
    public void eat(){
        System.out.println("喝酒奶");
    }
}
class Bread implements IFood
{
    public void eat(){
        System.out.println("吃面包");
    }
}
public class tsy
{
    public static void main(String args[]) {
        IFood food = Factory.getInstance(args[0]);
        food.eat();
    }
}

 

 

　　此时主类通过工厂Factory和客户端联系，不存在主类和客户端的耦合问题。