设计模式

发表于 | 本文总阅读量 次
字数统计: 2.5k | 阅读时长 ≈ 9

设计模式一部分

1.面向对象思想设计原则

1-1.单一职责原则

  • 其实就是开发人员经常说的”高内聚，低耦合“
  • 也就是说，每个类应该只有一个职责，对外只能提供一种功能，而引起类变化的原因应该只有一个。在设计模式中，所有的设计模式都遵循这一原则

1-2.开闭原则

  • 核心思想是：一个对象对扩展开放，对修改关闭。
  • 其实开闭原则的意思就是：对类的改动是通过增加代码进行的，而不是修改现有代码。
  • 也就是说软件开发人员一旦写出了可以运行的代码，就不应该去改动它，而是要保证它能一直运行下去，如何能够做到这一点呢?这就需要借助于抽象和多态，即把可能变化的内容抽象出来，从而使抽象的部分是相对稳定的，而具体的实现则是可以改变和扩展的。

1-3.里氏替换原则

  • 核心思想：在任何父类出现的地方都可以用它的子类来替代。
  • 其实就是说：同一个继承体系中的对象应该有共同的行为特征。

1-4.依赖注入原则

  • 核心思想：要依赖于抽象，不要依赖于具体实现。
  • 其实就是说：在应用程序中，所有的类如果使用或依赖于其他的类，则应该依赖这些其他类的抽象类，而不是这些其他类的具体类。为了实现这一原则，就要求我们在编程的时候针对抽象类或者接口编程，而不是针对具体实现编程。

1-5.接口分离原则

  • 核心思想：不应该强迫程序依赖它们不需要使用的方法。
  • 其实就是说：一个接口不需要提供太多的行为，一个接口应该只提供一种对外的功能，不应该把所有的操作都封装到一个接口中。

1-6.迪米特原则

  • 核心思想：一个对象应当对其他对象尽可能少的了解
  • 其实就是说：降低各个对象之间的耦合，提高系统的可维护性。在模块之间应该只通过接口编程，而不理会模块的内部工作原理，它可以使各个模块耦合度降到最低，促进软件的复用

2.设计模式

​ 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

​ 设计模式不是一种方法和技术，而是一种思想

​ 设计模式和具体的语言无关，学习设计模式就是要建立面向对象的思想，尽可能的面向接口编程，低耦合，高内聚，是设计的程序可复用

​ 学习设计模式能够促进对面向对象思想的理解，反之亦然。它们相辅相成

设计模式的几个要素：

  • 名字：必须有一个简单，有意义的名字
  • 问题：描述在何时使用模式
  • 解决方案：描述设计的组成部分以及如何解决问题
  • 效果：描述模式的效果以及优缺点

设计模式的分类：

  • 创建型模式：对象的创建

  • 结构型模式：对象的组成(结构)

  • 行为型模式：对象的行为

  • 创建型模式

    • 简单工厂模式，工厂方法模式，抽象工厂模式，建造者模式，原型模式，单例模式。(6个)

  • 结构型模式

    • 外观模式、适配器模式、代理模式、装饰模式、桥接模式、组合模式、享元模式。(7个)

  • 行为型模式

    • 模版方法模式、观察者模式、状态模式、职责链模式、命令模式、访问者模式、策略模式、备忘录模式、迭代器模式、解释器模式。(10个)

3.简单工厂模式

工厂方法模式概述：

  • 工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。

优点：

  • 客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性

缺点：

  • 需要额外的编写代码，增加了工作量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
public abstract class Animal {
	public abstract void eat();
}
//猫工厂
public class Cat extends Animal {
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
}
//狗工厂
public class Dog extends Animal {
	@Override
	public void eat() {
		System.out.println("狗吃肉");
	}
}
//优化，动物工厂
public class AnimalFactory {
    private AnimalFactory() {
    }
    public static Dog createDog() {
        return new Dog();
    }
    public static Cat createCat() {
        return new Cat();
    }
    //优化，动物
    public static Animal createAnimal(String type) {
        if ("dog".equals(type)) {
            return new Dog();
        } else if ("cat".equals(type)) {
            return new Cat();
        } else {
            return null;
        }
    }
}
//测试类
public class AnimalDemo {
    public static void main(String[] args) {
        // 具体类调用
        Dog d = new Dog();
        d.eat();
        Cat c = new Cat();
        c.eat();
        System.out.println("------------");
        // 工厂有了后，通过工厂给造
        Dog dd = AnimalFactory.createDog();
        Cat cc = AnimalFactory.createCat();
        dd.eat();
        cc.eat();
        System.out.println("------------");
        // 工厂改进后
        Animal a = AnimalFactory.createAnimal("dog");
        a.eat();
        a = AnimalFactory.createAnimal("cat");
        a.eat();
        // NullPointerException
        a = AnimalFactory.createAnimal("pig");
        if (a != null) {
            a.eat();
        } else {
            System.out.println("对不起，暂时不提供这种动物");
        }
    }
}

4.工厂方法

工厂方法模式概述：

  • 工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。

优点：

  • 客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性

缺点：

  • 需要额外的编写代码，增加了工作量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
//动物
public abstract class Animal {
	public abstract void eat();
}
//工厂
public interface Factory {
	public abstract Animal createAnimal();
}
//狗
public class Dog extends Animal {
	@Override
	public void eat() {
		System.out.println("狗吃肉");
	}
}
//狗工厂
public class DogFactory implements Factory {
	@Override
	public Animal createAnimal() {
		return new Dog();
	}

}
public class Cat extends Animal {
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
}
public class CatFactory implements Factory {
	@Override
	public Animal createAnimal() {
		return new Cat();
	}
}
public class AnimalDemo {
	public static void main(String[] args) {
		// 需求：我要买只狗
        // 启动工厂
		Factory f = new DogFactory();
		Animal a = f.createAnimal();
		a.eat();
		System.out.println("-------");
		//需求：我要买只猫
		f = new CatFactory();
		a = f.createAnimal();
		a.eat();
	}
}

5.单例模式

单例设计模式概述：

  • 单例模式就是要确保类在内存中只有一个对象，该实例必须自动创建，并且对外提供。

优点：

  • 在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。

缺点：

  • 没有抽象层，因此扩展很难。

  • 职责过重，在一定程序上违背了单一职责

单例模式：保证类在内存中只有一个对象。

如何保证类在内存中只有一个对象呢?

  • 把构造方法私有
  • 在成员位置自己创建一个对象
  • 通过一个公共的方法提供访问

5-1.饿汉式：类一加载就创建对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class Student {
	// 构造私有
	private Student() {
	}
	// 自己造一个
	// 静态方法只能访问静态成员变量，加静态
	// 为了不让外界直接访问修改这个值，加private
	private static Student s = new Student();
	// 提供公共的访问方式
	// 为了保证外界能够直接使用该方法，加静态
	public static Student getStudent() {
		return s;
	}
}
public class StudentDemo {
	public static void main(String[] args) {
		//一开始
		Student s1 = new Student();
		Student s2 = new Student();
		System.out.println(s1 == s2); // false

		// 通过单例如何得到对象呢?
		Student s1 = Student.getStudent();
		Student s2 = Student.getStudent();
		System.out.println(s1 == s2);
		// 外部修改对象
		// Student.s = null;
		System.out.println(s1); // null，cn.itcast_03.Student@175078b
		System.out.println(s2);// null，cn.itcast_03.Student@175078b
	}
}

5-2.懒汉式：用的时候，才去创建对象

面试题：单例模式的思想是什么?请写一个代码体现。

  • 开发：饿汉式(是不会出问题的单例模式)
  • 面试：懒汉式(可能会出问题的单例模式)
    懒加载(延迟加载) ，可能会线程安全问题，要加synchronized
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Teacher {
	private Teacher() {
	}
	private static Teacher t = null;
    //改良，加synchronized
	public synchronized static Teacher getTeacher() {
		// t1,t2,t3
		if (t == null) {
			//t1,t2,t3
			t = new Teacher();
		}
		return t;
	}
}
public class TeacherDemo {
	public static void main(String[] args) {
		Teacher t1 = Teacher.getTeacher();
		Teacher t2 = Teacher.getTeacher();
		System.out.println(t1 == t2);
		System.out.println(t1); // cn.itcast_03.Teacher@175078b
		System.out.println(t2);// cn.itcast_03.Teacher@175078b
	}
}

5-3.Runtime类的概述和使用

Runtime类概述

  • 每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。
  • 应用程序不能创建自己的 Runtime 类实例。

Runtime类使用

  • public Process exec(String command)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class RuntimeDemo {
	public static void main(String[] args) throws IOException {
		Runtime r = Runtime.getRuntime();
        //打开扫雷
        r.exec("winmine");
        //打开记事本
		r.exec("notepad");
        //打开计算器
		r.exec("calc");
        //关机，10000秒后
        r.exec("shutdown -s -t 10000");
        //取消关机命令
		r.exec("shutdown -a");
	}
}
//源码，提供一个静态的公共对象，饿汉式
/*
 * class Runtime {
 * 		private Runtime() {}
 * 		private static Runtime currentRuntime = new Runtime();
 * 		public static Runtime getRuntime() {
 *       	return currentRuntime;
 *   	}
 * }
 */
-------------本文结束感谢您的阅读-------------

本文标题:设计模式

文章作者:Linhuide

发布时间:2020年04月02日 - 17:04

最后更新:2020年04月03日 - 17:04

原始链接:https://linhuide.github.io/post/364ea8cc.html

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

坚持原创技术分享，您的支持将鼓励我继续创作！