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设计模式