设计模式简单代码示例

设计模式

简单工厂模式

public interface People {
    void speak();
}

public class American implements People {
    @Override
    public void speak() {
        System.out.println("American");
    }
}
public class Chinese implements People {
    @Override
    public void speak() {
        System.out.println("Chinese");
    }
}
public class French implements People {
    @Override
    public void speak() {
        System.out.println("Franch");
    }
}

public class PeopleFactory {
    public static People createPeople(Locale locale){
        People people = null;
        switch(locale.getCountry()){
            case "CN":
                people = new Chinese();
                break;
            case "US":
                people = new American();
                break;
            case "FR":
                people = new French();
                break;
        }
        return people;
    }

    public static void main(String[] args){
        People people1 = PeopleFactory.createPeople(Locale.CHINA);
        People people2 = PeopleFactory.createPeople(Locale.FRANCE);
        People people3 = PeopleFactory.createPeople(Locale.US);
        people1.speak();
        people2.speak();
        people3.speak();
    }
}

输出：
Chinese
Franch
American

• 优点：工厂封装对象的生产，调用方不用关心所需对象的来源
• 缺点：违反开闭原则，每次新增对象都需要修改工厂内部方法

策略模式

public interface PriceActivityStrategy {
    void sale();
}

public class PriceReduceStrategy implements PriceActivityStrategy {
    @Override
    public void sale() {
        System.out.println("This is a pricereduceStrategy!");
    }
}
public class DiscountStrategy implements PriceActivityStrategy {
    @Override
    public void sale() {
        System.out.println("This is a discountStrategy!");
    }
}

public class ShopSaleContext {

    public static Map<String, PriceActivityStrategy> map = new HashMap<>();

    public static void registPriceStrategy(PriceActivityStrategy priceActivityStrategy) {
        map.put(priceActivityStrategy.getClass().getSimpleName(), priceActivityStrategy);
    }

    public static void sale(String saleTypeName) {
        map.get(saleTypeName).sale();
    }

    public static void main(String[] args) {
        PriceActivityStrategy discountStrategy = new DiscountStrategy();
        PriceActivityStrategy priceReduceStrategy = new PriceReduceStrategy();
        ShopSaleContext.registPriceStrategy(discountStrategy);
        ShopSaleContext.registPriceStrategy(priceReduceStrategy);
        ShopSaleContext.sale(DiscountStrategy.class.getSimpleName());
        ShopSaleContext.sale(PriceReduceStrategy.class.getSimpleName());
    }
}

输出
This is a discountStrategy!
This is a pricereduceStrategy!

• 优点：增加了可扩展性，代码更加灵活
• 缺点：随着策略的增多，调用方需要关注的策略也会越来越多

代理模式

public interface Product {
    void process();
}

public class ProductA implements Product {
    @Override
    public void process() {
        System.out.println("this is a productA");
    }
}

public class ProxyA implements Product {

    private Product product;

    public ProxyA(Product product) {
        this.product = product;
    }

    @Override
    public void process() {
        product.process();
    }

    public static void main(String[] args){
        ProxyA proxy = new ProxyA(new ProductA());
        proxy.process();
    }
}

• 优点：代理与被代理对象之间分离，起到解耦作用，也保护了被代理对象不暴露
• 缺点：增加了系统设计的复杂性