JAVA笔记

一、方法

1、初始方法

1、程序开始执行的时候先执行main方法，因为main方法是程序的入口。

2、在java语言中，所有的方法体中的代码必须遵守自上而下的执行顺序依次逐行执行。

3、main方法不需要程序员手动调用，是由JVM调用的。

4、除了main方法以外的其他方法，都需要程序员手动调用。

5、方法只有在调用的时候才会执行，不调用是不会执行的。

6、方法体内的变量属于局部变量，方法执行结束之后内存会释放。

7、代码示例

public class Test {
    public static void main(String[] args) {
        sum(100,200);
    }
    public static void sum(int x, int y) {
        int z = x + y;
        System.out.println("计算结果为：" + z);
    }
    public static void test() {
        /*
        Error:(14, 28) java: 找不到符号
        符号:   变量 x
        位置: 类 test.Test001
        System.out.println(x); //局部变量的内存已经被释放
         */
        
    }
}

2、方法

1、方法的定义：[修饰符列表] 返回值类型 方法名 （形式参数列表）{方法体}；

2、修饰符列表不是必须的，是可选的。

3、返回值类型可以是任何类型，是java中的合法数据类型就行，数据类型包括基本数据类型、引用数据类型，即返回值类型可以是：byte、short、int、long、float、double、boolean、char、String…

4、返回值一般指方法执行结束之后的结果，这个结果一般都是数据，数据就有数据类型。

5、第一个方法执行之后不返回任何值的时候，返回值类型也不能为空，必须写上void关键字，即void关键字表示方法执行结束之后不返回任何结果。

6、如果方法的返回值类型不是void，那么必须使用“return 值”这样的语句来返回方法的执行结果，如果没有这样的语句，编译器会报错。

7、只要return语句执行结束，return语句所在的方法必然执行结束。

8、如果方法的返回值类型是void，那么方法体中不能有“return 值”这样的语句，但可以有“return；”这样的语句，“return；”作用是终止当前方法。

9、形式参数列表中的每个参数都是局部变量，方法执行结束之后内存会释放，形式参数的个数可以是0-N个，多个参数之间使用英文逗号隔开。

10、方法的调用：实参和形式参数的类型必须一一对应

​ 类名.方法名(实际参数列表);

11、方法虽然有返回值，但是我们可以不接受。

12、如果A方法和B方法在同一个类中，A调用B方法，“ 类名. ”可以省略，如果在不同的类中，“ 类名. ”不可以省略。

public class Test001 {
    public static void main(String[] args) {
        Test001.test2(); //不省略 类名.
        test1(); //省略 类名.

        MyTest.MyTest1(); //正确，类名. 不能省略

        /*
        Error:(11, 9) java: 找不到符号
          符号:   方法 MyTest2()
          位置: 类 test.Test001
          MyTest2();
         */

    }
    public static void test1() {
        System.out.println("test1");
    }
    public static void test2() {
        System.out.println("test2");
    }
    public static void test3() {
        System.out.println("test3");
    }
}
class  MyTest{
    public static void MyTest1(){
        System.out.println("MyTest1");
    }
    public static void MyTest2(){
        System.out.println("MyTest2");
    }
}

13、注意：break；语句用来终止switch和离它最近的循环，return；语句用来终止离它最近的一个方法。

14、代码示例

public class Test {
    public static void main(String[] args) {
        int ret = sum();
        System.out.println(ret);
    }

    /*
        Error:(16, 5) java: 缺少返回语句
        对于编译器来说，它不负责运行程序，编译器只知道flag变量是boolean类型
        有可能是true，有可能是false
        public static int sum(){
            boolean flag = true;
            if (flag) {
                编译器觉得以下的代码可能执行，也可能不执行，为了确保程序不出现
                任何异常，所以编译器报错：缺少返回语句
                return 1;
            }
        }
     */
    public static int sum(){
        boolean flag = true;
        if (flag) {
            return 1;
        }
        return 0;
    }
}

3、方法重载

1、局部变量只在方法体内有效，方法执行完毕之后，局部变量的内存空间就会被释放。

2、JVM主要有三块区域：栈内存、堆内存、方法区内存。

3、方法在调用的时候，该方法需要的内存空间在栈中分配，方法不调用是不会分配内存的。

4、方法调用的时候，在栈中分配内存空间，此时发生入栈，方法执行结束之后，内存空间被释放，发生弹栈。

5、方法重载机制：在同一个类中，功能相似的方法可以使用相同的方法名，不同的参数列表，即构成方法的重载。

6、方法重载的条件：

1. 在同一个类中
2. 方法名相同
3. 参数列表不同：参数个数不同算不同、参数类型不同算不同、参数顺序不同算不同

7、方法的重载和方法的返回值类型无关。

8、方法的重载和方法的修饰符列表无关。

public class Test {
    public static void main(String[] args) {

    }
    public static void test1(int a,double b) {

    }
    //参数顺序不同算不同
    public static void test2(double b,int a){

    }
    //参数个数不同算不同
    public static void test3(int a){

    }
    //参数类型不同算不同
    public static void test4(String a,String b){

    }

}

4、递归

1、递归：方法自己调用自己。

2、当递归时程序没有结束条件，一定会发生：栈内存溢出错误：StackOverflowError
所以：递归必须要有结束条件。

3、代码示例：

//计算1-n的和
public class Test {
    public static void main(String[] args) {
        System.out.println("1-100的和为：" + sum(100));
    }
    public static int sum(int n){
        if (n == 1){
            return 1;
        }
        return n + sum(n - 1);
    }
}

//计算1-n的阶乘
public class Test {
    public static void main(String[] args) {
        System.out.println("1-100的和为：" + jieCheng(5));
    }
    public static int jieCheng(int n){
        if (n == 1){
            return 1;
        }
        return n * jieCheng(n - 1);
    }
}

4、只要是构造方法执行，必然在构造方法执行之前，自动执行“实例语句块”中的代码。
实际上这也是SUN公司为java程序员准备一个特殊的时机，叫做对象构建时机。静态代码块在类加载时执行，并且在main方法执行之前执行。