挖掘一件神秘武器——static

今天刚好看了《Effective Java》的Item1静态工厂，那就顺便把static复习一下叭！

神秘在哪

（这里我们之讨论OOP中的static所修饰的函数和数据）

• 首先，什么是static数据？
  • 同属一个类的对象所共有的变量（基本）
  • 在应用层面，它代替了全局变量的存在（毕竟在Java、C#这种OOP纯度高的语言，没有全局变量）
• 接着，static函数有什么不可代替的地方吗？
  • 静态函数只能操作静态数据
  • 可由类本身直接调用，不必创建对象

static特性

对代码的直接访问

// 普通函数
Math math = new Math();
math.Add( a, b);
// 用static函数
Math.Add( a, b);

显而易见的两个小优点：

• 代码少了
• 省了对象创建的空间

但是，这么点小小的优点，还不足以让static称为一件神秘武器，go on

隔离性和游离性

• 隔离性

  • 不可访问普通数据
  • 不可访问普通函数
  • 特点：隔离！格格不入！

• 游离性

• 编译角度上看，static其实放在哪个类里并不重要，放心移植

• static和所在的类，并非拥有关系，类只是static的一个标签

普通函数和所在类的关系，像是“主人和狗”，忠心耿耿；而static和所在类，就像旅人和旅店，随时可能因为架构而调整

将函数参数反客为主

类名淡化，突出参数重要性！！！

// 普通函数
person.Eat(food);// static函数
static xxx.Eat(Dog dog,Food food);

static的应用场景

实现工具包函数

比如我们经常写一些Util或者Helper之类的

class Util{static public int Sum(int a,int b);static public int Minus(int a,int b);
}

实现单例

也就是我们常说的单例模式，屏蔽掉构造，让用户通过static函数来拿这一单一对象

public Single{private static Single singleInstance;private Single(){}public static Single getSingleInstance(){if(singleInstance == null){singleInstance = new Single();}return singleInstance;}
}

我们来仔细比较一下两段代码：

//Code.1
public Single{static public void FuncA(Object o);static public void FuncB(Object o);static public void FuncC(Object o);
}// Code.2
public Single{private static Single singleInstance;private Single(){}public static Single getSingleInstance(){if(singleInstance == null){singleInstance = new Single();}return singleInstance;}public void FuncA(Object o);public void FuncB(Object o);public void FuncC(Object o);
}// 分别调用FuncA
Object o = new Object();
// call 1
Single.FuncA(o);
// call 2
Single.getSingleInstance().FuncA(o);

• 从内存占用的角度上看，两者是一样的，而非第二种大（易错点）
• 从语言的角度去抠的话，是得不到答案的

那他们到底有什么不同呢？我们从应用场景分析来看：

• 第一种

  • 函数间关联不紧密
  • 函数无状态，彼此调用互不影响，类里没有static数据
  • 场景：工具包函数、类扩展函数

• 第二种

  • 函数关联紧密耦合，可能共享成员数据
  • 只是一个普通的类，不过它提供单例对象而已
  • 类名就透露出其天然唯一性，比如：Earth

千万别弄混用错了！static变量是与程序共存亡的，需要我们时时刻刻去维护。

来看一个错误案例：

public class ModelOperation {static int count = 0;static String name = "";public static void Reset(){count  = 0;name = "";}public static void Operation1(){Reset();// 操作1}public static void Operation2(){Reset();// 操作2}
}

这个案例中，两个函数执行都要Reset()一遍，不累吗？？？维护成本岂不是贼高。

我们应该使用单例进行总处理：

public class ModelOperation {static int count = 0;static String name = "";private static ModelOperation singleInstance;private ModelOperation(){}public static void Reset(){count  = 0;name = "";}public static ModelOperation getSingleInstance(){if(singleInstance == null){singleInstance = new ModelOperation();} else {singleInstance.Reset();}return singleInstance;}public void Operation1(){// 操作1}public void Operation2(){// 操作2}
}

是不是有内味了！！！再比如，很多语言系统里的消息广播类：

class NotificationCenter {public static NotificationCenter defaultCenter;public void AddObserver(Object o,String eventName);public void RemoveObserver(Object o);public void PostMessageName(String eventName,Object param);
}

• 从函数名就可以看出来，它仨是紧密耦合、互相配合的；光从名字就能推测功能；里面必然有个observerArray的private变量数组来存储observer对象（通过私有变量串联绑定达到耦合）

• 假设我们都用static函数，而非单例，NotificationCenter.AddObserver(o,eventName)这句代码，会让我不知道我这个对象加到哪去了，但是NotificationCenter.defaultCenter.AddObserver(o,eventName)就一目了然了

实现类扩展

程序员进阶路上的重中之重！！！！

啥是类扩展

就是在不添加子类的情况下，实现对已知类功能的扩展。

来看个例子：

class Person {// bla bla bla
}class PersonExtention {static void Drive(Person p,Car c){// 人就具备了开车的功能了}
}

好处如下：

• 淡化类名的词汇语境，增强可读性，让用户把注意力专注在方法上
• 省去了对象的创建，直接访问代码区的方法

当然，类作为static函数的第一个参数并不都是类扩展，来看个例子：

static public void Vote(Person p){votedList.add(p);
}

这只是抽取Person对象的信息，投到数组中，并不是功能的扩展！

何必类扩展

OK，我们再说回PersonExtention，仔细想想，这样不麻烦吗？我直接把代码写到原来的Person类里不就行了，何必多此一举呢？？？？

不急，我们把问题拉出来：

Q：扩展函数和主体类分开，有什么好处？

A：类扩展函数实现了类功能的可拆卸性

• 扩展函数和主体类可能都不在一个库里，要访问时才引用

• 方便日后的安全删除

当然了，也只有可被拆卸的功能才能放在类扩展里

总的来说呢，类扩展是一种设计思路，而非具体技术，部分语言有支持类扩展的关键字（比如：Object-C的category，Swift的extension，C#的this），而static是实现类扩展的通用技术。

适用场景

场景一：对主体类瘦身

扩展函数有个局限性，只能访问主体类public暴露出来的东西，但是反过来想，我们在自己的代码中，那些public的东西，是否可以移出去呢？？？代码一来简化，二来实现功能可拆卸，不香吗？当然，也不是什么都要往外送，这不是教条化的东西，根据业务本身选择。

比如说，任何场景都用得到，就写在本体类；特定场景，就写在类扩展

// 假设有个游戏系统的人这么定义的
class Person {public void Drive(Car car);public void Eat(Food food);
}// 假设人的驾驶用两种场景：城市中赛车，水里游泳，那么我们在大海里是不用载具的，就可以移出去
class Person {public void Eat(Food food);
}class PersonExtension {static public void Drive(Person person,Car car);
}

万一哪天玩家都不喜欢开车的功能，删就完了，一点影响都没有，甚至都不知道有Drive()这个东西

如果这个时候，我们用一手继承，场景相当微妙：

class Driver extends Person {public void Drive(Car car);
}

它一样能做到可拆卸，更重要的是它做到了标识性！

• 假设游戏里的每个人既要会开车，又要会游泳，优先选择类扩展
• 假设游戏里的人需要不同的职业身份，不同职业的人做不同的事情，还是用多个子类继承为妙；不同子类，特殊功能一般是互斥的（比如赛车手进不了游泳馆）

场景二：对第三方类的扩展

我们自己导进来的库，我们想修改，改不了咋办，类扩展呀！（扩展要把方法都重搞一遍，成本太高难维护）

// 假设已经导了Person的库
class PersonEx {static public void Eat(Person person, Food food){person.energy += food.calorie;}
}// 使用该方法
PersonEx。Eat(person,food);

这类使用是我们最经常会用到的！！！比“瘦身”使用多得多，重点理解！！！

与继承的区别

• 更轻

• 功能拆卸隐蔽

• 无额外标识、层级

让数据互动起来吧

前面说到的，static扩展让参数反客为主，相当于给参数穿了个装备，我们试着多加点参数，让他们互动起来

一样，我们先看个案例：

class Solder extends Person {BigDecimal money;Book[] books;public SoldBook(Person buyer , Book book){this.books.remove(book);this.money.add(book.price);buyer.books.add(book);// solder似乎没有权力直接从buyer口袋里掏钱buyer.money.minus(book.price);}
}

直接在卖家这边操作买家，好像不太妥当把？最好加一个中间媒介：

class BookService {static public void SoldBooks(Person solder,Person buyer,Book[] books);
}

买书、卖书的人其实并不在乎对象是谁，在乎交易的是外层平台，这是符合显示交易模型的。（这个模型中，先后顺序其实并不重要）

构建上层建筑

核心：用于实现基础功能之上的复合服务

• 需求整理
  • 外部需求（提供API）：上层建筑
  • 内部需求（功能实现）：底层地基
  • 外部需求往往可以展现为内部需求的符合需求 → “分治”思想

还是看个例子先：

// 我们有3种搜索类，分别对应三种产品
interface BaseSearch {Product[] Search();
}
class ProductASearch implements BaseSearch {Product[] Search();
}
class ProductBSearch implements BaseSearch {Product[] Search();
}
class ProductCSearch implements BaseSearch {Product[] Search();
}

这时候，有人要买我的服务，甲公司要A和B服务，乙公司就要个C，这不就是子功能上的复合吗？！

而static函数，正是构建服务函数的主要形式：（保证信息完备且无状态）

static public Product[] SearchProduct(boolean a,boolean b,boolean c){Product[] products = new Product[]();if(a){ProductASearch searchA = new ProductASearch();products.add(searchA.Search());}if(b){ProductBSearch searchB = new ProductBSearch();products.add(searchB.Search());}if(c){ProductCSearch searchC = new ProductCSearch();products.add(searchC.Search());}
}

再写个给甲公司服务的方法：

static public Product[] JiaCompanySearch(){return SearchProduct(true,true,false);
}

给他起个优雅的名字——“定制化服务”

总结

• static并不是OOP而产生的技术，是从传统的全局变量和函数演化而来的

• static无法被继承，更不能多态

• 是OOP的补充，让代码更优雅

• 传统用法：当作全局使用，还能做单例

• 实际业务开发用法：工具类、类扩展，让数据互动，还能构建复合需求的服务函数