1.开闭原则:用抽象构建架构,用实现扩展细节
2.依赖倒置原则:高层模块不应该依赖于底层模块,二者都应该依赖其抽象
3.单一职责原则:单个接口或类不应该有多个职责,应该尽可能的划分职责,通过组合的方式,完成更为复杂的业务
4.接口隔离原则:一个接口不要包含过多的职责,应合理划分,跟单一职责原则相辅相成
5.迪米特法则:也就最少知道原则,一个对象尽量让其它对象保持最少的了解
6.里氏替换原则:在引用父类的地方,都可以替换为其子类。从而可以实现子类间的动态切换。换句话说就是要有面向接口的编程思维。结合“开闭原则”,完美
7.合成复用原则:多用组合,少用继承
第一章.简单工厂模式
1.在代码中命名需要规范,命名规范可以使其他开发人员阅读自己的代码时能够更好的理解代码,也方便自己在开发时理解自己的代码。
2.将业务逻辑与界面逻辑分离,降低业务与界面的耦合。
3.使用面向对象的三大特性对代码进行优化:
封装:将业务逻辑和界面逻辑单独封装,避免在修改代码是造成不必要的修改。
继承:将运算类抽象成一个抽象类,具体的运算类继承于该抽象类,实现代码复用。
多态:用父类引用指向子类对象,在调用时调用子类的具体方法实现多态。
抽象的运算符类
@Data
@AllArgsConstructor
@NoArgsConstructor
public abstract class Operator {
protected double numberA;
protected double numberB;
public abstract double getResult();
}
具体的运算符类
//加法运算类
public class Addition extends Operator {
@Override
public double getResult() {
return numberA + numberB;
}
}
//除法运算类
public class Division extends Operator {
@Override
public double getResult() {
return numberA / numberB;
}
}
//乘法运算类
public class Multiplication extends Operator{
@Override
public double getResult() {
return numberA * numberB;
}
}
//减法运算类
public class Subtraction extends Operator{
@Override
public double getResult() {
return numberA - numberB;
}
}
工厂类
public class OperatorFactory {
public static Operator getOperator(String operatorChar){
Operator operator = null;
switch (operatorChar.charAt(0)) {
case '+':
operator = new Addition();
break;
case '-':
operator = new Subtraction();
break;
case '*':
operator = new Multiplication();
break;
case '/':
operator = new Division();
break;
}
return operator;
}
}
主类
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第一个操作数");
double numberA = scanner.nextDouble();
scanner.nextLine();
System.out.println("请输入运算符");
String operatorChar = scanner.nextLine();
System.out.println("请输入第二个操作数");
double numberB = scanner.nextDouble();
Operator operator = OperatorFactory.getOperator(operatorChar);
operator.setNumberA(numberA);
operator.setNumberB(numberB);
System.out.println(operator.getResult());
}
}
这个工厂类还可以使用反射进行优化
反射优化后的工厂类
public class OperatorFactory {
private static Map<String, String> book;
static {
book=new HashMap<>();
book.put("+", "com.DesignPatterns.simpleFactory.proxy.Addition");
book.put("-", "com.DesignPatterns.simpleFactory.proxy.Subtraction");
book.put("*", "com.DesignPatterns.simpleFactory.proxy.Multiplication");
book.put("/", "com.DesignPatterns.simpleFactory.proxy.Division");
}
public static Operator getOperator(String operatorChar) {
Operator operator = null;
try {
Class<?> operatorClass = Class.forName(book.get(operatorChar));
operator = (Operator) operatorClass.newInstance();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return operator;
}
}