接口，抽象类，工厂设计模式，代理模式

一、接口的结构:

• 抽象方法
• 全局常量

public interface InterfaceA {
     public static final String PRINT = "print";
     public abstract void print();
}

image.png

Modifier 'static' is redundant for interface fields修饰符'static'对于接口字段是多余的.

最终写法：

public interface InterfaceA {
     String PRINT = "print";
     void print();
}

public interface InterfaceB {
    String HELLO = "Hello world";
    void sayHello();
}

• 其他内部结构

  • 内部类
  • 内部抽象类
  • 内部接口

public interface InterfaceA {
     String PRINT = "print"; // 很少直接在接口里定义全局常量
     void print();

     interface InternalA{
          void test1();
     }
     class A{
          public void test() {
          }
     }

     abstract class BB{
          public abstract void test();
     }
}

二、接口和抽象类

抽象类可以实现接口，但接口不能继承抽象类。接口可以继承多个接口

public abstract class AbstractA implements InterfaceA{
}

public interface InterfaceC extends InterfaceA, InterfaceB { 
}

public class TestImpl implements InterfaceC {
    public void print() {
        System.out.println(PRINT);
    }

    public void sayHello() {
        System.out.println(HELLO);
    }
}

三 、使用接口定义标准

四、工厂设计模式

三要素：

• 接口（标准），
• 具体实现类，
• 中间层（工厂类）

中间层不需要普通属性，所以方法定义为static。

//接口类
public interface Fruit {
    void eat();
}
// 具体实现类
public class Apple implements Fruit {
    public void eat() {
        System.out.println("吃苹果...");
    }
}
public class Cherry implements Fruit {
    public void eat() {
        System.out.println("eat cherry...");
    }
}
//工厂类
public class FruitFactory {
    public static Fruit getInstance(String className) {
        if (className.equals("Apple")) {
            return new Apple();
        } else if (className.equals("Cherry")) {
            return new Cherry();
        } else {
            return null;
        }
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        Fruit fruit = FruitFactory.getInstance(s);
        fruit.eat();
    }
}

五 、代理设计模式

首先理解下概念：
代理设计模式是 在不改变源码的情况下，实现对目标对象的功能扩展

• 静态代理

public interface Subject {
    void get(); // 核心操作主题
}

public class RealSubject implements Subject {
    public void get() {
        System.out.println("真实主题..."); //真实主题
    }
}

public class ProxySubjcet implements Subject {
    private Subject subject; // 代理的真实主题
    public ProxySubjcet(Subject subject) {
        this.subject = subject;
    }
    public void prepare() {
        System.out.println("正式主题开始前的准备...");
    }
    public void get() {
        prepare();
        subject.get(); // 真实主题
        destory();
    }
    public void destory() {
        System.out.println("主题结束之后的完善工作...");
    }
}

  public static void main(String[] args) {
        // 静态代理的实现
        Subject subject = new ProxySubjcet(new RealSubject());
        subject.get()；
    }

• 动态打理

final RealSubject realSubject = new RealSubject();
        Subject subject = (Subject) Proxy.newProxyInstance(
                realSubject.getClass().getClassLoader(),
                realSubject.getClass().getInterfaces(),
                new InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("开始前的准备");
                        // 执行目标方法
                        Object invoke = method.invoke(realSubject, args);
                        System.out.println("结束之后的完善");
                        return invoke;
                    }
                }
        );
        subject.get();

• Cglib代理

理解java的三种代理模式

六、抽象类和接口的区别

类是共性 对象是个性

image.png

区别：

区别	抽象类	接口
定义关键字	abstract	interface
组成	属性，常量，抽象、构造、普通方法	抽象方法，全局常量
权限	各种权限	public
子类实现	extends单继承一个抽象类	implements 实现多个接口
关系	抽象类可以实现多个接口	接口不能继承抽象类，但接口利用extends实现接口的多继承
对象实例化	依靠子类对象的向上转型实现抽象类或者接口的实例化	同←
设计模式	模板设计模式	工厂设计模式，代理设计模式
操作局限	单继承局限	没有单继承局限

通过以上，抽象类和接口都可以限制子类要覆写的方法要求，当抽象类和接口都可以实现的情况下，优先考虑接口，而抽象类在实际应用中，往往作为接口和普通类之间的过渡来使用。