java第三阶段学习末尾

学习大纲

• 语句块
• 方法
• 方法的基本使用
• 方法的重载
• 递归

---

学习笔记

语句块

语句块（又被称为复合语句），使用花括号括起的任意数量的java语句，块确定了局部变量的作用域，块中的程序代码，作为一个整体，是要被一起执行的。块可以被嵌套在另一个块中，但是不能在两个嵌套的快内声明同名变量。语句块可以使用外部变量，而外部无法使用语句快中定义的变量，因为语句块中定义的变量作用域只限于语句块内。

方法

方法就是一段用来完成特定功能的代码片段，类似于c语言中的函数，方法用于定义该类的行为特征和实例，方法是类和对象行为特征的抽象，方法很类似与面向过程中的函数，面向过程中，函数是最基本的单位，整个程序由一个个函数调用组成，面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
格式： [修饰符1 修饰符2 ……] 返回值类型 方法名（形式列表参数）{
代码
}
形式参数：在定义时，方法名后面括号内的参数为形式参数
实参：方法在调用时，方法名后面括号里的内容为实际参数
返回值：可有可无，看需要
返回值类型：如int，double等，如果没有返回值，用void

关于方法的基本使用
！！！注意：

• 实参的数目，数据类型和次序必须和调用的方法声明的形式参数列表匹配，
• return语句中止方法的运行并指定要返回的数据
   单单的return可以终止无返回值程序运行
• java中进行方法调用中传递参数时，遵循值传递的原则（传递的都是数据的副本）
• 基本数据传递的是该数据值得copy值
• 引用类型传递的是该对象引用的copy值，但指向的是同一个对象

方法的重载

方法的重载是指一个类中可以定义多个方法名字相同，但参数不同的方法。调用时，会根据不同的参数匹配对应的方法。

！！！注意：
重载的方法，实际上是完全不同的方法（相互之间是独立的），只是名称相同而已。

构成方法重载的条件：
不同的含义：参数类型，形参个数，形参次序不同

递归

递归的基本思想就是“自己调用自己”
一个使用递归技术的方法将会直接或者间接的调用自己。
利用递归可以用简单的程序来解决一些复杂的问题：例如斐波那契数列，汉诺塔，快排等。
递归结构包括两部分：

1. 定义递归头。即什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归结束的条件。
2. 递归体，什么时候需要调用自身的方法

！！！注意：任何能用递归解决的问题也能用迭代解决问题。当递归方法可以更加自然的反映问题，并且易于理解和调试，并且不强调效率问题时，可以采用递归。
在要求高性能的情况下尽量避免使用递归，递归调用既花时间又耗内存

代码

/**

• 语句块
• @author L

*/
public class TestMethodAndBlock {
public static void main(String[] args) {
int n;
int j;
{
int a;
//int n; 报错不能重复定义n，（语句块内可以使用外部变量）

	}
	int a;//可以定义a，因为上面语句块中的a已经结束了
}

}

/**
*测试方法的基本使用使用

• @author L

*/
public class TestMethod {
public static void main(String[] args) {
//printsth(); 不能这么直接调用方法，要通过对象来调用方法
TestMethod tt = new TestMethod();//new一个对象？如果方法前面加了关键字static就不用这一步了！有深层次的原因！
tt.printsth();
int y = tt.add(12, 13, 14);
System.out.println(y);
}
void printsth() {
System.out.println(“我是谁”);
System.out.println(“我在哪”);
System.out.println(“我在干什么”);
}
/void add(int a,int b,int c) {
int sum = a + b + c;
System.out.println(sum);
}/
int add(int a,int b,int c) {
int sum = a + b + c;
System.out.println(sum+1);
return sum;
}

}

/**

• 测试方法重载
• @author Administrator

*/
public class TestOverload {
public static void main(String[] args) {
System.out.println(add(2,3));
System.out.println(add(2,3,4));
System.out.println(add(2.2,3));
System.out.println(add(2,3.3));
}
public static int add(int n1,int n2) { //使用static可以不用new出一个对象（创建对象）而在该类中直接调用本类中的static方法
int sum = n1 + n2;
return sum;
}
//方法名相同，形参数目不同，构成了方法重载
public static int add(int n1,int n2,int n3) {
int sum = n1+n2+n3;
return sum;
}
//方法名形同，但是形参类型不同，构成了方法重载
public static double add(double n1,int n2) {
double sum = n1 + n2;
return sum;
}
//方法名相同，但是参数类型数目不同，次序不同
public static double add(int n1,double n2) {
double sum = n1+n2;
return sum;
}
//编译错误：只有返回值不同，不构成方法重载
/public static double add(int n1,int n2) {
int sum = n1 + n2;
return sum;
}/
//不构成重载，因为只是形参名不一样
/public static int add(int n2,int n1) {
int sum = n1+n2;
return sum;
}/

}

/**

• 测试递归
• @author Administrator

/
public class TestRecursion01 {
public static void main(String[] args) {
int i=20;
long sum = 1;
long d1=System.currentTimeMillis();
long x = jieceng(i);
long d2=System.currentTimeMillis();
System.out.println(“阶乘的结果：”+x);
System.out.println(“递归过程的耗时：”+(d2-d1));
long d3=System.currentTimeMillis();
while(i>=1) {
sum =sumi;
i–;
}
long d4=System.currentTimeMillis();
System.out.println(“阶乘的结果：”+sum);
System.out.println(“用循环做阶乘的耗时：”+(d4-d3));
}
//用递归法求i的阶乘
static long jieceng(int i) {
if(i==1) {//递归头
return i;
}
else {//递归体
return i*jieceng(i-1);
}
}
//为什么上面两者测试耗时的结果是一样的？
}