核心+变化
“凡是钱能解决的问题，就不是大问题。有很多问题是钱无法解决的，比如生老病死，比如不再相爱。”，看过《蜗居》的朋友一眼就能认出来。虽然这部电视剧讲的是chugui，但是毫无违和感，我当时都看出来真感情了。
海藻和宋思明虽然是因借钱开始的，但是后面的发展却远远超出了它。这里面钱是问题的核心，后面发生的事情都是围绕着核心的变化。
社会是一张庞大而复杂的网，有节点和连线组成。节点就是人，连线就是人际关系。这里面人是核心，人际关系是围绕着核心的变化。
那到底是核心影响变化呢，还是变化影响核心呢，还是二者皆而有之呢？不管怎样，请记住都是：核心+变化。
如果把核心看作是数据，那变化就是行为。如果把核心看作是字段，那变化就是方法。
哎呀，终于回到了编程上，差点没绕回来。
那些年，我的专业课老师
“好了，我们这本书已经讲完了”。老师，明明后面还有一半呢，怎么就讲完了呢？“后面那是指针，给你们讲了你们也不懂”。
都看看，这可是我计算机生涯的第一门语言，C语言呀，碰上这样的老师，“不仅侮辱了我们的人格，还侮辱了我们的智商”。所以我今天取得的“成就”都是我自己努力得来的。
哈哈，开个玩笑，不管怎样，还是要感谢老师带我“上道”的。其它老师的“名言”，后续再分享。
有句话怎么讲，“明知山有虎、偏向虎山行”，就是不信这个邪了，我倒要看看指针有多难。
事实证明，很多事情因人而异。好多人都说指针很难，但是我从一开始学习指针，直到现在，从来没觉得它难。
指针只不过是在变量的基础上又往前走了一步。变量对应的是数据本身，指针对应的是数据的地址。所以从指针获取数据需要执行一步解引用，即星号（*）操作符。
不过变量类型很多，所以指针的类型也很多，还有指向指针的指针，因此指针在写法上比较繁琐，不容易记住，但并不难理解。
C语言中的函数指针
人们对带“美”字的东西都比较感兴趣。如美景、美食、美酒、美元、美女等。当然也有讨厌的，如美国。
来个美食吧。鱼类绝对算一个，特别是深海鱼。无污染，低脂肪，高蛋白，维生素，不饱和脂肪酸，而且肉质嫩滑，味道鲜美。关键还符合我国的传统文化，年年有鱼啊。
岛国喜欢做成生鱼片或寿司。我国的花样就多了，红烧鱼，清蒸鱼，水煮鱼，麻辣鱼，剁椒鱼，酸菜鱼，蕃茄鱼，烤鱼等等。
那么问题来了，如何用C语言实现这么多的做鱼呢？
首先从生活入手，厨房 + 厨师 + 生鱼 = 熟鱼。假设每个厨师只会做一种鱼。用伪代码表示：
CookedFish kitchen(UncookedFish, CookWay) {
if (CookWay == "生鱼片") {
//厨师A做生鱼片
} else if (CookWay == "红烧鱼") {
//厨师B做红烧鱼
} else if (CookWay == "酸菜鱼") {
//厨师C做酸菜鱼
}...
}
这个方法看起来很臃肿，因为它把所有的做鱼方法都放进来了。
就像所有的厨师都在厨房里候着，然后进来一条生鱼，并告知要做成什么样的，对应的厨师起身去做鱼，剩余的厨师仍继续候着。
现实中是厨师都在自己的岗位上，而非厨房里，需要做鱼的时候，厨师和生鱼进厨房即可。
就像这样，厨房（厨师，生鱼）= 熟鱼，用伪代码表示：
CookedFish kitchen(Cooker*, UncookedFish) {
//厨师做鱼
Cooker(UncookedFish);
}
这里已经不需要CookWay了，因为一个厨师只会做一种鱼，从厨师就可以知道鱼的做法了。
这里面的核心是鱼，围绕核心的变化是厨师。如果鱼是字段，那厨师就是方法了。
第一种方法之所以繁琐，是因为我们只把字段传进来了，方法全部在“厨房”里。其实即使厨房里有再多的方法，一次也只能用一个。
为了简洁和更加符合实际，我们除了把字段传进来之外，也把方法传进来了。即，既把鱼传进来，也把厨师传经来。这样厨房里只有一个厨师在工作，就清爽多了。
我们可以看到，除了数据（鱼）可以当作参数传递外，行为（厨师）也可以当作参数传递。
C语言不是OO的，没有对象的概念，也没有方法的概念，只有函数，一段可执行的代码就是函数。
为了传递函数，需要用到函数指针，Cooker*就是函数指针，它指向的就是一个代码片段。
函数指针代表的是函数签名，即某一类函数。
如void (*fp)();这里的fp就是函数指针，它表示所有没有入参也没有返回值的这类函数。
如下：
//函数
void foo(){...};
void bar(){...};
//把函数赋给函数指针
fp = &foo;
fp = &bar;
//通过指针调用函数
(*fp)();
再看一个例子：
//函数指针
int (*fp2)(int, int);
//加
int add(int a, int b) {
return a + b;
}
//减
int sub(int a, int b) {
return a + b;
}
//乘
int mul(int a, int b) {
return a + b;
}
//除
int div(int a, int b) {
return a + b;
}
//函数
int op2(int (*fp2)(int, int), int a, int b) {
return fp2(a, b);
}
//调用，把函数当作参数传入
op2(add, 1, 2) == 3;
op2(sub, 2, 1) == 1;
op2(mul, 1, 2) == 2;
op2(div, 4, 2) == 2;
看不懂函数指针没关系，后面还有C#和Java代码。
C#中的Lambda表达式
初次接触lambda表达式就是在C#中，已是很多年前的事了。C#确实从C和C++中继承了很多特性。
在C#中应该也支持指针，但是不推荐使用。为了完成C语言中函数指针这种功能，C#提供了类型安全的“函数指针”，就是委托。
委托的关键字是delegate，它的用法如下：
public delegate void FB(int a);
委托表示的是方法签名，即一类方法。此处定义的委托类型是FB，它表示所有入参为一个整型且没有返回值的方法。
所以可以把方法赋值给委托，自然可以调用委托，如下：
//一个整型入参，无返回值
public void Foo(int a)
{
Console.WriteLine("Foo: " + a);
}
//一个整型入参，无返回值
public void Bar(int a)
{
Console.WriteLine("Bar: " + a);
}
//委托的赋值与调用
public void TestDelegate()
{
//把方法赋给委托
FB fb = this.Foo;
//调用委托
fb(1);
//把方法赋给委托
fb = this.Bar;
//调用委托
fb(2);
}
委托还可以用作方法的参数，此时就可以把一个方法当作参数传给其它方法。
//第一个参数FB就是委托
public void TestDelegate(FB fb, int a)
{
fb(a);
}
//下面是对这个方法的调用
Program p = new Program();
//p.Foo是一个方法，可以作为参数传入
p.TestDelegate(p.Foo, 1);
//p.Bar是一个方法，可以作为参数传入
p.TestDelegate(p.Bar, 2);
lambda表达式本质上就是一段可执行的代码，但是不同语言对它的实现是不同的，在C#中就实现为委托。
public void TestLambda()
{
//这就是lambda表达式的写法，它被赋值给了委托
FB fb = (int a) => Console.WriteLine("lambda 1: " + a);
fb(1);
//lambda表达式
fb = (a) =>
{
Console.WriteLine("lambda 2: " + a);
};
fb(2);
}
由于编译器会进行类型推断，所以可以省略参数类型。如果只有一个入参的话，可以省略那个小括号。如果只有一个语句的话，可以不用要大括号。
lambda表达式作为参数传递：
public void TestLambda(FB fb, int a)
{
fb(a);
}
//lambda表达式直接作为参数
p.TestLambda((int a) => Console.WriteLine("lambda 1: " + a), 1);
//lambda表达式直接作为参数
p.TestLambda((a) => { Console.WriteLine("lambda 2: " + a); }, 2);
C#中的匿名方法，如下：
public void TestAnonymousMethod()
{
//匿名方法可以赋值给委托，用关键字delegate替代方法名
FB fb = delegate(int a)
{
Console.WriteLine("anonymous method: " + a);
};
fb(1);
fb(2);
}
匿名方法作为参数传递：
public void TestAnonymousMethod(FB fb, int a)
{
fb(a);
}
//匿名方法直接作为方法参数
p.TestAnonymousMethod(delegate(int a) { Console.WriteLine("anonymous method: " + a); }, 1);
//匿名方法直接作为方法参数
p.TestAnonymousMethod(delegate(int a) { Console.WriteLine("anonymous method: " + a); }, 2);
总之，C#中的普通方法，lambda表达式，匿名方法，最后都可以赋值给委托进行传递和调用。
看不懂C#没关系，后面还有Java代码。
Java中的Lambda表达式
自从Java换了爸爸后，简直像坐上了火箭。各种其它语言的特性都陆续加进来了。从Java 8开始也可以使用lambda表达式了。
不过说来惭愧，我用的不多，因为它在我的编程生涯中已经不再“稀奇”了，因为之前已经在C#中体验过了。
Java也是从C和C++发展过来的，继承了一些特性，但抛弃的更多。类似函数指针的功能，就被优化没了。
因此在Java语言中，对于行为（可执行代码片段）的传递，无法做到方法级别，只能再往上走一步，做到接口级别或类级别。
也就是说，你想传递一个方法时，必须要传递一个类或对象作为方法的载体才行。这种使用方式其实一直都存在着的。
Java 8中引入一个新的概念叫做函数式接口。它规定这样的接口只能包含一个抽象方法，但可以包含其它带默认实现的任意方法。
函数式接口也可以像普通接口那样使用。只不过会有一些特定功能，毕竟是为了配合Java 8支持函数式编程而特意起的这个名字。
有一个函数式接口叫做Consumer<T>，它只有一个抽象方法是void accept(T t);这个方法接收一个入参但没有返回值。
所以这个函数式接口就代表了这样一类方法，即有一个入参但没有返回值的所有方法。所以函数式接口大致上也可以看作是一类方法的“方法签名”。
定义一个函数式接口变量，表示只有一个入参但没有返回值的这类方法。
//函数式接口变量
public Consumer<Integer> fb;
可以把方法赋值给函数式接口，然后进行调用，如下：
//只有一个入参且没有返回值的方法
public void foo(int a) {
System.out.println("foo: " + a);
}
//只有一个入参且没有返回值的方法
public void bar(int a) {
System.out.println("bar: " + a);
}
//函数式接口的赋值与调用
public void testFunctionalInterface() {
//把方法赋值给函数式接口变量
fb = this::foo;
//调用函数式接口，就是调用赋给它的方法
fb.accept(1);
//把方法赋给函数式接口变量
fb = this::bar;
//调用
fb.accept(2);
}
注意引用方法时使用了::操作符，这个应该是C++中的写法吧。
函数式接口作为方法参数：
public void testFunctionalInterface(Consumer<Integer> fb, int a) {
fb.accept(a);
}
Program p = new Program();
//把方法作为参数传给其它方法
p.testFunctionalInterface(p::foo, 1);
//把方法作为参数传给其它方法
p.testFunctionalInterface(p::bar, 2);
毫无悬念，lambda表达式可以赋给函数式接口变量。
public void testLambda() {
//lambda表达式的写法
fb = (Integer a) -> System.out.println("lambda 1: " + a);
fb.accept(1);
//lambda表达式
fb = (a) -> {
System.out.println("lambda 2: " + a);
};
fb.accept(2);
}
很显然，没有太多的惊喜。
lambda表达式作为参数传递：
public void testLambda(Consumer<Integer> fb, int a) {
fb.accept(a);
}
//lambda表达式直接作为参数传递
p.testLambda((Integer a) -> System.out.println("lambda 1: " + a), 1);
//lambda表达式直接作为参数传递
p.testLambda((a) -> { System.out.println("lambda 2: " + a); }, 2);
Java中的匿名类：
public void testAnonymousClass() {
//匿名类，函数式接口作为普通接口使用
fb = new Consumer<Integer>() {
@Override
public void accept(Integer a) {
System.out.println("anonymous class: " + a);
}
};
fb.accept(1);
fb.accept(2);
}
匿名类作为参数传递：
public void testAnonymousClass(Consumer<Integer> fb, int a) {
fb.accept(a);
}
//匿名类直接做参数
p.testAnonymousClass(new Consumer<Integer>() {
@Override
public void accept(Integer a) {
System.out.println("anonymous class: " + a);
}
}, 1);
//匿名类直接做参数
p.testAnonymousClass(new Consumer<Integer>() {
@Override
public void accept(Integer a) {
System.out.println("anonymous class: " + a);
}
}, 2);
总之，在Java中无论是普通方法，还是lambda表达式，或是匿名类，其实它们最后都变成了一个类，且都实现了这个函数式接口。
只不过匿名类是我们自己定义的。lambda表达式最后对应的类是编译器造出来的，所以它是“人造”的，但不是匿名的。
看不懂Java没关系，只要明白了原理就算是知道了精髓。
in C# VS in Java
为了“模拟”函数指针的功能，在C#中使用委托，在Java中使用函数式接口。
函数式接口其实就是一个接口，它看起来具有表示“方法签名”的功能，但是很丑陋。
委托看起来更像“方法签名”，也很优雅，但不要被迷惑，其实它也是一个类，没有什么高级东西。
对于引用方法的写法不同，C#中使用this.Foo，this.Bar，Java中使用this::foo，this::bar。
lambda表达式的写法略微不同，C#中是() => {}，Java中是() -> {}。
关于匿名，C#中虽然叫匿名方法，其实最后还是一个类，而且是委托类型的。直接用delegate关键字定义匿名方法。
Java中就叫匿名类，名副其实，最后就是一个类。只不过需要先定义一个接口，然后直接使用接口实现匿名类。
我们发现C#和Java对lambda表达式的支持其实差不多。不同的是C#更优雅一些，Java更丑陋一些。
思想提升
一定要明白不仅普通数据可以当作参数传递，代码片段（就是逻辑）也可以当作参数传递。
这个思想就是核心，至于写法和用法就是围绕着核心的变化而已。
PS：最近几年很少看到语言之争啊，莫非大家都觉得PHP是世界上最好的语言啦?。Oracle选择收费和有闭源的趋势，微软却选择免费、开源和跨平台，上帝才知道这是怎么回事。
编程新说
用独特的视角说技术
