设计模式---六大设计原则
2023-03-31 10:46:28 时间
六大设计原则
- 单一职责原则
- 接口隔离原则
- 开闭原则
- 依赖倒置原则
- 里氏代换原则
- 迪米特法则
单一职责原则
我们分别看两个案例,一个是遵守单一职责原则,另一个是违背。
违背的案例
public class Computer {
void calc() {
System.out.println("计算数据"); // 基本功能,么得问题
}
void display() {
System.out.println("显示计算结果"); // 现在的计算机确实有显示功能
}
void run() {
System.out.println("以百米冲刺的速度奔跑"); // 这什么玩意儿?这个类到底是干嘛的
}
}
遵守的案例
public class Computer {
void calc() {
System.out.println("计算数据"); // 基本功能,么得问题
}
void display() {
System.out.println("显示计算结果"); // 现在的计算机确实有显示功能
}
}
public class Humam {
void run() {
System.out.println("以百米冲刺的速度奔跑"); // 人会跑不是很正常嘛
}
}
单一职责的核心:限制类的职责范围,杜绝功能复杂的类的产生。
接口隔离原则也是同样的思想,就不废话了。
开闭原则
public class Style {
public void set() {
System.out.println("设置圆角");
}
}
当需要改变样式的时候。
违背的案例
class Style {
public void set() {
// System.out.println("设置圆角");
System.out.println("设置order");
/*
直接修改原有的方法上做修改
*/
}
}
遵守的案例
// 将原有的Style类抽象成接口,这样对客户端也没有影响,
// 因为用的还是Style并没有改名,只是原来是个类,现在变成了接口
interface Style {
void set();
}
class Radius implements Style {
public void set() {
System.out.println("设置圆角");
}
}
class Order implements Style { // 不对原有的实现类修改,而是增加一个新个实现类
public void set() {
System.out.println("设置order");
}
}
开闭原则的核心:对修改关闭,对拓展开放。
不在原有的代码上增减新的代码,而是添加新的模块。核心要点是面向接口编程。
依赖倒置原则
违背的案例
class Radius {
public void set() {
System.out.println("设置圆角");
}
}
class Order {
public void set() {
System.out.println("设置order");
}
}
class Client {
public void setRadius(Radius radius) {
adius.set();
}
public void setOrder(Order order) {
rder.set();
}
}
遵守的案例
interface Style {
void set();
}
class Radius implements Style {
public void set() {
System.out.println("设置圆角");
}
}
class Order implements Style {
public void set() {
System.out.println("设置order");
}
}
class Client {
public void setStyle(Style style) {
style.set();
}
}
依赖倒置的核心:从依赖具体类变为依赖抽象或接口。面向接口编程。
里氏代换原则
违背的案例
class CacheCard {
protected int balance;
public void peek() {
System.out.println("余额:" + balance);
}
public void deposit(int num) {
balance += num;
System.out.println("存款金额:" + num);
peek();
}
public void withdraw(int num) {
balance += num;
System.out.println("取款金额:" + num);
peek();
}
}
class CreditCard extends CacheCard {
public void deposit(int num) { // 信用卡并没有存钱这个功能,不应该重写
balance += num;
System.out.println("还款金额:" + num);
peek();
}
public void withdraw(int num) { // 也没有取款的功能,不应该重写
balance += num;
System.out.println("支付金额:" + num);
peek();
}
}
遵守的案例
interface BankCard {
int balance;
default void peek() {
System.out.println("余额:" + balance);
}
void positive(int num);
void negative(int num);
}
class CacheCard implements BankCard {
public void positive(int num) {
balance += num;
System.out.println("存款金额:" + num);
peek();
}
public void negative(int num) {
balance -= num;
System.out.println("取款金额:" + num);
peek();
}
}
class CreditCard implements BankCard {
public void positive(int num) {
balance += num;
System.out.println("还款金额:" + num);
peek();
}
public void negative(int num) {
balance -= num;
System.out.println("支付金额:" + num);
peek();
}
}
里氏代换原则的核心思想:使用父类能够实现的功能,使用其子类依旧能实现。限制方法重写的范围,从业务的角度出发我们只可以重写父类中被允许重写的方法,而不是从Java语法角度(那能重写的多了去了)出发重写方法。
迪米特法则
违背的案例
class Student {
String name;
String sex;
int score;
}
class Teacher {
String name;
String sex;
Student[] students;
int max() {
int res = 0;
for (student : students) {
res = Math.max(res, student.score);
}
return res;
}
int min() {
int res = 0;
for (student : students) {
res = Math.min(res, student.score);
}
return res;
}
}
class President {
String name;
String sex;
Student[] students; // 不应该依赖Student类,而应该依赖Teacher类,将所有对于students的操作封装到Teacher类中
Teacher[] teachers;
int avg() { // 这个方法应该在Teacher中定义
int res = 0;
for (student : students) {
res += student.score;
}
return res / students.length;
}
String[] teachersName() { // 获取所有的老师名字
String[] res = new String[teachers.length];
for (int i = 0; i < res.length; i ++) {
res[i] = teachers[i].name;
}
return res;
}
}
遵守的案例
class Student {
String name;
String sex;
int score;
}
class Teacher {
String name;
String sex;
Student[] students;
int max() {
int res = 0;
for (student : students) {
res = Math.max(res, student.score);
}
return res;
}
int min() {
int res = 0;
for (student : students) {
res = Math.min(res, student.score);
}
return res;
}
int avg() { // 这个方法应该在Teacher中定义
int res = 0;
for (student : students) {
res += student.score;
}
return res / students.length;
}
}
class President {
String name;
String sex;
Teacher[] teacher; // 依赖Teacher类
int[] avgs() { // 获取每个班级的平均分
int[] res = new int[teacher.length];
for (int i = 0; i < res.length; i ++) {
res[i] = teacher[i].avg(); // 实际计算调用Teacher内的计算
}
return res;
}
String[] teachersName() { // 获取所有的老师名字
String[] res = new String[teachers.length];
for (int i = 0; i < res.length; i ++) {
res[i] = teachers[i].name;
}
return res;
}
}
迪米特法则的核心思想:最少知道,最少依赖。类的定义应当把对于其他类的依赖降到最低。
遵守迪米特法则的同时也基本满足了单一职责原则。
相关文章
- 分享自学编程中经常遇到的问题和一些自学方法
- dart系列之:时间你慢点走,我要在dart中抓住你
- 记一次ThinkPHP框架错误解决处理!
- Kubernetes集群多租户资源管理
- Kubernetes中自定义Controller
- 复杂JSON结构创建语法
- 央视频“数字雪花”互动项目上线,为全民打造冰雪体育盛宴
- 2021-22 世界质量报告(World Quality Report)
- Go WebSocket开发与测试实践【gorilla/websocket】
- 苹果为什么不搞中台,也不搞大BU?
- 为数字经济筑基,联想启天商用平板斩获中国企业级IT年度推荐产品奖
- Java Collectors API实践
- GitHub Actions 还能这么玩?
- 大厂员工“35岁危机”背后真相:校招生“真的很便宜”
- 下单延迟10s撤单性能测试
- 算法推荐监管落地 用户可以向平台说“不”了吗
- 单元测试再出发
- 2020_883《C程序设计》
- 2021年Web 3开发者报告:以太坊、波卡(Polkadot)、Cosmos、Solana 以及比特币是最大
- Java&Go三种HTTP客户端性能测试