Java中的重载和this关键字

笔记输出来源：拉勾教育Java就业急训营

修改时间：2020年12月17日21时20分
作者：pp_x
邮箱：pp_x12138@163.com

继续补充中…

重载（Overload）的概念

• 若方法名相同，参数列表不同，这样的方法之间构成重载关系

重载的体现形式

• 方法的重载主要体现在：参数的个数不同、参数的类型不同、参数的顺序不同，与返回值类型和形参变量名无关，但建议返回值类型相同
• 判断方法能否构成重载的核心：调用方法时能否区分

package object2;
/**
 * @author pp_x
 * 重载的测试
 */
public class OverloadTest {

    // 自定义成员方法
    void show() {
        System.out.println("show()");
    }
    void show(int i) { // ok  体现在方法参数的个数不同
        System.out.println("show(int)");
    }
    void show(int i, double d) { // ok  体现在方法参数的个数不同
        System.out.println("show(int, double)");
    }
    void show(int i, int j) { // ok  体现在方法参数的类型不同
        System.out.println("show(int, int)");
    }
    void show(double d, int i) { // ok  体现在方法参数的顺序不同
        System.out.println("show(double, int)");
    }
	/*
	void show(double a, int b) { // error 与参数变量名无关
		System.out.println("show(double, int)");
	}
	*/
	/*
	int show(double d, int i) { // error, 与返回值类型无关
		System.out.println("show(double, int)");
	}
	*/
    public static void main(String[] args) {

        // 1.声明OverloadTest类型的引用指向该类型的对象
        OverloadTest olt = new OverloadTest();
        // 2.调用show方法
        olt.show();
        olt.show(66);
        olt.show(66, 3.14);
        olt.show(66, 118);
        olt.show(3.14, 118);
        //ot.show(3.14, 66);
    }
}

重载的实际意义

• 在于调用者只需要记住一个方法名即可以调用不同的版本，来实现不同的功能

this关键字的基本概念

• 如果在构造方法中出现this，代表当前正在构造的对象，可以调用对象的构造方法
• 如果在成员方法中出现this，代表当前对象，可以调用对象的成员方法

/**
 * @author pp_x
 * 编程测试this关键字
 */
public class ThisTest {
    
    // 自定义构造方法
    ThisTest() {
        // this代表当前正在构造的对象
        System.out.println("构造方法中：this = " + this);
    }
    // 自定义成员方法
    void show() {
        // this代表当前正在调用的对象
        System.out.println("成员方法中：this = " + this);
    }
    public static void main(String[] args) {

        // 1.声明ThisTest类型的引用指向该类型的对象
        ThisTest tt = new ThisTest();
        // 2.调用show方法
        tt.show();
        System.out.println("main方法中：tt = " + tt);
    }
}

this的工作原理

• 在构造方法中和成员方法中访问成员变量时，编译器会自动加上this.的前缀，而this.相当于汉语中的”我的“，当不同对象调用同一个方法的时候，由于调用方法的对象不同导致this关键字不同，从而this.的方式访问的结果也不同

this关键字的使用方式

• 1、如果局部变量和成员变量（类变量+实例变量）同名时，方法体会优先使用局部变量（就近原则），如希望使用成员变量，则加上前缀this.

public class ThisTest2 {
    //定义实例变量 name age
    //实例变量时没有static修饰的成员变量
    String name;
    int age;
    ThisTest2(String name,int age){
       // name = name;
       // age = age; // 就近原则  此时的name都代表形参
        this.name = name;//待用实例变量中的name
        this.age = age; // 调用实例变量中的age
    }
    void show(){
        System.out.println("name = "+name+"age = "+ age);
    }
    public static void main(String[] args) {
        ThisTest2 tt2 = new ThisTest2("liuxiao",18);
        tt2.show();
    }
}

• 2、this关键字除了可以通过this.的方法调用成员变量和成员方法时，还能作为方法的返回值

/**
 * this作为方法返回值
 */
public class ThisTest3 {
    String name;
    int age;
    ThisTest3(String name,int age){
        this.name = name;
        this.age = age;
    }
    ThisTest3 getThisTest3(){
        return this;
    }

    public static void main(String[] args) {
        ThisTest3 tt3 = new ThisTest3("柳潇",18);
        ThisTest3 tt4 =tt3.getThisTest3();
        System.out.println(tt3);
        System.out.println(tt4);
    }
}

• 3、在构造方法中的第一行可以使用this()，可以调用本类中的其他构造方法

/**
 * this用来调用其他构造方法
 */
public class Boy_ThisTest {
    String name;
    Boy_ThisTest(){
        this("无名");
        System.out.println("无参构造方法");
    }
    Boy_ThisTest(String name){
        System.out.println("有参构造方法");
        this.name = name;
    }
    public static void main(String[] args) {
        Boy_ThisTest bt = new Boy_ThisTest();
    }
}

引用变量注意事项

• 引用类型变量用于存放对象的地址，可以给引用类型赋值为null，表示不指向任何对象
• 当某个引用类型变量为null时无法对对象实施访问（因为它没有指向任何对象）。此时，如果通过引用访问成员变量或调用方法，会产生NUllPointerException异常（空指针异常）

阶乘案例

/**
 * 阶乘的测试
 */
public class JieChengTest {
    /*第一种方式  递推
    int show(int n){
        int num = 1;
        for (int i = 1 ; i< n ; i++){
            num *= i;
        }
        return num;
    }*/
    //第二种方式  递归
    int show(int n){
        if (n ==1 ){
           return 1;
        }
        else {
            return n*show(n-1);
        }
    }
    public static void main(String[] args){
        JieChengTest jct = new JieChengTest();
        var res = jct.show(10);
        System.out.println(res);
    }
}

递归注意事项

• 使用递归必须要有递归的规律以及推出条件
• 使用递归必须是的问题简单化并非复杂化
• 若递归影响到程序的执行性能，则使用地推代之

费式数列的递归实现

• 1 1 2 3 5 8 13

/**
 * 费式数列的实现  递归
 */
public class FeeTest {
    //地定义成员方法实现费式数列中第n项数值的计算并返回
    int show(int n){
        if(n == 1|| n == 2){
            return 1;
        }
        else {
            return show(n-1)+show(n-2);
        }
    }
    public static void main(String[] args) {
        FeeTest ft = new FeeTest();
        int res = ft.show(5);
        System.out.println(res);

    }
}

递推实现费式数列

/**
 * 递推实现费式数列
 */
public class FeeTest_2 {
    int ia = 1;//指向第一个数
    int ib = 1;//指向第二个数 作为最终结果
    int ic;//记录两者和
    int show(int n){
            for (int i  = 3 ; i< n; i++){
                int ic = ia + ib;
                ia = ib;
                ib = ic;//三个式子用来保证ia ib相邻 且ib始终指向结果
            }
            return ib;
    }
    public static void main(String[] args) {
        FeeTest_2 ft2 = new FeeTest_2();
        int res = ft2.show(10);
        System.out.println(res);
    }
}

各修饰词的作用域