1.面向对象的三大特性
1）封装（Encapsulation）
隐藏对象的具体实现细节，通过共有方法暴露对象的功能。内部结构可以自由修改，同时可对成员进行更加精确的控制 (比如在setter方法中加值合法判断)
2）继承（Inheritance）
使用已经存在的类作为基础类（父类），在此基础上建立新类（子类）， 子类既可复用父类的功能，也能进行扩展，从而实现代码复用。 另外，Java不能像C++那样同时继承多个父类，只能树形的继承， 比如：Man -> Human -> Animal，或通过接口和内部类实现多继承。
另外，关于继承还需注意以下几点：
1.子类拥有父类非private的属性与方法
2.构造方法只能调用，不能实现，子类默认调用父类的无参构造方法，
如果父类没有无参的构造方法，需要使用super显式调用！
3.慎用继承，要考虑是否需要从子类向父类进行向上转型！
3）多态（Polymorphism）
定义：一个类实例的相同方法在不同的情形下有不同的表现形式
分为以下两种：
编译时多态（OverLoading）——方法重载
运行时多态（OverRidding）——继承+方法重写+向上转型(父类引用指向子类对象)
运行时多态(动态绑定，new后面什么类型，动态类型就是什么类型)
示例如下：
C++代码
class Animal() { fun show() { println("动物") }}
class People：Animal() { fun show() { println("人类") }}
//下述代码打印结果：人类
Animal animal = new People()
animal.show()
口诀：鸡湿衣冠剧组(继承，实现，依赖，关联，聚合，组合)
继承和实现就不说了，后面四个只是语意层次的区别
两个类的相关程度，依赖<关联<聚合<组合
依次的UML类图标记：
继承/泛化（Generalization）： 子类
父类
实现（Realization）：实现类
接口
依赖（Dependency）：不持有引用，具体表现：局部变量，函数参数，
返回值使用
依赖类，比如大佬依赖于递茶小弟；
关联（Association）：持有引用，具体表现：成员变量， 箭头指向被关联类，可双向，一对多或多对多：
聚合（Aggregation）：成员变量，关联是处于同一层次的，而聚合则 是整体和局部层次的，比如：社团和小弟，另外即使没有了社团， 小弟们依旧可以到别的地方搞事情。
组合（Composition）：与聚合类似，程度更加强烈，共生死，组合类负责被组合类的生命周期，比如：社团和大佬，如果没了社团， 大佬也就就不能存在了。
单一职责原则（Single Responsibility Principle）
每一个类应该专注于做一件事情。 即：高内聚，低耦合。
开闭原则（Open Close Principle）
一个对象对扩展开放，对修改关闭。即：对类的改动是通过增加代码进行的，而不是修改现有代码。
里氏替换原则（Liskov Substitution Principle）
在任何父类出现的地方都可以用它的子类来替代。
依赖倒置原则（Dependence Inversion Principle）
要依赖于抽象，不要依赖于具体实现。
接口隔离原则（Interface Segregation Principle）
应当为客户端提供尽可能小的单独的接口，而不是提供大的总的接口。
迪米特原则（Law Of Demeter）
一个对象应当尽量少地与其他对象之间发生相互作用，使得系统功能模块相对独立。
组合/聚合复用原则（Composite/Aggregate Reuse Principle）
尽量使用组合/聚合的方式，而不是使用继承。
创建型（5种）：主要用于处理对象的创建，实例化对象：
单例，建造者，原型，工厂方法，抽象工厂
结构型（7种）：处理类或对象间的组合
适配器，装饰者，结合，桥接，外观，享元，代理
行为型（11种）：描述类或对象怎样进行交互和职责分配
策略，观察者，迭代器，命令，备忘录，中介者，解释器，访问者，责任链，状态，模板方法
作用：保证类在内存中的对象唯一性。
适用场景：
1.避免创建多个实例浪费资源
2.避免多个实例因多次调用而出现错误
3.一般写工具类，线程池，缓存，数据库会用到。
套路(三个要点)：
1.不允许在类外new对象 ——构造方法私有化
2.在类中创建对象 ——通过new在本类中创建一个实例
3.对外提供获取该实例的方法 ——定义公有方法返回创建的实例
饿汉与懒汉的区别
前者在类装载时就实例化，后者只有在第一次被使用时才实例化。 (饿汉的优点是避免线程同步问题，缺点是即使没用到这个实例还是会加载) (懒汉的优点是实现了懒加载，但需要解决线程安全问题！)
7种单例套路：
1）饿汉式，没有实现懒加载~
Java代码
public class Singleton() {
private static Singleton instance = new Singleton();
private Singleton(){ }
public static Singleton getInstance() {
return instance;
}
}
//获取单例对象
Singleton mSingleton = Singleton.getInstance();
2）懒汉式
虽然达到了懒加载，但是却存在线程安全问题，比如有两个线程都刚好执行完if(instance == null)，接着准备执行instance = new Singleton() 语句，这样的结果会导致我们实例化了两个Singleton对象，为了解决线程不安全问题，可以对getInstance()方法加锁。
Java代码
public class Singleton {
private static Singleton instance = null;
private Singleton() { }
private static Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}
3）懒汉式加锁版
为getInstance方法加锁虽然保证了线程安全，但是每次执行getInstance() 都需要同步，而实例化对象只需要执行一次就够了，后面获取该示例， 应该直接return就好了，方法同步效率太低，一种改进后的写法是：synchronized (Singleton.class) { instance = new Singleton(); }但是，这样写依然是线程不安全的，如果你还是想用懒汉式的话，推荐双重检查锁定（DCL，Double Check Lock）。
Java代码
public class Singleton {
private static Singleton instance = null;
private Singleton() { }
private static synchronized Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}
4）懒汉式双重校验锁（DCL）
代码中进行了两次if检查，这样就可以保证线程安全，初始化一次后，后面再次访问时，if检查，直接return 实例化对象。volatile是1.5后引入的，volatile关键字会屏蔽Java虚拟机所做的一些代码优化，会导
致系统运行效率降低，而更好的写法是使用静态内部类来实现单例！
Java代码
public class Singleton{
private static volatile Singleton instance = null;
private Singleton() { }
public static Singleton getInstance() {
if(instance == null) {
synchronized(Singleton.class) {
if(instance == null) instance = new Singleton();
}
}
return instance;
}
}
5）静态内部类实现单例（推荐）
和饿汉式类似，都是通过类加载机制来保证初始化实例的时候只有一个线程，从而避免线程安全问题，饿汉式的Singleton类被加载时，就会实例化，而静态内部类这种，当Singleton类被加载时，不会立即实例化，调用getInstance() 方法才会装载SingletonHolder类，从而完成Singleton的实例化。
Java代码
public class Singleton {
private Singleton() { }
private static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton()
}
}
6）枚举实现单例
INSTANCE即为SingletonEnum类型的引用，得到它就可以调用
枚举中的方法。既避免了线程安全问题，还能防止反序列化
重新创建新的对象，但是失去了类的一些特性，而且没有延时加载。
Java代码
public enum SingletonEnum {
INSTANCE;
private Singleton instance;
SingletonEnum() {
instance = new Singleton();
}
public Singleton getInstance() {
return instance;
}
}
//调用方式
SingletonEnum.INSTANCE.method();
7）容器实现单例
将多种单例类型注入到一个统一的管理类中，在使用时根据key获取对象
对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使
用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用
户隐藏了具体实现，降低了耦合度。
Java代码
public class SingletonManager {
private static Map<String,Object> objMap = new HashMap<String,Object>();
private Singleton(){ }
public static void registerService(String key,Object instance) {
if(!objMap.containsKey(key)) {
objMap.put(key,instance);
}
}
public static Object getService(String key) {
return objMap.get(key);
}
}
将复杂对象的构建与表示分离开来，使得同样的构建过程可以创建不同的表示，缺点是可能产生多余的创建者与构建过程对象，消耗内存，不适用于内部建造顺序不稳定，变化复杂的对象，可能导致需要创建很多具体的建造者来实现这些变化。
例子：玩游戏创建角色时的自定义，不同的搭配生成不同的角色。
四个角色与UML类图
示例代码：
Java代码
//产品类
class Character {
private String sex;
private String face;
private String clothes;
void setSex(String sex) { this.sex = sex;}
void setFace(String face) { this.face = face; }
void setClothes(String clothes) { this.clothes = clothes;}
String showMsg() { return "你创建了一个穿着 " + clothes + " 一副 " + face + " 的" + sex + "ヾ(≧▽≦*)o 戳菊狂笑~"; }
}
//抽象Builder接口
interface Builder {
void setSex(String sex);
void setFace(String face);
void setClothes(String clothes);
Character build();
}
//Builder接口实现类
class ConcreteBuilder implements Builder {
private Character mCharacter = new Character();
@Override public void setSex(String sex) { mCharacter.setSex(sex); }
@Override public void setFace(String face) { mCharacter.setFace(face); }
@Override public void setClothes(String clothes) { mCharacter.setClothes(clothes); }
@Override public Character build() {return mCharacter;}
}
//装配过程类
class Director {
private Builder mBuilder = null;
Director(Builder builder) { this.mBuilder = builder; }
Character createCharacter(String sex, String face, String clothes) {
this.mBuilder.setSex(sex);
this.mBuilder.setFace(face);
this.mBuilder.setClothes(clothes);
return mBuilder.build();
}
}
//客户端调用类
public class Game {
public static void main(String[] args) {
Builder builder = new ConcreteBuilder();
Director director = new Director(builder);
Character character = director.createCharacter("基佬","硬汉脸","死库水");
System.out.println(character.showMsg());
}
}
输出结果：
下面两种场景可以考虑使用原型模式：
1.当初始化类对象需要消耗非常多资源，或者说要进行繁琐
的数据准备或者权限，如果想简化创建，可以使用原型模式。
2.一个对象提供给其他对象访问，而各个调用者可能都需要
修改对象的值，可以考虑使用原型模式克隆多个对象供调用者
使用（保护性拷贝）
三个角色与UML类图
Java中 == 与equals的区别
==，基本数据类型(int,long等)，比较存储的值是否相等
对比的是引用类型，比较的是所指对象地址是否相等
equals，不能用于比较基本数据类型，如果**没对equals()方法进行重写，比较的是指向的对象地址，如果想要比较对象内容，需要自行重写**方法，做相应的判断！！！！String调equals是可以判断内容是否一样，是因为对equals()方法进行了重写，具体可参见源码！
克隆需要满足的三个条件
1.x.clone()!=x，即不是同一对象
2.x.clone().getClass == x.getClass()，即对象类型一致
3.如果对象obj的equals()方法定义恰当的话，那么
obj.clone().equals(obj) == true应当是成立的。(推荐，不强制)
Java中如何使用
Prototype原型类(想被克隆的类)实现Cloneable接口，重写clone()方法。
Java代码
ConcretePrototype cp1 = new ConcretePrototype();
ConcretePrototype cp2 = (ConcretePrototype)cp1.clone();
需注意：
1.执行克隆方法，不会调用构造方法
2.克隆会生成的新的对象成员，但指向的却是同一个内存地址！
3.克隆前后数据类型一致！
4.克隆的时候，类中基本数据类型的属性会新建，但是引用类型的
只会生成个新的引用变量，引用变量的地址依旧指向同一个内存地址！
实现深拷贝的两种套路：
这种只新建基本类型数据，不新建引用类型数据，称为浅拷贝，如果连引用类型数据也新建的话，则称为深拷贝。
两个套路：
1.引用类型也实现Cloneable接口，如果属性的类型也是对象，那么需要一直递归的克隆下去
2.序列化，属性的类型是引用类型的话，需要实现Serializable接口，然后自己写个方法来在里面**完成对象转二进制流与二进制流转对象**的方法，然后返回克隆后的对象！
具体代码见：3.Prototype Pattern
四.工厂方法模式（Factory Method Pattern）
关于三种工厂模式，其实理解起来非常简单，只是把对象的创建放到一个特定的类中，相比起我们直接new对象，这种套路会写多几个类，但是却拥有更好的扩展性，而且当创建的对象发生改变，可以减少一定的修改量。(想想你在项目中有一个类在多处都new了，现在需要对这个类的构造方法，或者相关参数做些修改，你需要找到每个new这个类的地方进行修改，而如果你把工作都丢给一个工厂类，你可能只需要修改这个类) 另外，简介下这几种工厂模式的区别：
简单工厂模式：最简单的直接把new对象丢到一个工厂类中；
工厂方法模式：对工厂类进行抽象，实现具体工厂类以创建不同对象；
抽象工厂模式：当工厂需要创建多种相互关联或依赖的对象，有两个名
产品等级结构与产品族，具体是什么的自己看~
简单工厂模式的三个角色：
代码示例：
Java代码
abstract class Tea {
public abstract void 加奶茶();
public abstract void 加料();
}
class YeGuoTea extends Tea{
@Override public void 加奶茶() { System.out.println("加了一把奶茶");}
@Override public void 加料() {System.out.println("加了一把椰果");}
}
class ZhenZhuTea extends Tea{
@Override public void 加奶茶() { System.out.println("加了一把奶茶");}
@Override public void 加料() {System.out.println("加了一把珍珠");}
}
public class Me {
public static Tea makeTea(int type) {
System.out.println("==============");
Tea tea = type == 0 ? new ZhenZhuTea() : new YeGuoTea();
tea.加奶茶();
tea.加料();
return tea;
}
}
public class Store {
public static void main(String[] args) {
for (int i = 0;i < 3;i++) {
Tea tea = Me.makeTea(buyTea()); //小猪制作奶茶
}
}
/* 模拟用户下单，0代表要珍珠奶茶，1代表要椰果奶茶 */
private static int buyTea() {
return new Random().nextInt(2);
}
}
输出结果：
工厂方法模式(静态工厂)：
其实就是在简单工厂模式基础上，把工厂创建不同产品的内部逻辑抽取出来，生成一个抽象工厂，再创建具体工厂类，生产不同的产品。
UML类图
代码示例：
Java代码
//工厂接口/抽象类
abstract class MakeTea {
abstract Tea 小猪带特效的奶茶制作工艺();
}
//工厂实现类1
class ZhenZhuMakeTea extends MakeTea {
@Override
Tea 小猪带特效的奶茶制作工艺() {
System.out.println("====== 珍珠小弟炮制港式珍珠奶茶 ======");
Tea tea = new ZhenZhuTea();
tea.加奶();
tea.加茶();
tea.加料();
tea.打包();
return tea;
}
}
//工厂实现类2
class YeGuoMakeTea extends MakeTea {
@Override
Tea 小猪带特效的奶茶制作工艺() {
System.out.println("====== 椰果小弟炮制日式椰果奶茶 ======");
Tea tea = new YeGuoTea();
tea.加奶();
tea.加茶();
tea.加料();
tea.打包();
return tea;
}
}
//客户端调用
public class StoreS {
public static void main(String[] args) {
//初始化两个小弟
ZhenZhuMakeTea zhenzhu = new ZhenZhuMakeTea();
YeGuoMakeTea yeguo = new YeGuoMakeTea();
for (int i = 0;i < 3;i++) {
Tea tea = buyTea() == 0 ? zhenzhu.小猪带特效的奶茶制作工艺()
: yeguo.小猪带特效的奶茶制作工艺();
}
}
/* 模拟用户下单，0代表要珍珠奶茶，1代表要椰果奶茶 */
private static int buyTea() {
return new Random().nextInt(2);
}
}
输出结果：
