JAVA笔记7__接口应用/Object类/简单工厂模式/静态代理模式/适配器模式

/**
 * 接口应用
 */
public class Main {
    public static void main(String[] args) {
        Person p = new Person("fish7");
        p.setIsay(new BeforeGong());
        p.say();
        p.setIsay(new AfterGong());
        p.say();
    }
}

class Person{ //只有在运行期才和say行为关联起来，这就叫面向接口编程
    private String name;
    private Isay isay; //把接口作为类中的一个属性（组合）
    
    public Person(String name){
        this.name = name;
    }
    public void setIsay(Isay isay){ //可以传BeforeGong也可以传AfterGong
        this.isay = isay;
    }
    public void say(){
        isay.say();
    }
}
interface Isay{ //把说话的行为抽象出一个接口
    public void say(); //把可变化的行为抽象出来，定义成接口，并提供不同的实现
}
class BeforeGong implements Isay{
    public void say(){
        System.out.println("I‘m a man.");
    }
}
class AfterGong implements Isay{
    public void say(){
        System.out.println("I‘m a woman~");
    }
}

/**
 * 策略设计模式：定义了一系列的算法，将每一种算法封装起来并可以相互替换使用
 * 策略模式让算法独立于使用它的客户应用而独立变化
 * OO设计原则：
 * 1.面向接口编程（面向抽象编程）
 * 2.封装变化
 * 3.多用组合，少用继承
 */

/**
 * Object类：所有类的父类
 */
public class Main {
    public static void main(String[] args) {
        A a = new A("a");
        System.out.println(a);
        A b = new A("a");
        A c = new A("b");
        System.out.println(a.equals(b)); //输出true
        System.out.println(a.equals(c)); //输出false
        method(a);
    }
    public static void method(Object obj){
        if(obj instanceof A){
            A t1 = (A)obj;
            t1.eat();
        }
    }
}

class A{
    String name;
    A(String name){
        this.name = name;
    }
    public String toString(){ //重写Obejct类中的toString()方法
        return "fuck u";
    }
    public boolean equals(Object obj){ //重写Obejct类中的equals()方法，判断两个对象值是否相等
        if(obj instanceof A){
            A a = (A)obj;
            if(this.name.equals(a.name))
                return true;
            else
                return false;
        }else{
            return false;
        }
    }
    void eat(){
        System.out.println("I‘m eating....");
    }
}

/**
 * 简单工厂模式：由一个工厂对象决定创建出哪一种产品类的实例
 * 如果clothDoll或barbieDoll发生了改动，只需在DollFactory改就行了，而不需要客户端也改
 */
public class Main { //客户端
    public static void main(String[] args) {
        Doll r1 = DollFactory.getInstance("cloth");
        System.out.println(r1.info());
        Doll r2 = DollFactory.getInstance("barbie");
        System.out.println(r2.info());
    }
}

class DollFactory{ //服务器
    public static Doll getInstance(String name){
        if("cloth".equals(name))
            return new clothDoll();
        if("barbie".equals(name))
            return new barbieDoll();
        return null;
    }
}
interface Doll{
    public String info();
}
class clothDoll implements Doll{
    public String info(){
        return "I‘m a clothDoll...";
    }
}
class barbieDoll implements Doll{
    public String info(){
        return "I‘m a barbieDoll...";
    }
}

/**
 * 静态代理模式：为其他对象提供一种代理以控制对这个对象的访问
 * 
 */
public class Main {
    public static void main(String[] args) {
        Person p1 = new Person("fish7");
        Proxyer m = new Proxyer(p1); //创建代理人，并传入被代理人
        m.date(); //相亲
    }
}

interface subject{ //“主题”接口
    public void date(); //相亲
}
class Person implements subject{ //被代理人
    private String name;
    Person(String name){
        this.name = name;
    }
    public void date(){
        System.out.println("I‘m "+name+", I‘m dating....");
    }
}
class Proxyer implements subject{
    private subject target; //代理目标对象
    Proxyer(subject target){
        this.target = target;
    }
    private void before(){ //相亲前要做的事
        System.out.println("为代理人找到匹配人");
    }
    private void after(){ //相亲后要做的事
        System.out.println("本次相亲结束");
    }
    public void date(){
        before();
        target.date();
        after();
    }
}

/**
 * 适配器模式：将一个类的接口转换成客户希望的另外一个接口
 * 适配器模式使得原本因为接口不兼容而不能在一起工作的那些类可以一起工作
 * 
 */
public class Main {
    public static void main(String[] args) {
        //System.out.println();
        PowerA a = new plugA();
        start(a);
        PowerB b = new plugB();
        PowerAdapter pa = new PowerAdapter(b); //适配器
        start(pa);
    }
    public static void start(PowerA s){
        s.Insert();
    }
}

class PowerAdapter implements PowerA{ //适配器，把B口“变成”A口
    private PowerB b; //要进行适配的接口
    public PowerAdapter(PowerB b){
         this.b = b;
    }
    public void Insert(){
        b.Connect();
    }
}
interface PowerA{ //电源A接口
    public void Insert();
}
interface PowerB{ //电源B接口
    public void Connect();
}
class plugA implements PowerA{
    public void Insert(){
        System.out.println("电源A接口已经插入插头，开始工作....");
    }
}
class plugB implements PowerB{
    public void Connect(){
        System.out.println("电源B接口已经插入插头，开始工作....");
    }
}