设计模式
设计模式 + 反射 + 泛型 + 注解/配置文件等
单例模式
最简单，考的最多的一个设计模式
要点
（1）构造器私有化
（2）在本类中创建这个唯一的实例
分类
//饿汉式
//形式一
class Hungry{
public static final Hungry INSTANCE = new Hungry();
private Hungry(){
}
}
//形式二
class Hungry{
private static final Hungry INSTANCE = new Hungry();
private Hungry(){
}
public static Hungry getInstance(){
return INSTANCE;
}
}
//懒汉式
//形式一：（有线程安全问题）
class Lazy{
private static Lazy instance;
private Lazy(){
}
//延迟创建对象
public static Lazy getInstance(){
if(instance == null){
instance = new Lazy();
}
return instance;
}
}
//形式二：（解决线程安全问题）
//也可以叫双检锁模式
public class Lazy{
private static Lazy instance;
private Lazy(){}
public static Lazy getInstance(){
if(instance == null){
synchronized(Lazy.class){
if(instance == null){
instance = new Lazy();
}
}
}
return instance;
}
}
//枚举式
enum Single{
INSTANCE
}
//是特殊的饿汉式
模板设计模式（识别）
使用的情景
当某个功能在实现时，它的主体的算法结构是确定的，只是其中的某一个或几个步骤无法给出具体的实现，那么这个时候，把这个或几个的步骤抽取成抽象方法，由子类去给出具体的实现，那么子类继承父类时，既可以保留父类的主体算法结构，又可以对这几个抽象部分给出具体的实现
示例代码：
例如：计算某段代码的执行时间
算法结构：
1、获取开始时间
2、执行代码
3、获取结束时间
4、计算差值
public abstract class CalTime{
public final long getTime(){
//1、获取开始时间
long start = System.currentTimeMillis();
//2、执行代码
doWork();
//3、获取结束时间
long end = System.currentTimeMillis();
//4、计算差值
return end - start;
}
protected abstract void doWork();
}
class MyCalTime extends CalTime{
public void doWork(){
.......
}
}
工厂设计模式
为什么要用工厂模式
把创建对象者与对象的使用者分离（把创建者与使用者分离）
解耦合
形式
1、简单工厂模式
特点 一个工厂生产所有产品
缺点 增加一个新产品， 就要修改工厂类代码 违反了“对扩展开发，对修改关闭”的面向对象的设计原则
优点 类少，简单
示例代码
//1、产品的接口
interface Car{
void run();
}
//2、各种产品
class Benz implements Car{
public void run(){
...
}
}
class BMW implements Car{
public void run(){
...
}
}
//3、工厂
class SimpleFactory {
public static Car getCar(String type){
if("benz".equals(type)){
return new Benz();
}else if("bmw".equals(type)){
return new BMW();
}
return null;
}
}
//4、使用者
Car car = SimpleFactory.getCar("benz");
car.run();
2、工厂方法模式
特点 个产品配一个工厂
缺点 类比较多
优点 增加一个新产品，对原来的代码不需要修改，只需要增加对应的工厂即可
示例代码
//1、产品的接口
interface Car{
void run();
}
//2、各种产品
class Benz implements Car{
public void run(){
...
}
}
class BMW implements Car{
public void run(){
...
}
}
//3、各种工厂
interface Factory{
Car getCar();
}
class BenzFactory implements Factory{
public Benz getCar(){
return new Benz();
}
}
class BMWFactory implements Factory{
public BMW getCar(){
return new BMW();
}
}
//4、使用者
BenzFactory f = new BenzFactory();
Car car = f.getCar();
car.run();
3、抽象工厂设计模式
标签：Lazy,return,Car,Hungry,class,设计模式,public From： https://www.cnblogs.com/woniupa/p/17183660.html