前言
文章内容输出来源:拉勾教育Java就业训练营
上一章内容,java 反射机制
常用设计原则和设计模式
常用的设计原则
软件开发的流程
- 需求分析文档、概要设计文档、详细设计文档、编码和测试、安装和调试、维护和升级
常用的设计原则
- 开闭原则(Open Close Principle)
对扩展开放对修改关闭,为了使程序的扩展性好,易于维护和升级。 - 里氏代换原则(Liskov Substitution Principle)
任何基类可以出现的地方,子类一定可以出现,多使用多态的方式。 - 依赖倒转原则(Dependence Inversion Principle)
尽量多依赖于抽象类或接口而不是具体实现类,对子类具有强制性和规范性 - 接口隔离原则(Interface Segregation Principle)
尽量多使用小接口而不是大接口,避免接口的污染,降低类之间耦合度。(将大接口拆分成小接口) - 迪米特法则(最少知道原则)(Demeter Principle)
一个实体应当尽量少与其他实体之间发生相互作用,使系统功能模块相对独立。高内聚,低耦合。 - 合成复用原则(Composite Reuse Principle)
尽量多使用合成/聚合的方式,而不是继承的方式。
A类
public class A {
public void show() {
System.out.println("这是A类中的show方法!");
}
}
B类要调用A类中的show方法,请问如何实现?
B类
public class B/* extends A*/ {
private A a; // 合成复用原则
public B(A a) {
this.a = a;//初始化
}
public void test() {
// 调用A类中的show方法
a.show();
}
}
常用的设计模式
基本概念
- 设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
- 设计模式就是一种用于固定场合的固定套路。
基本分类
- 创建型模式 - 单例设计模式、工厂方法模式、抽象工厂模式、…
- 结构型模式 - 装饰器模式、代理模式、…
- 行为型模式 - 模板设计模式、…
设计模式详解
单例设计模式
- 单例设计模式主要分为:饿汉式 和 懒汉式,懒汉式需要对多线程进行同步处理。
public class Singleton {
// 2.声明本类类型的引用指向本类类型的对象并使用private static关键字修饰
private static Singleton sin = null;
// 1.私有化构造方法,使用private关键字修饰
private Singleton() {}
// 3.提供公有的get方法负责将上述对象返回出去,使用public static关键字修饰
public static /*synchronized*/ Singleton getInstance() {
/*synchronized (Singleton.class) {
if (null == sin) {
sin = new Singleton();
}
return sin;
}*/
if (null == sin) {
synchronized (Singleton.class) {
if (null == sin) {
sin = new Singleton();
}
}
}
return sin;
}
}
普通工厂模式
基本概念
- 普通工厂方法模式就是建立一个工厂类,对实现了同一接口的不同实现类进行实例的创建。
类图结构
接口
public interface Sender {
// 自定义抽象方法来描述发送的行为
/*public abstract*/ void send();
}
继承接口的实现类
SmsSender类
//发送短信
public class SmsSender implements Sender{
@Override
public void send() {
System.out.println("正在发送短信!");
}
}
MailSender 类
//发送邮件
public class MailSender implements Sender{
@Override
public void send() {
System.out.println("正在发送邮件!");
}
}
工厂类SendFactory
public class SendFactory {
// 自定义成员方法实现对象的创建
public Sender produce(String type) {
//当需要进行加功能时,例如在new对象前先打印一句话
System.out.println("随便加一句打印进行测试");
if ("mail".equals(type)) return new MailSender();
if ("sms".equals(type)) return new SmsSender();
return null;
}
}
测试类SebdFactiryTest
public class SebdFactiryTest {
public static void main(String[] args) {
// 缺点:代码复杂,可读性略差
// 优点:扩展性和可维护性更强! 尤其是在创建大量对象的前提下
// 1.声明工厂类类型的引用指向工厂类类型的对象
SendFactory sf =new SendFactory();
// 2.调用生产方法来实现对象的创建
Sender se = sf.produce("mail");
// Sender se = sf.produce("maill");//当输入错误时就会报错,为空指针异常
// 3.使用对象调用方法模拟发生的行为
se.send();
System.out.println("-------------------------------------");
// 优点:代码简单,可读性强 在创建单个对象时有优势
// 缺点:扩展性和可维护性略差
Sender sender1 = new MailSender();
sender1.send();
}
}
输出>>>
随便加一句打印进行测试
正在发送邮件!
-------------------------------------
正在发送邮件!
缺点
- 在普通工厂方法模式中,如果传递的字符串出错,则不能正确创建对象,并且可能出现空指针异常。
多个工厂方法模式
类图结构
修改工厂类改变成多工厂类
public class SendFactory {
// 自定义成员方法实现对象的创建
public Sender produce(String type) {
//当需要进行加功能时,例如在new对象前先打印一句话
System.out.println("随便加一句打印进行测试");
if ("mail".equals(type)) return new MailSender();
if ("sms".equals(type)) return new SmsSender();
return null;
}
public Sender produceMail() {
return new MailSender();
}
public Sender produceSms() {
return new SmsSender();
}
}
测试类
public class SebdFactiryTest {
public static void main(String[] args) {
// 缺点:代码复杂,可读性略差
// 优点:扩展性和可维护性更强! 尤其是在创建大量对象的前提下
// 1.声明工厂类类型的引用指向工厂类类型的对象
SendFactory sf =new SendFactory();
// 2.调用生产方法来实现对象的创建
// Sender se = sf.produce("mail");
// Sender se = sf.produce("maill");//当输入错误时就会报错,为空指针异常
// 3.使用对象调用方法模拟发生的行为
Sender se =sf.produceMail();
se.send();
System.out.println("-------------------------------------");
// 优点:代码简单,可读性强 在创建单个对象时有优势
// 缺点:扩展性和可维护性略差
Sender sender1 = new MailSender();
sender1.send();
System.out.println("-------------------------------------");
}
}
输出>>>
正在发送邮件!
-------------------------------------
正在发送邮件!
-------------------------------------
缺点
- 在多个工厂方法模式中,为了能够正确创建对象,先需要创建工厂类的对象才能调用工厂类中的生 产方法。
静态工厂方法模式
类图结构
工厂类进行修改:
public class SendFactory {
public static Sender produceMail() {
return new MailSender();
}
public static Sender produceSms() {
return new SmsSender();
}
}
测试类
public class SebdFactiryTest {
public static void main(String[] args) {
// 缺点:代码复杂,可读性略差
// 优点:扩展性和可维护性更强! 尤其是在创建大量对象的前提下
// 1.声明工厂类类型的引用指向工厂类类型的对象
// SendFactory sf =new SendFactory();
// 2.调用生产方法来实现对象的创建
// Sender se = sf.produce("mail");
// Sender se = sf.produce("maill");//当输入错误时就会报错,为空指针异常
// 3.使用对象调用方法模拟发生的行为
// Sender se =sf.produceMail();
Sender se =SendFactory.produceMail();//静态调用
se.send();
System.out.println("-------------------------------------");
// 优点:代码简单,可读性强 在创建单个对象时有优势
// 缺点:扩展性和可维护性略差
Sender sender1 = new MailSender();
sender1.send();
System.out.println("-------------------------------------");
}
}
输出>>>
正在发送邮件!
-------------------------------------
正在发送邮件!
-------------------------------------
实际意义
- 工厂方法模式适合:凡是出现了大量的产品需要创建且具有共同的接口时,可以通过工厂方法模式 进行创建。
主要缺点
- 工厂方法模式有一个问题就是,类的创建依赖工厂类,也就是说,如果想要拓展程序生产新的产 品,就必须对工厂类的代码进行修改,这就违背了开闭原则。
抽象工厂模式
类图结构
定义接口ProvIder
public interface ProvIder {
// 自定义抽象方法描述产品的生产行为
Sender produce();
}
实现接口类
MailSendFactory 实现Provlider
public class MailSendFactory implements ProvIder {
@Override
public Sender produce() { return new MailSender();}
}
SmsSendFactory 实现Provlider
public class SmsSendFactory implements Provider {
@Override
public Sender produce() {
return new SmsSender();
}
}
测试类
public class SebdFactiryTest {
public static void main(String[] args) {
// 缺点:代码复杂,可读性略差
// 优点:扩展性和可维护性更强! 尤其是在创建大量对象的前提下
// 1.声明工厂类类型的引用指向工厂类类型的对象
// SendFactory sf =new SendFactory();
// 2.调用生产方法来实现对象的创建
// Sender se = sf.produce("mail");
// Sender se = sf.produce("maill");//当输入错误时就会报错,为空指针异常
// 3.使用对象调用方法模拟发生的行为
// Sender se =sf.produceMail();
Sender se =SendFactory.produceMail();//静态调用
se.send();
System.out.println("-------------------------------------");
// 优点:代码简单,可读性强 在创建单个对象时有优势
// 缺点:扩展性和可维护性略差
Sender sender1 = new MailSender();
sender1.send();
System.out.println("-------------------------------------");
ProvIder provIder= new MailSendFactory();
Sender sender2= provIder.produce();
sender2.send();
}
}
输出>>>
正在发送邮件!
-------------------------------------
正在发送邮件!
-------------------------------------
正在发送邮件!
装饰器模式
基本概念
装饰器模式就是给一个对象动态的增加一些新功能,要求装饰对象和被装饰对象实现同一个接口, 装饰对象持有被装饰对象的实例。
类图结构
接口
public interface Sourceable {
void method();
}
实现类
public class Source implements Sourceable{
@Override
public void method() {
System.out.println("装饰之前挺好的");
}
}
装饰类
//装饰类
public class Decorator implements Sourceable {
private Sourceable source;
public Decorator(Sourceable sourceable){
this.source = sourceable;
}
@Override
public void method() {
source.method();//保证原有功能不变
System.out.println("装饰之后会更好");
}
}
测试类
public class SourceableTest {
public static void main(String[] args) {
Sourceable sourceable =new Source();
sourceable.method();
System.out.println("------------------");
// 接下来使用装饰类实现功能
Sourceable sourceable1= new Decorator(sourceable);
sourceable1.method();
}
}
输出>>>
装饰之前挺好的
------------------
装饰之前挺好的
装饰之后会更好
实际意义
- 可以实现一个类功能的扩展。
- 可以动态的增加功能,而且还能动态撤销(继承不行)。
- 缺点:产生过多相似的对象,不易排错。
代理模式
基本概念
代理模式就是找一个代理类替原对象进行一些操作。
比如我们在租房子的时候找中介,再如我们打官司需要请律师,中介和律师在这里就是我们的代 理。
类图结构
Proxy代理实现Sourceable类
public class Proxy implements Sourceable {
private Source source;
public Proxy() {
source = new Source();
}
@Override
public void method() {
source.method();
System.out.println("我和装饰器不一样");
}
}
测试类SourceableTest
public class SourceableTest {
public static void main(String[] args) {
Sourceable sourceable =new Source();
sourceable.method();
System.out.println("------------------");
// 接下来使用装饰类实现功能
Sourceable sourceable1= new Decorator(sourceable);
sourceable1.method();
System.out.println("------------------");
//使用代理类实现功能
Sourceable sourceable2 =new Proxy();
sourceable2.method();
}
}
实际意义
如果在使用的时候需要对原有的方法进行改进,可以采用一个代理类调用原有方法,并且对产生的 结果进行控制,这种方式就是代理模式。
使用代理模式,可以将功能划分的更加清晰,有助于后期维护。
代理模式和装饰器模式的比较
装饰器模式通常的做法是将原始对象作为一个参数传给装饰者的构造器,而代理模式通常在一个代 理类中创建一个被代理类的对象。
装饰器模式关注于在一个对象上动态的添加方法,然而代理模式关注于控制对对象的访问。
模板方法模式
基本概念
模板方法模式主要指一个抽象类中封装了一个固定流程,流程中的具体步骤可以由不同子类进行不 同的实现,通过抽象类让固定的流程产生不同的结果。
类图结构
模板类AbstractCalculator
public abstract class AbstractCalculator {
//自定义成员方法,实现将参数指定的表达式按照测试指定的规则进行切割并且返回计算结果 1+1 +
public int splitExpression(String exp, String op) {
String[] sArr = exp.split(op);
return calculate(Integer.parseInt(sArr[0]), Integer.parseInt(sArr[1]));
}
//自定义抽象方法实现运算
public abstract int calculate(int ia, int ib);
}
模板实现类
做减法
public class Minus extends AbstractCalculator {
@Override
public int calculate(int ia, int ib) {
return ia - ib;
}
}
做加法
public class Plus extends AbstractCalculator {
@Override
public int calculate(int ia, int ib) {
return ia +ib;
}
}
测试类
public class AbstractCalculatorTest {
public static void main(String[] args) {
AbstractCalculator ac= new Plus();
int i = ac.splitExpression("1+1", "\\+");
System.out.println("最终的结果为:" + i);
AbstractCalculator ac1 = new Minus();
int i1 = ac1.splitExpression("1+1", "\\+");
System.out.println("最终的结果为:" + i1);
}
}
输出>>>
最终的结果为:2
最终的结果为:0
实际意义
将多个子类共有且逻辑基本相同的内容提取出来实现代码复用。 不同的子类实现不同的效果形成多态,有助于后期维护。