java学习------------------接口

关于java的学习记录：

1.

/**
 * 接口的基本定义：如果一个类之中只是由抽象方法和全局常量所组成，那么在这种情况下不会将其定义为一个抽象类，
 * 而只会将其定义为接口，所谓接口就是一个特殊的类，这个类里面只有抽象方法
 * 接口对象不可能直接实例化
 * 接口必须要有子类，但是此时一个子类可以使用implements关键字实现多个接口
 * 接口的子类（如果不是抽象类）必须要覆写接口中的全部抽象方法
 * 接口的对象可以利用子类对象向上转型进行实例化操作
 * 一个接口可以通过extends关键字继承多个接口，接口不能为继承抽象类
 * 在java里面。接口的主要功能是解决单继承问题
 * 在接口里面可以定义普通内部类、抽象内部类、内部接口
 * 在一个接口内部如果使用了static去定义一个内部接口表示是一个外部接口
 */
public class Demo1 {
/**
 * 接口在实际的开发之中有三大核心作用：
 * 1.定义不同层之间的操作标准
 * 2.表示一种操作的能力
 * 3.表示将服务器端的远程方法视图暴露给客户端
 */
    public static void main(String[] args) {
//        X x=new X();//实例化子类对象
//        A a=x;//向上转型
//        B b=x;
//        a.print();
//        b.get();
        A a=new X();
        B b=(B)a;
        b.get();
        C c=(C)b;
        c.change();
        System.out.println(a instanceof A);
        System.out.println(a instanceof B);
        //在定义结构上，A和B接口没有直接联系，但是这两个接口却拥有同一个子类
    }

}
interface A{
    public static final String MSG="hello";//全局常量
    public abstract void print();//抽象方法
}
//可以如下写法：接口里面最终访问权限是public
//interface A{
//    String MSG="hello";//全局常量
//    void print();//抽象方法
//}
interface B{
    public abstract void get();
}
abstract class C{
    public abstract void change();
}
class X extends C implements A,B{
    public void print() {
        System.out.println("A接口的抽象方法");
    }
    public void get() {
        System.out.println("B接口的抽象方法");
    }
    public void change() {
        System.out.println("C抽象类的抽象方法");
    }
}

2.

/**
 * 接口的实际应用---标准
 */
public class Demo2 {

    public static void main(String[] args) {
        Computer com=new Computer();
        com.plugin(new Flash());
        com.plugin(new Print());
    }

}
//标准可以连接不同层的操作类
interface USB{
    public void start();
    public void stop();
}
class Computer{
    public void plugin(USB usb) {  //插入
        usb.start(); //固定操作
        usb.stop();
    }
}
class Flash implements USB{
    public void start() {
        System.out.println("U盘开始使用");
    }
    public void stop() {
        System.out.println("U盘停止使用");
    }
}
class Print implements USB{
    public void start() {
        System.out.println("打印机开始使用");
    }
    public void stop() {
        System.out.println("打印机停止使用");
    }

}

3.

public class Demo3 {

    public static void main(String[] args) {
        Fruit f=Factory.getInstance("orange");
        f.eat();
    }

}
interface Fruit{
    public void eat();
}
class Apple implements Fruit{
    public void eat() {
        System.out.println("***，吃苹果");
    }
}
class Orange implements Fruit{
    public void eat() {
        System.out.println("***,吃橘子");
    }
}
class Factory{
    public static Fruit getInstance(String className) {
        if("apple".equals(className)) {
            return new Apple();
        }else if("orange".equals(className)) {
            return new Orange();
        }else {
            return null;
        }
    }

}

4.

/**
 * 接口的应用---代理设计模式proxy
 * 代理设计模式的核心精髓就在于有一个主题操作接口（可能有多种方法），
 * 核心业务主题只完成核心功能，而代理主题负责完成各种与核心业务相关的功能
 */
public class Demo4 {

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

}
interface Subject{//整个操作的核心主题
    public void make();//整个临幸的核心功能
}
class RealSubject implements Subject{
    public void make() {
        System.out.println("核心主题");
    }
}
class ProxySubject implements Subject{
    private Subject subject;
    //要接受一个真实主题的操作对象
    public ProxySubject(Subject subject) {
        this.subject=subject;
    }
    public void prepare() {
        System.out.println("核心主题前的准备");
    }
    public void make() {
        this.prepare();
        this.subject.make();//告诉皇帝可以开始了
        this.destroy();
    }
    public void destroy() {
        System.out.println("核心主题完成后的操作");
    }
}