Java 设计模式

简单工厂模式

定义父类

public abstract class People {
   public void run(){
       System.out.println("这是公共方法，我是人，我会走路");
   }
    public abstract  void say();//私有方法，子类自己实现

}

子类实现

public class BlackPeople extends People{
    public void say() {
        System.out.println("我是黑种人，我说的是非洲话");
    }
}

public class WhitePeople extends People{
    public void say() {
        System.out.println("我是白种人，我说的是美国话");
    }
}

public class YellowPeople extends People{
    public void say() {
        System.out.println("我是黄种人，我说的是中国话");
    }
}

创建工厂

public class PeopleFactory {
    //创建黑人
    public People createBlack(){
        return  new BlackPeople();
    }
    //创建黄人
    public People createYellow(){
        return  new YellowPeople();
    }
    //创建白人
    public People createWhite(){
        return  new WhitePeople();
    }
}

主类调用

public class TestDemo {
    public static void main(String[] args) {
        PeopleFactory peopleFactory = new PeopleFactory();
        People p1 = peopleFactory.createBlack();
        p1.run();
        p1.say();

        People p2 = peopleFactory.createWhite();
        p2.run();
        p2.say();

        People p3 = peopleFactory.createYellow();
        p3.run();
        p3.say();
    }
}

 运行看输出:

 

 此设计模式为最简单的简单工厂模式，解决不需要关系创建的过程，只需要简单调用即可。

 

抽象工厂模式

 

 

 创建发动机接口

public interface BaseEngine {
    void createEngine();
    void washEngine();
}

创建各品牌汽车发动机

奥迪牌

public class AudiEngine implements BaseEngine {
    public void createEngine() {
        System.out.println("制造奥迪发动机");
    }

    public void washEngine() {
        System.out.println("洗奥迪发动机");
    }
}

捷达牌

public class JettaEngine implements BaseEngine {
    public void createEngine() {
        System.out.println("制造捷达发动机");
    }

    public void washEngine() {
        System.out.println("洗捷达发动机");
    }
}

创建公共抽象工厂类

public abstract class AbstractCarFactory {
    public abstract BaseEngine createCar();
}

实现各个牌子的汽车工厂类

奥迪的工厂

public class AudiCarFactory  extends AbstractCarFactory {
    public BaseEngine createCar() {
        return new AudiEngine();
    }
}

捷达的工厂

public class JettaCarFactory extends AbstractCarFactory {
    public JettaEngine createCar() {
        return new JettaEngine();
    }
}

 

调用测试：

public class CarDemo {
    public static void main(String[] args) {
        AbstractCarFactory audiCarFactory  = new AudiCarFactory();
        BaseEngine audi = audiCarFactory.createCar();
        audi.createEngine();
        audi.washEngine();


        AbstractCarFactory jettaCarFactory  = new JettaCarFactory();
        BaseEngine jetta = jettaCarFactory.createCar();
        jetta.createEngine();
        jetta.washEngine();
    }
}

抽象工厂设计模式是简单工程设计模式的提升，使用该方法再扩展汽车品牌也无需更改原有的类代码，只需要添加对应的类和工厂即可

 

策略模式

 

 创建支付策略

public interface PayStrategy {
    //支付
    void pay();
}

创建各支付实现类

public class Alipay implements PayStrategy {
    public void pay() {
        System.out.println("使用支付宝");
    }
}

public class WechatPay implements PayStrategy{
    public void pay() {
        System.out.println("使用微信支付");
    }
}

创建上下文类

public class Context {
    private PayStrategy payStrategy;
    public Context(PayStrategy payStrategy){
        this.payStrategy  = payStrategy;
    }
    public void pay(){
        this.payStrategy.pay();
    }
}

 

 

 调用

public class TestDemo {
    public static void main(String[] args) {
        Context ali =new Context(new Alipay());
        ali.pay();
        Context wechat =new Context(new WechatPay());
        wechat.pay();
    }
}

结果