设计模式觉醒系列(01)设计模式的基石 | 六大原则的核心是什么?

package lading.java.designpattern.srp.baddeom;
/**
 * 订单类，负责了订单计算和订单报告生产两个功能
 * 违反单一职责原则
 * @author lading
 */
public class Order {
    private double price;
    private String customerType;
    public Order(double price, String customerType) {
        this.price = price;
        this.customerType = customerType;
    }
    /**
     * 功能1：根据客户类型，计算订单的总价
     *
     * @return
     */
    public double calculateTotal() {
        if (customerType.equals("vip")) {
            return price * 0.8;
        } else if (customerType.equals("normal")) {
            return price;
        }
        return price;
    }
    /**
     * 功能2：生成订单报告打印
     *
     * @return
     */
    public String generateReport() {
        return "原价：" + price + ",用户类型" + customerType + ",订单最终总价为：" + calculateTotal();
    }
}

package lading.java.designpattern.srp.nicedemo;
/**
 * 订单类，只负责订单最终金额计算
 * @author lading
 */
public class Order {
    private double price;
    private String customerType;
    public Order(double price, String customerType) {
        this.price = price;
        this.customerType = customerType;
    }
    public double getPrice() {
        return price;
    }
    public String getCustomerType() {
        return customerType;
    }
    /**
     * 功能1：根据客户类型，计算订单的总价
     *
     * @return
     */
    public double calculateTotal() {
        if (customerType.equals("vip")) {
            return price * 0.8;
        } else if (customerType.equals("normal")) {
            return price;
        }
        return price;
    }
}
package lading.java.designpattern.srp.nicedemo;
/**
 * 订单报告
 */
public class OrderReport {
    private Order order;
    public OrderReport(Order order) {
        this.order = order;
    }
    /**
     * 功能2：生成订单报告打印
     *
     * @return
     */
    public String generateReport() {
        return "原价：" + order.getPrice() + ",用户类型" + order.getCustomerType() + ",订单最终总价为：" + order.calculateTotal();
    }
}

package lading.java.designpattern.ocp.baddemo;
public class Order {
    private String customerType;//客户类型
    private double totalPrice;//订单总价
    public Order(String customerType, double totalPrice){
        this.customerType = customerType;
        this.totalPrice = totalPrice;
    }
    public String getCustomerType() {
        return customerType;
    }
    public double getTotalPrice() {
        return totalPrice;
    }
}

package lading.java.designpattern.ocp.baddemo;
/**
 * 订单计费
 */
public class OrderCalculator {
    public double calculate(Order order){
        //VIP客户 8 折
        if("VIP客户".equals(order.getCustomerType())){
            return order.getTotalPrice() * 0.8;
        }
        //节假日 85 折
        if("节假日".equals(order.getCustomerType())){
            return order.getTotalPrice() * 0.85;
        }
        //普通客户 无折扣
        return order.getTotalPrice();
    }
}
package lading.java.designpattern.ocp.baddemo;
/**
 * 计费终端
 */
public class CounterDemo {
    public static void main(String[] args) {
        //订单总价
        double totalPrice = 1000;
        Order orderVip = new Order("VIP客户", totalPrice);
        Order orderHoliday = new Order("节假日", totalPrice);
        Order orderNormalCus = new Order("普通客户", totalPrice);
        OrderCalculator orderCalculator = new OrderCalculator();
        System.out.println("订单总价："+ totalPrice);
        System.out.println(orderVip.getCustomerType() +" : " + orderCalculator.calculate(orderVip));
        System.out.println(orderVip.getCustomerType() +" : " + orderCalculator.calculate(orderHoliday));
        System.out.println(orderVip.getCustomerType() +" : " + orderCalculator.calculate(orderNormalCus));
    }
}

package lading.java.designpattern.ocp.nicedemo;
/**
 * 价格策略
 * 1. 定义一个接口，里面定义一个方法，方法入参是订单的价格，返回值是订单的最终价格
 */
public interface IPriceStrategy {
    double calculateTotal(double price);
}

package lading.java.designpattern.ocp.nicedemo;
/**
 * 会员价格策略
 * 8折
 */
public class VipPriceStrategy implements IPriceStrategy {
    @Override
    public double calculateTotal(double price) {
        return price * 0.8;
    }
}
package lading.java.designpattern.ocp.nicedemo;
/**
 * 普通客户收费策略-无折扣
 */
public class NormalCusPriceStrategy implements IPriceStrategy
{
    @Override
    public double calculateTotal(double price) {
        return price;
    }
}
package lading.java.designpattern.ocp.nicedemo;
/**
 * 节假日价格策略
 * 85折
 */
public class HolidayPriceStrategy implements IPriceStrategy{
    @Override
    public double calculateTotal(double price) {
        return price * 0.85;
    }
}
// 如要要新增收费规则或者促销策略，继续新增实现IPriceStrategy类即可

package lading.java.designpattern.ocp.nicedemo;
public class Order {
    private double price;
    private IPriceStrategy priceStrategy;
    public Order(double price, IPriceStrategy priceStrategy) {
        this.price = price;
        this.priceStrategy = priceStrategy;
    }
    public double getPrice() {
        return price;
    }
    public double getTotal(){
        return priceStrategy.calculateTotal(price);
    }
}

package lading.java.designpattern.ocp.nicedemo;
public class CounterDemo {
    public static void main(String[] args) {
        //订单总价
        double price = 1000;
        System.out.println("订单总价："+ price);
        Order vipOrder = new Order(price, new VipPriceStrategy());
        Order normalOrder = new Order(price, new NormalCusPriceStrategy());
        Order holidayOrder = new Order(price, new HolidayPriceStrategy());
        System.out.println("VIP客户 total price: " + vipOrder.getTotal());
        System.out.println("普通客户 total price: " + normalOrder.getTotal());
        System.out.println("节假日 total price: " + holidayOrder.getTotal());
    }
}