1. 工厂模式
1. 概念
工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
- **意图：**定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
- **解决的问题：**主要解决了接口选择的问题
- **如何使用：**我们明确地计划不同条件下创建不同实例时。
- **关键代码：**创建过程在其子类执行。
- 应用实例： 您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。
2. UML 图：
3. 代码实现
Shape 接口
package pri.zsl.jdbc.models.factory;
/**
* @author m1767
*/
public interface Shape {
/**
*画形状
*/
void draw();
}
Circle 实现类
package pri.zsl.jdbc.models.factory;
/**
* @author m1767
*/
public class Circle implements Shape{
/**
* 画形状
*/
@Override
public void draw() {
System.out.println("circle");
}
}
Rectangle 实现类
package pri.zsl.jdbc.models.factory;
/**
* @author m1767
*/
public class Rectangle implements Shape{
/**
* 画形状
*/
@Override
public void draw() {
System.out.println("rectangle!!!!!");
}
}
Factory 类
package pri.zsl.jdbc.models.factory;
/**
* @author m1767
*/
@SuppressWarnings("all")
public class Factory {
public static Shape getShape(String name) {
Shape shape = null;
switch (name) {
case "rectangle":
shape = new Rectangle();
break;
default:
shape = new Circle();
break;
}
return shape;
}
}
Test 测试
package pri.zsl.jdbc.models.factory;
/**
* @author m1767
*/
public class Test {
public static void main(String[] args) {
Shape shape = Factory.getShape("rectangle");
shape.draw();
}
}
结果展示
//rectangle!!!!!
2. 抽象工厂模式
1. 概念
抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
-
**意图：**提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
-
**主要解决：**主要解决接口选择的问题。
-
**何时使用：**系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。
-
**如何解决：**在一个产品族里面，定义多个产品。
-
**应用实例：**工作了，为了参加一些聚会，肯定有两套或多套衣服吧，比如说有商务装（成套，一系列具体产品）、时尚装（成套，一系列具体产品），甚至对于一个家庭来说，可能有商务女装、商务男装、时尚女装、时尚男装，这些也都是成套的，即一系列具体产品。假设一种情况（现实中是不存在的，要不然，没法进入共产主义了，但有利于说明抽象工厂模式），在您的家中，某一个衣柜（具体工厂）只能存放某一种这样的衣服（成套，一系列具体产品），每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用 OOP 的思想去理解，所有的衣柜（具体工厂）都是衣柜类的（抽象工厂）某一个，而每一件成套的衣服又包括具体的上衣（某一具体产品），裤子（某一具体产品），这些具体的上衣其实也都是上衣（抽象产品），具体的裤子也都是裤子（另一个抽象产品）。
2. UML 图
3. 代码实现
抽象工厂类
package pri.zsl.jdbc.models.abstractfactory;
import pri.zsl.jdbc.models.abstractfactory.color.Color;
import pri.zsl.jdbc.models.abstractfactory.shape.Shape;
/**
* @author m1767
*/
public abstract class AbFactory {
/**
*获取Color实现类
* @return Color 返回Color实现类
* @param color 颜色名字
*/
public abstract Color getColor(String color);
/**
*获取 Shape 实现类
* @return Shape 返回 Shape 实现类
* @param shape 颜色名字
*/
public abstract Shape getShape(String shape);
}
ShapeFactory 工厂类
package pri.zsl.jdbc.models.abstractfactory.shape;
import pri.zsl.jdbc.models.abstractfactory.AbFactory;
import pri.zsl.jdbc.models.abstractfactory.color.Color;
/**
* @author m1767
*/
@SuppressWarnings("all")
public class ShapeFactory extends AbFactory {
/**
* 获取Color实现类
*
* @param color 颜色名字
* @return Color 返回Color实现类
*/
@Override
public Color getColor(String color) {
return null;
}
/**
* 获取 Shape 实现类
*
* @param shape 颜色名字
* @return Shape 返回 Shape 实现类
*/
@Override
public Shape getShape(String shape) {
if (shape == null) {
return null;
}
if (shape.equals("rectangle")) {
return new Rectangle();
} else {
return new Circle();
}
}
}
ColorFactory 工厂类
package pri.zsl.jdbc.models.abstractfactory.color;
import pri.zsl.jdbc.models.abstractfactory.AbFactory;
import pri.zsl.jdbc.models.abstractfactory.shape.Shape;
/**
* @author m1767
*/
public class ColorFactory extends AbFactory {
/**
* 获取Color实现类
*
* @param color 颜色名字
* @return Color 返回Color实现类
*/
@Override
public Color getColor(String color) {
if (color == null) {
return null;
}
if ("red".equals(color)) {
return new Red();
}else{
return new Green();
}
}
/**
* 获取 Shape 实现类
*
* @param shape 颜色名字
* @return Shape 返回 Shape 实现类
*/
@Override
public Shape getShape(String shape) {
return null;
}
}
工厂制造类
package pri.zsl.jdbc.models.abstractfactory;
import pri.zsl.jdbc.models.abstractfactory.color.ColorFactory;
import pri.zsl.jdbc.models.abstractfactory.shape.ShapeFactory;
/**
* @author m1767
*/
@SuppressWarnings("all")
public class FactoryProducer {
public static AbFactory getFactory(String choice) {
if ("color".equalsIgnoreCase(choice)){
return new ColorFactory();
}else if ("shape".equalsIgnoreCase(choice)){
return new ShapeFactory();
}
return null;
}
}
Test测试
package pri.zsl.jdbc.models.abstractfactory;
import pri.zsl.jdbc.models.abstractfactory.color.Color;
import pri.zsl.jdbc.models.abstractfactory.shape.Shape;
/**
* @author m1767
*/
public class Test {
public static void main(String[] args) {
// 获取Color工厂
AbFactory abFactory = FactoryProducer.getFactory("color");
// 获取Shape工厂
AbFactory abFactory1 = FactoryProducer.getFactory("shape");
// 获取Color子类
Color color = abFactory.getColor("red");
// 获取Shape子类
Shape shape = abFactory1.getShape("circle");
shape.draw();
color.drawColor();
}
}
结果展示
//circle
//red
3. 单例模式
1. 概念
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
-
注意事项
- 1、单例类只能有一个实例。
- 2、单例类必须自己创建自己的唯一实例。
- 3、单例类必须给所有其他对象提供这一实例。
-
**意图：**保证一个类仅有一个实例，并提供一个访问它的全局访问点。
-
**主要解决：**一个全局使用的类频繁地创建与销毁。
-
**何时使用：**当您想控制实例数目，节省系统资源的时候。
-
**如何解决：**判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
-
**关键代码：**构造函数是私有的。
-
应用实例：
- 1、一个班级只有一个班主任。
- 2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
- 3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。
-
优点：
- 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
- 2、避免对资源的多重占用（比如写文件操作）。
2. UML 图
3. 代码实现
SingleObject 类
package pri.zsl.jdbc.models.single;
/**
* @author m1767
*/
@SuppressWarnings("all")
public class SingleObject {
private static SingleObject singleObject = new SingleObject();
private SingleObject(){
}
public static SingleObject getInstance(){
return singleObject;
}
public void show(){
System.out.println("hello world!!!");
}
}
Test 测试
package pri.zsl.jdbc.models.single;
/**
* @author m1767
*/
public class Test {
public static void main(String[] args) {
SingleObject object = SingleObject.getInstance();
object.show();
}
}
结果展示
//hello world!!!
4. 适配器模式
1. 概念
适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。
这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。举个真实的例子，读卡器是作为内存卡和笔记本之间的适配器。您将内存卡插入读卡器，再将读卡器插入笔记本，这样就可以通过笔记本来读取内存卡。
我们通过下面的实例来演示适配器模式的使用。其中，音频播放器设备只能播放 mp3 文件，通过使用一个更高级的音频播放器来播放 vlc 和 mp4 文件。
-
**意图：**将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
-
**主要解决：**主要解决在软件系统中，常常要将一些"现存的对象"放到新的环境中，而新环境要求的接口是现对象不能满足的。
-
何时使用： 1、系统需要使用现有的类，而此类的接口不符合系统的需要。 2、想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作，这些源类不一定有一致的接口。 3、通过接口转换，将一个类插入另一个类系中。（比如老虎和飞禽，现在多了一个飞虎，在不增加实体的需求下，增加一个适配器，在里面包容一个虎对象，实现飞的接口。）
-
**如何解决：**继承或依赖（推荐）。
-
**关键代码：**适配器继承或依赖已有的对象，实现想要的目标接口。
-
应用实例： 1、美国电器 110V，中国 220V，就要有一个适配器将 110V 转化为 220V。 2、JAVA JDK 1.1 提供了 Enumeration 接口，而在 1.2 中提供了 Iterator 接口，想要使用 1.2 的 JDK，则要将以前系统的 Enumeration 接口转化为 Iterator 接口，这时就需要适配器模式。 3、在 LINUX 上运行 WINDOWS 程序。 4、JAVA 中的 jdbc。
-
优点： 1、可以让任何两个没有关联的类一起运行。 2、提高了类的复用。 3、增加了类的透明度。 4、灵活性好。
-
缺点： 1、过多地使用适配器，会让系统非常零乱，不易整体进行把握。比如，明明看到调用的是 A 接口，其实内部被适配成了 B 接口的实现，一个系统如果太多出现这种情况，无异于一场灾难。因此如果不是很有必要，可以不使用适配器，而是直接对系统进行重构。 2.由于 JAVA 至多继承一个类，所以至多只能适配一个适配者类，而且目标类必须是抽象类。
-
**使用场景：**有动机地修改一个正常运行的系统的接口，这时应该考虑使用适配器模式。
-
**注意事项：**适配器不是在详细设计时添加的，而是解决正在服役的项目的问题。
2. URL图
3. 代码实现
##### AdvanceMediaPlayer 先进的播放器接口
package pri.zsl.jdbc.models.adapter;
/**
* @author m1767
*/
@SuppressWarnings("all")
public interface AdvancedMediaPlayer {
public void playVlc(String fileName);
public void playMp4(String fileName);
}
Mp4Player 播放器
package pri.zsl.jdbc.models.adapter;
/**
* @author m1767
*/
public class Mp4Player implements AdvancedMediaPlayer {
@Override
public void playVlc(String fileName) {
}
@Override
public void playMp4(String fileName) {
System.out.println("Playing mp4 file. Name: "+fileName);
}
}
VlcPlayer播放器
package pri.zsl.jdbc.models.adapter;
/**
* @author m1767
*/
public class VlcPlayer implements AdvancedMediaPlayer {
@Override
public void playVlc(String fileName) {
System.out.println("Playing vlc file. Name: "+fileName);
}
@Override
public void playMp4(String fileName) {
}
}
MediaAdapter 播放转接器
package pri.zsl.jdbc.models.adapter;
/**
* @author m1767
*/
public class MediaAdapter implements MediaPlayer {
AdvancedMediaPlayer adapter;
public MediaAdapter(String audioType) {
if ("vlc".equalsIgnoreCase(audioType)){
adapter = new VlcPlayer();
}else if("mp4".equalsIgnoreCase(audioType)){
adapter = new Mp4Player();
}
}
@Override
public void play(String audioType, String fileName) {
if ("vlc".equalsIgnoreCase(audioType)) {
adapter.playVlc(fileName);
}else if ("mp4".equalsIgnoreCase(audioType)){
adapter.playMp4(fileName);
}
}
}
MediaPlayer 媒体播放器接口
package pri.zsl.jdbc.models.adapter;
/**
* @author m1767
*/
@SuppressWarnings("ALL")
public interface MediaPlayer {
public void play(String audioType,String fileName);
}
AudioPlayer 音频播放器
package pri.zsl.jdbc.models.adapter;
/**
* @author m1767
*/
public class AudioPlayer implements MediaPlayer{
MediaAdapter mediaAdapter;
@Override
public void play(String audioType, String fileName) {
if ("mp3".equalsIgnoreCase(audioType)){
System.out.println("Playing mp3 file. Name: "+ fileName);
}else if ("vlc".equalsIgnoreCase(audioType) || "mp4".equalsIgnoreCase(audioType)){
mediaAdapter = new MediaAdapter(audioType);
mediaAdapter.play(audioType,fileName);
}else{
System.out.println("Invalid media "+audioType+ " format no supported");
}
}
}
Test 测试
package pri.zsl.jdbc.models.adapter;
/**
* @author m1767
*/
public class Test {
public static void main(String[] args) {
AudioPlayer player = new AudioPlayer();
player.play("mp3", "beyond the horizon.mp3");
player.play("mp4", "alone.mp4");
player.play("vlc", "far far away.vlc");
player.play("avi", "mind me.avi");
}
}
结果展示
/*
Playing mp3 file. Name: beyond the horizon.mp3
Playing mp4 file. Name: alone.mp4
Playing vlc file. Name: far far away.vlc
Invalid media avi format no supported
*/
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
