2020 11.20曾宇欣
设计模式的六大原则
-
开闭原则：
- 开闭原则的意思是
对扩展开放，对修改关闭。在程序需要进行扩展的时候，不能去修改原有的代码，简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点
- 开闭原则的意思是
-
里氏替换原则：
-
里氏替换原则主要阐述了有关继承的一些原则，也就是什么时候应该使用继承，什么时候不应该使用继承，以及其中蕴含的原理。里氏替换原是继承复用的基础，它反映了基类与子类之间的关系，是对开闭原则的补充，是对实现抽象化的具体步骤的规范
-
里氏替换原则的作用
- 里氏替换原则是实现开闭原则的重要方式之一。
- 它克服了继承中重写父类造成的可复用性变差的缺点。
- 它是动作正确性的保证。即类的扩展不会给已有的系统引入新的错误，降低了代码出错的可能性。
- 加强程序的健壮性，同时变更时可以做到非常好的兼容性，提高程序的维护性、可扩展性，降低需求变更时引入的风险。
-
里氏替换原则的实现方法
-
里氏替换原则通俗来讲就是：子类可以扩展父类的功能，但不能改变父类原有的功能。
-
子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法
-
子类中可以增加自己特有的方法
-
当子类的方法重载父类的方法时，方法的前置条件（即方法的输入参数）要比父类的方法更宽松
-
当子类的方法实现父类的方法时（重写/重载或实现抽象方法），方法的后置条件（即方法的的输出/返回值）要比父类的方法更严格或相等
//举例里氏替换原则在“企鹅不是鸟”实例中的应用 //鸟类
class Bird {
int flySpeed;
public void setSpeed(int speed){
flySpeed = speed;
}
public int getFlyTime(int distance){
return (distance / flyspeed);
}
}
//燕子类
class Swallow extends Bird{}
//企鹅类
class Penguin extends Bird{
public void setSpeed(int speed)
{
flySpeed=0;
}
}
public static void mian(String[] args){
Bird b1 = new Swallow();
Bird b2 = new Penguin();
b1.setSpeed(120);
b2.setSpeed(120);
System.out.println("如果飞行300公里：");
System.out.println("燕子将飞行"+bird1.getFlyTime(300)+"小时.");
System.out.println("企鹅将飞行"+bird2.getFlyTime(300)+"小时。");
}此程序会报错，企鹅重写了鸟类的setSpeed方法，这违背了里氏替换原则。正确的做法是取消企鹅的继承关系，定义鸟类和企鹅更一般的父类，比如动物类，他们都具有奔跑的能力。
-
-
-
依赖倒置原则
依赖倒置原则的原始定义为：高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。其核心思想是：要面向接口编程，不要面向实现编程。
-
依赖倒置原则的作用
- 依赖倒置原则可以降低类间的耦合性。
- 依赖倒置原则可以提高系统的稳定性。
- 依赖倒置原则可以减少并行开发引起的风险。
- 依赖倒置原则可以提高代码的可读性和可维护性。
-
依赖倒置原则的实现方法
依赖倒置原则的目的是通过要面向接口的编程来降低类间的耦合性。
1.每个类尽量提供接口或抽象类，或者两者都具备。
2.变量的声明类型尽量是接口或者抽象类。
3.任何类都不应该从具体类派生。
4.使用继承时尽量遵循里氏替换原则。
//依赖倒置原则在“顾客购物程序”中的应用。 public class DIPtest{
public static void main(Stirng[] args){
Customer c = new Customer();
c.shop(new TaoBao());
c.shop(new JingDong());
}
}
interface Shop{
public String sell();
}
class TaoBao implements Shop{
public sell(){
return "a,b,c";
}
}
class JingDong implements Shop{
public String sell(){
return "d,e,f";
}
}
class Customer{
public void shopping(Shop shop){
System.out.print(shop.sell());
}
}
-
-
单一职责原则
单一职责原则规定一个类应该有且仅有一个引起它变化的原因，否则类应该被拆分。
-
接口隔离原则
要为各个类建立它们需要的专用接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。
接口隔离原则的实现方法
在具体应用接口隔离原则时，应该根据以下几个规则来衡量。
-
接口尽量小，但是要有限度。一个接口只服务于一个子模块或业务逻辑。
-
为依赖接口的类定制服务。只提供调用者需要的方法，屏蔽不需要的方法。
-
了解环境，拒绝盲从。每个项目或产品都有选定的环境因素，环境不同，接口拆分的标准就不同深入了解业务逻辑。
-
提高内聚，减少对外交互。使接口用最少的方法去完成最多的事情。
// 学生成绩管理系统 //学生成绩管理程序一般包含插入成绩、删除成绩、修改成绩、计算总分、计算均分、打印成绩信息、査询成绩信息等功能，如果将这些功能全部放到一个接口中显然不太合理，正确的做法是将它们分别放在输入模块、统计模块和打印模块等 3 个模块中
public class ISPtest{
public static void main(Stirng[] args){}
}
//输入模块接口
interface InputModule{
void insert();
void delete();
void modify();
}
//统计模块接口
interface CountModule{
void countTotalScore();
void countAverage();
}
//打印模块接口
interface PrintModule
{
void printStuInfo();
void queryStuInfo();
}
//实现类
class StuScoreList implements InputModule,CountModule,PrintModule{
private StuScoreList(){
InputModule input =StuScoreList.getInputModule();
CountModule count =StuScoreList.getCountModule();
PrintModule print =StuScoreList.getPrintModule();
input.insert();
count.countTotalScore();
print.printStuInfo();
}
public static InputModule getInputModule()
{
return (InputModule)new StuScoreList();
}
public static CountModule getCountModule()
{
return (CountModule)new StuScoreList();
}
public static PrintModule getPrintModule()
{
return (PrintModule)new StuScoreList();
}
public void insert()
{
System.out.println("输入模块的insert()方法被调用！");
}
public void delete()
{
System.out.println("输入模块的delete()方法被调用！");
}
public void modify()
{
System.out.println("输入模块的modify()方法被调用！");
}
public void countTotalScore()
{
System.out.println("统计模块的countTotalScore()方法被调用！");
}
public void countAverage()
{
System.out.println("统计模块的countAverage()方法被调用！");
}
public void printStuInfo()
{
System.out.println("打印模块的printStuInfo()方法被调用！");
}
public void queryStuInfo()
{
System.out.println("打印模块的queryStuInfo()方法被调用！");
}
}
-
-
迪米特法则的定义
如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。
//明星与经纪人的关系实例。 public class LoDtest
{
public static void main(String[] args)
{
Agent agent=new Agent();
agent.setStar(new Star("林心如"));
agent.setFans(new Fans("粉丝韩丞"));
agent.setCompany(new Company("中国传媒有限公司"));
agent.meeting();
agent.business();
}
}
//经纪人
class Agent{
private Start myStart;
private Fans myFans;
private Company myCompany;
public void setStart(String name){
this.myStart = name;
}
public void setFans(String name){
this.myFans = name;
}
public void setCompany(String name){
this.myCompany = name;
}
public void meeting(){
System.out.println(myFans.getName()+"与明星"+myStar.getName()+"见面了。");
}
public void business(){
System.out.println(myCompany.getName()+"与明星"+myStar.getName()+"洽淡业务。");
}
}
//明星
class Star
{
private String name;
Star(String name)
{
this.name=name;
}
public String getName()
{
return name;
}
}
//粉丝
class Fans
{
private String name;
Fans(String name)
{
this.name=name;
}
public String getName()
{
return name;
}
}
//媒体公司
class Company
{
private String name;
Company(String name)
{
this.name=name;
}
public String getName()
{
return name;
}
} -
合成复用原则
如果要使用继承关系，则必须严格遵循里氏替换原则。合成复用原则同里氏替换原则相辅相成的，两者都是开闭原则的具体实现规范。
评论