不要担心冗长，3分钟解决面试和学习问题，收藏再看
目的：当作一种模板，结合自身特点，针对项目需求来使用
单例模式
特点：
实现方式：
1、饿汉式
2、线程安全的懒汉式
3、双重校验锁
4、静态内部类
使用经验：
工厂模式
特点：
实现方式：
1、简单工厂模式
2、工厂方法模式
3、抽象工厂模式
编辑
使用经验:
适配器模式
组成：
特点：
实现方式：
编辑
使用经验：
代理模式
特点：
实现方式：
1、静态代理：
2、动态代理
编辑
使用经验：
观察者模式
特点：
实现方式：
编辑
使用经验:
先初始化好变量，需要时直接返回
//Kotlin
object Singleton{
}
//Java
public class Singleton{
private Singleton(){}
private static Singleton instace = new Singleton();
public static Singleton getInstance(){
return instance;
}
}使用同步锁解决懒汉式线程安全问题
//Kotlin
Class Singleton private constructor(){
companion object{
private var instance:Singleton? = null
get(){
if(field == null) {
field = Singleton()
}
return field
}
@Synchronized
fun getInstance() = instance!!
}
//Java
public class Singleton{
private Singleton(){}
private static Singelton instance;
public static sychronized Singleton getInstance(){
if(instance==null){
instance = new Singleton();
}
return instance;
}
}考虑线程安全，基于同步锁来创建并返回唯一实例对象
//Kotlin
companion object{
val instance:Singleton by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
Singleton()
}
}
//Java
public class Singleton{
private volatile static Singleton instance;
private Singleton(){}
public static Singleton getInstance(){
if(instace == null){
synchronized(Singleton.class){
if(instance == null){
instance = new Singleton();
}
}
}
return instance;
}
}静态提供单个实例，实例通过内部类创建
//Kotlin
class Singleton private constructor(){
companion object{
val instance = SingletonHolder.holder
}
private object SingletonHolder{
val holder = Singleton()
}
}
//Java
public class Singleton{
private static class SingletonHolder{
private static Singleton instance = new Singleton();
}
private Singleton(){}
public static Singleton getInstance(){
return SingletonHolder.instance;
}
}只创建一个工厂，工厂可以产多个产品（利用接口实现统一）
接口：
产品类:
class CarA :ICar {
private lateinit var color: String
private lateinit var engine:String
private lateinit var wheels:String
private lateinit var system:String
override fun printColor() {
color = "red"
println("it is red")
}
override fun installEngine() {
engine = "EngineA"
println("it is $engine")
}
override fun installWheels() {
TODO("Not yet implemented")
}
override fun installSystem() {
TODO("Not yet implemented")
}
override fun doit(){
printColor()
installEngine()
}
override fun toString(): String {
return "$color+$engine"
}
}
工厂类：
class SimpleFactory {
companion object{
val CAR_A = "CarA"
val CAR_B = "CarB"
fun buildCar(type:String):ICar?{
var car:ICar? = null
when(type){
CAR_A-> car = CarA()
CAR_B-> car = CarB()
}
car?.doit()
return car
}
}
}
通过工厂创建：
val A = SimpleFactory.buildCar(SimpleFactory.CAR_A)
输出结果：
多产品类对应多工厂，所有产品类对应一个接口（统一产品大致操作），所有工厂类对应一个接口（统一工厂的大致操作如“生产产品”）
产品接口：
interface ICar {
fun printColor()
fun installEngine()
fun installWheels()
fun installSystem()
fun doit()
}
工厂接口：
interface IFactory {
fun buildCar():ICar
}
工厂类同简单工厂模式一致
新增产品类如CarC，同样实现ICar接口，创建对应工厂C来实现IFactory接口
class CCarFactory:IFactory {
private val carC = CarC()
override fun buildCar(): ICar {
carC.doit()
return carC
}
}
有多个工厂，一个工厂可以生产多种产品（工厂间一个接口统一，同类产品间一个接口统一）
多产品统一接口：
多个工厂，接口统一:
不修改现有代码，将不兼容的类组合在一起
在代理类构造中真实类，最后由调用代理类的同名方法实现真实类的功能
代理对象不需要接口，利用JDK的API动态构建代理对象
可以手动添加多个观察者，当观察对象调用某些方法，会通知并更新所有观察者的信息
所有观察者以集合形式存储在对象类里
添加观察者：
通知所有观察者数据更新：