Java设计模式
1.设计模式的目的
1.代码的重用性(即：相同功能的代码，不用多次编写)
2.可读性(即：编程规范性，便于其他程序员的阅读和理解)
3.可扩展性(即：当需要增加新的功能时，非常的方便，称为可维护性)
4.可靠性(即：当增加新的功能后，对原来的功能没有影响)
5.使程序对外呈现高内聚、低耦合的特性
2.设计模式的七大原则
设计模式原则，其实就是程序员在编程时，应当遵守的原则，也是各种设计模式的基础(即：设计模式为什么这样设计的依据)
设计模式常用的七大原则有：
- 单一职责原则
- 接口隔离原则
- 依赖倒转(倒置)原则
- 里氏替换原则
- 开闭原则
- 迪米特法则
- 合成复用原则
2.1单一职责原则
2.1.1基本介绍
对类来说，一个类应该只负责一项职责。如类A负责两个不同的职责：职责1，职责2。当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为A1，A2
2.1.2应用实例
- 方案1
package com.nnuo.principles.singleresponsibility;
public class SingleResponsibility1 {
public static void main(String[] args) {
Vehicle vehicle = new Vehicle();
vehicle.run("摩托车");
vehicle.run("汽车");
vehicle.run("飞机");
}
}
// 交通工具类
// 方式1
// 1. 在方式1 的run方法中，违反了单一职责原则，即管了在公路上的交通工具，又管了在天上的交通工具
// 2. 解决的方案非常的简单，根据交通工具运行方法的不同，分解成不同类即可
class Vehicle{
public void run(String vehicle){
System.out.println(vehicle + " 在公路上运行。。。");
}
}
- 方案2
package com.nnuo.principles.singleresponsibility;
public class SingleResponsibility2 {
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("潜水艇");
}
}
// 方案2的分析
// 1. 遵守单一职责原则
// 2. 但是这样做的改动很大，既将类分解，同时又修改客户端
// 3. 改进方案，直接修改Vehicle类，改动的代码会比较少=>方案3
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
package com.nnuo.principles.singleresponsibility;
public class SingleResponsibility3 {
public static void main(String[] args) {
Vehicle2 vehicle2 = new Vehicle2();
vehicle2.runRoad("汽车");
vehicle2.runAir("飞机");
vehicle2.runWater("潜艇");
}
}
// 方式3的分析
// 1. 这种修改方案没有对原来的类做大的修改，只是增加方法
// 2. 这里虽然没有在类这个级别上遵守单一职责原则，但是在方法级别上，仍然事遵守单一职责
class Vehicle2{
public void runRoad(String vehicle){
System.out.println(vehicle + "在公路运行。。。");
}
public void runAir(String vehicle){
System.out.println(vehicle + "在天上运行。。。");
}
public void runWater(String vehicle){
System.out.println(vehicle + "在水里运行。。。");
}
}
2.1.3 单一职责原则小结
- 降低类的复杂度，一个类只负责一项职责
- 提高类的可读性，可维护性
- 降低变更引起的风险
- 通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级别违反单一职责原则：只有类中方法量足够少，可以在方法级别保持单一职责原则
2.2接口隔离原则
2.2.1基本介绍
客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。
2.2.2应用实例
接口隔离之前：
package com.nnuo.principles.segregation;
public class Segregation1 {
}
// 接口
interface Interface1{
void operation1();
void operation2();
void operation3();
void operation4();
void operation5();
}
//实现类B
class B implements Interface1{
@Override
public void operation1() {
System.out.println("B 实现了 operation1");
}
@Override
public void operation2() {
System.out.println("B 实现了 operation2");
}
@Override
public void operation3() {
System.out.println("B 实现了 operation3");
}
@Override
public void operation4() {
System.out.println("B 实现了 operation4");
}
@Override
public void operation5() {
System.out.println("B 实现了 operation5");
}
}
//实现类D
class D implements Interface1{
@Override
public void operation1() {
System.out.println("D 实现了 operation1");
}
@Override
public void operation2() {
System.out.println("D 实现了 operation2");
}
@Override
public void operation3() {
System.out.println("D 实现了 operation3");
}
@Override
public void operation4() {
System.out.println("D 实现了 operation4");
}
@Override
public void operation5() {
System.out.println("D 实现了 operation5");
}
}
class A {// A类通过接口Interface1 依赖(使用) B类，但是只会用到1，2，3方法
public void depend1(Interface1 i){
i.operation1();
}
public void depend2(Interface1 i){
i.operation2();
}
public void depend3(Interface1 i){
i.operation3();
}
}
class C {// C类通过接口Interface1 依赖(使用) D类，但是只会用到1，4，5方法
public void depend1(Interface1 i){
i.operation1();
}
public void depend4(Interface1 i){
i.operation4();
}
public void depend5(Interface1 i){
i.operation5();
}
}
接口隔离改进之后
package com.nnuo.principles.segregation.improve;
public class Segregation1 {
public static void main(String[] args) {
//使用一把
A a = new A();
a.depend1(new B());//A类通过接口去依赖(使用)B类
a.depend1(new D());//D类也实现了Interface1，A类中的depend1()方法参数为接口Interface1,所以A类也可以通过接口Interface1使用D类
a.depend2(new B());
a.depend3(new B());
C c = new C();
c.depend1(new D());//C类通过接口去使用实现类D
c.depend1(new B());//C类通过接口去使用实现类B,谁实现了接口1就可以使用谁
c.depend4(new D());
c.depend5(new D());
}
}
//接口1
interface Interface1{
void operation1();
}
//接口2
interface Interface2{
void operation2();
void operation3();
}
//接口3
interface Interface3{
void operation4();
void operation5();
}
//接口1和2的实现类B
class B implements Interface1,Interface2{
@Override
public void operation1() {
System.out.println("B 实现了 operation1");
}
@Override
public void operation2() {
System.out.println("B 实现了 operation2");
}
@Override
public void operation3() {
System.out.println("B 实现了 operation3");
}
}
//接口1和3的实现类D
class D implements Interface1,Interface3{
@Override
public void operation1() {
System.out.println("D 实现了 operation1");
}
@Override
public void operation4() {
System.out.println("D 实现了 operation4");
}
@Override
public void operation5() {
System.out.println("D 实现了 operation5");
}
}
class A{// A类通过接口Interface1和Interface2 依赖(使用) B类，但是只会用到1，2，3方法
public void depend1(Interface1 i1){
i1.operation1();
}
public void depend2(Interface2 i2){
i2.operation2();
}
public void depend3(Interface2 i2){
i2.operation3();
}
}
class C{// C类通过接口Interface1和Interface3 依赖(使用) D类，但是只会用到1,4,5方法
public void depend1(Interface1 i1){
i1.operation1();
}
public void depend4(Interface3 i3){
i3.operation4();
}
public void depend5(Interface3 i3){
i3.operation5();
}
}