构造方法

• 方法名与类名相同

• 没有返回值,void都不需要

  默认构造方法

• 若类中没有定义任何构造方法, 编译器会自动添加一个无参空构造方法, 叫做缺省/默认构造方法

• 若类中出现了构造方法, 则编译器不再提供任何形式的构造方法

方法重载

函数重载时建议函数的返回值保持一致

/*
    编程实现方法重载主要形式的测试案例
*/
public class OverloadTest {
    void show() {
        System.out.println("show()");
    }
    void show(int i) { //ok 体现于方法参数的个数不同
        System.out.println("show(int)");
    }
    void show(int i, double a) { //ok 体现于方法参数的个数不同
        System.out.println("show(int, double)");
    }
    void show(int i, int a) { //ok 体现于方法参数的类型不同
        System.out.println("show(int, int)");
    }
    void show(double i, int a) { //ok 体现于方法参数的个数不同
        System.out.println("show(double, int)");
    }
    /*
    void show(int aa, double bb) { //error 与形参的名称无关 错误: 已在类 OverloadTest中定义了方法 show(int,double)
        System.out.println("show(int, double)");
    }
    int show(int aa, double bb) { //error 与函数返回值 无关
        System.out.println("show(int, double)");
    }
    */
    public static void main(String[] args) {
        OverloadTest ot = new OverloadTest();
        ot.show();
        ot.show(1);
        ot.show(1, 0.1);
        ot.show(6, 88); 
        ot.show(88.6, 1);
    }
}

方法重载实际意义

• 调用者只需要记住一个方法即可,来实现不同的功能

this关键字

public class ThisTest {
    ThisTest() {
        System.out.println("构造方法中this="+this);
    }
    void show() {
        System.out.println("成员方法this=" + this);
    }
    public static void main(String[] args) {
        ThisTest tt = new ThisTest();
        System.out.println("main方法中tt="+tt);
        tt.show();
    }
}

• 函数的形参参数最好与实参名称一致
• 就近原则 懒人原则

• 错误: 递归构造器调用 ```java / 编程实现 Boy类的定义 /

public class Boy { String name; Boy() { this(“123”); System.out.println(“无参构造方法”); }

Boy(String name) {
    this();
    System.out.println("==有参构造方法");
    this.name = name;
}
void show() {
    System.out.println("Boy's name is " + name);
}
public static void main(String[] args) {
    Boy b1 = new Boy();
    b1.show();
    Boy b2 = new Boy("张飞");
    b2.show();
}

}

<a name="67MrQ"></a>
# 引用变量的注意事项
Exception in thread "main" java.lang.NullPointerException 空指针异常

- 其它异常: 数组下标越界异常, 算数异常
<a name="B0QBT"></a>
# 递归的案例
<a name="kvjKN"></a>
## 计算n!的值
![image.png](https://cdn.nlark.com/yuque/0/2020/png/1567843/1594532011663-fbf598ee-68e7-4b34-afad-010e424134a0.png#align=left&display=inline&height=49&margin=%5Bobject%20Object%5D&name=image.png&originHeight=98&originWidth=1219&size=70245&status=done&style=none&width=609.5)
```java
public class JieChengTest {
    //递推的方式
    int show1(int n) {
        int num = 1;
        for(int i = 1; i < n + 1; i++) {
            num *= i;
        }
        return num;
    }
    //递归的方式
    int show2(int n) {

        if(1 == n) return 1;
        return n * show2(n -1);
    }


    public static void main(String[] args) {
        JieChengTest jc = new JieChengTest();
        System.out.println(jc.show2(5));

    }
}

• 递归方式的原理分析:

Fibonnic数列

public class FeeTest {

    int show0(int n) {
        if(1 == n || 2 == n) return 1;
        return show0(n-1) + show0(n-2);
    }

    int show1(int n, int[] temp) {
        if(1 == n || 2 == n) return 1;
        if(temp[n] > 0) {
            return temp[n];
        }
        else {
            temp[n] = show1(n-1, temp) + show1(n-2, temp);
            return temp[n];
        }
    }

    int show2(int n) {
        if(n < 3) return 1;
        int sum = 0;
        int p = 1;
        int q = 1;
        for(int i = 3; i < n + 1; i++) {
            sum = p + q;
            p = q;
            q = sum;
        }
        return sum;
    }

    public static void main(String[] args) {
        FeeTest ft = new FeeTest();
        System.out.println(ft.show2(55));
    }
}

代码拆分

Fee.java —> 功能类

public class Fee{
    int show0(int n) {
        if(1 == n || 2 == n) return 1;
        return show0(n-1) + show0(n-2);
    }

    int show1(int n, int[] temp) {
        if(1 == n || 2 == n) return 1;
        if(temp[n] > 0) {
            return temp[n];
        }
        else {
            temp[n] = show1(n-1, temp) + show1(n-2, temp);
            return temp[n];
        }
    }

    int show2(int n) {
        int sum=1;
        int p = 1;
        int q = 1;
        for(int i = 3; i < n + 1; i++) {
            sum = p + q;
            p = q;
            q = sum;
        }
        return sum;
    }
}

FeeTest.java —> 测试类

/*
    编程实现对费氏数列类的测试
*/

public class FeeTest {    
    public static void main(String[] args) {
        Fee ft = new Fee();
        System.out.println(ft.show2(55));
    }    
}

javac FeeTest.java以后
自动编译 Fee.java
FeeTest.java

封装

• 封装
  • 隐藏成员变量的细节
  • 保证成员变量数值的合理性

封装的实现流程

• 1. 私有化变量
• 1. 提供公有的get和set方法
• 1. 在公有的构造方法中调用set方法进行合理值的判断

案例2

/*
    编程实现Student类的测试
*/

import java.util.Scanner;

public class StudentTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入学生的人数:");
        int studentNum = sc.nextInt();

        Student[] stu = new Student[studentNum];

        for(int i = 1; i < stu.length + 1; i++) {
            System.out.println("请依次输入学号 姓名 录入第" + i + "个学生的信息:");
            stu[i - 1] = new Student();  //这一步很重要,引用存的是地址, 需要初始化  否则会报:java.lang.NullPointerException
            stu[i - 1].setUid(sc.nextInt());
            stu[i - 1].setName(sc.next());
        }

        for(int i = 1; i < stu.length + 1; i++) {
            stu[i - 1].show();
        }

        sc.close();
    }
}

JavaBean

JavaEE框架会用到这个.

总结:

1. 构造方法(重中之重)

语法格式,默认构造方法,实现成员变量的初始化

2. 方法重载（重点）

重载的概念, 体现形式,实际意义

3. this关键字(原理)

概念,原理,使用方式

4. 递归(难点)

概念、使用原则

6. 封装(重中之重)

概念， 实现流程