设计模式:七大设计原则
设计模式是为了让程序具有更好的
代码重用性(相同功能的代码,不用多次编写)
可读性(编程规范性,便于其他程序员的阅读和理解)
可扩展性(当需要增加新的功能时,非常的方便,称为可维护)
可靠性(当我们增加新的功能后,对原来的功能没有影响)
使程序呈现高内聚,低耦合的特性。
一、单一职责
1、基本介绍
在Java中,对一个类来说,一个类应该只负责一项职责。如类A负责两个不同职责:职责1,职责2。当职责1需求变更而改变A时,可能造成职责2执行错误,所以需要将类A的粒度分解为A1,A2
2、注意事项和细节
降低类的复杂度,一个类只负责一项职责。
提高类的可读性,可维护性。
降低变更引起的风险。
通常情况下,我们应当遵守单一职责原则(一个类只负责一项职责)。只有在逻辑足够简单,才可以在代码级违反单一职责原则;只有类中方法数量足够少,才可以在方法级别保持单一原则。(可参照代码Demo3)
3、代码实现案例
(1)Demo1(违反了单一职责原则)
package com.dashu.principle.single_responsibility;
public class SinglenessDemo {
public static void main(String[] args) {
Vehicle vehicle = new Vehicle();
vehicle.run("汽车");
vehicle.run("飞机");
vehicle.run("轮船");
}
}
/**
* 问题:
* 在该Demo中,类Vehicle违反了单一职责原则。包含了同时在三中场景运行的交通工具(水路空);同时汽车和轮船不应该在公路上运行
* <p>
* 解决:
* 遵守单一职责原则。根据交通工具运行场景不同,分解成不同的类。
*/
/**
* 交通工具
*/
class Vehicle {
public void run(String vehicle) {
System.out.println(vehicle + "在公路上运行。。。");
}
}
(2)Demo2(采用单一职责原则)
package com.dashu.principle.single_responsibility;
public class SinglenessDemo {
public static void main(String[] args) {
RoadVehicle roadVehicle = new RoadVehicle();
roadVehicle.run("汽车");
AirVehicle airVehicle = new AirVehicle();
airVehicle.run("飞机");
WaterVehicle waterVehicle = new WaterVehicle();
waterVehicle.run("轮船");
}
}
/**
* 问题:
* 在该Demo中,遵守了单一职责原则
* 但是这样做的改动很大(Demo逻辑很简单),即将类分解了,同时修改客户端
* <p>
* 解决:
* 直接修改Vehicle类,在方法层级上实现单一职责原则
*/
/**
* 道路交通工具
*/
class RoadVehicle {
public void run(String vehicle) {
System.out.println(vehicle + "在公路上运行。。。");
}
}
/**
* 天空交通工具
*/
class AirVehicle {
public void run(String vehicle) {
System.out.println(vehicle + "在天空中运行。。。");
}
}
/**
* 水上交通工具
*/
class WaterVehicle {
public void run(String vehicle) {
System.out.println(vehicle + "在水上运行。。。");
}
}
(3)Demo3(方法级别单一原则)
package com.dashu.principle.single_responsibility;
public class SinglenessDemo {
public static void main(String[] args) {
AllVehicle vehicle = new AllVehicle();
vehicle.run("汽车");
vehicle.runAir("飞机");
vehicle.runWater("轮船");
}
}
/**
* 这种修改方法没有对原来的类做出大的修改,只是增加方法
* 这里虽然没有在类这个级别上遵守单一职责原则,但是在方法上,任然遵守单一职责
*/
/**
* 交通工具
*/
class AllVehicle {
public void run(String vehicle) {
System.out.println(vehicle + "在公路上运行。。。");
}
public void runAir(String vehicle) {
System.out.println(vehicle + "在天空中运行。。。");
}
public void runWater(String vehicle) {
System.out.println(vehicle + "在水上运行。。。");
}
}
二、接口隔离原则
1、基本介绍
一个类对另外一个类的依赖应该建立在最小接口上。
2、案例
3、改进
4、代码实现案例
(1)Demo1(违反接口隔离原则)
/**
* 接口F
*/
public interface F {
public void a();
public void b();
public void c();
public void d();
public void e();
}
/**
* 接口F实现类A
*/
public class A implements F {
@Override
public void a() {
}
@Override
public void b() {
}
@Override
public void c() {
}
@Override
public void d() {
}
@Override
public void e() {
}
}
/**
* 接口F实现类B
*/
public class B implements F {
@Override
public void a() {
}
@Override
public void b() {
}
@Override
public void c() {
}
@Override
public void d() {
}
@Override
public void e() {
}
}
public class C {
/**
* 类C依赖接口F,使用了abc三个方法
*/
public void test() {
F f = new A();
f.a();
f.b();
f.c();
}
}
public class D {
/**
* 类D依赖接口F,使用了ade三个方法
*/
public void test() {
F f = new B();
f.a();
f.d();
f.e();
}
}
(2)Demo2(采用接口隔离原则)
/**
* 接口F
*/
public interface F {
public void a();
}
/**
* 接口G
*/
public interface G {
public void b();
public void c();
}
/**
* 接口H
*/
public interface H {
public void d();
public void e();
}
/**
* 接口F,G实现类A
*/
public class A implements F, G {
@Override
public void a() {
}
@Override
public void b() {
}
@Override
public void c() {
}
}
/**
* 接口F,H实现类B
*/
public class B implements F,H {
@Override
public void a() {
}
@Override
public void d() {
}
@Override
public void e() {
}
}
public class C {
/**
* 类C依赖接口F,G。使用了abc三个方法
*/
public void test() {
F f = new A();
G g = new A();
f.a();
g.b();
g.c();
}
}
public class D {
/**
* 类C依赖接口F,H。使用了ade三个方法
*/
public void test() {
F f = new B();
H h = new B();
f.a();
h.d();
h.e();
}
}
三、依赖倒转原则
1、基本介绍
依赖倒转原则是指:
- 高层模块不应该依赖低层模块,二者都应该依赖其抽象
- 抽象不应该依赖细节,细节应该依赖抽象
- 依赖倒转的中心思想就是
面接接口编程
设计理念:相对于细节的多变性,抽象的东西要稳定得多。以抽象为基础搭建的架构比以细节为基础的架构要稳定得多。在java
中,抽象指的就是接口和抽象类,细节就是具体的实现类
使用接口或抽象类的目的就是为了制定好规范,而不涉及任何具体的操作,把展现细节的任务交给他们的实现类去完成。
2、案例
3、改进
4、代码实现案例
(1)Demo1(违反依赖倒转原则)
public class QQ {
public void message(){
System.out.println("QQ消息");
}
}
public class WX {
public void message(){
System.out.println("微信消息");
}
}
public class Email {
public void message(){
System.out.println("Email消息");
}
}
public class User {
public void receive(QQ qq){
qq.message();
}
public void receive(WX wx){
wx.message();
}
public void receive(Email email){
email.message();
}
}
public class Client {
public static void main(String[] args) {
User user = new User();
user.receive(new QQ());
user.receive(new WX());
user.receive(new Email());
}
}
(2)Demo2(遵循依赖倒转原则)
public interface Message {
void message();
}
public class QQ implements Message{
@Override
public void message(){
System.out.println("QQ消息");
}
}
public class WX implements Message{
@Override
public void message(){
System.out.println("微信消息");
}
}
public class Email implements Message{
@Override
public void message(){
System.out.println("Email消息");
}
}
public class User {
public void receive(Message message) {
message.message();
}
}
public class Client {
public static void main(String[] args) {
User user = new User();
user.receive(new QQ());
user.receive(new WX());
user.receive(new Email());
}
}
5、比对
当我们想要接收短信类型的消息时,Demo1不仅需要添加一个短信类型的消息类(Note),同时也要再在User类中添加一个用于接收短信类型的方法
public void receive(Note note){
note.message();
}
而Demo2中,我们只需要添加一个短信类型的消息类(Note),并实现接口Message
6、依赖关系传递的三种方式
(1)通过接口传递依赖
public interface OpenAndClose {
void open(Tv tv);
}
public class OpenAndCloseImpl implements OpenAndClose{
@Override
public void open(Tv tv) {
tv.play();
}
}
public interface Tv {
void play();
}
public class ChangHong implements Tv{
@Override
public void play() {
System.out.println("长虹电视机,打开");
}
}
/**
* 通过接口传递依赖
*/
public class Client {
public static void main(String[] args) {
ChangHong changHong = new ChangHong();
OpenAndClose openAndClose = new OpenAndCloseImpl();
openAndClose.open(changHong);
}
}
(2)通过构造方法传递依赖
public interface OpenAndClose {
void open();
}
public class OpenAndCloseImpl implements OpenAndClose {
private Tv tv;
public OpenAndCloseImpl(Tv tv){
this.tv = tv;
}
@Override
public void open() {
tv.play();
}
}
public interface Tv {
void play();
}
public class ChangHong implements Tv {
@Override
public void play() {
System.out.println("长虹电视机,打开");
}
}
/**
* 通过构造方法传递依赖
*/
public class Client {
public static void main(String[] args) {
ChangHong changHong = new ChangHong();
OpenAndClose openAndClose = new OpenAndCloseImpl(changHong);
openAndClose.open();
}
}
(3)通过setter方法传递依赖
public interface OpenAndClose {
void open();
void setTv(Tv tv);
}
public class OpenAndCloseImpl implements OpenAndClose {
private Tv tv;
@Override
public void open() {
tv.play();
}
@Override
public void setTv(Tv tv) {
this.tv = tv;
}
}
public interface Tv {
void play();
}
public class ChangHong implements Tv {
@Override
public void play() {
System.out.println("长虹电视机,打开");
}
}
/**
* 通过setter方法传递依赖
*/
public class Client {
public static void main(String[] args) {
ChangHong changHong = new ChangHong();
OpenAndClose openAndClose = new OpenAndCloseImpl();
openAndClose.setTv(changHong);
openAndClose.open();
}
}
四、里氏替换原则
1、面向对象中继承性得思考和说明
- 继承包含这样得一层含义:父类中凡是已经实现好的方法,实际上是在设定规范和契约,虽然它不强制要求所有的子类必须遵循这些契约,但是如果子类对这些已经实现的方法任意修改,就会对整个继承体系造成破坏
- 继承在给程序设计带来便利的同时,也带来了弊端。比如使用继承会给程序带来侵入性,程序的可移植性降低,增加对象间的耦合性,如果一个类被其他类所继承,则当这个类需要修改时,必须考虑到所有的子类,并且父类修改后,所有涉及到子类的功能都有可能产生故障
2、里氏替换原则
- 里氏替换原则在1988年,由麻省理工学院的一位姓里的女士提出的
- 如果对每个类型为T1的对象o1,都有类型为T2的对象o2,使得T1定义的所有程序P在所有对象o1都代换成o2时,程序P的行为没有发生变化,那么类型T2是类型T1的子类型。
- 所有引用基类的地方必须透明地使用其子类的对象
- 在使用继承时,遵循里氏替换原则,在子类中尽量不要重写父类的方法
- 里氏替换原则告诉我们,继承实际上让两个类耦合性增强了,在适当的情况下,可以通过聚合、组合、依赖来解决问题
3、代码实现案例
(1)Demo1(违反里氏替换原则)
public class A {
public int func1(int x,int y){
return x-y;
}
}
public class B extends A{
@Override
public int func1(int x, int y){
return x-y;
}
}
public class Client {
public static void main(String[] args) {
A a = new A();
System.out.println(a.func1(10, 5));
A b = new B();
/**
* 这里本意是调用父类A的func1方法计算x与y的和,但是子类B重写了func1方法,导致结果为计算x与y的差。所以引起程序错误
*/
System.out.println(b.func1(10, 5));
}
}
(2)Demo2(遵循里氏替换原则)
public class Base {
}
public class A extends Base {
public int func1(int x, int y) {
return x + y;
}
}
public class B extends Base {
A a = new A();
public int func1(int x, int y) {
return x - y;
}
public int func2(int x, int y) {
return a.func1(x, y);
}
}
/**
* 类A和类B继承一个更加基础的类,如果类B想要使用类A的func1方法,则通过依赖A来使用func1方法。
*/、
public class Client {
public static void main(String[] args) {
A a = new A();
B b = new B();
System.out.println(a.func1(10, 5));
System.out.println(b.func1(10, 5));
System.out.println(b.func2(10, 5));
}
}
五、开闭原则
1、基本介绍
- 开闭原则是编程中最基础、最重要得设计原则
- 一个软件实体(类,接口、模块、函数)应该对扩展能力开发(对提供方),对修改关闭(对使用方),用抽象构建框架,用实现扩展细节
- 当软件需要变化时,尽量通过扩展软件实体的行为来实现变化,而不是通过修改已有的代码来实现变化
- 编程中遵循其他原则,以及使用设计模式的目的就是遵循开闭原则
2、代码实现案列
(1)Demo1(违反开闭原则)
/**
* 形状
*/
public class Shape {
int type;
}
/**
* 圆形
*/
public class Circle extends Shape{
Circle() {
super.type=2;
}
}
/**
* 三角形
*/
public class Triangle extends Shape{
Triangle() {
super.type=3;
}
}
/**
* 矩形
*/
public class Rectangle extends Shape{
Rectangle() {
super.type=1;
}
}
/**
* 绘图
*/
public class GraphicEditor {
public void drawShape(Shape shape) {
if (shape.type == 1) {
drawRectangle(shape);
} else if (shape.type == 2) {
drawCircle(shape);
} else if (shape.type == 3) {
drawTriangle(shape);
}
}
private void drawTriangle(Shape shape) {
System.out.println("绘制三角形");
}
private void drawCircle(Shape shape) {
System.out.println("绘制圆形");
}
private void drawRectangle(Shape shape) {
System.out.println("绘制矩形");
}
}
/**
* 该方式唯一的有点就是简单,容易理解。但是严重违反了开闭原则
*
* 当我们添加一个五角形
* 1、添加一个五角星类
* 2、在“GraphicEditor”添加一个绘画五角星的方法,
* 3、在方法“drawShape”中添加一个条件判断
*
*/
public class Client {
public static void main(String[] args) {
GraphicEditor graphicEditor = new GraphicEditor();
graphicEditor.drawShape(new Rectangle());
graphicEditor.drawShape(new Circle());
graphicEditor.drawShape(new Triangle());
}
}
(2)Demo2(遵循开闭原则)
/**
* 图形接口
*/
public interface Shape {
void draw();
}
/**
* 圆形
*/
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("绘画圆形");
}
}
/**
* 矩形
*/
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("绘画矩形");
}
}
/**
* 三角形
*/
public class Triangle implements Shape {
@Override
public void draw() {
System.out.println("绘画三角形");
}
}
/**
* 绘图
*/
public class GraphicEditor {
public void drawShape(Shape shape) {
shape.draw();
}
}
/**
* 该方式遵循了开闭原则
*
* 当我们添加一个五角形,只需要添加一个五角星类就可以了
*
*
*/
public class Client {
public static void main(String[] args) {
GraphicEditor graphicEditor = new GraphicEditor();
graphicEditor.drawShape(new Rectangle());
graphicEditor.drawShape(new Circle());
graphicEditor.drawShape(new Triangle());
}
}
六、迪米特法则
1、基本介绍
- 一个对象应该对其他对象保持最少的了解
- 类与类的关系越密切,耦合度越大
- 迪米特法则又叫最少知道原则,即一个类对自己依赖的类知道的越少越好。对于一个被依赖的类不管多么复杂,都尽量将逻辑封装在类的内部。对外除了提供的public方法,不对外泄露任何信息
- 迪米特法则还有一个更简单的定义:只与直接的朋友通信
- 直接的朋友:每个对象都会与其他对象有耦合关系,只要两个对象之间有耦合关系,我们就说这两个对象之间是朋友关系。耦合的方式很多,依赖、关联、组合、聚合等。我们称出现成员变量、方法参数、方法返回值中的类为直接朋友,而出现在局部变量中的类不是直接朋友。也就是说,陌生的类最好不要以局部变量的形式出现在类的内部。
2、代码实现案列
(1)Demo1(违反迪米特法则)
/**
* 学校员工类
*/
public class CollegeEmployee {
private String id;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
import java.util.ArrayList;
import java.util.List;
/**
* 学校员工的管理类
*/
public class CollegeManager {
public List<CollegeEmployee> getEmployeeList() {
ArrayList<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
for (int i = 0; i < 10;i++) {
CollegeEmployee collegeEmployee = new CollegeEmployee();
collegeEmployee.setId("学院员工id="+i);
list.add(collegeEmployee);
}
return list;
}
}
/**
* 学校总部员工类
*/
public class Employee {
private String id;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
/**
* 学校管理类
*/
public class SchoolManager {
public List<Employee> getEmployeeList() {
ArrayList<Employee> list = new ArrayList<Employee>();
for (int i = 0; i < 5; i++) {
Employee employee = new Employee();
employee.setId("学校总部员工id=" + i);
list.add(employee);
}
return list;
}
void printEmployee(CollegeManager c) {
List<CollegeEmployee> employeeList = c.getEmployeeList();
System.out.println("学院员工");
for (CollegeEmployee employee : employeeList) {
System.out.println(employee.getId());
}
System.out.println("-----------------------");
List<Employee> employeeList1 = getEmployeeList();
System.out.println("学院总部员工");
for (Employee employee : employeeList1) {
System.out.println(employee.getId());
}
}
}
/**
* CollegeEmployee不是SchoolManager的直接朋友
* <p>
* 类SchoolManager的方法printEmployee使用了一个陌生类CollegeEmployee,违反了迪米特法则。
*/
public class Client {
public static void main(String[] args) {
SchoolManager schoolManager = new SchoolManager();
schoolManager.printEmployee(new CollegeManager());
}
}
(2)Demo2(遵循迪米特法则)
/**
* 学校员工类
*/
public class CollegeEmployee {
private String id;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
import java.util.ArrayList;
import java.util.List;
/**
* 学校员工的管理类
*/
public class CollegeManager {
public List<CollegeEmployee> getEmployeeList() {
ArrayList<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
for (int i = 0; i < 10; i++) {
CollegeEmployee collegeEmployee = new CollegeEmployee();
collegeEmployee.setId("学院员工id=" + i);
list.add(collegeEmployee);
}
return list;
}
void printEmployee() {
List<CollegeEmployee> employeeList = getEmployeeList();
System.out.println("学院员工");
for (CollegeEmployee employee : employeeList) {
System.out.println(employee.getId());
}
}
}
/**
* 学校总部员工类
*/
public class Employee {
private String id;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
import java.util.ArrayList;
import java.util.List;
/**
* 学校管理类
*/
public class SchoolManager {
public List<Employee> getEmployeeList() {
ArrayList<Employee> list = new ArrayList<Employee>();
for (int i = 0; i < 5; i++) {
Employee employee = new Employee();
employee.setId("学校总部员工id=" + i);
list.add(employee);
}
return list;
}
void printEmployee(CollegeManager c) {
c.printEmployee();
System.out.println("-----------------------");
List<Employee> employeeList1 = getEmployeeList();
System.out.println("学院总部员工");
for (Employee employee : employeeList1) {
System.out.println(employee.getId());
}
}
}
/**
* 遵循迪米特法则,只与直接朋友通信
*/
public class Client {
public static void main(String[] args) {
SchoolManager schoolManager = new SchoolManager();
schoolManager.printEmployee(new CollegeManager());
}
}
七、合成复用原则
1、基本介绍
合成复用原则(Composite Reuse Principle,CRP)又叫组合/聚合复用原则(Composition/Aggregate Reuse Principle,CARP)。它要求在软件复用时,要尽量先使用组合或者聚合等关联关系来实现,其次才考虑使用继承关系来实现。
如果要使用继承关系,则必须严格遵循里氏替换原则。合成复用原则同里氏替换原则相辅相成的,两者都是开闭原则的具体实现规范。
合成复用原则的重要性
通常类的复用分为继承复用和合成复用两种,
继承复用虽然有简单和易实现的优点,但它也存在以下缺点。
继承复用破坏了类的封装性。因为继承会将父类的实现细节暴露给子类,父类对子类是透明的,所以这种复用又称为“白箱”复用。
子类与父类的耦合度高。父类的实现的任何改变都会导致子类的实现发生变化,这不利于类的扩展与维护。
它限制了复用的灵活性。从父类继承而来的实现是静态的,在编译时已经定义,所以在运行时不可能发生变化。
采用组合或聚合复用时,可以将已有对象纳入新对象中,使之成为新对象的一部分,新对象可以调用已有对象的功能,它有以下优点。
它维持了类的封装性。因为成分对象的内部细节是新对象看不见的,所以这种复用又称为“黑箱”复用。
新旧类之间的耦合度低。这种复用所需的依赖较少,新对象存取成分对象的唯一方法是通过成分对象的接口。
3复用的灵活性高。这种复用可以在运行时动态进行,新对象可以动态地引用与成分对象类型相同的对象。