设计模式

面向对象的普适设计原则

• 单一职责原则
  高内聚，低耦合。每个类应该只有一个职责，对外只能提供一种功能。
• 开闭原则
  一个对象，对拓展开发，对修改关闭。一个组件能运行，就尽量不去修改它，而是通过抽象和多态（继承）来拓展功能。
• 里氏替换原则
  任何父类出现的地方都可以用它的子类来替换。虽然多态会导致同一个方法的行为会差异，但我们需要让同一个继承体系下的对象具备相似的特征，不要使得差异过大。
• 依赖注入原则
  要依赖于抽象，不要依赖于具体实现。其实就是说：在应用程序中，所有的类如果使用或依赖于其他的类，则应该依赖这些其他类的抽象类，而不是这些其他类的具体类。为了实现这一原则，就要求我们在编程的时候针对抽象类或者接口编程，而不是针对具体实现编程。我的理解是这样能使程序的拓展性和移植性达到最大化。
• 接口分离原则
  不应该强迫程序依赖它们不需要使用的方法。一个接口不需要提供太多的行为，一个接口应该只提供一种对外的功能，不应该把所有的操作都封装到一个接口中。
• 迪米特原则
  一个对象应当对其他对象尽可能少的了解，降低各个对象之间的耦合，提高系统的可维护性。在模块之间应该只通过接口编程，而不理会模块的内部工作原理，它可以使各个模块耦合度降到最低，促进软件的复用。

设计模式分类

• 创建型模式（对象的创建）：简单工厂、工厂方法、抽象工厂、建造者、原型、单例
• 结构型模式（对象的组成）：外观、适配器、代理、装饰、桥接、组合、享元
• 行为型模式（对象的行为）：模板方法、观察者、状态、职责链、命令、访问者、策略、备忘录、迭代、解释器

单个设计模式介绍

简单工厂模式

public class FoodFactory {

    private FoodFactory() {}

    public static Food creatFood(String name) {
        if(name != null && name.length() > 0) {
            if (name.equalsIgnoreCase("noodles")) {
                return new Noodles();
            } else if (name.equalsIgnoreCase("Chicken")) {
                return new Chicken();
            }
        }
        return null;
    }
}
public static void main(String[] args) {
        Food food1 = FoodFactory.creatFood("noodles");
        Food food2 = FoodFactory.creatFood("Chicken");
        food1.smell();
        food2.smell();
    }

又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例。客户端不需要在负责对象的创建，从而明确了各个类的职责。这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护。

工厂方法模式

public interface AnimalFactory {
    public abstract Animal creatAnimal();
}
public class DogFactory implements AnimalFactory {
    @Override
    public Animal creatAnimal() {
        return new Dog();
    }
}
public static void main(String[] args) {
        DogFactory dogFactory = new DogFactory();
        Animal animal = dogFactory.creatAnimal();
        animal.eat();
        CatFactory catFactory = new CatFactory();
        Animal animal1 = catFactory.creatAnimal();
        animal1.eat();
}

工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。
客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性。
缺点就是需要额外的编写代码，增加了工作量。

单例模式

//饿汉式
public class Student {
    private Student(){}
    private static Student student = new Student();

    public static Student getStudent() {
        return student;
    }

}
//懒汉式
public class Student {
    private Student(){}
    private static Student student = null;

    public static Student getStudent() {
        if(student == null) {
            student = new Student();
        }
        return student;
    }

}
public static void main(String[] args) {
        Student student1 = Student.getStudent();
        Student student2 = Student.getStudent();
        System.out.println(student1 == student2);
    }

单例模式就是要确保类在内存中只有一个对象，该实例必须自动创建，并且对外提供。
在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。
缺陷在于没有抽象层，因此扩展很难；职责过重，在一定程序上违背了单一职责。
构建单例模式的要点在于不能让外界直接创建实例。
两种单例模式对比
饿汉式：使用不会有什么问题（除非类加载时系统开销特别大）。
懒汉式：体现懒加载思想。但会有线程安全问题，解决方式是方法上加同步锁。
代码运用实例：Runtime类
每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。应用程序不能创建自己的 Runtime 类实例。
有个常用的方法：exec() 在单独的进程中执行指定的字符串命令。

Runtime r = Runtime.getRuntime();
    r.exec("winmine");扫雷
    r.exec("notepad");记事本
    r.exec("calc");计算器
    r.exec("shutdown -s -t 10000"); 10000秒后关机
    r.exec("shutdown -a");取消关机命令。