面向对象思想的设计原则
1.单一职责原则
2.开闭原则
3.里氏替换原则
4.依赖注入原则
5.接口分离原则
6.迪米特原则
一、单一职责原则
高内聚、低耦合：自己能做的，就不麻烦别人。
即：
每个类应该只有一个职责，对外只能提供一种功能，而引起类变化的原因应该只有一个，在设计模式中，所有的设计模式都遵循这一原则。
二、开闭原则（open closed principle）ocp原则
核心思想：一个对象对扩展开放，对修改关闭。
对类的改动是通过增加代码进行的，而不是修改现有的代码。
也就是说软件开发人员一旦写出了可以运行的代码，就不应该去改动它，而是要保证它能一直运行下去。这需要借助于抽象和多态，即把可能变化的内容抽象出来，从而使抽象的部分是相对稳定的，而具体的实现则是可以改变的和扩展的。
三、里氏替换原则
核心思想：在任何父类出现的地方都可以用它的子类来替代。即：同一个继承体系中的对象，应该有共同的行为特征。
四、依赖注入原则
核心思想：要依赖于抽象，不要依赖于具体的实现。即在应用程序中，所有的类如果使用或依赖于其他的类，则应该依赖于这些其他类的抽象类，而不是这些其他类的具体类。
为了实现这一原则，就要求我们在编程的时候针对抽象类或者接口编程，而不是针对具体的实现编程。
五、接口分离原则
核心思想：不应该强迫程序依赖他们不需要的方法，即 一个接口不需要提供太多的行为，一个接口应该只提供一种对外的功能，不应该把所有的操作都封装到一个接口中。
六、迪米特原则
核心思想：一个对象应当对其他的对象尽可能的了解，即 降低个个对象间的耦合，提高系统的可维护性，在模块间应该只通过接口编程，而不会理会模块的内部工作原理，它可以使各个模块耦合度讲到最低，促进软件的复用。
总结：高内聚、低耦合、可复用。
设计模式（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;
}
}
java
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。