接口的定义与使用

接口的基本概念

接口就是一个抽象方法和全局常量的集合，在java中接口用interface关键字来定义、

1.接口一旦定义完成之后，就需要对其有一个核心的说明，接口里面只存在public权限，

2.当一个子类需要实现接口又继承抽象类的时候，先使用extends先继承，再用implements来实现接口，这个关系是一个对多个，

//因为接口和类的定义命名要求相同，所以为了区分接口，所以在接口前面加一个字母I
interface IMessage{
    public static final String MSG="www.mldn.cn";
    public abstract void print();//抽象方法
}
interface INews{
    public abstract String get();
}
class MessageImpl implements IMessage,INews{
    public void print(){
        System.out.println(IMessage.MSG);
    }
    public String get(){
        return IMessage.MSG; //建议访问常量都加上类名称
    }
}
class NewsImpl implements INews{
    public String get(){
        return null;
    }
}
public class Newbegin{
    public static void main(String args    []) {
        INews m=new MessageImpl(); //子类为父接口
        //现在m表示的并不是INews 而是 MessageImpl
        //MessageImpl是IMessage的子类
        IMessage ms=(IMessage)m;
        System.out.println(m.get()); //调用被子类所覆写的方法
    }
}

接口的使用限制

3.一个抽象类可以使用implements实现多个接口，但是接口不能继承抽象类，

interface INews{
    public abstract String get();//即便不写public，也是public
}
//可以在类上进行明确描述，在以后开发中也经常出现以下的命名习惯
abstract class AbstractMessage implements INews{
    public abstract void print();

}
class NewsImpl extends AbstractMessage {
    public String get(){//权限更加严格了，所以无法覆写
        return "www";
    }
    public void print(){//有方法体称为覆写
        
    }
}
public class Newbegin{
    public static void main(String args    []) {
        INews news=new NewsImpl();
        System.out.println(news.get());
        //NewsImpl是抽象类和接口的共同子类
        AbstractMessage am=(AbstractMessage)news;
        am.print(); 
    }
}

实际上此时的结构关系属于三层继承。

4.一个接口可以使用extengds来继承多个父接口。

5.接口可以定义一系列的内部结构，包括：内部的普通类，内部抽象类，以及内部接口，其中使用static定义的内部接口就相当于

是一个外部接口！

接口的使用定义标准

接口在开发中有三大核心应用环境

　　定义操作标准

　　表示能力

　　在分布式开发中暴露远程服务方法

现在要描述出一个概念：电脑可以使用任何USB设备（键盘，U盘，打印机！！）

范例：

interface IUSB{
    public void setup(); //安装USB驱动
    public void work();  //进行工作
}
class Computer{
    public void plugin(IUSB usb){
        usb.setup(); //安装
        usb.work(); //工作
    }
}
class Flash implements IUSB{//定义一个USB设备
    public void setup(){
        System.out.println("安装U盘驱动！");
    }
    public void work(){
        System.out.println("进行数据的传输");
    }
}
class Print implements IUSB{//定义一个USB设备
    public void setup(){
        System.out.println("安装打印机驱动！");
    }
    public void work(){
        System.out.println("进行文件打印");
    }
}
public class Newbegin{
    public static void main(String args    []) {
         Computer com=new Computer();
         com.plugin(new Flash());
         com.plugin(new Print());
    }
}

以上的例子可以看出，接口是在类之上的设计！

工厂设计模式

范例：传统代码开发

interface IFruit{//定义一个水果的操作
    public void eat();//吃水果
}
class Apple implements IFruit{
    public void eat(){
    System.out.println("吃苹果");
    }
}
class orange implements IFruit{
    public void eat(){
    System.out.println("剥皮吃橘子");
    }
}
public class Newbegin{
    public static void main(String args    []) {
        IFruit fru=new Apple();
        fru.eat();
    }
}

java实现可移植性的一个关键是JVM，而不同的操作系统有不同的JVM 程序 JVM 操作系统

New是开发当中最大的耦合元凶，而开发中想要进行解耦合关键在于应用第三方

范例：

interface IFruit{//定义一个水果的操作
    public void eat();//吃水果
}
class Factory{
    public static IFruit getInstanse(String className){
        if("1".equals(className)){
            return new Apple();
        }
        if("2".equals(className)){
            return new Orange();
        }
        return null;
    }
}
class Apple implements IFruit{
    public void eat(){
    System.out.println("吃苹果");
    }
}
class Orange implements IFruit{
    public void eat(){
    System.out.println("剥皮吃橘子");
    }
}
public class Newbegin{
    public static void main(String args    []) {
        if(args.length!=1){
            System.out.println("程序错误");
            System.exit(1);
        }
        
        IFruit fru=Factory.getInstanse(args[0]);
        fru.eat();
    } 
}

当更换使用的IFruit子类的时候主方法没有任何的改变

总结：以后只要是你编写的接口如果想要取得实例化对象第一反应写工厂类，

代理设计模式（Proxy）

所谓代理严格来就是来讲就是两个子类共同实现一个接口，其中一个子类负责真实的业务实现，而另外的子类负责辅助真实的业务主题的操作。

范例：实现代理设计

interface ISubject{
    public void save();//核心功能是救人
}
class RealSubject implements ISubject{
    public void save(){
        System.out.println("英勇的制止了不法的情爱");
    }
}
class ProxySubject implements ISubject{//代理实现
    private ISubject subject;//真正的操作业务
    //在创建代理类对象的时候必须设置要代理的真实主题
    public ProxySubject(ISubject subject){
        this.subject=subject;
    }
    public void broke(){
        System.out.println("1.破门而入");
    }
    public void get(){
        System.out.println("2.得到见义勇为");
    }
    public void save(){//接口子类一定要实现的抽象方法
        this.broke();//真实操作前的准备
        this.subject.save();//调用真实业务
        this.get();//操作后的收尾
    }
}
class Factory{
    public static ISubject getInstanse(){
        return new ProxySubject(new RealSubject());
    }
}
public class Newbegin{
    public static void main(String args    []) {
        ISubject sub=Factory.getInstanse();
        //通过代理类对象发出，利用代理类来实现真实业务调用
        sub.save();//救人的核心操作
    } 
}

代理的本质在于：所有的真实业务操作都有一个辅助的功能类完成，

抽象类与接口的区别

抽象类与接口都是属于常用的类结构设计，在开发中都会出现，按照优先选择来讲，接口一定要比抽象类方便，

从概念上来讲两者进行一些简单的对比：

NO	区别	抽象类	接口
1	关键字	abstract class 类名称{}	interface 接口名称{}
2	结构组成	抽象方法，普通方法，全局常量，全局变量，属性，构造方法	接口和全局常量
3	权限	可以使用各种权限	只能使用public访问权限
4	子类使用	子类利用我们的extends继承抽象类	子类利用implements关键字来实现接口
5	关系	一个抽象类可以实现若干个接口	一个接口不能继承抽象类，但可以使用extends来继承多个父接口
6	子类限制	一个类只能够继承一个抽象类	一个子类可以实现多个接口

　　　　除了单继承的局限外，实际上使用抽象类和接口都是类似的，但是在实际开发中，抽象类的设计要比接口复杂

现在要掌握的是如何定义接口以及更好的实现子类

　　　　对于现在已经学习的概念发现结构体很多：类，对象，抽象类，接口，那么这几者的具体关系，可以通过如下的一张图来描述

1.接口是java的核心，慢慢的学习到接口的使用和设计

2.开发中优先考虑接口，避免单继承局限，