接口

接口：比抽象类更抽象的类，是一种规范标准。可以表示一种能力，定义不同层之间的操作标准。
      在进行某些公共操作的时候一定要定义出接口
      接口和类都是类型
      如果没有继承关系，就要用接口(优先考虑)
      ★接口必须要有子类★
范例：
public interface A{
/*接口里面只能是抽象方法*/
    public static final String MSG = "Hello";    //全局变量
    public abstract void print();    //抽象方法
}
接口存在抽象方法，所以接口对象★★★不能new进行实例化★★★的操作

注意：
    一个子类可以实现（implements）多个接口
    ◆一个接口可以extends多个接口◆
    ★类和接口之间  不能（extends），只能（implements）★
    ★类和类，接口和接口可以继承（extends）★
    子类一定要实现（implements）接口的●所有●的方法【重写全部的抽象方法，向上转型】
范例：
/*接口A*/
public interface A {    //定义了接口
    String MSG = "Hello";    //全局常量
    void print();    //抽象方法，不写访问修饰符默认是public
}

/*接口B*/
public interface B {
    public void get();    //这里是抽象方法，可以省略abstract
}

//X类实现了 A和B两个接口
public class X implements A,B{
    public void print(){
        System.out.println("A接口的抽象方法");
    }
    
    public void get(){
        System.out.println("B接口的抽象方法");
    }
}

public class TestX{
    public static void main(String[] args) {
        X x = new X();//接口A,B不能实例化    实例化子类对象
        A a = x;
        B b = x;
        a.print();
        b.get();
        System.out.println(b instanceof A);    /*多个栈空间可以指向同一个堆空间*/
        System.out.println(a instanceof B);    /*一个栈空间【不可以】指向多个堆空间*/
    }
}

如果X不想实现print方法，就定义X为抽象类，print()为抽象方法，再写一个其非抽象类的子类实现即可
如果既有继承，又有实现，那么先写extends，再写implements，它们的所有抽象方法都要重写
接口里面可以定义普通内部类，抽象内部类，内部接口
    如果内部类，内部接口有static，此时内部类称为外部类，或外部接口
范例：
public interface A {
    public void fun1();
    
    abstract class B{//内部类
        abstract void fun2();
    }
}
//看不到内部类B
class H implements A{

    @Override
    public void fun1() {
        System.out.println("A的抽象方法");
    }
}

//调用A所有的方法
class D extends A.B implements A{

    @Override
    public void fun1() {
        System.out.println("A的抽象方法");
    }

    @Override
    void fun2() {
        System.out.println("B的抽象方法");
    }
}

//调用内部类B
class E extends A.B{

    @Override
    void fun2() {
        System.out.println("B的抽象方法");
    }
}

应用：USB
/*定义USB接口*/
public interface UsbInterFace {
    void start();
    void stop();
}

/*要做的事情computer*/
public class Computer{
    public void plugIn(UsbInterFace usbInterface) {
        usbInterface.start();
        usbInterface.stop();
    }
}

/*USB的类型1,实现USB*/
public class UDisk implements UsbInterFace {
    @Override
    public void start() {
        System.out.println("U盘开始工作了");
    }

    @Override
    public void stop() {
        System.out.println("U盘停止工作了");
    }
}

/*USB的类型2,实现USB*/
public class UsbFan implements UsbInterFace{
    @Override
    public void start() {
        System.out.println("电风扇开始工作了");
    }

    @Override
    public void stop() {
        System.out.println("电风扇停止工作了");
    }
}

/*测试类*/
public class TestComputer {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.plugIn(new UsbFan());
        computer.plugIn(new UDisk());
    }
}

【工厂设计模式】
    普通：在Factory类的方法中加if
    高级：修改配置
范例1:
/*Fruit接口*/
public interface Fruit {
    void eat();
}

/*实现子类1*/
public class Apple implements Fruit {
    @Override
    public void eat() {
        System.out.println("吃苹果");
    }
}

/*实现子类2*/
public class Orange implements Fruit {
    @Override
    public void eat() {
        System.out.println("吃橘子");
    }
}

/*工厂类，批量生产实现子类*/
public class Factory {
    public static Fruit getInstance(String className){
        //有多少子类就写多少子类
        if ("apple".equalsIgnoreCase(className)) {
            return new Apple();
        } else if("orange".equalsIgnoreCase(className)){
            return new Orange();
        } else {
            return null;
        }
    }
}

/*测试类*/
public class TestFruit {
    public static void main(String[] args) {
        Fruit f = Factory.getInstance("orange");【工厂类.（静态方法）getInstance（“用户输入的实现子类的名称”）】
        f.eat();
    }
}

范例2:
/**
 * 墨盒类
 */
public interface Ink {
    public String getColor();
    /*接口内的抽象方法，可以有返回值，也可以没有返回值*/
}

/**
 * 纸张类
 */
public interface Paper {
    public String getSize();
}

public class MyColorInk implements Ink {
    @Override
    public String getColor() {
        return "暗金色";
    }
}

public class MyColorInkV3 extends MyColorInk {
    @Override
    public String getColor() {
        return "暗红色";
    }
}

public class LaojiuPaper implements Paper{
    @Override
    public String getSize() {
        return "A6L";
    }
}

public class LaojiuPaper implements Paper{
    @Override
    public String getSize() {
        return "A6L";
    }
}

import java.io.IOException;
import java.util.Properties;

/**
 * 配置类
 */
public class Config {
    public static Properties props = new Properties();
    //静态块-生命周期在整个应用程序运行之前
    static{
        //加载配置文件
        try {
            props.load(Config.class.getClassLoader().
                    getResourceAsStream("MyConfig.properties")
            );
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 根据传入的名称得到相应实现类的实例（使用反射技术）
     * @param name
     * @return 
     * @throws ClassNotFoundException
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    public static Object getInstance(String name) throws ClassNotFoundException, InstantiationException, IllegalAccessException{
        //根据接口名得到实现类的全称
        String fullName = getProperty(name);
        if(null == fullName) return null;
        //得到实现类
        Class objClass = Class.forName(fullName);
        //返回实现类的实例
        return objClass.newInstance();
    }
    
    /**
     * 根据键得到配置文件中对应的值
     * @param key 
     * @return
     */
    public static String getProperty(String key){    //key == 对象
        return props.getProperty(key);
    }
}

★同一个java projiect中的MyConfig.properties记事本★（控制台输出的结果MyColorInk，LaojiuPaper）
ink=com.ljxy.kenny.printerdemo.MyColorInk
paper=com.ljxy.kenny.printerdemo.LaojiuPaper

【代理设计模式】
范例：
public interface Subject {  //整个操作的核心主题
    public void make();     //整个主题的核心功能
}
/*实现子类1*/
public class RealSubject implements Subject {    //真正执行核心功能的人
    public void make() {
        System.out.println("皇帝陛下正在XX。");
    }
}
/*实现子类2-代理*/
public class ProxySubject implements Subject {    
    private Subject subject;
    /*代理的带参构造方法*/
    public ProxySubject(Subject subject){
        this.subject=subject;
    }
    
    @override
    public void make() {
        this.prepare();
        this.subject.make();
        this.destory();
    }
    
    public void prepare(){
        System.out.println("为临幸做准备！");
    }
    
    public void destory(){
        System.out.println("把娘娘搬走了，皇帝伺候睡觉了！");
    }
}

public class TestDemo {
    public static void main(String args[]){
        Subject sub=new ProxySubject(new RealSubject());//实际实施临幸的RealSubject
        sub.make();         //调用的是代理主题操作
    }
}