/*	组合数
从4个人中选2个人参加活动，一共有6种选法。
从n个人中选m个人参加活动，一共有多少种选法？下面的函数实现了这个功能。
请仔细分析代码，填写缺少的部分(下划线部分)。
注意：请把填空的答案（仅填空处的答案，不包括题面）存入考生文件夹下对应题号的“解答.txt”中即可。
直接写在题面中不能得分。
 */
public class 组合数 {
	// n 个元素中任取 m 个元素，有多少种取法
	public static int f(int n, int m){
		if(m>n) return 0;
		if(m==0) return 1;

		return f(n-1,m-1) + f(n-1,m);	// 填空
	}
	public static void main(String[] args){
		System.out.println(f(4,2));
	}
}
运行结果:
6

    

全栈工程师开发手册 （作者：栾鹏）

 js系列教程4-函数、函数参数教程全解
js中的4种函数调用模式
javascript一共有4种调用模式：函数调用模式、方法调用模式、构造器调用模式和间接调用模式。
【1】函数调用模式
当一个函数并非一个对象的属性时，那么它就是被当做一个函数来调用的。对于普通的函数调用来说，函数的返回值就是调用表达式的值
function add(x,y){
    return x+y;
}
var sum = add(3,4);
console.log(sum)//7

使用函数调用模式调用函数时，非严格模式下，this被绑定到全局对象；在严格模式下，this是undefined
function add(x,y){
    console.log(this);//window
}    
add();

function add(x,y){
    'use strict';
    console.log(this);//undefined
}    
add();//window

因此，'this’可以用来判断当前是否是严格模式
var strict = (function(){return !this;}());

重写
因为函数调用模式的函数中的this绑定到全局对象，所以会发生全局属性被重写的现象
var a = 0;
function fn(){
    this.a = 1;
}
fn();
console.log(this,this.a,a);//window 1 1

【2】方法调用模式
当一个函数被保存为对象的一个属性时，我们称它为一个方法。当一个方法被调用时，this被绑定到该对象。如果调用表达式包含一个提取属性的动作，那么它就是被当做一个方法来调用
var o = {
    m: function(){
        console.log(1);
    }
};
o.m();//1

方法可以使用this访问自己所属的对象，所以它能从对象中取值或对对象进行修改。this到对象的绑定发生在调用的时候。通过this可取得它们所属对象的上下文的方法称为公共方法。
var o = {
    a: 1,
    m: function(){
        return this;
    },
    n: function(){
        this.a = 2;
    }
};
console.log(o.m().a);//1
o.n();
console.log(o.m().a);//2

任何函数只要作为方法调用实际上都会传入一个隐式的实参——这个实参是一个对象，方法调用的母体就是这个对象，通常来讲，基于那个对象的方法可以执行多种操作，方法调用的语法已经很清晰地表明了函数将基于一个对象进行操作
rect.setSize(width,height);
setRectSize(rect,width,height);

假设上面两行代码的功能完全一样，它们都作用于一个假定的对象rect。可以看出，第一行的方法调用语法非常清晰地表明这个函数执行的载体是rect对象，函数中的所有操作都将基于这个对象
和变量不同，关键字this没有作用域的限制，嵌套的函数不会从调用它的函数中继承this。如果嵌套函数作为方法调用，其this的值指向调用它的对象。如果嵌套函数作为函数调用，其this值不是全局对象(非严格模式下)就是undefined(严格模式下)
var o = {
    m: function(){
         function n(){
             return this;
         }
         return n();
    }
}
console.log(o.m());//window


var o = {
    m: function(){
         function n(){
             'use strict';
             return this;
         }
         return n();
    }
}
console.log(o.m());//undefined

如果想访问这个外部函数的this值，需要将this的值保存在一个变量里，这个变量和内部函数都同在一个作用域内。通常使用变量self或that来保存this
var o = {
    m: function(){
        var self = this;
        console.log(this === o);//true
         function n(){
             console.log(this === o);//false
             console.log(self === o);//true
             return self;
         }
         return n();
    }
}
console.log(o.m() === o);//true

【3】构造函数调用模式
如果函数或者方法调用之前带有关键字new，它就构成构造函数调用

function fn(){
    this.a = 1;
};
var obj = new fn();
console.log(obj.a);//1

如果构造函数调用在圆括号内包含一组实参列表，先计算这些实参表达式，然后传入函数内
function fn(x){
    this.a = x;
};
var obj = new fn(2);
console.log(obj.a);//2

如果构造函数没有形参，javascript构造函数调用的语法是允许省略实参列表和圆括号的。凡是没有形参的构造函数调用都可以省略圆括号
var o = new Object();
//等价于
var o = new Object;

[注意]尽管构造函数看起来像一个方法调用，它依然会使用这个新对象作为调用上下文。也就是说，在表达式new o.m()中，调用上下文并不是o
var o = {
    m: function(){
        return this;
    }
}
var obj = new o.m();
console.log(obj,obj === o);//{} false
console.log(obj.constructor === o.m);//true

构造函数通常不使用return关键字，它们通常初始化新对象，当构造函数的函数体执行完毕时，它会显式返回。在这种情况下，构造函数调用表达式的计算结果就是这个新对象的值
function fn(){
    this.a = 2;
}
var test = new fn();
console.log(test);//{a:2}

如果构造函数使用return语句但没有指定返回值，或者返回一个原始值，那么这时将忽略返回值，同时使用这个新对象作为调用结果
function fn(){
    this.a = 2;
    return;
}
var test = new fn();
console.log(test);//{a:2}

如果构造函数显式地使用return语句返回一个对象，那么调用表达式的值就是这个对象
var obj = {a:1};
function fn(){
    this.a = 2;
    return obj;
}
var test = new fn();
console.log(test);//{a:1}

【4】间接调用模式
javascript中函数也是对象，函数对象也可以包含方法。call()和apply()方法可以用来间接地调用函数
这两个方法都允许显式指定调用所需的this值，也就是说，任何函数可以作为任何对象的方法来调用，哪怕这个函数不是那个对象的方法。两个方法都可以指定调用的实参。call()方法使用它自有的实参列表作为函数的实参，apply()方法则要求以数组的形式传入参数
var obj = {};
function sum(x,y){
    return x+y;
}
console.log(sum.call(obj,1,2));//3
console.log(sum.apply(obj,[1,2]));//3

函数根据有没有参数，有没有返回值，可以相互组合，一共有4种

* 无参数，无返回值

* 无参数，有返回值

* 有参数，无返回值

* 有参数，有返回值
<1>无参数，无返回值的函数此类函数，不能接收参数，也没有返回值，一般情况下，打印提示灯类似的功能，使用这类的函数    def printMenu():        print(’--------------------------’)        print(’      xx涮涮锅 点菜系统’)        print(’’)        print(’  1.  羊肉涮涮锅’)        print(’  2.  牛肉涮涮锅’)        print(’  3.  猪肉涮涮锅’)        print(’--------------------------’)<2>无参数，有返回值的函数此类函数，不能接收参数，但是可以返回某个数据，一般情况下，像采集数据，用此类函数    # 获取温度    def getTemperature():        #这里是获取温度的一些处理过程        #为了简单起见，先模拟返回一个数据        return 24    temperature = getTemperature()    print(‘当前的温度为:%d’%temperature)结果:    当前的温度为: 24<3>有参数，无返回值的函数此类函数，能接收参数，但不可以返回数据，一般情况下，对某些变量设置数据而不需结果时，用此类函数<4>有参数，有返回值的函数此类函数，不仅能接收参数，还可以返回某个数据，一般情况下，像数据处理并需要结果的应用，用此类函数    # 计算1~num的累积和    def calculateNum(num):        result = 0        i = 1        while i<=num:            result = result + i            i+=1        return result    result = calculateNum(100)    print(‘1~100的累积和为:%d’%result)结果:    1~100的累积和为: 5050<5>小总结

* 函数根据有没有参数，有没有返回值可以相互组合

* 定义函数时，是根据实际的功能需求来设计的，所以不同开发人员编写的函数类型各不相同
函数的嵌套调用

一个函数里面又调用了另外一个函数，这就是所谓的函数嵌套调用

如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置
变量起作用的代码范围称为变量的作用域，不同作用域内同名变量之间互不影响就像不同文件夹的同名文件间互不影响一样。一个变量在函数外部定义和在内部定义，其作用域是不同的，函数内部定义的变量一般称为局部变量在函数外部定义的变量一般称为去全局变量局部变量

* 局部变量，就是函数内部定义的变量

* 不同的函数，可以定义相同的名字的局部变量，但是各用个的互不影响

* 局部变量的作用,为了临时保存数据需要在函数中定义变量来进行存储，这就是他的作用
在函数内部定义的普通变量值在该函数内起作用，当函数运行结束后，在其内部定义的局部变量将被自动删除而不可访问。在函数内部定义的全局变量当函数结束后仍然存在并且可以访问全局变量

* 如果一个变量，既能在一个函数中使用，也能在其他函数中使用，这样的变量就是全局变量
定义全局变量a = 100def test1():print(a)def test2():print(a)# 调用函数test1()test2()注意修改全局变量既然全局变量，就是能够在所有的函数中进行使用，那么可否进行修改呢？1、在函数外边定义的变量叫做全局变量2、全局变量能够在所有的函数中进行访问3、如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错4、如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的，强龙不压地头蛇>>> a = 1>>> def f():… a += 1… print （a）…>>> f()Traceback (most recent call last):File “”, line 1, in File “”, line 2, in fUnboundLocalError: local variable ‘a’ referenced before assignment>>>>>>>>> li = [1,]>>> def f2():… li.append(1)… print li…>>> f2()[1, 1]>>> li[1, 1]1、在函数中不使用global声明全局变量时不能修改全局变量的本质是不能修改全局变量的指向，即不能将全局变量指向新的数据。2、对于不可变类型的全局变量来说，因其指向的数据不能修改，所以不使用global时无法修改全局变量。3、对于可变类型的全局变量来说，因其指向的数据可以修改，所以不使用global时也可修改全局变量。

① 类内有自定义构造函数和自定义复制构造函数
  根据C++标准定义，如果程序已定义构造函数，默认情况下编译器就不再隐含生成默认构造函数。注意，这里的“构造函数”包括复制构造函数（因为复制构造函数也是构造函数的一种）。
  此时该类一共有2个构造函数：自定义构造函数和自定义复制构造函数。
② 类内有自定义构造函数，无任何复制构造函数
  根据C++标准定义，有自定义构造函数，则无默认构造函数；无自定义复制构造函数，则隐含生成默认复制构造函数。下面使用代码检验：
#include <iostream>
using namespace std;

class A{
public:
	int x;
	A(int x_=0): x(x_){}
};

int main()
{
	A a;
	cout << a.x << endl;
	A b(a);	//这里调用了默认复制构造函数
	cout << b.x << endl;

	return 0;
}

代码能正确执行；
  类A中没用声明任何复制构造函数，但是可以执行A b(a);说明编译器隐含生成了默认复制构造函数（使用单步跟踪检验，确实如此）。
  此时该类一共有2个构造函数：自定义构造函数和默认复制构造函数。
③ 类内无任何构造函数，无任何复制构造函数
  根据C++标准定义，编译器应该隐含生成默认构造函数和默认复制构造函数。下面用代码检验：
#include <iostream>
using namespace std;

class A{
public:
	int x=0;/*注：可能在早期的C++版本中，类的数据成员不能在声明时进行初始化，
			但是在C++11新标准下，类的数据成员可以在声明时进行初始化，但不建议，
			因为这样做破坏了类的抽象性)*/
};

int main()
{
	A a;	//这里调用了默认构造函数
	cout << a.x << endl;
	A b(a);	//这里调用了默认复制构造函数
	cout << b.x << endl;

	return 0;
}

代码能正确执行；
  注意到，类的数据成员x在声明时同时定义了初始值。可能在早期的C++版本中，类的数据成员不能在声明时进行初始化，但是在C++11新标准下，类的数据成员可以在声明时进行初始化，但不建议，因为这样做破坏了类的抽象性。
  此时该类一共有2个构造函数：默认构造函数和默认复制构造函数。
⭐④ 类内无任何构造函数，有自定义复制构造函数
  （情况④较为特殊，应重点注意）

  按照C++标准，编译器应该隐含生成默认构造函数，事实是否如此？下面用代码来检验：
#include <iostream>
using namespace std;

class A{
public:
	int x=0;
	A(A &a){ }
};

int main()
{
	A a; //编译器提示错误，错误信息：类A不存在默认构造函数
	cout << a.x << endl;
	A b(a);	//这里调用了默认复制构造函数
	cout << b.x << endl;

	return 0;
}

  代码执行错误，编译器并没有隐含生成默认构造函数。
  此时该类一共有1个构造函数：自定义复制构造函数。
PS C++11新标准中，默认构造函数和默认复制构造函数的一些新特性