程序设计第三次作业—单一职责原则、开放封闭原则、里氏替换原则

最新推荐文章于 2022-09-18 11:58:00 发布

原创最新推荐文章于 2022-09-18 11:58:00 发布

· 289 阅读

0 ·

版权

设计模式专栏收录该内容

14 篇文章

订阅专栏

//单一职责原则：一个类应该只负责一项职责。
//方式1

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Vehicle vehicle = new Vehicle();
		vehicle.run("摩托车");
		vehicle.run("汽车");
		vehicle.run("飞机");
	}
}
class Vehicle {
	public void run(String vehicle) {
		System.out.println(vehicle + " 在公路上跑 ");
	}
}

//方式2：根据交通工具运行方法不同，分解成不同类

public class Main {

	public static void main(String[] args) {
		RoadVehicle roadVehicle = new RoadVehicle();
		roadVehicle.run("摩托车");
		roadVehicle.run("汽车");
		AirVehicle airVehicle = new AirVehicle();
		airVehicle.run("飞机");
		WaterVehicle waterVehicle = new WaterVehicle();
		waterVehicle.run("轮船");
	}
}
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 + " 在水里游 ");
	}
}

/方案2的分析：
1.遵守单一职责原则
2.但是改动很大，即要将类分解，又要修改客户端
3.改进:保留并修改Vehicle类，改动的代码会比较少/

//方案3 保留并修改Vehicle类

public class Main {

	public static void main(String[] args) {
		Vehicle2 Vehicle = new Vehicle2();
		Vehicle.run("摩托车");
		Vehicle.run("汽车");
		Vehicle.runAir("飞机");
		Vehicle.runWater("轮船");
	}
}

class Vehicle2 {
	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 + "在水里游");
	}

}

/方案3的分析：
1.这种修改方法没有对原来的类做大的修改，只是增加方法；
2.增加的部分不影响原有部分，降低了变更引起的风险；
3.这里在类这个级别上没有遵守单一职责原则，但是在方法级别上，仍然是遵守单一职责。/

//开放-封闭原则：开闭原则中“开”，是指对于组件功能的扩展是开放的，是允许对其进行功能扩展的；
*开闭原则中“闭”，是指对于原有代码的修改是封闭的，即不应该修改原有的代码。

public class Main {

	public static void main(String[] args) {
		GraphicDraw graphicdraw = new GraphicDraw();
		graphicdraw.drawgraph(2);
	}
}
//方式1
class Rectangle {
	void draw() {
		System.out.println("矩形");
	}
}

class Circle {
	void draw() {
		System.out.println("圆形");
	}
}

class Triangle { // 新增三角形——肯定要改
	void draw() {
		System.out.println("三角形");
	}
}
class GraphicDraw {
	void drawgraph(int type) {
		if (type == 1) {
			Rectangle rec = new Rectangle();
			rec.draw();
		} else if (type == 2) {
			Circle c = new Circle();
			c.draw();
		} else if (type == 3) { // 新增绘制三角形
			Triangle t = new Triangle();
			t.draw();
		}
	}
}

/*方式1的优缺点：
1)优点是比较好理解，简单易操作。
2)缺点是违反了开闭原则（对扩展（提供方）开放，对修改（使用方）关闭）：需要给类增加新功能的时候，尽量不要修改代码，或者尽可能少修改代码。
3)本例，需要新增一个图形种类时，修改的地方比较多
改进思路：发现Rectangle和Circle有共同的draw方法，创建抽象Shape类做成基类，并提供抽象的draw方法，让子类去实现，当需要新的图形时，只需要让新的图形继承Shape，并实现draw方法。画图类GraphicDraw不出现具体的类，用抽象类Shape。这样使用方的代码就不需要修改，满足开闭原则。 */
//方式2：

public class Main {

	public static void main(String[] args) {
		GraphicDraw graphicdraw = new GraphicDraw();
		graphicdraw.drawgraph(new Circle());
		graphicdraw.drawgraph(new Rectangle());
		graphicdraw.drawgraph(new Triangle());
	}
}

abstract class Shape { // Shape类，基类
	public abstract void draw(); // 抽象方法
}

class GraphicDraw { // 新增绘制图形不需修改此类
	void drawgraph(Shape s) {
		s.draw();
	}
}

class Rectangle extends Shape {
	public void draw() {
		System.out.println("矩形");
	}
}

class Circle extends Shape {
	public void draw() {
		System.out.println("圆形");
	}
}

class Triangle extends Shape { // 新增三角形
	public void draw() {
		System.out.println("三角形");
	}
}

/*里氏替换原则：只要有父类出现的地方，都可以使用子类来替代。而且不会出现任何错误或者异常。

但是反过来却不行。子类出现的地方,不能使用父类来替代。 
里氏代换原则的主要作用：规范继承时子类的一些书写规则。其主要目的就是保持父类方法不被覆盖。*/
/依赖倒转原则：
1)高层模块不应该依赖低层模块，二者都应该依赖其抽象
2)抽象不应该依赖细节，细节应该依赖抽象
3)依赖倒转(倒置)的中心思想是面向接口编程
4)依赖倒转原则是基于这样的设计理念: 相对于细节的多变性，抽象的东西要稳定的多。
以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在Java中，抽象指的是接口或抽象类，细节就是具体的实现类。
5)使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成。/

public class Main {

	public static void main(String[] args) {
		Person person = new Person();
		person.receive(new Email());
	}
}

class Email {
	public String getInfo() {
		return "电子邮件信息: hello world ";
	}
}

// Person 类 接受消息,将Email类 作为参数 产生了依赖 如果 参数发生变化,即接受的是微信 或短信 整个方法需要改动
class Person {
	public void receive(Email email) {
		System.out.println(email.getInfo());
	}
}

/分析：
1.简单，比较容易想到
2.如果我们获取的对象是微信,短信等,则新增类，同时Perons也要增加相应的接收方法
3.解决:引入一个抽象的接口 IReceiver,表示接收者，这样Person 类与接口IReceiver发生依赖因为Emai1, WeiXin等属于接收的范围，它们各自实现IReceiver接口, 这样就符合依赖倒转原则/
//解决方案：
定义接受的接口 */

public class Main {

	public static void main(String[] args) {
		Person person = new Person();
		person.receive(new Email()); // 传入不同实现类 实现不同的接受
		person.receive(new WenXin());
	}
}

interface IReciver {
	public String getInfo();
}

class Email implements IReciver {
	public String getInfo() {
		return "电子邮件信息: hello world ";
	}
}

class WenXin implements IReciver {
	public String getInfo() {
		return "微信信息: hello WenXin ";
	}
}

class Person {
	public void receive(IReciver reciver) {
		System.out.println(reciver.getInfo());
	}
}