java接口

1.接口的定义

1.1.接口的基本定义

interface IClassName{
    public String getClassName();
}
class Company implements IClassName{
    public String getClassName() {
        return "classname";
    }
}
public class interface_01 {
    public static void main(String[] args) {
        IClassName comp = new Company();
        System.out.println(comp.getClassName());
    }
}

1.2.接口的继承

1.MessageImpl子类的对象可以任意的实现父接口的转换。
2.Object类对象可以接收所有的数据类型，包括基本数据类型、类对象、接口对象、数组。 
3.由于接口描述的是一个公共的定义标准，所以在接口中所有的抽象方法的访问权限都是public，所以写与不写都是一样的。

注意：
1.接口中的方法不写访问权限也是public，不是default，所以覆写的时候只能够使用public。
2.接口中的抽象方法abstract写于不写都一样。 在实际开发过程中，实现接口的有可能是抽象类，一个抽象类可以实现多个接口。
3.一个普通类只能够继承一个抽象类并且可以实现多个父接口，但是要求先继承后实现。

interface IMessage{
    public static final String INFO="www.sina.com.cn";//全局常量
    public abstract String getInfo();//抽象方法
    //3.由于接口描述的是一个公共的定义标准，所以在接口中所有的抽象方法的访问全县都为public，所以写与不写都是一样的。
    //String INFO="www.sina.com.cn";//方法不写访问权限也是public，不是default，所以覆写的时候只能够使用public。
    //String getInfo();//abstract写于不写都一样。 在实际开发过程中，实现接口的又可能是抽象类，一个抽象类可以实现多个接口，
    //一个普通类只能够继承一个抽象类并且可以实现多个父接口，但是要求先继承后实现。
}
abstract class DatabaseAbstract{
    public abstract boolean getDatabaseAbstract();
}
interface IChannel{
    public abstract boolean connect();
}
class MessageImpl extends DatabaseAbstract implements IMessage, IChannel{//一个子类可以实现多个接口
    public String getInfo() {
        if(this.connect()) {
            if(this.getDatabaseAbstract()) {
                return "数据库得到一个消息：房价又跌了！";
            }else {
                return "数据库消息无法访问！";
            }
        }
        return "通道建立失败!";
    }
    public boolean connect() {
        System.out.println("通道建立成功！");
        return true;
    }
    public boolean getDatabaseAbstract() {
        return true;
    }
}
public class interface_02 {
    public static void main(String[] args) {
        IMessage msg = new MessageImpl();
        System.out.println(msg.getInfo());
        //System.out.println(IMessage.INFO);
        
        //IChannel chnl = (IChannel) msg;  //1.MessageImpl子类的对象可以任意的实现父接口的转换。
        //System.out.println(chnl.connect());
        
        //Object obj = msg;
        //IChannel chan = (IChannel)obj;
        //System.out.println(chan.connect());//2.Object类对象可以接收所有的数据类型，包括基本数据类型、类对象、接口对象、数组。 
    }
}

1.3.接口的多继承

　　需要覆写接口中的所有抽象方法：包括本接口中的方法和继承的所有方法。

interface IMessage{
    public abstract String getInfo();
}
interface IChannel{
    public boolean connect();
}
//extends在类继承上只能够继承一个父类，但是接口上可以继承多个父接口。
interface IService extends IMessage, IChannel{//接口多继承
    public String service();
}
class MessageService implements IService{
    public String getInfo() {
        return "";
    }
    public boolean connect() {
        return true;
    }
    public String service() {
        return "获取消息服务。";
    }
}
public class interface_03 {
    public static void main(String[] args) {
        MessageService msg = new MessageService();
        System.out.println(msg.service());
    }
}

 

在实际的开发中，接口的使用往往有三种形式：

　　1.进行标准设置；

　　2.表示一种操作的能力；

　　3.暴露远程方法视图，这个一般都在RPC分布式开发中使用。

 

1.4.接口定义加强

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

 

1.4.1.自从JDK1.8之后开始，为了解决接口设计的缺陷，在接口中允许开发者使用default定义普通方法。 

interface IMessage{
    public String message();
    public default boolean connect() {
        System.out.println("建立消息的连接通道。");
        return true;
    }
}
class MessageImpl implements IMessage{
    public String message() {
        return "www.sina.com.cn";
    }
}
public class interface_04 {
    public static void main(String[] args) {
        IMessage msg = new MessageImpl();
        System.out.println(msg.connect());
    }
}

　　接口中的普通方法必须追加default声明，但是需要提醒的是，该操作属于挽救功能，所以如果不是必须的情况下，不应该作为设计的首选。

 

1.4.2.除了可以追加普通方法之外，接口里面也可以定义static方法，而static方法就可以通过接口直接调用。

举例：在接口中定义static方法

interface IMessage{
    public String message();
    public default boolean connect() {
        System.out.println("建立消息的连接通道。");
        return true;
    }
    public static IMessage getInstance() {
 8         return new MessageImpl();
 9     }
}
class MessageImpl implements IMessage{
    public String message() {
        if(this.connect()) {
            return "www.sina.com.cn";
        }
        return "消息没有发送！";
    }
}
public class interface_04 {
    public static void main(String[] args) {
        IMessage msg = IMessage.getInstance();
        System.out.println(msg.connect());
    }
}

　　如果现在真的可以在接口里面定义普通方法或者static方法，那么这个功能就已经可以取代抽象类了，但是不应该将这两个组成作为接口的主要设计原则。我们所写的代码里面还是应该奉行：接口就是抽象方法。

1.5.使用接口定义标准

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

　　电脑上可以插入各种USB的设备，所以电脑上认的是USB标准，而不关心这个标准的具体实现类。

　　举个例子：

interface IUSB{
    public boolean check();
    public void work();
}
class Computer{
    public void plugin(IUSB usb) {
        if(usb.check()) {
            usb.work();
        }else {
            System.out.println("硬件设备安装出现问题！");
        }
    }
}
class Keyboard implements IUSB{
    public boolean check() {
        return true;
    }
    public void work() {
        System.out.println("开始进行码字任务。");
    }
}
class Printer implements IUSB{
    public boolean check() {
        return false;
    }
    public void work() {
        System.out.println("开始进行照片打印。");
    }
}
public class interface_05 {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.plugin(new Keyboard());
        computer.plugin(new Printer());
    }
}

1.6.工厂设计模式

 　　对于接口而言，已经可以明确的是，必须有子类，而且子类可以通过对象的向上转型来获取接口的实例化对象。但是在进行对象实例化的过程中，也有可能存在设计问题。

 举个例子：

interface IFood{
    public void eat();
}
class Bread implements IFood{
    public void eat() {
        System.out.println("吃面包。");
    }
}
public class interface_06 {
    public static void main(String[] args) {
        IFood food = new Bread();
        food.eat();
    }
}

在本程序中根据接口定义来子类的定义，并且利用对象的向上转型进行接口对象实例化处理。

现在出现了问题：客户端需要明确的知道具体的哪一个子类，如果现在面包吃腻了，需要牛奶了，那么客户端就要作出相应的修改。

interface IFood{
    public void eat();
}
class Bread implements IFood{
    public void eat() {
        System.out.println("吃面包。");
    }
}
class Milk implements IFood{
10     public void eat() {
11         System.out.println("喝牛奶。");
12     }
13 }
public class interface_06 {
    public static void main(String[] args) {
        IFood food = new Milk();
        food.eat();
    }
}

所以，此时的程序就出现了耦合的问题，而造成耦合最直接的元凶是“关键字new”。

　　以Java的设计为例，Java实现可移植性的关键是JVM，而JVM的核心原理：利用一个虚拟机来运行Java程序，所有的程序并不与具体的操作系统有任何关联，而是由JVM来进行匹配。所以得出结论：良好的设计应该避免耦合。

举个例子：

interface IFood{
    public void eat();
}
class Bread implements IFood{
    public void eat() {
        System.out.println("吃面包。");
    }
}
class Milk implements IFood{
    public void eat() {
        System.out.println("喝牛奶。");
    }
}
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;
        }
    } 
}
public class interface_06 {
    public static void main(String[] args) {
        IFood food = Factory.getInstance(args[0]);
        food.eat();
    }
}

　　在本程序中，客户端程序类与IFood接口的子类没有任何的关联，所有的关联都是通过Factory类来完成的，而在程序运行的时候可以通过初始化参数进行要使用的子类定义，如果日后需要进行子类扩充的时候，只需要修改Factory类即可实现。使用工厂模式完全隐藏了实现的子类。

1.7.代理设计模式

　　代理设计模式的主要功能，是可以帮助用户将所有的开发注意力只集中在核心业务功能的处理上。

例如：肚子饿了，如何可以吃到食物。 

interface IEat{
    public void get();
}
class EatReal implements IEat{
    public void get() {
        System.out.println("【真实主题】得到一份食物，然后开始品尝美食。");
    }
}
class EatProxy implements IEat{//服务代理
    private IEat eat;//为吃服务
    public EatProxy(IEat eat) {//一定要有一个代理项
        this.eat = eat;
    }
    public void get() {
        this.prepare();
        this.eat.get();
        this.clean();
    }
    public void prepare() {//准备过程
        System.out.println("【代理主题】1、精心购买食材。");
        System.out.println("【代理主题】2、小心的处理食材。");
    }
    public void clean() {
        System.out.println("【代理主题】3、收拾碗筷。");
    }
}
public class interface_07 {
    public static void main(String[] args) {
        IEat eat = new EatProxy(new EatReal());
        eat.get();
    }
}

代理接口设计模式的主要特点是：一个接口提供两个子类，其中一个子类是真实业务操作类，另外一个子类是代理业务操作类。没有代理业务操作，真实业务无法执行。

工厂设计模式例子：

　　定义类Shape，用来表示一般二维图形。Shape具有抽象方法area()和perimeter()，分别用来计算形状的面积和周长。试定义一些形状类（如矩形、三角形、圆形、椭圆形等），这些类均为Shape类的子类。

 

abstract class AbsShape{
    public abstract double area();
    public abstract double perimeter();
}
class Circular extends AbsShape{
    private double radius;
    public Circular(double radius) {
        this.radius = radius;
    }
    public double area() {
        return Math.PI * radius * radius;
    }
    public double perimeter() {
        return 2 * Math.PI * radius;
    }
}
class Triangle extends AbsShape{
    private double length;
    private double width;
    public Triangle(double length,double width) {
        this.length = length;
        this.width = width;
    }
    public double area() {
        return this.length * this.width;
    }
    public double perimeter() {
        return 2 * (this.length + this.width);
    }
}
class Factory_a{
    public static AbsShape getInstance(String className, double... args) {
        if("Circular".equalsIgnoreCase(className)) {
            return new Circular(args[0]);
        }else if("Triangle".equalsIgnoreCase(className)) {
            return new Triangle(args[0], args[1]);
        }else {
            return null;
        }
    }
}
public class 计算面积 {
    public static void main(String[] args) {
        AbsShape asa = Factory_a.getInstance("circular", 3.0);
        AbsShape asb = Factory_a.getInstance("triangle", 2.0, 1.5);
        System.out.println("圆的面积："+ asa.area() + "，圆的周长：" + asa.perimeter());
        System.out.println("矩形的面积："+ asb.area() + "，矩形的周长：" + asb.perimeter());
    }
}

 运行结果：

圆的面积：28.274333882308138，圆的周长：18.84955592153876
矩形的面积：3.0，矩形的周长：7.0