31天重构学习笔记（java版本）
准备下周分享会的内容，无意间看到.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.集合的封装
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"); } }