设计模式
设计模式
充分利用面向对象的原则：封装、继承、多态和组合等而产生的
为什么要学习设计模式？
-
提高思维和编程能力
-
对大型项目和项目构建很有好处
-
使代码的重用性高、维护性好、可靠性高、灵活性强
单例模式
饿汉模式
//饿汉单例
public class Hungry {
//可能会浪费资源，因为所有东西都加载到内存中，因此未来解决这个，出现了懒汉
byte[] bytes0 = new byte[1024];
byte[] bytes1 = new byte[1024];
byte[] bytes2 = new byte[1024];
private Hungry(){
}
private final static Hungry HUNGRY = new Hungry();
public static Hungry getInstance(){
return HUNGRY;
}
}
懒汉模式
//懒汉式单例
public class LazyMan {
private LazyMan(){
System.out.println(Thread.currentThread().getName() + "ok");
}
private static LazyMan lazyMan;
public static LazyMan getInstance(){
if (lazyMan == null){
lazyMan = new LazyMan();
}
return lazyMan;
}
//多线程模式
public static void main(String[] args) {
for (int i = 0 ; i < 10 ; i++){
new Thread(() -> {
LazyMan.getInstance();
}).start();
}
}
}
多线程模式下，会造成混乱，因此得解决这个办法
//懒汉式单例
public class LazyMan {
private LazyMan(){
System.out.println(Thread.currentThread().getName() + "ok");
}
private volatile static LazyMan lazyMan;
//双重检测，加锁 DCL懒汉模式
public static LazyMan getInstance(){
if(lazyMan == null){
synchronized (LazyMan.class){
if (lazyMan == null){
lazyMan = new LazyMan(); //有可能发生错误，因为这不是一个原子性操作
/**
* 正常：
* 1.分配内存空间
* 2.执行构造方法，初始化对象
* 3.把这个对象执向这个空间
*
* 正常：123
* 重排：132
*
* A线程可能先执行132，没问题；
* 到了B时，由于A已经执分配的空间了，所以程序认为B不等于NULL
* 直接return lazyMan ,但是此时lazyMan还没完成构造,这时候，B线程空间是一片空的
* 就可能产生问题，因此一定要加volatile
*/
}
}
}
return lazyMan;
}
//多线程模式
public static void main(String[] args) {
for (int i = 0 ; i < 10 ; i++){
new Thread(() -> {
LazyMan.getInstance();
}).start();
}
}
}
工厂模式
创建者和调用者分离
简单工厂模式
具体代码实现
//汽车的接口
public interface Car {
void name();
}
//车工厂的实现
public class CarFactory {
//方法一
public static Car getCar(String car){
if (car.equals("五菱")){
return new Wuling();
}else if(car.equals("特斯拉")){
return new Tesla();
}else{
return null;
}
}
/**
//方法二
public static Car getWuling(){
return new Wuling();
}
public static Car getTesla(){
return new Tesla();
}
*/
}
//五菱汽车的实现
public class Wuling implements Car {
@Override
public void name() {
System.out.println("五菱宏光");
}
}
//特斯拉的实现
public class Tesla implements Car {
@Override
public void name() {
System.out.println("特斯拉汽车");
}
}
//消费者的实现类
public class Consummer {
public static void main(String[] args) {
Car car = CarFactory.getCar("五菱");
Car car1 = CarFactory.getCar("特斯拉");
car.name();
car1.name();
}
}
简单工厂模式不满足开闭原则，增加汽车实现类要修改工厂类的代码
工厂方法模式
//car接口
public interface Car {
void name();
}
//car工厂接口
public interface CarFactory {
Car getCar();
}
车工厂
public class WulingFactory implements CarFactory {
@Override
public Car getCar() {
return new Wuling();
}
}
public class TeslaFactory implements CarFactory {
@Override
public Car getCar() {
return new Tesla();
}
}
public class MobikeFactory implements CarFactory {
@Override
public Car getCar() {
return new Mobike();
}
}
汽车实现类
public class Wuling implements Car {
@Override
public void name() {
System.out.println("五菱宏光");
}
}
public class Mobike implements Car {
@Override
public void name() {
System.out.println("摩拜单车");
}
}
public class Tesla implements Car {
@Override
public void name() {
System.out.println("特斯拉汽车");
}
}
消费者
public class Consummer {
public static void main(String[] args) {
Car car = new WulingFactory().getCar();
Car car1= new TeslaFactory().getCar();
Car car2 = new MobikeFactory().getCar();
car.name();
car1.name();
car2.name();
}
}
虽然说工厂方法模式保证了封闭原则，但是具体情况具体分析，有时候简单工厂更好用
抽象工厂模式
生产工厂的超级工厂
个人理解：有一个手机的概念（接口）后，有人去实现，于是有了手机这个产品，不同的人做出不同的手机，比如华为做出了华为手机，小米做出了小米手机。
华为、小米等可以理解为生产不同产品的工厂，他们即可以生产手机，也可以生产路由器，因此华为和小米的可以抽象成一个超级工厂的概念(接口)。
手机接口
public interface Phone {
void start();
void shotdown();
void call();
void sendmessage();
}
路由器接口
public interface Router {
void start();
void close();
void openwifi();
}
手机实现类
//华为的实现
public class HuaweiPhone implements Phone {
@Override
public void start() {
System.out.println("华为手机开机");
}
@Override
public void shotdown() {
System.out.println("华为手机关机");
}
@Override
public void call() {
System.out.println("华为手机打电话");
}
@Override
public void sendmessage() {
System.out.println("华为手机发消息");
}
}
//小米的实现
public class XiaomiPhone implements Phone {
@Override
public void start() {
System.out.println("小米手机开机");
}
@Override
public void shotdown() {
System.out.println("小米手机关机");
}
@Override
public void call() {
System.out.println("小米手机打电话");
}
@Override
public void sendmessage() {
System.out.println("小米手机发消息");
}
}
路由器实现
//华为路由器实现
public class HuaweiRouter implements Router{
@Override
public void start() {
System.out.println("华为路由器开机");
}
@Override
public void close() {
System.out.println("华为路由器关机");
}
@Override
public void openwifi() {
System.out.println("华为路由器打开wifi");
}
}
//小米路由器实现
public class XiaomiRouter implements Router {
@Override
public void start() {
System.out.println("小米路由器开机");
}
@Override
public void close() {
System.out.println("小米路由器关机");
}
@Override
public void openwifi() {
System.out.println("小米路由器打开wifi");
}
}
超级工厂的概念（接口）
public interface ProductFactory {
//生产手机
Phone phoneProduct();
//生产路由器
Router routerProduct();
}
华为工厂
public class HuaweiFactory implements ProductFactory {
@Override
public Phone phoneProduct() {
return new HuaweiPhone();
}
@Override
public Router routerProduct() {
return new HuaweiRouter();
}
}
小米工厂
public class XiaomiFactory implements ProductFactory{
@Override
public Phone phoneProduct() {
return new XiaomiPhone();
}
@Override
public Router routerProduct() {
return new XiaomiRouter();
}
}
客户端
public class Client {
public static void main(String[] args) {
System.out.println("==================小米产品======================");
XiaomiFactory xiaomiFactory = new XiaomiFactory();
//小米手机
Phone xiaomiPhone = xiaomiFactory.phoneProduct();
xiaomiPhone.start();
xiaomiPhone.call();
xiaomiPhone.sendmessage();
xiaomiPhone.shotdown();
//小米路由器
Router xiaomiRouter = new XiaomiFactory().routerProduct();
xiaomiRouter.start();
xiaomiRouter.openwifi();
xiaomiRouter.close();
System.out.println("==================华为产品======================");
HuaweiFactory huaweiFactory = new HuaweiFactory();
//华为手机
Phone huaweiPhone = huaweiFactory.phoneProduct();
huaweiPhone.start();
huaweiPhone.call();
huaweiPhone.sendmessage();
huaweiPhone.shotdown();
//华为路由器
Router huaweiRouter = new HuaweiFactory().routerProduct();
huaweiRouter.start();
huaweiRouter.openwifi();
huaweiRouter.close();
}
}
浙公网安备 33010602011771号