Java--开发模式深入理解

Java–开发模式深入理解

Java 三大特性

1. 封装。

Java封装。封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象。

就是将一个实体或者一个操作过程封装到一个抽象数据类型(class)内，在一个class中，可定义成员变量(class的属性)，以及方法(class的操作)。该抽象数据类型(class)封装后，只提供给外界可供使用的操作接口(API)，调用者不需要关注其内部具体实现，达到高内聚，低耦合的目的。

那么什么时候使用封装呢？ 当需要定义一个实体或者业务操作的时候，就要用到封装。或者说现实世界的everything 与 Java Object的一一映射。

2. 继承。

Java继承是另外一个特性。继承一般是类的继承和接口的实现。类的继承就是公共类的抽象，一定要明白什么是“抽象”的概念即事物的高度概括。如下图所示。



代码实现：

Animal类：

package com.inherit;

public class Animal {

private String name;
private int id;
public Animal() {
}
public Animal(String name, int id) {
super();
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}

}

Dog类：

package com.inherit;

public class Dog extends Animal {
private String voice;

public Dog() {
}

public Dog(String name,int id,String voice) {
super(name,id);
this.voice = voice;
}

public String getVoice() {
return voice;
}

public void setVoice(String voice) {
this.voice = voice;
}

}

Insect类：

package com.inherit;

public class Insect extends Animal {

private String autumn;

public Insect() {
}
public Insect(String name, int id,String autumn) {
super(name, id);
this.autumn = autumn;
}

public String getAutumn() {
return autumn;
}

public void setAutumn(String autumn) {
this.autumn = autumn;
}

}

3. 多态。

多态就是同一个接口或抽象类，使用不同的实例而执行不同的操作，同时也包括方法的重载，方法的重写等。即面向接口编程、面向抽象类编程。

如下图所示。



**代码实现：

Printer类：**

package com.more;

public abstract class Printer {

private String brand;

public abstract void print();

public Printer(String brand) {
super();
this.brand = brand;
}

public void setBrand(String brand) {
this.brand = brand;
}
public String getBrand() {
return brand;
}

}

ColorPrinter类：

package com.more;

public class ColorPrinter extends Printer {

public ColorPrinter(String brand) {
super(brand);
}
@Override
public void print() {
System.out.println(this.getBrand() + "is running");
}

}

BWPrinter类：

package com.more;

public class BWPrinter extends Printer {

public BWPrinter(String brand) {
super(brand);
}

@Override
public void print() {
System.out.println(this.getBrand()+"is running");
}

}

Java设计模式七大原则

设计模式的提出，其根本原因就是为了实现代码的复用性，增加代码的可维护性，并达到高内聚低耦合的目的。设计模式的实现遵循了一些原则，从而达到代码的复用性及增加可维护性的目的，设计模式对理解面向对象的三大特征有很好的启发，不看设计模式，很难深层地体会到面向对象开发带来的好处 。在刚开始学习中，很难做到将这些模式融汇贯通，所以这个需要我们在编码前多思考，等想充分了，在开始实践编码。下面是设计模式应当遵循的七大原则。

1. 单一职责原则

一个类只负责一项职责。如果一个类承担的职责过多，就等于把这些职责耦合在一起了。一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力。

2. 开闭原则

对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，要实现一个热插拔的效果，因此我们需要使用接口和抽象类。

3. 里氏代换原则

尽量使用父类的引用。在面向接口或抽象类的编程中，尽量使用父类的引用，达到高扩展性和健壮性。

4. 依赖倒置原则

面向接口或抽象编程。高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。即针对接口编程，不要针对实现编程。

5. 接口隔离原则

一个接口负责一个功能模块。在程序设计中，依赖几个专用的接口要比依赖一个综合的接口更灵活。接口是设计时对外部设定的“契约”，通过分散定义多个接口，可以预防外来变更的扩散，提高系统的灵活性和可维护性。

6. 迪米特法则

低耦合，高内聚。迪米特法则又叫最少知道原则。就是一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类来说，无论逻辑多么复杂，都尽量地的将逻辑封装在类的内部，对外除了提供的public方法，不对外泄漏任何信息。迪米特法则还有一个更简单的定义：只与直接的朋友通信。首先来解释一下什么是直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖、关联、组合、聚合等。其中，我们称出现成员变量、方法参数、方法返回值中的类为直接的朋友，而出现在局部变量中的类则不是直接的朋友。也就是说，陌生的类最好不要作为局部变量的形式出现在类的内部

7. 组合/聚合原则

类之间尽量使用组合/聚合的关系方式。该原则就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分：新的对象通过向这些对象的委派达到复用已有功能的目的。

UML类图关系

Java设计模式