抽象类与接口小结

接⼝定义：接⼝就是抽象⽅法和全局常量的集合，在Java中接⼝使⽤interface关键字定义

1. 接口定义方法默认为抽象方法。接口中数据成员默认为public static final
2. 接口的实现用implements
3. 接口不能进行实例化。
4. 接口可以继承多个接口，此时的接口里面有继承的抽象方法。

一、工厂设计模式

接口GG

public interface GG {
    void println();
}

接口INews

 public interface INews {
    String getNews();
}

接口 IMessage

  public interface IMessage {
    String MSG = "i am a betterman";
    String ACE="团灭";
    void printl();
}

/⼦类如果要想使⽤接⼝，那么就必须使⽤implements关键字来实现接⼝
同时，⼀个⼦类可以实现多个接⼝，【可以使⽤接⼝来实现多继承的概念】对于接⼝的⼦类（不是抽象类）必须覆写接⼝中的全部抽象⽅法。随后可以利⽤⼦类的向上转型通过实例化⼦类来得到接⼝的实例化对象。

class MessageImpl implements IMessage,INews,GG{

    @Override
    public void printl() {
        System.out.println(IMessage.MSG);
    }

    @Override
    public String getNews() {
        return IMessage.ACE;
    }

    @Override
    public void println() {
        System.out.println("GGboy变身");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        IMessage iMessage=new MessageImpl();
        iMessage.printl();
        INews iNews=new MessageImpl();
        System.out.println(iNews.getNews());
        IMessage iMessage10=new MessageImpl();
        ((MessageImpl) iMessage).println();
    }
}

1.简单工厂模式：专⻔定义⼀个类⽤来创建其它类的实例，被创建的实例通常都具有共同的⽗类。

所需要的：
（1.） ⼀个抽象产品类
（2.） 具体产品类
（3.） 一个工厂
优点：简单易实现。
把类的实例化交给工厂，易于解耦
.
接口Computer

public interface Computer {
    void printComputer();
}

MacbookproComputer

public class MacbookproComputer implements Computer{
    @Override
    public void printComputer() {
        System.out.println("MacbookproComputer");
    }
}

SurfaceproComputer

public class SurfaceproComputer implements Computer {
    @Override
    public void printComputer() {
        System.out.println("SurfaceproComputer");
    }
}

ComputerFactory

public class ComputerFactory {
    public static Computer getInstance(String type){
        Computer computer =null;
        if(type.equals("MAC")){
            computer =new MacbookproComputer();
        }
        else if(type.equals("Surface")){
            computer=new SurfaceproComputer();
        }
        return  computer;
    }
}

Client

import java.util.Scanner;

public class Client {
    public void buyComputer(Computer computer){
        computer.printComputer();
    }
    public static void main(String[] args) {
        Client client=new Client();
        System.out.println("请输入你要的电脑型号: MAC 或 Surface");
        Scanner scanner=new Scanner(System.in);
        String type=scanner.nextLine();
        Computer computer =ComputerFactory.getInstance(type);
        client.buyComputer(computer);
    }
}

2.⼯⼚⽅法模式：定义⼀个⽤来创建对象的接⼝，让⼦类决定实例化哪⼀个类，让⼦类决定实例化延迟到⼦类。
⼯⼚⽅法模式是针对每个产品提供⼀个⼯⼚类，在客户端中判断使⽤哪个⼯⼚类去创建对象。
概要

1. ⼀个抽象产品类

2. 多个具体产品类

3. ⼀个抽象⼯⼚

4. 多个具体⼯⼚ - 每⼀个具体产品对应⼀个具体⼯⼚
   

   computer /MacbookProComputer/SurfaceBoolComputer的代码与上面的一样就不放了

   Computer代码

    public interface ComputerFactory {
    Computer createComputer();
    }
   

AppleFactory代码

   public class AppleFactory implements ComputerFactory {
        @Override
        public Computer createComputer() {
            return  new MacbookProComputer();
        }
    }

MsFactory代码

public class MsFactory implements ComputerFactory {
    @Override
    public Computer createComputer() {
        return new SurfaceBookComputer();
    } 
  }

Client代码

public class Client {
    public void buyComputer(Computer computer){
        computer.printComputer();
    }

    public static void main(String[] args) {
        Client client = new Client();
        ComputerFactory factory= new MsFactory();
        client.buyComputer(factory.createComputer());
        System.out.println("===========================");
        ComputerFactory factory1=new AppleFactory();
        client.buyComputer(factory1.createComputer());
    }
}

3.代理设计模式：两个⼦类共同实现⼀个接⼝，其中⼀个⼦类负责真实业务实现，另外⼀个⼦类完成辅助真实业务主题的
操作。

接口

public interface ISubject {
    void buyComputer();
}

ProxySubject

public class ProxySubject implements ISubject {
    private ISubject subject;
    public ProxySubject(ISubject subject){
        this.subject=subject;
    }
    public void ProduceComputer(){
        System.out.println("1.生产MSI电脑");
    }
    public void afterSale(){
        System.out.println("3.MSI售后服务团队");
    }
    @Override
    public void buyComputer() {
        this.ProduceComputer();
        this.subject.buyComputer();
        this.afterSale();
    }
}

RealSubject

public class RealSubject implements ISubject{
    @Override
    public void buyComputer() {
        System.out.println("2.买一台MSI电脑");
    }
}

主程序

  class Factory{
    public static ISubject getInstance(){
        return new ProxySubject(new RealSubject());
    }
}
public class Client {
    public static void main(String[] args) {
        ISubject subject=Factory.getInstance();
        subject.buyComputer();
    }
}