首先提一下java的设计原则:
1.CHANGE (能应对变化)
2.KISS(keep it simple &studio 保持代码简单的易读性)
3.DRY(don't repeat youself 不要写一些重复的代码)
4.SRP(single responsibility principle 单一职责原则)
5.OCP(open closed principle 对外开放,对内封闭)
6.LSP(liskov substitution principle 里氏置换原则)
7.ISP(interface single principle 接口隔离原则)
8.DIP(dependence Inversion principle 依赖倒置原则)
当然,还有其他很多例如:CARP LOD COC ....
关于java的设计原则,网上有很多.可以参考:http://blog.csdn.net/gaolei1201/article/details/47082783
现在,开始要说的是,在什么样的场景下使用他们.
案例:输出三行 hello World
首先,我们肯定想到的是:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
System.out.println("Hello World");
System.out.println("Hello World");
}
}
现在,需求变化了,客户希望输出的是三个Hello Java .那么怎么办呢?修改很简单,直接复制Java粘贴替换World就可以.但是,这显然有问题的,如果输出是10多二十行呢?那不是要复制粘贴而多次?这时候,可以把HelloWorld抽取出来,单独做一个类.该类提供一个方法,返回HelloWorld语带代码:
public class HelloWorld {
public static void main(String[] args) {
System.out.println(new A().getStr());
System.out.println(new A().getStr());
System.out.println(new A().getStr());
}
}
class A {
public String getStr(){
return "Hello World" ;
}
}
但是,很明显.客户有可能要输出的是Hello Java ,Hello Html ...显然,每次都需要修改类A,这就违反了之前的开闭原则.那么怎么重构呢?可以这样:
public class HelloWorld {
public static void main(String[] args) {
System.out.println(new A().getStr(new Java()));
System.out.println(new A().getStr(new World()));
System.out.println(new A().getStr(new Html()));
}
}
class A {
public String getStr(B b){
return "Hello "+b.getcontent() ;
}
}
abstract class B {
public String getcontent() {
return setStr() ;
}
abstract String setStr() ;
}
class Java extends B{
@Override
String setStr() {
return "Java";
}
}
class World extends B {
@Override
String setStr() {
return "World";
}
}
class Html extends B{
@Override
String setStr() {
return "Html";
}
}
这样,下次如果需要PHP的时候,只需要扩展类B 然后返回php就行了,不在需要修改源代码.这里每次都需要new Java 很明显,这里用之前提到的LSP(里氏替换原则),但是又有一个问题,每次调用都需要去写实例化代码,这样代码显的比较的臃肿.也违反了之前提到的SRP(单一职责原则)这时候,我们采用Java设计模式的代理模式,做一个工厂,工厂传入一个参数.让工厂来实例化.于是代码如下:
public class HelloWorld {
public static void main(String[] args) {
System.out.println(new A().getStr(HelloFactory.getInstance("Java")));
System.out.println(new A().getStr(HelloFactory.getInstance("Html")));
System.out.println(new A().getStr(HelloFactory.getInstance("World")));
}
}
class A {
public String getStr(B b){
return "Hello "+b.getcontent() ;
}
}
abstract class B {
public String getcontent() {
return setStr() ;
}
abstract String setStr() ;
}
class Java extends B{
@Override
String setStr() {
return "Java";
}
}
class World extends B {
@Override
String setStr() {
return "World";
}
}
class Html extends B{
@Override
String setStr() {
return "Html";
}
}
class HelloFactory {
public static B getInstance(String str){
switch (str) {
case "Java":
return new Java() ;
case "Html":
return new Html() ;
case "Hello":
return new World() ;
default :
return null ;
}
}
}
但是这样还有一个问题,如果我要新增一个php,那么工厂类又要重新写!很明显,违反了开闭原则.这时候,我们可以采用反射机制来实现,代码如下:
package test.com;
public class HelloWorld {
public static void main(String[] args) {
try {
System.out.println(new A().getStr(HelloFactory.getInstance("Java")));
System.out.println(new A().getStr(HelloFactory.getInstance("Html")));
System.out.println(new A().getStr(HelloFactory.getInstance("World")));
} catch (Exception e) {
e.printStackTrace();
}
}
}
class A {
public String getStr(B b) {
return "Hello " + b.getcontent();
}
}
abstract class B {
public String getcontent() {
return setStr();
}
abstract String setStr();
}
class Java extends B {
@Override
String setStr() {
return "Java";
}
}
class World extends B {
@Override
String setStr() {
return "World";
}
}
class Html extends B {
@Override
String setStr() {
return "Html";
}
}
class HelloFactory {
public static B getInstance(String str) throws Exception {
// 这里采用的是包名+类名形式,因为我这个类是在test.com包下.
return (B) Class.forName("test.com." + str).newInstance();
}
}现在可以直接新增一个php的类,然后通过工厂来实例化了.但是,这里还有一个问题,如果是第三方使用我的方法来输出Hello World ,那么每次第三方要新增的时候,我都要去修改我的源代码...oh,no!!必须重构~~,那么采用接口方式吧,把控制权给到第三方(使用我代码开发的人):
package test.com;
public class HelloWorld {
public static void main(String[] args) {
try {
System.out.println(new A().getStr(HelloFactory.getInstance("Java")));
System.out.println(new A().getStr(HelloFactory.getInstance("Html")));
System.out.println(new A().getStr(HelloFactory.getInstance("World")));
} catch (Exception e) {
e.printStackTrace();
}
}
}
class A {
public String getStr(B b) {
return "Hello " + b.getcontent();
}
}
interface B {
public String getcontent();
}
class Java implements B {
public String getcontent() {
return "Java";
}
}
class World implements B {
@Override
public String getcontent() {
return "World";
}
}
class Html implements B {
@Override
public String getcontent() {
return "Html";
}
}
class HelloFactory {
public static B getInstance(String str) throws Exception {
// 这里采用的是包名+类名形式,因为我这个类是在test.com包下.
return (B) Class.forName("test.com." + str).newInstance();
}
}
现在,第三方使用我的程序的时候,只需要实现我提供的接口B,就可以了.不再依赖我去修改我自己的程序了.但是,如果我要想输出的是Java Hello,或者就是Html这样的格式的时候呢? 不是还需要修改我的代码么?所以,我必须把更多的控制权给到使用者(第三方).:
package test.com;
public class HelloWorld {
public static void main(String[] args) {
try {
System.out.println(HelloFactory.getInstance("Java").getStr(n->{
return n+" Hello" ;
}));
System.out.println(HelloFactory.getInstance("Html").getStr(n->{
return n+" is too hard" ;
}));
System.out.println(HelloFactory.getInstance("World").getStr(n->{
return n+" is open" ;
}));
} catch (Exception e) {
e.printStackTrace();
}
}
}
abstract class A {
public String getStr(C c) {
return c.setStr(getName()) ;
}
abstract String getName() ;
}
interface C {
public String setStr(String str);
}
class Html extends A {
@Override
String getName() {
return "Html";
}
}
class Java extends A {
@Override
String getName() {
return "Java";
}
}
class World extends A {
@Override
String getName() {
return "World";
}
}
class HelloFactory {
public static A getInstance(String str) throws Exception {
// 这里采用的是包名+类名形式,因为我这个类是在test.com包下.
return (A) Class.forName("test.com." + str).newInstance();
}
}
这样,第三方想要什么格式的都有了.但是这里还有一个问题,如果我不实用Java,而要使用php的时候,每次都要实现抽象类,然后使用匿名接口,然后再重新编译.那么如果做成配置文件,是不是就不再需要重新编译了呢?于是可以改写:
package test.com;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Properties;
public class HelloWorld {
public static void main(String[] args) {
Properties properties = new Properties();
try {
InputStream inputStream = new BufferedInputStream(new FileInputStream("src/test/com/mySet.properties"));
properties.load(inputStream);
System.out.println(HelloFactory.getInstance(properties.getProperty("key1").toString()).getStr(n -> {
return n + " Hello";
}));
System.out.println(HelloFactory.getInstance(properties.getProperty("key2").toString()).getStr(n -> {
return n + " Hello";
}));
System.out.println(HelloFactory.getInstance(properties.getProperty("key3").toString()).getStr(n -> {
return n + " Hello";
}));
} catch (Exception e) {
e.printStackTrace();
}
}
}
abstract class A {
public String getStr(C c) {
return c.setStr(getName());
}
abstract String getName();
}
interface C {
public String setStr(String str);
}
class Html extends A {
@Override
String getName() {
return "Html";
}
}
class Java extends A {
@Override
String getName() {
return "Java";
}
}
class World extends A {
@Override
String getName() {
return "World";
}
}
class HelloFactory {
public static A getInstance(String str) throws Exception {
// 这里采用的是包名+类名形式,因为我这个类是在test.com包下.
return (A) Class.forName("test.com." + str).newInstance();
}
}
配置文件(mySet.properties):
key1=Java
key2=Html
key3=World到这里,如果第三方想要输出什么格式,都可以自由发挥.想要输出php只需修改配置文件就可以了.也不需要再对我的代码惊醒重新编译.貌似比较完善了..
但是,真的这样吗?
现在,写了这么多代码,但是好像我什么都没做...要实现什么样的输出,都需要去先实现我的抽象类,然后在修改配置文件.我什么都没做啊,貌似.但是,比起最初的版本,我实际确实做了太多的工作,那么该不该如此做呢?例如客户只需要输出一个Hello World,而你却给我如此一大堆,最还要我自己写一大堆实现类,配置.就为了一个Hello World? 肯定有病!!
所以,这就是代码的另一个原则YAGNI(You Ain’t Gonna Need It 你是不是真的需要它!) 我理解为中庸,儒家思想嘛.
对于Java思想来说,这只是冰山一角.自我勉励吧.
来源：oschina
链接：https://my.oschina.net/u/2708086/blog/744804