准备下周分享会的内容,无意间看到.net版本的重构31天,花了两个小时看了下,可以看成是Martin Fowler《重构》的精简版
原文地址:http://www.lostechies.com/blogs/sean_chambers/archive/2009/07/31/31-days-of-refactoring.aspx
原文代码地址:https://github.com/schambers/days-of-refactoring
圣殿骑士写的.net版本的读书笔记地址:http://www.cnblogs.com/KnightsWarrior/p/31DaysOfRefactoring.html
有百度文库的可以直接下载:http://wenku.baidu.com/view/27423a5c3b3567ec102d8a0c.html?pn=51
抽个时间(就这周六吧,不过得先把分享会的PPT写好 囧),把java版本的写下,先mark下
周六总算是写完了,不过还想是多跨了一周 囧。有时间,在加下描点,还有pdf下载吧。累,回家咯 ^^ --20151114
1.集合的封装
/**
* @title 封装集合对象,不要暴露太多方法给外部访问内部数据
* @desc
* @atuh lwx
* @createtime on 2015/11/12 23:50
*/
public class Day_1 {
public static void main(String[] args) {
Day1Test day1Test = new Day1Test();
//获取到了内部对象
List<String> list = day1Test.getList();
//肆无忌惮的操作
list.add("a");
day1Test.iterator();
//正确的做法
Day1Test2 day1Test2 = new Day1Test2();
//获取到了内部对象
List<String> list2 = day1Test2.getList();
//肆无忌惮的操作
list2.add("a");
day1Test2.iterator();
}
static class Day1Test {
private List<String> list = new ArrayList<String>();
public List getList() {
return list;
}
//模拟不暴露给外部
protected void add(String value) {
list.add(value);
}
protected void remove(String value) {
list.remove(value);
}
public void iterator() {
for (String str : list) {
System.out.println(str);
}
}
}
static class Day1Test2 {
private List<String> list = new ArrayList<String>();
public List getList() {
return new ArrayList(list);
}
//模拟不暴露给外部
protected void add(String value) {
list.add(value);
}
protected void remove(String value) {
list.remove(value);
}
public void iterator() {
for (String str : list) {
System.out.println(str);
}
}
}
}
2.移动方法
Move method does exactly what it sounds like, move a method to a better location(移动方法到更合适的位置)
public class Day_2 {
public static void main(String[] args) {
}
}
class BankAccount1
{
public BankAccount1(int accountAge, int creditScore, AccountInterest1 accountInterest)
{
AccountAge = accountAge;
CreditScore = creditScore;
AccountInterest1 = accountInterest;
}
public int AccountAge ;
public int CreditScore;
public AccountInterest1 AccountInterest1 ;
}
class AccountInterest1
{
public BankAccount1 Account ;
public AccountInterest1(BankAccount1 account)
{
Account = account;
}
public double InterestRate()
{
return CalculateInterestRate();
}
public boolean IntroductoryRate()
{
return CalculateInterestRate() < 0.05;
}
public double CalculateInterestRate()
{
if (Account.CreditScore > 800)
return 0.02;
if (Account.AccountAge > 10)
return 0.03;
return 0.05;
}
}
class BankAccount {
public BankAccount(int accountAge, int creditScore, AccountInterest accountInterest) {
AccountAge = accountAge;
CreditScore = creditScore;
AccountInterest = accountInterest;
}
public int AccountAge;
public int CreditScore;
public AccountInterest AccountInterest;
//这个方法跟BankAccount没有直接关系
public double CalculateInterestRate() {
if (CreditScore > 800)
return 0.02;
if (AccountAge > 10)
return 0.03;
return 0.05;
}
}
class AccountInterest {
public BankAccount Account;
public AccountInterest(BankAccount account) {
Account = account;
}
public double InterestRate() {
return Account.CalculateInterestRate();
}
public boolean IntroductoryRate() {
{
return Account.CalculateInterestRate() < 0.05;
}
}
}
3.提升方法
简单点说,如果子类都有相同的方法,那就应该将方法提上到父类层
abstract class Vehicle {
// other methods
}
class Car extends Vehicle {
public void Turn(String str) {
// code here
}
}
public class Motorcycle extends Vehicle {
public void Turn(String str) {
// code here
}
}
提升后的结构
abstract class Vehicle1 {
public void Turn(String str) {
// code here
}
}
class Car1 extends Vehicle1 {
}
public class Motorcycle1 extends Vehicle1 {
}
4.下移方法
与第三个上升方法相比,有时候,父类的方法,随着业务的变化,只适合部分子类的时候,则需要将父类的方法下移到具体需要的子类中,这样才符合接口最小原则^^
abstract class Animal {
//狗吠
public void Bark() {
// code to bark
}
}
class Dog extends Animal {
}
class Cat extends Animal {
}
正常小猫是不会狗吠的,当然,有些接口可能当初定义的时候,有些子类还未出现,因此不会有这样的问题。随着业务的增加,这样的问题出现了,那么,我们就要及时的将接口下移
abstract class Animal1 {
}
class Dog1 extends Animal1 {
//狗吠
public void Bark() {
// code to bark
}
}
class Cat1 extends Animal1 {
}
5.提升字段
同提升方法,思路一样的,就不多说了
abstract class Account {
}
public class CheckingAccount extends Account {
private int _minimumCheckingBalance = 5;
}
public class SavingsAccount extends Account {
private int _minimumSavingsBalance = 5;
}
上升后的结构
abstract class Account1 {
protected int _minimumCheckingBalance = 5;
}
public class CheckingAccount1 extends Account1 {
}
public class SavingsAccount1 extends Account1 {
}
6.下移字段
abstract class Task {
protected String _resolution;
}
public class BugTask extends Task {
}
public class FeatureTask extends Task {
}
改造后的情况
abstract class Task1 {
}
class BugTask1 extends Task1 {
protected String _resolution;
}
class FeatureTask1 extends Task1 {
}
7.重命名(类、方法、参数)
demo就不上,只提一点,命名规则不要担心太长,而选择简写,这样反而为后期的维护带来麻烦。
8.使用委托代替继承
设计模式中,很多模式就使用了委托的方式,来解耦继承带来的强依赖,比如装饰者,适配器模式等等。
class Sanitation {
public String WashHands() {
return "Cleaned!";
}
}
public class Child extends Sanitation {
}
正确的做法
class Sanitation1 {
public String WashHands() {
return "Cleaned!";
}
}
class Child1 {
private Sanitation1 Sanitation;
public Child1() {
Sanitation = new Sanitation1();
}
public String WashHands() {
return Sanitation.WashHands();
}
}
上述其实就是代理者模式的框架思路了,如果把Sanitation1暴露出来,就是装饰者了。
9.提取接口
官方已经找不到这个页面的链接了,参考了其他地方,做法其实也很简单,就是遵循了接口最小原则来设计的
interface Bird {
public void eat();
public void fly();
//我们假设有的鸟是不会唱歌的
public void song();
}
重新设计后
interface Bird1 {
public void eat();
public void fly();
}
interface SongBird extends Bird1 {
//我们假设有的鸟是不会唱歌的
public void song();
}
10.提取方法
提取方法是重构中很常见到的一种手法。他可以通过方法名,增加代码的可读性,减少不必要的注释说明。
class Receipt {
private List<Float> discounts;
private List<Float> itemTotals;
public float CalculateGrandTotal() {
float subTotal = 0f;
for (Float itemTotal : itemTotals)
subTotal += itemTotal;
if (discounts.size() > 0) {
for (Float discount : discounts)
subTotal -= discount;
}
float tax = subTotal * 0.065f;
subTotal += tax;
return subTotal;
}
}
使用分离方法后的结构
class Receipt1 {
private List<Float> discounts;
private List<Float> itemTotals;
public float CalculateGrandTotal() {
float subTotal = 0f;
subTotal=addItemTotals(itemTotals);
subTotal=minuteDiscounts(itemTotals);
subTotal=calcTax(subTotal);
return subTotal;
}
float addItemTotals(List<Float> itemTotals){
float subTotal = 0f;
for (Float itemTotal : itemTotals) {
subTotal += itemTotal;
}
return subTotal;
}
float minuteDiscounts(List<Float> discounts){
float subTotal = 0f;
if (discounts.size() > 0) {
for (Float discount : discounts)
subTotal -= discount;
}
return subTotal;
}
float calcTax( float subTotal){
float tax = subTotal * 0.065f;
subTotal += tax;
return subTotal;
}
}
11.切换到策略模式
很多时候,要完成目标的方式不是只有一种,当我们需要使用不同的条件,来获取不同的结果的时候,我们可以使用策略模式,这样,不会因为新增加一个条件,而去修改判断逻辑
public class ClientCode {
public int CalculateShipping() {
ShippingInfo shippingInfo = new ShippingInfo();
return shippingInfo.CalculateShippingAmount(State.Alaska);
}
}
public enum State {
Alaska,
NewYork,
Florida;
}
public class ShippingInfo {
public int CalculateShippingAmount(State shipToState) {
if (shipToState == State.Alaska) {
return GetAlaskaShippingAmount();
} else if (shipToState == State.NewYork) {
return GetNewYorkShippingAmount();
} else if (shipToState == State.Florida) {
return GetFloridaShippingAmount();
} else
return 0;
}
}
private int GetAlaskaShippingAmount() {
return 15;
}
private int GetNewYorkShippingAmount() {
return 10;
}
private int GetFloridaShippingAmount() {
return 3;
}
如果判断条件足够简单,上述做法,其实是可以容忍的,但是,如果Getxx方法变的足够复杂的时候,考虑到单一责任原则,一个类的变化,有且只有一个原因引起,这样,每个判断条件方法发生变化,类都必须做出修改,
这样就不合适了。而且使用类封装,可以更好的实现复用。
static class ShippingInfo1{
//模拟一个工厂
private static Map<State,CalculateShippingAmountStrategy>strategyFactory=new HashMap<State, CalculateShippingAmountStrategy>();
static {
strategyFactory.put(State.Alaska,new GetAlaskaShippingAmount());
strategyFactory.put(State.NewYork,new GetNewYorkShippingAmount());
strategyFactory.put(State.Florida,new GetFloridaShippingAmount());
}
public int CalculateShippingAmount(State shipToState) {
return strategyFactory.get(shipToState).calc();
}
}
interface CalculateShippingAmountStrategy{
public int calc();
}
static class GetAlaskaShippingAmount implements CalculateShippingAmountStrategy{
public int calc(){
return 15;
}
}
static class GetNewYorkShippingAmount implements CalculateShippingAmountStrategy{
public int calc(){
return 10;
}
}
static class GetFloridaShippingAmount implements CalculateShippingAmountStrategy{
public int calc(){
return 3;
}
}
12.解耦依赖
六大设计原则中的最少知识原则(迪米特)说的就是,对依赖的了解,降低到最少。作者强调,当我们进行单元测试的时候,我们就需要一定的隔离,否则无法进行mock.这个自己也是深有体会。
良好的隔离,确实可以让单元测试的Mock变得非常的简单和容易。先看下面的例子,由于AnimalFeedingService直接依赖了静态类Feeder,因此当我们需要只测试FoodBowlEmpty的逻辑判断走向的时候,必然会触发
Feeder的方法,这其实并不是我们想要的。但是又无法直接对静态类进行mock.
public class AnimalFeedingService
{
private boolean FoodBowlEmpty;
public void Feed()
{
if (FoodBowlEmpty)
Feeder.ReplenishFood();
// more code to feed the animal
}
}
public static class Feeder
{
public static void ReplenishFood()
{
// fill up bowl
}
}
解决的办法,就是让Service跟静态的对象解耦
public class AnimalFeedingService1
{
public IFeederService FeederService ;
public AnimalFeedingService1(IFeederService feederService)
{
FeederService = feederService;
}
private boolean FoodBowlEmpty ;
public void Feed()
{
if (FoodBowlEmpty)
FeederService.ReplenishFood();
// more code to feed the animal
}
}
public interface IFeederService
{
void ReplenishFood();
}
public class FeederService implements IFeederService
{
public void ReplenishFood()
{
Feeder.ReplenishFood();
}
}
13.提取方法对象
这并不是一种很常见的重构手段,即当我们对象中定义了很多变量,及其需要利用这些变量进行一些业务操作的时候,可以考虑将方法提取到一个新的类中,这样就解耦了变量与逻辑操作的直接关联。
也比较符合单一责任原则。
public class OrderLineItem
{
public int Price ;
}
public class Order
{
private List<OrderLineItem> OrderLineItems ;
private List<Integer> Discounts;
private int Tax ;
public int Calculate()
{
int subTotal = 0;
// Total up line items
for (OrderLineItem lineItem : OrderLineItems)
{
subTotal += lineItem.Price;
}
// Subtract Discounts
for (int discount : Discounts)
subTotal -= discount;
// Calculate Tax
int tax = subTotal * Tax;
// Calculate GrandTotal
int grandTotal = subTotal + tax;
return grandTotal;
}
}
咋看,代码并没有什么大的问题,order中定义了很多关于自身的属性,还有对属性的一些业务操作,但是,计算价格,其实并不是order对象本身应该关系的。因此,需要引入一个计算order price能力的类
public class Order1
{
private List<OrderLineItem> OrderLineItems ;
private List<Integer> Discounts;
private int Tax ;
public int Calculate(){
return new OrderCalculator(this).Calculate();
}
}
public class OrderCalculator{
private Order1 order;
private List<OrderLineItem> OrderLineItems ;
private List<Integer> Discounts;
private int Tax ;
public OrderCalculator(Order1 order){
this.order=order;
}
public int Calculate()
{
int subTotal = 0;
// Total up line items
for (OrderLineItem lineItem : OrderLineItems)
{
subTotal += lineItem.Price;
}
// Subtract Discounts
for (int discount : Discounts)
subTotal -= discount;
// Calculate Tax
int tax = subTotal * Tax;
// Calculate GrandTotal
int grandTotal = subTotal + tax;
return grandTotal;
}
}
14.单一责任
上面的问题,其实一直提到设计原则,自然也提到了单一责任原则SRP,要学重构,SRP是必然要知道,且学会的思想,并且灵活应用到重构代码中。
下面作者举了一个Video的例子,Video类中有两个方法,分别负责统计客户购买的Video数量,并且计算每个客户的购买金额
public class Video
{
public void PayFee(int fee)
{
}
public void RentVideo(Video video, Customer customer)
{
customer.Videos.add(video);
}
public int CalculateBalance(Customer customer)
{
return customer.LateFees.size();
}
}
public class Customer
{
public List<Integer> LateFees;
public List<Video> Videos ;
}
很明显,顾客购买Video的金额,并不是Video本身应该关系的,而是每个Customer应该关系的,因此,需要将计算购买金额的方法下移到Customer类中来完成
public class Video1
{
public void RentVideo(Video1 video, Customer1 customer)
{
customer.Videos.add(video);
}
}
public class Customer1
{
public List<Integer> LateFees;
public List<Video1> Videos ;
public void PayFee(int fee)
{
}
public int CalculateBalance(Customer1 customer)
{
return customer.LateFees.size();
}
}
15.移除拷贝
当我们有两段一样的代码的时候,很明显,我们需要对他进行简单的封装(具体如何处理,这里先不说,技巧很多种),让重复的代码彻底消息掉。这个可能也是重构最简单,也是最好用的一种方式了
public class MedicalRecord
{
public Date DateArchived ;
public boolean Archived;
public void ArchiveRecord()
{
Archived = true;
DateArchived = new Date();
}
public void CloseRecord()
{
Archived = true;
DateArchived = new Date();
}
}
我们模拟了一段在两个方法中都存在相同逻辑的代码,这时候,我们就要对他进行重构了
public class MedicalRecord1
{
public Date DateArchived ;
public boolean Archived;
public void ArchiveRecord()
{
init();
}
public void CloseRecord()
{
init();
}
public void init()
{
Archived = true;
DateArchived = new Date();
}
}
16.封装条件
简单来说,就是对复杂的条件逻辑判断,进行单独处理,这样,当条件参数发生变化的时候,不会影响到真实的业务逻辑流程
public class RemoteControl {
private String[] Functions;
private String Name;
private int CreatedYear;
public String PerformCoolFunction(String buttonPressed) {
// Determine if we are controlling some extra function
// that requires special conditions
if (Functions.length > 1 && Name == "RCA" && CreatedYear > new Date().getYear() - 2) {
return "doSomething";
}
return "";
}
}
如何处理呢
public class RemoteControl2 {
private String[] Functions;
private String Name;
private int CreatedYear;
public String PerformCoolFunction(String buttonPressed) {
// Determine if we are controlling some extra function
// that requires special conditions
if (HasExtraFunctions()) {
return "doSomething";
}
return "";
}
private boolean HasExtraFunctions()
{
return Functions.length > 1 && Name == "RCA" && CreatedYear > new Date().getYear() - 2 ;
}
}
17.提取父类
如何理解呢?简单来说,就是当我们发现定义的方法,可以被抽象成更高层次对象的时候,就需要考虑抽象一个更上层的父类,并将接口迁移到父类中去定义
public class Dog
{
public void EatFood()
{
// eat some food
}
public void Groom()
{
// perform grooming
}
}
重构后的效果
public class Animal
{
public void EatFood()
{
// eat some food
}
public void Groom()
{
// perform grooming
}
}
public class Dog1 extends Animal
{
}
但是需要注意,过多的继承容易引起耦合,所以有时候,我们需要考虑接口或则聚合来解决继承带来的强依赖。
18.条件判断代替异常
这个其实在很多语言规则中,都有提到,就是不能使用异常来代替控制逻辑,比如《effective java》一书中就有提到。
public class Microwave
{
public boolean Start()
{
boolean foodCooked = false;
try
{
//do something perhaps throw new exception
foodCooked = true;
}
catch (Exception e)
{
foodCooked = false;
}
return foodCooked;
}
}
}
重构后的效果
public class Microwave1
{
public boolean Start()
{
boolean foodCooked = false;
//mock 模拟先判断是否满足某种条件,避免异常发生
if(true){
//do something
foodCooked = true;
}else {
foodCooked = false;
}
return foodCooked;
}
}
19.拓展工厂类
将创建对象的过程给封装起来,这就是工厂模式的设计初衷。将一些列有关系的产品簇组合成一个最终的产品,便是抽象工厂了。好像讲偏了,回归正题,使用工厂模式,从重构角度来看,就是为了实现单一职责,使得
代码更加稳定。
public class PoliceCarController
{
public PoliceCar New(int mileage, boolean serviceRequired)
{
PoliceCar policeCar = new PoliceCar();
policeCar.ServiceRequired = serviceRequired;
policeCar.Mileage = mileage;
return policeCar;
}
}
class PoliceCar{
public boolean ServiceRequired;
public int Mileage;
}
重构后的效果
public interface IPoliceCarFactory
{
PoliceCar Create(int mileage, boolean serviceRequired);
}
public class PoliceCarFactory implements IPoliceCarFactory
{
public PoliceCar Create(int mileage, boolean serviceRequired)
{
PoliceCar policeCar = new PoliceCar();
policeCar.ServiceRequired = serviceRequired;
policeCar.Mileage = mileage;
return policeCar;
}
}
public class PoliceCarController1
{
public IPoliceCarFactory PoliceCarFactory ;
public PoliceCarController1(IPoliceCarFactory policeCarFactory)
{
PoliceCarFactory = policeCarFactory;
}
public PoliceCar New(int mileage, boolean serviceRequired)
{
return PoliceCarFactory.Create(mileage, serviceRequired);
}
}
20.提取子类
这个方式,之前好像已经提到的下移方法类似,也是为了遵循接口隔离原则。
public interface Ball
{
public void play();
public void size();
//打气
public void pumpUp();
}
球,可以用来玩,也都有他们的大小,但是不是每种球,都需要打球的pumpUp
因此需要将pumpUp方法下移到具体子类中
public interface BasketBall extends Ball2{
//打气
public void pumpUp();
}
public interface Ball2
{
public void play();
public void size();
}
21合并集成
//将子类的方法迁移到父类中 不多说了,我想静静
public abstract class Website
{
public abstract String Title();
}
public abstract class StudentWebsite extends Website
{
public abstract boolean IsActive() ;
}
改造后的结构
public abstract class Website2
{
public abstract String Title();
public abstract boolean IsActive() ;
}
public abstract class StudentWebsite2 extends Website
{
}
虽然感觉跟上移方法很像,但是确实在职责区分中,一定需要判断好,方法到底归属于父类还是子类。
22.分解方法
是不是想到了"提取方法"了,omg。果然够2,我只贴代码,不说话 orz
public class CashRegister
{
public CashRegister()
{
Tax = 0.06f;
}
private float Tax ;
public void AcceptPayment(Customer customer, List<Product> products, int payment)
{
float subTotal = 0f;
for (Product product : products)
{
subTotal += product.Price;
}
for (Product product : products)
{
subTotal -= product.AvailableDiscounts;
}
float grandTotal = subTotal * Tax;
customer.DeductFromAccountBalance(grandTotal);
}
}
public class Customer
{
public void DeductFromAccountBalance(float amount)
{
// deduct from balance
}
}
public class Product
{
public int Price ;
public int AvailableDiscounts ;
}
方法封装后的结构
public class CashRegister2
{
public CashRegister2()
{
Tax = 0.06f;
}
private float Tax ;
private List<Product> Products;
public void AcceptPayment(Customer customer, List<Product> products, int payment)
{
int subTotal = CalculateSubtotal();
subTotal = SubtractDiscounts(subTotal);
float grandTotal = AddTax(subTotal);
SubtractFromCustomerBalance(customer, grandTotal);
}
private void SubtractFromCustomerBalance(Customer customer, float grandTotal)
{
customer.DeductFromAccountBalance(grandTotal);
}
private float AddTax(int subTotal)
{
return subTotal * Tax;
}
private int SubtractDiscounts(int subTotal)
{
for (Product product : Products)
{
subTotal -= product.AvailableDiscounts;
}
return subTotal;
}
private int CalculateSubtotal()
{
int subTotal = 0;
for (Product product : Products)
{
subTotal += product.Price;
}
return subTotal;
}
}
23.引入参数对象
此重构模式非常的好用,也非常容易上手,重点推荐,下面代码中,可以比较下
public void test(boolean check, String str, int order) {
//todo
}
public void test(Argument argument) {
//todo
}
class Argument {
boolean check;
String str;
int order;
}
24.分解复杂判断
原意是移除箭头模式,简言之,即对于复杂的逻辑判断if else{if else ..}类似这样嵌套判断,可以有一些重构的技巧
public class Security
{
public List list;
public Security(List list)
{
this.list = list;
}
public boolean HasAccess(Date date, String []arrs, List<String> exemptions)
{
boolean hasPermission = false;
if (date != null)
{
if (arrs != null)
{
if (arrs.length == 0)
{
if (null!=exemptions&&exemptions.get(0).equals("abc"))
{
hasPermission = true;
}
}
}
}
return hasPermission;
}
}
如何重构呢,比较通用的一个做法是判断一次,return一次
public boolean HasAccess2(Date date, String[] arrs, List<String> exemptions) {
boolean hasPermission = false;
if (date == null||arrs==null) {
return false;
}
if(arrs.length!=0){
return false;
}
if (null != exemptions && exemptions.get(0).equals("abc")) {
return true;
}
return false;
}
最后是stackoverflow上,关于arrowhead pattern的一些建议:http://stackoverflow.com/questions/17804005/how-to-prevent-the-arrowhead-anti-pattern/17813388
25.引入契约检查
Design by contract,即要求我们对输入和输出都进行验证,已保证系统不会因为意想不到的情况出现,而导致程序出现不可以控的情况
先看下面的例子
public class CashRegister
{
public int TotalOrder(List<String> products, Calendar calendar)
{
int orderTotal =products.size();
orderTotal+=calendar.get(Calendar.SUNDAY);
return orderTotal;
}
}
采用DBC后的重构效果
public int TotalOrder2(List<String> products, Calendar calendar)
{
if (products == null) {
throw new NullPointerException("products must not be empty");
}
if (products.size() == 0) {
throw new ArithmeticException("products's size must more than one");
}
//calendar校验省略
int orderTotal = products.size();
orderTotal += calendar.get(Calendar.SUNDAY);
//输出校验
if (orderTotal == 0) {
throw new SecurityException("orderTotal's value must bigger than 0");
}
return orderTotal;
}
更多关于DBC:https://en.wikipedia.org/wiki/Design_by_contract
26.避免双重否定
没什么好说的,直接上代码吧。
/**
* @title 避免双重否定
* @desc
* @atuh lwx
* @createtime on 2015/11/14 16:27
*/
public class Day_26 {
static boolean isEmpty(String str){
if(null==str||str.length()==0){
return true;
}
return false;
}
static boolean isNotEmpty(String str){
return !isEmpty(str);
}
public static void main(String[] args) {
if(!isEmpty("")){
//todo
}
//
if(isNotEmpty("")){
}
}
}
27.移除上帝类
如何理解所谓的上帝类呢,说白了,就是一些“功能强大的工具/管理类”,他可能庞大到整个业务系统只会有一个的工具类,这样就违反了单一责任原则。
public class CustomerService {
public int CalculateOrderDiscount(String str) {
// do work
return 0;
}
public boolean CustomerIsValid(String str) {
// do work
return true;
}
public List<String> GatherOrderErrors() {
// do work
return null;
}
public void Register(Object customer) {
// do work
}
public void ForgotPassword(Object customer) {
// do work
}
}
职责明确后的结构
public class CustomerService2 {
public int CalculateOrderDiscount(String str) {
// do work
return 0;
}
public boolean CustomerIsValid(String str) {
// do work
return true;
}
public List<String> GatherOrderErrors() {
// do work
return null;
}
}
public class CustomerRegistrationService{
public void Register(Object customer) {
// do work
}
public void ForgotPassword(Object customer) {
// do work
}
}
28.重命名布尔类型方法
如果有Boolean类型参数,则为了简化外部调用带来的困难,一般会使用重命名方法来简化调用带来的困难,当然,也可以通过重载来弱化boolean变量在使用中带来的不变
public class BankAccount
{
public void CreateAccount( Object customer,boolean withChecking, boolean withSavings)
{
// do work
}
}
改造后的结果
public class BankAccount2
{
public void CreateAccountWithChecking(Object customer)
{
CreateAccount(customer, true, false);
}
public void CreateAccountWithCheckingAndSavings(Object customer)
{
CreateAccount(customer, true, true);
}
private void CreateAccount(Object customer, boolean withChecking, boolean withSavings)
{
// do work
}
}
29.去除中间人
如何理解去除中间人呢?简单理解,就是当A需要通过B去访问C的时候,并且B除了调用C的方法,不在有任何作用的时候,则B就成了所谓的中间人,就应该被delete掉
public class Consumer {
public AccountManager AccountManager;
public Consumer(AccountManager accountManager) {
AccountManager = accountManager;
}
public void Get(int id) {
Account account = AccountManager.GetAccount(id);
}
}
public class AccountManager {
public AccountDataProvider DataProvider;
public AccountManager(AccountDataProvider dataProvider) {
DataProvider = dataProvider;
}
public Account GetAccount(int id) {
return DataProvider.GetAccount(id);
}
}
public class AccountDataProvider {
public Account GetAccount(int id) {
// get account
return null;
}
}
class Account {
}
重构后的效果
public class Consumer2
{
public AccountDataProvider AccountDataProvider ;
public Consumer2(AccountDataProvider dataProvider)
{
AccountDataProvider = dataProvider;
}
public void Get(int id)
{
Account account = AccountDataProvider.GetAccount(id);
}
}
这里需要作两点补充:第一,AccountManager当初设计是为了隔离Consumer与AccountProvider,后面可能随着业务形态发生变化,两者可以直接调用的时候,AccountManager对象就失去了意义。
举个简单的例子,我们买电视,都是去超市去买,因为你不可能直接去厂家拿货,如果哪天你的角色变成代理商或则厂家工人了,也许,你就可以内部直接拿货了
第二,有时候,对于两个需要隔离的对象,需要制造一个中间人,来隔离他们。好比,你原先是公司的员工,享受福利,离职后,就不会再有这种福利了。内部的一些东西,你也就接触不到了。
30.尽快返回
return as soon as possible。即对之前的复杂逻辑判断的一个侧面说明了。
public class Order {
public Object Customer;
public int CalculateOrder(Object customer, List<Object> products, int discounts) {
Customer = customer;
int orderTotal = 0;
if (products.size() > 0) {
orderTotal = products.size();
if (discounts > 0) {
orderTotal -= discounts;
}
}
return orderTotal;
}
}
改造后
public class Order2 {
public Object Customer;
public int CalculateOrder(Object customer, List<Object> products, int discounts) {
Customer = customer;
int orderTotal = 0;
if (products.size() == 0) {
return 0;
}
orderTotal = products.size();
if (discounts > 0) {
orderTotal -= discounts;
}
return orderTotal;
}
}
31.使用多态代替条件
上面其实也提到了策略模式替换多条件,其实是类似的。如果对java的单双派机制,有更多了解的,可以移步我之前写的一篇文章,java单双派机制理解
/**
* @title 使用多态代替条件判断
* @desc
* @atuh lwx
* @createtime on 2015/11/14 17:41
*/
public class Day_31 {
public static void main(String[] args) {
Day_31 day_31 = new Day_31();
Parent parent = new Parent();
Son son = new Son();
Daughter daughter = new Daughter();
day_31.invokeSay(parent);
day_31.invokeSay(son);
day_31.invokeSay(daughter);
System.out.println("华丽的分割线");
//使用动态方式
day_31.invokeSay2(parent);
day_31.invokeSay2(son);
day_31.invokeSay2(daughter);
//考虑重载解决 -->又涉及到单分派-->通过使用访问者模式来解决
}
public void invokeSay(Object parent) {
if (parent instanceof Son) {
((Son) parent).say();
} else if (parent instanceof Daughter) {
((Daughter) parent).say();
} else {
((Parent)parent).say();
}
}
public void invokeSay2(Parent parent) {
parent.say();
}
}
class Parent {
public void say() {
System.out.println("parent say");
}
}
class Son extends Parent {
public void say() {
System.out.println("Son say");
}
}
class Daughter extends Parent {
public void say() {
System.out.println("Daughter say");
}
}