设计模式 （23种）& 面向对象思想的设计原则

面向对象思想的设计原则

1.单一职责原则
2.开闭原则
3.里氏替换原则
4.依赖注入原则
5.接口分离原则
6.迪米特原则

1、单一职责原则

高内聚、低耦合：本身能作的，就不麻烦别人。
即：
每一个类应该只有一个职责，对外只能提供一种功能，而引发类变化的缘由应该只有一个，在设计模式中，全部的设计模式都遵循这一原则。

2、开闭原则（open closed principle）ocp原则

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

3、里氏替换原则

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

4、依赖注入原则

核心思想：要依赖于抽象，不要依赖于具体的实现。即在应用程序中，全部的类若是使用或依赖于其余的类，则应该依赖于这些其余类的抽象类，而不是这些其余类的具体类。
为了实现这一原则，就要求咱们在编程的时候针对抽象类或者接口编程，而不是针对具体的实现编程。

5、接口分离原则

核心思想：不该该强迫程序依赖他们不须要的方法，即 一个接口不须要提供太多的行为，一个接口应该只提供一种对外的功能，不该该把全部的操做都封装到一个接口中。

6、迪米特原则

核心思想：一个对象应当对其余的对象尽量的了解，即 下降个个对象间的耦合，提升系统的可维护性，在模块间应该只经过接口编程，而不会理会模块的内部工做原理，它可使各个模块耦合度讲到最低，促进软件的复用。

总结：高内聚、低耦合、可复用。

设计模式（Design Pattern）：经验的总结

1.设计模式不是一种方法和技术，而是一种思想。
2.设计模式与具体的语言无关，学习设计模式就是要创建面向对象的思想，尽量的面向接口编程，高内聚、低耦合，使设计的程序可复用。
3.学习设计模式可以促进对面向对象思想的理解，反之亦然，它们相辅相成。

设计模式的分类

建立型模式： 对象的建立 (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 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("------------");
}

工厂方法模式：

工厂方法模式中的抽象工厂类（最好是个接口-好维护）负责定义建立对象的接口，具体对象的建立工做由继承extends（实现implements）抽象工厂的具体类实现。

优势：

客户端不须要再负责对象的建立，从而明确了各个类的职责，若是有新的对象增长，只须要增长一个具体的类和具体的工厂类便可，不影响已有的代码，后期维护容易，加强了系统的扩展性。

缺点：

须要额外的编写代码，增长工做量。

public interface Factory {
    //工厂接口 
    public abstract Animal createAnimal();
}

public class DogFactory implements Factory {

    @Override
    public Animal createAnimal() {
        return new Dog();
    }
}

public class CatFactory implements Factory {

    @Override
    public Animal createAnimal() {
        return new Cat();
    }
}

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 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();
    }
}

单例模式：

如何确保是单例呢？
一个类在内存中只会加载一次，若是对象随着类的加载而加载，对象不也就是一个吗？
此时想到了static关键字。

饿汉式：类一加载，就建立对象。（是不会出现问题的单例模式）
懒汉式：用的时候，才建立对象。（可能出现问题的单例模式）

开发用饿汉式，面试用懒汉式

懒汉式设计两个问题：
1.懒加载（延时加载）
2.线程安全问题（方法上加锁synchronized-静态方法，锁对象为类名.class）

a.是否有多线程环境
b.是否有共享数据
c.是否有多条语句操做共享数据

单例设计模式就是要要确保类在内存中只有一个对象，该实例必须自动建立，而且对外提供。
优势：

在系统内存中只存在一个对象，所以能够节约系统资源，对于一些须要频繁建立和销毁的对象，单例模式无疑能够提升系统的性能。

缺点：

没有抽象层，所以扩展很难。
指责很重，在必定程度上违背了单一职责。

饿汉式

public class Student {
    // 构造私有
    private Student() {
    }

    // 本身造一个
    // 静态方法只能访问静态成员变量，加静态
    // 为了避免让外界直接访问修改这个值，加private(格外注意一下)
    private static Student s = new Student();

    // 提供公共的访问方式
    // 为了保证外界可以直接使用该方法，加静态
    public static Student getStudent() {
        return s;
    }
}

/*
 * 单例模式：保证类在内存中只有一个对象。
 * 
 * 如何保证类在内存中只有一个对象呢?
 *         A：把构造方法私有
 *         B:在成员位置本身建立一个对象
 *         C:经过一个公共的方法提供访问
 */
public class StudentDemo {
    public static void main(String[] args) {
        // Student s1 = new Student();
        // Student s2 = new Student();
        // System.out.println(s1 == s2); // false
        
        // 经过单例如何获得对象呢?
        // Student.s = null;
        Student s1 = Student.getStudent();
        Student s2 = Student.getStudent();
        System.out.println(s1 == s2);

        System.out.println(s1); 
        System.out.println(s2);
    }
}

懒汉式：

/*
 * 单例模式：
 *         饿汉式：类一加载就建立对象
 *         懒汉式：用的时候，才去建立对象
 * 
 * 面试题：单例模式的思想是什么?请写一个代码体现。
 *      思想是：确保内存中的对象只有一份
 *         开发：饿汉式(是不会出问题的单例模式)
 *         面试：懒汉式(可能会出问题的单例模式)
 *             A:懒加载(延迟加载)    
 *             B:线程安全问题
 *                 a:是否多线程环境    是
 *                 b:是否有共享数据    是
 *                 c:是否有多条语句操做共享数据     是
 */
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); 
        System.out.println(t2);
    }
}

单例模式的应用：JDK的源码

Runtime类 （饿汉式）

每一个Java应用程序都有一个Runtime类的实例，使应用程序可以与其运行的环境相链接。

exec（String command）

import java.io.IOException;

/*
 * Runtime:每一个 Java 应用程序都有一个 Runtime 类实例，使应用程序可以与其运行的环境相链接。
 * exec(String command)
 */
public class RuntimeDemo {
    public static void main(String[] args) throws IOException {
        Runtime r = Runtime.getRuntime();
//        r.exec("winmine");  //    打开扫雷
        // r.exec("notepad"); // 打开记事本
        // r.exec("calc"); // 打开计算器
//        r.exec("shutdown -s -t 10000"); //  10000s后关机
        r.exec("shutdown -a"); // 取消关机
    }
}

总结：单例模式三步走

第一步：私有化构造方法
第二步：在类的内部建立好对象
第三步：把已经建立好的对象返回给外部

class Runtime {
      private Runtime() {}
      private static Runtime currentRuntime = new Runtime();// 懒汉式-JDK源码
      public static Runtime getRuntime() {
          return currentRuntime;
      }
  }