JIYIK CN >

The single responsibility principle is the simplest principle in object-oriented design. The so-called single responsibility, to put it simply, is that a class is responsible for only one function. The single responsibility principle is defined as follows:

Single Responsibility Principle: A class is only responsible for the corresponding responsibilities in a functional area, and the functional responsibility should be completely encapsulated by this class.

In our program design process, a class should not have too many methods, as long as they can complete their corresponding functions. If a class contains two functions, it is possible that when we modify one function, it will affect the other function.

Suppose we have an instance of a shopping cart

//购物车
class Cart
{
	// 添加商品
	public function addItem(){ /* ... */}

	// 移除商品
	public function deleteItem(){/* ... */}

	// 获取商品
	public function getItem(){/* ... */}

	// 设定订单信息
	public function setOrderInfo($info){/* ... */}

	// 取得付款信息
	public function getPaymentInfo(){/* ... */}

	// 保存订单
	public function saveOrder(){/* ... */}

	// 发送订单确认邮件
	public function sendMail(){/* ... */}

}

$cart = new Cart();
$cart->addItem(); // 添加商品
$cart->getPaymentInfo(); //获取付款信息

We can see that in a shopping cart class, in addition to the methods of adding, deleting and getting items, there are also methods for setting order information, obtaining payment information, saving orders and sending order confirmation emails. Obviously, this class has done something that it should not be responsible for. If we use the order somewhere else, we still have to instantiate an instance of a shopping cart, which is very strange. Therefore, according to the single responsibility principle, we need to split this class. Take out the order method and define a separate Order class.

// 订单
class Order
{

	// 设定订单信息

	public function setOrderInfo($info){/* ... */}
	
	// 取得付款信息

	public function getPaymentInfo(){/* ... */}
	
	// 保存订单

	public function saveOrder(){/* ... */}

	// 发送订单确认邮件

	public function sendMail(){/* ... */}

}

// 重构后的购物车
class Cart
{
	// 添加商品
	public function addItem(){ /* ... */}	

	// 移除商品
	public function deleteItem(){/* ... */}	

	// 获取商品
	public function getItem(){/* ... */}
}

$cart = new Cart();
$order = new Order();
$cart->addItem(); // 添加商品
$order->getPaymentInfo(); //获取付款信息

With this split, when we need to use the order in other places, we only need to instantiate an Order object instead of a Cart object. Even if we need an order in our shopping cart, we can just instantiate an Order object and use the methods in it.

In this way, even if the order function needs to be modified in the future, it will not affect the basic functions of the shopping cart. Such code is also very convenient to maintain in the future. And the readability is also very high.

In a nutshell, the single responsibility principle actually means don't interfere in other people's business and just do what you are supposed to do.