设计模式
1、简单工厂设计模式
简单工厂模式最大的优点在于实现对象的创建和对象的使用分离，将对象的创建交给专门的工厂类负责，但是其最大的缺点在于工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑代码，而且产品较多时，工厂方法代码将会非常复杂。
简单工厂模式包含如下角色：
-
Factory：工厂角色
工厂角色负责实现创建所有实例的内部逻辑
-
Product：抽象产品角色
抽象产品角色是所创建的所有对象的父类，负责描述所有实例所共有的公共接口
-
ConcreteProduct：具体产品角色
具体产品角色是创建目标，所有创建的对象都充当这个角色的某个具体类的实例。
类图：
2、工厂方法模式
优点：
此模式中，通过定义一个抽象的核心工厂类，并定义创建产品对象的接口，创建具体产品实例的工作延迟到其工厂子类去完成。这样做的好处是核心类只关注工厂类的接口定义，而具体的产品实例交给具体的工厂子类去创建。当系统需要新增一个产品是，无需修改现有系统代码，只需要添加一个具体产品类和其对应的工厂子类，使系统的扩展性变得很好，符合面向对象编程的开闭原则。
缺点：
工厂方法模式虽然扩展性好，但是增加了编码难度，大量增加了类的数量，所以怎么选择还是看实际的需求。
工厂方法模式包含如下角色：
- Product：抽象产品
- ConcreteProduct：具体产品
- Factory：抽象工厂
- ConcreteFactory：具体工厂
例子：
//宝马和奔驰的共同父类
public class Car {
private String name;
public void run(){
System.out.println(name+"在马路上跑...");
}
...
}
public class BenzCar extends Car{
public BenzCar() {
super("奔驰");
}
}
public class BMWCar extends Car{
public BMWCar() {
super("宝马");
}
}
//定义工厂接口Factory
public interface CarFactory {
//生产一辆车，工厂子类重写这个方法
Car creat();
}
//奔驰车的工厂方法，实现工厂接口，返回新创建的奔驰车实例
public class BenzCarFactory implements CarFactory{
@Override
public Car creat() {
return new BenzCar();
}
}
//宝马车的工厂方法，实现工厂接口，返回新创建的奔驰车实例
public class BMWCarFactory implements CarFactory{
@Override
public Car creat() {
return new BMWCar();
}
}
所以当新增一个产品时，我们只需要新增一个实现了工厂接口的工厂方法和产品实体类。
3、抽象工厂
例1： 用抽象工厂模式设计农场类。
分析：农场中除了像畜牧场一样可以养动物，还可以培养植物，如养马、养牛、种菜、种水果等。
本例用抽象工厂模式来设计两个农场，一个是韶关农场用于养牛和种菜，一个是上饶农场用于养马和种水果，可以在以上两个农场中定义一个生成动物的方法 newAnimal() 和一个培养植物的方法 newPlant()。
// 抽象动物类
public interface Animal {
public void disc();
}
// 为两个农场实现动物类
public class Cattle implements Animal{
@Override
public void disc() {
System.out.println("奶牛产的奶真纯啊");
}
}
public class Horse implements Animal{
@Override
public void disc() {
System.out.println("马儿跑的真快啊");
}
}
// 抽象植物类
public interface Plant {
}
// 为两个农场实现植物类
public class Fruit implements Plant{
}
public class Vegetable implements Plant{
}
// 为两个农场抽象农场类
public abstract interface Farm {
abstract Animal creatAnimal();
abstract Plant creatPlant();
}
// 上饶农场产出奶牛和蔬菜
public class SGfarmFactory implements Farm{
@Override
public Animal creatAnimal() {
return new Cattle();
}
@Override
public Plant creatPlant() {
return new Vegetable();
}
}
// 韶关农场产出马和水果
public class SRfarmfFactory implements Farm{
@Override
public Animal creatAnimal() {
return new Horse();
}
@Override
public Plant creatPlant() {
return new Fruit();
}
}
// 测试类
public class Main {
public static void main(String[] args) {
SRfarmfFactory sRfarmfFactory = new SRfarmfFactory();
Animal animal = sRfarmfFactory.creatAnimal();
Plant plant = sRfarmfFactory.creatPlant();
animal.disc();
}
}
抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务、分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。
4 、创建者设计模式
public class Computer {
// 鼠标
public String mouse;
// 键盘
public String keyboard;
// cpu
public String cpu;
// 内存
public String memoryBank;
// 主板
public String mainBoard;
// 省略构造器、get set方法、toString()
// 生产电脑的生成器
class ComputerBuilder{
private final Computer computer = new Computer();
public ComputerBuilder buildMouse(String type){
computer.setMouse(type);
return this;
}
public ComputerBuilder buildKeyboard(String type){
computer.setKeyboard(type);
return this;
}
public ComputerBuilder buildCpu(String type){
computer.setCpu(type);
return this;
}
public ComputerBuilder buildMemoryBank(String type){
computer.setMemoryBank(type);
return this;
}
public ComputerBuilder buildMainBoard(String type){
computer.setMainBoard(type);
return this;
}
public Computer build(){
return computer;
}
}
// 测试类
public class Main {
public static void main(String[] args) {
Computer computer = new ComputerBuilder()
.buildMainBoard("华硕")
.buildCpu("英特尔")
.buildMemoryBank("三星")
.buildKeyboard("雷柏")
.buildMouse("罗技")
.build();
System.out.println(computer);
}
}
5、 单例模式
所谓类的单例设计模式,就是采取一定的方法保证在整个系统中，某个类只能存在一个对象实例（不能自己new 对象）。
首先必须将类的构造器的访问权限设置为 private 。然后对外暴露一个获取该对象的接口，因为不能new，所以只能使用静态方法获取该对象，而静态方法又只能访问类中的静态成员变量，所以，该对象也只能为静态的
单例模式主要分为饿汉式和懒汉式：
饿汉式：（创建时就已经存在对象）
坏处：对象加载时间过长。
好处：饿汉式是线程安全的。
懒汉式：
好处：延迟对象的创建
单例模式的优点：
由于单例模式值生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依靠对象时，则可以用过在应用启动时直接产生一个单例对象，然后永远驻留内存的方式来解决。
1、饿汉式(静态属性)（不推荐）
public class SingletonV1 {
private SingletonV1() {
}
private static SingletonV1 instance = new SingletonV1();
public static SingletonV1 getInstance(){
return instance;
}
}
优点：写法简单，线程安全（类装载的时候就完成实例化，JVM保证了类加载的过程是线程安全的）
缺点：不是懒加载的，如果自始至终未使用该对象，会造成内存浪费
2、饿汉式（静态代码块）（不推荐）
与方式一类似，优缺点一样，只不过将new对象放在了静态代码块中，随着类的加载而加载
3、懒汉式（线程不安全）不推荐
public class SingletonV3 {
private static SingletonV3 instance = null;
private SingletonV3() {
}
private static SingletonV3 getInstance(){
if(instance == null){
instance = new SingletonV3();
}
return instance;
}
}
优点：懒加载
缺点：线程不安全
在多线程的情况下，如果多个线程同时判断instance == null，就会new多次实例，浪费资源
4、懒汉式（线程安全，同步方法）（不推荐）
public class SingletonV4 {
private static SingletonV4 instance = null;
private SingletonV4() {
}
public static synchronized SingletonV4 getInstance(){
if(instance == null){
instance = new SingletonV4();
}
return instance;
}
}
synchronized 解决了第三个线程安全的问题，但多线程环境下，每次执行getInstance()都需要同步，效率太低。
5、懒汉式（线程安全，同步代码块）不推荐
public class SingletonV5 {
private static SingletonV5 instance = null;
private SingletonV5() {
}
public static SingletonV5 getInstance(){
if(instance == null){
synchronized (SingletonV5.class){
instance = new SingletonV5();
}
}
return instance;
}
}
本意是对4的改进，但会遇到和3一样的问题
6、双重检查（懒汉式、线程安全）推荐
public class SingletonV6 {
private static volatile SingletonV6 instance = null;
private SingletonV6() {
}
public static SingletonV6 getInstance(){
if(instance == null){
synchronized (SingletonV6.class){
if (instance == null){
instance = new SingletonV6();
}
}
}
return instance;
}
}
对5的进一步改进，解决了5的问题
注意 该对象要加volatile修饰，
volatile关键字:
-
保证变量的可见性：当一个被volatile关键字修饰的变量被一个线程修改的时候，其他线程可以立刻得到修改之后的结果。
当一个线程向被volatile关键字修饰的变量写入数据的时候，虚拟机会强制它被值刷新到主内存中。
当一个线程用到被volatile关键字修饰的值的时候，虚拟机会强制要求它从主内存中读取。 -
屏蔽指令重排序：指令重排序是编译器和处理器为了高效，对程序进行优化的手段；
它只能保证程序执行的结果时正确的，但是无法保证程序的操作顺序与代码顺序一致。
这在单线程中不会构成问题，但是在多线程中就会出现问题。
非常经典的例子是在单例方法中同时对字段加入voliate，就是为了防止指令重排序。比如在上述第11行中，new instance分解为3步
-
分配内存
-
初始化对象
-
让instance变量指向1中为对象分配的内存地址
如果A线程在11行创建对象并出现了重排序，即先执行了1和3，B线程在第9行就会判断该对象不为空，直接返回一个未初始化的对象。
-
7、静态内部类
8、枚举
后面两种能实现6的效果，但在实际开发中推荐使用6
应用场景
扫一扫
512
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
