过度设计-举例(转)

[color=red]过度设计,需要更多设计时间和测试成本,如无必要,还是尽量简洁一些好。[/color]
未来的事情,比如 访问量,比如数据库的容量,比如是否需要改成分布式 都是无法预料的

再举一个例子,对闰年的判断逻辑:
  1、 if($Year%4==0) return True; else return Fasle;
  2、if ( ($Year%4==0 && $Year%100!=0 ) || $Year%400==0 ) retrue True; else return False;
  我选择了第一种逻辑,当然第二种更为标准。我的原因是:
  1、第一种逻辑速度够快;
  2、我做的不是日历程序,只是一个应用需要判断闰年;2100年,对我来说太遥远,我的编码活不到那一年,中间肯定被别人废弃了。在未来的80多年中,我的代码都不会出问题。


实际例子:

以前总是举不出过度设计的例子,今天遇上一件事,总算有了一个反例:
  程序员A编写代码,记录用户购买商品记录,设计1个8字节字段,前4个放用户ID,后4个放商品ID。
  粗看设计没有太大问题。实际编码中,发现数据库中商品ID,是long long类型,8个字节。他遇上困难,卡在那里了。他找上leader,说明要改设计,需要更多时间,完美兼容这种情况。
  但是现在没有足够的时间,来做大的变动,于是找了个折中方案,整个字段8字节放商品ID,另外再用一张表去关联用户ID同商品ID的购买关系。

  在我看来,这就是过度设计了。
  我的方案,仍然坚持原有设计,前4字节放用户ID,后4个字节放商品ID的后4字节。这个方案,是有缺陷的,商品ID是一个自增的循环数,存在一种 用户ID+商品ID后4字节 重复的可能性。
  但是我们考虑一下,现有商品ID增长到:约2亿,4个字节能够支撑40亿商品,现有商品库运营4年了。
  按照现在的业务发展速度,无论如何,2年内,我看不到一点重复的可能。不需要重新设计,简单把功能实现。并记录,规划在1年后重构这部分代码。(很可能在1年内,这个模块就因为其它原因要重构)
  为什么要为了未来的支撑能力,耗费现在的开发资源呢?做一个额外的表,不是增加新的逻辑吗?
### ### Java中常用的设计模式及其实际应用示例 设计模式是软件开发中的最佳实践,它们提供了经过验证的解决方案来解决常见的设计问题。Java 中广泛使用了多种设计模式,以提高代码的可重用性、可维护性和可扩展性。 #### 单例模式(Singleton Pattern) 单例模式确保一个类只有一个实例,并提供一个全局访问点。这种模式常用于需要频繁实例化然后销毁的对象,或者是创建代价很高的对象。 ```java public enum PersonSingleton { INSTANCE; private String name; public String getName() { return name; } } ``` 上述代码展示了如何通过枚举实现单例模式,这种方式不仅能避免多线程同步问题,还能防止反序列化导致重新生成新对象的情况[^4]。 #### 原型模式(Prototype Pattern) 原型模式是一种创建型设计模式,它允许一个对象再创建另外一个提供相同功能的对象,同时保证较高的性能。这通常通过克隆机制实现。 ```java public abstract class Prototype implements Cloneable { protected String id; public Prototype(String id) { this.id = id; } public String getId() { return id; } @Override public Object clone() throws CloneNotSupportedException { return super.clone(); } } public class ConcretePrototype extends Prototype { public ConcretePrototype(String id) { super(id); } } ``` 在这个例子中,`ConcretePrototype`继承自`Prototype`抽象类,并实现了`clone()`方法来复制自身[^4]。 #### 策略模式(Strategy Pattern) 策略模式定义了一系列算法,并将每一个算法封装起来,使它们可以互相替换。该模式让算法独立于使用它的客户而变化。 ```java public interface Strategy { int doOperation(int num1, int num2); } public class OperationAdd implements Strategy { @Override public int doOperation(int num1, int num2) { return num1 + num2; } } public class Context { private Strategy strategy; public Context(Strategy strategy){ this.strategy = strategy; } public int executeStrategy(int num1, int num2){ return strategy.doOperation(num1, num2); } } ``` 这段代码演示了一个简单的计算器应用,其中`Context`类使用不同的策略来进行加法运算[^5]。 #### 模板方法模式(Template Method Pattern) 模板方法模式在一个方法中定义了一个算法的骨架,而将一些步骤延迟到子类中。这样可以让子类在不改变算法结构的情况下重新定义某些特定步骤。 ```java public abstract class Game { abstract void initialize(); abstract void startPlay(); abstract void endPlay(); // Template method public final void play(){ // Initialize the game initialize(); // Start playing startPlay(); // End playing endPlay(); } } public class Cricket extends Game { @Override void initialize() { System.out.println("Cricket Game Initialized! Start playing."); } @Override void startPlay() { System.out.println("Cricket Game Started. Enjoy the game!"); } @Override void endPlay() { System.out.println("Cricket Game Finished!"); } } ``` 这里`Game`类中的`play()`是一个模板方法,它调用了几个抽象方法,这些方法的具体实现由子类如`Cricket`提供。 #### 观察者模式(Observer Pattern) 观察者模式是行为型模式的一种,当对象的状态发生改变时,所有依赖它的对象都会得到通知并自动更新。 ```java import java.util.ArrayList; import java.util.List; public class Subject { private List<Observer> observers = new ArrayList<>(); private int state; public void attach(Observer observer){ observers.add(observer); } public void detach(Observer observer){ observers.remove(observer); } public void notifyAllObservers(){ for (Observer observer : observers) { observer.update(); } } public int getState() { return state; } public void setState(int state) { this.state = state; notifyAllObservers(); } } public class BinaryObserver extends Observer { public BinaryObserver(Subject subject){ this.subject = subject; this.subject.attach(this); } @Override public void update() { System.out.println("Binary String: " + Integer.toBinaryString(subject.getState())); } } ``` 这个例子中,`Subject`类维护了一组`Observer`对象,并且在其状态发生变化时会通知所有的观察者[^5]。 #### 结论 以上提到的设计模式只是冰山一角,每种模式都有其适用场景和优点。理解并掌握这些设计模式可以帮助开发者编写出更加灵活、可维护和可靠的代码。在实际项目中选择合适的设计模式是非常重要的,同时也需要注意不要过度设计,以免增加不必要的复杂度。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值