几种简单的设计模式

先来说说最简单最常用的单例,

单例(Single),顾名思义,就是一个类只能有一个实例,他必须自行创建这个唯一的实例,必须自行向这个系统提供这个实例,在连接数据库的时候,我们可以通过单例产生唯一的连接资源。

class Single
{
static $link;
//私有方法 外部不允许调用

private function __construct()
{

self::$link= mysqli_connect('127.0.0.1','root','12345678');
}

public static function getInstance()
{
if(!self::$link){
new self();

}
return self::$link;
}

}


再来说一下工厂(Factory),这个吗,正如名字一样,工厂,你传入什么材料,就会生产出来什么东西,也就是你传入一个类名,就会调用不同的方法生产不同的类,有的时候在实例化新的类的时候要做一下判断,比如你要生产实例化大楼这个类,你需要水泥 钢筋很多材料,在生产前需要做一下判断,这个设计模式就叫做工厂方法模式(FactoryFunction)。

//工厂

class Factory
{
//传入不同的值 new不同的类
public  function factoryobj($type)
{
$className = $type.'Obj';
return  new $className();

}
}

//工厂方法

private $wood = 100;
private $stone = 100;
//实现抽象方法
public  function RealCreate()
{

//如果满足条件 允许创建
if($this->wood>50 && $this->stone>50){
//创建一个Ice对象
return new Ice();
}
}

我们再来说一个挺有意思的模式,叫做观察者模式(OberServer),观察者模式,就是定义对象间的一种一对多的依赖关系,让多个观察者 观察同一个被观察者,当这个被观察者发生状态时,使观察者发生变化,其实就是解除耦合,让耦合的双方都依赖于抽象方法,而不是依赖具体,从而使各方的变化都不会影响到另一边的变化。

//观察者
interface IOberServer
{
public function help($play);
}


class OberServer implements IoberServer
{
public $name;

public  function __construct($name)
{
$this->name = $name;
}

//执行真正的帮助行为
public function help($play)
{
echo $this->name .'帮助'.$play.'<br />';
}
}

//被观察者
class Ally extends AbstractAlly
{

public function __construct($players)
{
foreach ($players as $play) {
//将所有的对象添加进入$oberServerCollection集合中
$this->addOberServer($play);
}
}

//被观察者发生了某个行为 (某一个人被攻击了)
public function attack($play)
{
//其他人都在监听是否盟友被攻击了
$this->notify($play);
}

}//被观察者
class Ally extends AbstractAlly
{

public function __construct($players)
{
foreach ($players as $play) {
//将所有的对象添加进入$oberServerCollection集合中
$this->addOberServer($play);
}
}

//被观察者发生了某个行为 (某一个人被攻击了)
public function attack($play)
{
//其他人都在监听是否盟友被攻击了
$this->notify($play);
}

}

最后我们来说一下门面设计模式(Facade)吧 外部与一个子系统的通信,如果外部直接调用子方法的方法属性,会让代码很麻烦,耦合性很高,这个时候就能体现门面设计模式
的优势了,外部与一个子系统的通信必须通过一个统一的门面模式,就叫做门面设计模式,
//门面类
class Facade
{
//编写属性 类
private $_camera;
private $_light;
//private $_sensor;


public function __construct()
{
//初始化
//将对象赋值给变量
$this->_camera = new Camera();
$this->_light = new Light();

}
//相机的开关
public function start()
{
//变量调用该类下的方法
$this->_camera->startCamera();

}
public function stop()
{
$this->_camera->stopCamera();
}

}

//调用类
class Client
{
static $facade;

public static function useCamera()
{
//实例化 Facade();
self::$facade = new Facade();
self::$facade->start();
self::$facade->stop();
}

}


  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,我来为您简单介绍几种常用的Java设计模式,并附上示例代码。 1. 工厂模式(Factory Pattern) 定义:工厂模式是一种创建型设计模式,它提供了一种创建对象的最佳方式,而无需向客户端暴露创建逻辑,并且是通过使用一个公共接口来指向新创建的对象。 示例代码:假设我们有一个形状(Shape)接口,有三个不同的实现:圆形(Circle)、矩形(Rectangle)和正方形(Square)。我们可以使用工厂模式创建这些形状。 ``` public interface Shape { void draw(); } public class Circle implements Shape { @Override public void draw() { System.out.println("Drawing Circle"); } } public class Rectangle implements Shape { @Override public void draw() { System.out.println("Drawing Rectangle"); } } public class Square implements Shape { @Override public void draw() { System.out.println("Drawing Square"); } } public class ShapeFactory { public Shape getShape(String shapeType) { if (shapeType == null) { return null; } if (shapeType.equalsIgnoreCase("CIRCLE")) { return new Circle(); } else if (shapeType.equalsIgnoreCase("RECTANGLE")) { return new Rectangle(); } else if (shapeType.equalsIgnoreCase("SQUARE")) { return new Square(); } return null; } } ``` 我们可以使用ShapeFactory类来获取不同类型的形状对象: ``` ShapeFactory shapeFactory = new ShapeFactory(); Shape circle = shapeFactory.getShape("CIRCLE"); circle.draw(); Shape rectangle = shapeFactory.getShape("RECTANGLE"); rectangle.draw(); Shape square = shapeFactory.getShape("SQUARE"); square.draw(); ``` 2. 单例模式(Singleton Pattern) 定义:单例模式是一种创建型设计模式,它保证一个类只有一个实例,并提供一个全局访问点。 示例代码:假设我们有一个Settings类,用于存储应用程序的设置信息。我们可以使用单例模式确保只有一个Settings实例,以便在整个应用程序中共享设置。 ``` public class Settings { private static Settings instance = new Settings(); private Settings() {} public static Settings getInstance() { return instance; } public void setSetting(String key, String value) { // ... } public String getSetting(String key) { // ... return null; } } ``` 我们可以通过Settings.getInstance()方法获取Settings的唯一实例: ``` Settings settings = Settings.getInstance(); settings.setSetting("fontSize", "14"); String fontSize = settings.getSetting("fontSize"); ``` 3. 观察者模式(Observer Pattern) 定义:观察者模式是一种行为型设计模式,它定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象,当主题对象发生变化时,它的所有观察者都会收到通知并更新自己的状态。 示例代码:假设我们有一个Subject接口和两个实现:WeatherData和StockData,它们都维护着一些数据。我们可以使用观察者模式来让多个观察者监听这些主题对象的变化。 ``` public interface Subject { void registerObserver(Observer o); void removeObserver(Observer o); void notifyObservers(); } public interface Observer { void update(float temperature, float humidity, float pressure); } public class WeatherData implements Subject { private List<Observer> observers = new ArrayList<>(); private float temperature; private float humidity; private float pressure; @Override public void registerObserver(Observer o) { observers.add(o); } @Override public void removeObserver(Observer o) { observers.remove(o); } @Override public void notifyObservers() { for (Observer o : observers) { o.update(temperature, humidity, pressure); } } public void setMeasurements(float temperature, float humidity, float pressure) { this.temperature = temperature; this.humidity = humidity; this.pressure = pressure; measurementsChanged(); } private void measurementsChanged() { notifyObservers(); } } public class StockData implements Subject { private List<Observer> observers = new ArrayList<>(); private String symbol; private float price; @Override public void registerObserver(Observer o) { observers.add(o); } @Override public void removeObserver(Observer o) { observers.remove(o); } @Override public void notifyObservers() { for (Observer o : observers) { o.update(price); } } public void setPrice(float price) { this.price = price; priceChanged(); } private void priceChanged() { notifyObservers(); } } public class CurrentConditionsDisplay implements Observer { private float temperature; private float humidity; @Override public void update(float temperature, float humidity, float pressure) { this.temperature = temperature; this.humidity = humidity; display(); } private void display() { System.out.println("Current conditions: " + temperature + "F degrees and " + humidity + "% humidity"); } } public class StockPriceDisplay implements Observer { private float price; @Override public void update(float price) { this.price = price; display(); } private void display() { System.out.println("Stock price: $" + price); } } ``` 我们可以创建一个WeatherData对象和一个StockData对象,并向它们注册两个观察者:CurrentConditionsDisplay和StockPriceDisplay。当WeatherData或StockData对象中的数据发生变化时,它们会通知它们的观察者。 ``` WeatherData weatherData = new WeatherData(); StockData stockData = new StockData(); CurrentConditionsDisplay currentConditionsDisplay = new CurrentConditionsDisplay(); StockPriceDisplay stockPriceDisplay = new StockPriceDisplay(); weatherData.registerObserver(currentConditionsDisplay); stockData.registerObserver(stockPriceDisplay); weatherData.setMeasurements(80, 65, 30.4f); stockData.setPrice(100); ``` 这就是Java中的三种常用设计模式简单示例。希望对您有所帮助。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值