面向对象的好处:
通过封装、继承、多态把程序的耦合度降低;
用设计模式使得程序更加的灵活,容易修改,并且易于复用.
- 封装
把客观事物抽象成一个类,只能通过类提供的方法操作内部数据,细节不可见.
- 继承
子类拥有父类的方法和字段.
- 多态
一般来说多态是通过接口和抽象类来实现的，多个子类对接口、抽象类方法的不同实现，使得在使用接口和抽象类时有了不同的实现方式。(下面的OperationFactory就是最好的例子)
面向对象设计五大原则
单一职责原则(Single-Resposibility Principle)。”对一个类而言，应该仅有一个引起它变化的原因。”
开放封闭原则(Open-Closed principle)。”软件实体应该是可以扩展的，但是不可修改。”
Liskov替换原则(Liskov-Substituion Principle)。”子类型必须能够替换掉它们的基类型。”
依赖倒置原则(Dependecy-Inversion Principle)。”抽象不应依赖于细节，细节应该依赖于抽象。”
接口隔离原则(Interface-Segregation Principle)。”多个专用接口优于一个单一的通用接口。”
1
2
3
4
5
6
7
8
9
10
| package simple.factory;
public abstract class Operation {
public abstract double getResult(double a, double b);
}
|
1
2
3
4
5
6
7
8
9
10
11
12
| package simple.factory;
public class Add extends Operation {
public double getResult(double a, double b) {
return a + b;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
| package simple.factory;
public class Division extends Operation {
public double getResult(double a, double b) {
if (b == 0) throw new IllegalArgumentException("divide 0.");
return a / b;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| package simple.factory;
public class OperationFactory {
public static Operation createOperate(char opt) {
Operation operation = null;
switch (opt) {
case '+':
operation = new Add();
break;
case '/':
operation = new Division();
break;
default:
throw new IllegalArgumentException("can't calculate");
}
return operation;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| package simple.factory;
public class Main {
public static void main(String[] args) {
Operation operation = OperationFactory.createOperate('+');
double res = operation.getResult(1.2, 3.8);
System.out.println(res);
}
}
|
编程是一门技术,更是一门艺术.
