JavaSE|设计模式
JavaSE|设计模式
- 面向对象思想设计原则
- 单一职责原则
- 开闭原则
- 里氏替换原则
- 依赖注入原则
- 接口分离原则
- 迪米特原则
- 设计模式
- 概述
- 设计模式的几个要素
- 设计模式的分类
- 简单工厂模式
- 工厂方法模式
- 单例模式
- Runtime
面向对象思想设计原则
下面的原则有助于提高程序的维护性、扩展性、复用性。
单一职责原则
就是开发人员经常说的“高内聚，低耦合”
也就是说，每个类应该只有一个职责，对外只能提供一种功能，而引起类变化的原因应该只有一个。在设计模式中，所有的设计模式都遵循这一原则。
开闭原则
核心思想：一个对象对扩展开放，对修改关闭。
其实就是说：对类的改动是通过增加代码进行的，而不是修改现有代码。
也就是说软件开发人员一旦写出了可以运行的代码，就不应该去改动它，而是要保证它能一直运行下去。如何能够做到这一点呢？这就需要借助于抽象和多态，即把可能变化的内容抽象出来，从而使抽象的部分是相对稳定的，而具体实现则是可以改变和扩展的。
里氏替换原则
核心思想：在任何父类出现的地方都可以用它的子类来替代。
其实就是说：同一个继承体系中的对象应该有共同的行为特征。
依赖注入原则
核心思想：要依赖于抽象，不要依赖于具体实现。
其实就是说：在应用程序中，所有的类如果使用或依赖于其他的类，则应该依赖这些其他类的抽象类，而不是这些其他类的具体类。为了实现这一原则，就要求我们在编程的时候针对抽象类或者接口编程，而不是针对具体实现编程。
接口分离原则
核心思想：不应该强迫程序依赖它们不需要使用的方法。
其实就是说：一个接口不需要提供太多的行为，一个接口应该只提供一种对外的功能，不应该把所有的操作都封装到一个接口中。
迪米特原则
核心思想：一个对象应当对其他对象尽可能少的了解。
其实就是说：降低各个对象之间的耦合，提高系统的可维护性。在模块之间应该只通过接口编程，而不理会模块内部工作原理，它可以使各个模块耦合度降到最低，促进软件的复用。
设计模式
概述
设计模式是一套被反复使用、多数人只晓得、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码，让代码更容易被他人理解，保证代码的可靠性。
设计模式不是一种方法和技术，而是一种思想。
设计模式和具体的语言无关，学习设计模式就是要建立面向对象的思想，尽可能的面向接口编程，低耦合、高内聚，使设计的程序可复用。
学习设计模式能够促进对面向对象思想的理解，反之亦然，它们相辅相成。
设计模式的几个要素
名字：必须有一个简单、有意义的名字
问题：描述在何时使用模式
解决方案：描述设计的组成部分以及如何解决问题
效果：描述模式的效果以及优缺点
设计模式的分类
- 创建型模式：对象的创建
简单工厂模式，工厂方法模式，抽象工厂模式，建造者模式，原型模式，单例模式。（6个） - 结构型模式：对象的组成（结构）
外观模式，适配器模式，代理模式，装饰模式，桥接模式，组合模式，享元模式。（7个） - 行为型模式：对象的行为
模板方法模式，观察者模式，状态模式，职责链模式，命令模式，访问者模式，策略模式，备忘录模式，迭代器模式，解释器模式。（10个）
简单工厂模式
又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例。
优点：客户端不需要再负责对象的创建，从而明确了各个类的职责。
缺点：这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期维护。
public abstract class Animal {
public abstract void eat();
}
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃肉");
}
}
public class Cat 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();
// 工厂改进后
Animal a = AnimalFactory.createAnimal("dog");
a.eat();
a = AnimalFactory.createAnimal("cat");
a.eat();
a = AnimalFactory.createAnimal("pig");
if(a != null){
a.eat();
}else{
System.out.println("对不起，暂时不提供这种动物");
}
}
}
工厂方法模式
工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。
优点：客户端不需要再负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性。
缺点：需要额外的编写代码，增加了工作量。
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 interface Factory {
public abstract Animal createAnimal();
}
public class CatFactory implements Factory {
@Override
public Animal createAnimal() {
return new Cat();
}
}
public class DogFactory implements Factory {
@Override
public Animal createAnimal() {
return new Dog();
}
}
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();
}
}
单例模式
单例模式就是要确保类在内存中只有一个对象，该实例必须自动创建，并且对外提供。
优点：在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象，单例模式无疑可以提高系统的性能。
缺点：没有抽象层，因此扩展很难；职责过重，在一定程度上违背了单一职责。
如何保证类在内存中只有一个对象呢？
1.把构造方法私有
2.在成员位置自己创建一个对象
3.通过一个公共的方法提供访问
单例模式可以分为饿汉式和懒汉式：
饿汉式：类一加载就创建对象
懒汉式：用的时候，才去创建对象
面试题：单例模式的思想是什么？请写一个代码体现。
在实际开发中，通常用饿汉式，它是不会出问题的单例模式。
在面试中，可以写懒汉式，它是可能出问题的单例模式。
懒汉式单例模式是懒加载（延迟加载）的，并且会出现线程安全问题（当在多线程环境下时，有共享数据，且多条语句操作共享数据）
饿汉式：
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 = Student.getStudent();
Student s2 = Student.getStudent();
System.out.println(s1 == s2); // true
System.out.println(s1);
System.out.println(s2);
}
}
懒汉式：
public class Teacher {
private Teacher(){
}
private static Teacher t = null;
public synchronized static Teacher getTeacher(){
if(t == null){
t = new Teacher();
}
return t;
}
}
public class StudentDemo {
public static void main(String[] args) {
Teacher t1 = Teacher.getTeacher();
Teacher t2 = Teacher.getTeacher();
System.out.println(t1 == t2);
System.out.println(t1);
System.out.println(t2);
}
}
Runtime
每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。
应用程序不能创建自己的 Runtime 类实例。
JDK中Runtime类就是饿汉式的单例模式。
public class Runtime {
/** Don't let anyone else instantiate this class */
private Runtime() {}
private static Runtime currentRuntime = new Runtime();
public static Runtime getRuntime() {
return currentRuntime;
}
}
成员方法：
public Process exec(String command)
public class RuntimeDemo {
public static void main(String[] args) throws IOException {
Runtime r = Runtime.getRuntime();
// 打开记事本
r.exec("notepad");
}
}