JAVA OOP(二)——方法的重载、构造方法以及this关键字

方法的重载、构造方法以及this关键字

---

• 方法的重载
  
  • 重载的概念
  • 重载方法的调用
• 构造方法
  
  • 构造方法的语法结构
  • 默认的构造方法
  • 构造方法的作用
  • 构造方法的重载
• this关键字的使用

---

方法的重载

1）重载的概念

就像变量不能重复声明一样，我们规定不能有两个方法的签名完全一样，但是可以使方法名相同，参数列表不同。这种方法名相同但是参数列表不同情况我们称之为方法的重载。

方法的签名是值方法名和参数列表
代码案例：

public  void cry(int a){
    System.out.println();
}
public  void cry(int b){//报错
    System.out.println();
}

以上两个方法的方法名相同，参数列表也相同，所以不是重载，会报错

参数列表只看类型，不看变量名。上面两个方法中都是一个int型的参数，所以是相同的

代码案例:

public  void cry(int a){
    System.out.println();
}
public  void cry(double b){
    System.out.println();
}

以上两个方法满足重载的定义！

2）重载方法的调用

首先我们举一个例子，当我们登录淘宝账号的时候你会发现，你可以用手机号登录，也可以用邮箱登录，那如果我们要写一个登录方法，那我们要怎么写呢？如果写两个方法名不同的方法，那电脑怎么知道我们要调用哪一个方法呢？因为它并不知道我们会输入手机号还是邮箱，这个时候我们就可以用到重载，因为重载方法调用时根据你传入的参数来调用相应的方法的！
代码案例:

//先写一个用手机号登录的load方法，手机号我们用int型，密码用String型
public static  void load(int num,String pwd){
    ...
}
//再写一个用手机号登录的load方法，邮箱和密码都用String型
public  static void load(String eMail,String pwd){
        ....
}

调用方法的时候只管传入参数就行了，传的是哪个参数，就调用哪个方法

load(15755179999,"这是密码");
load("[email protected]","这也是密码");

可以把重载的方法看成完全不同的方法，只不过恰好它们方法名相同，因为调用的时候是通过参数决定的。

---

构造方法

我们都已经学过给如何给类实例化了（创建该类的实例就是创建它一个它的对象）

Cat   cat=new Cat();

我们看这一句代码可以发现，我们说过new Cat();就是创建了一个对象，出现关键字new就是创建了对象，那它是怎么创建的呢？简单来说，就是因为调用了Cat类的构造方法！而这个Cat()就是类Cat的构造方法。

1）构造方法的语法结构

构造方法是在类中定义的方法， 但不同于其他的方法，构造方法的定义有如下两点规则：
a）构造方法的名称必须与类名相同。
b）构造方法没有返回值，但也不能写void。

(访问控制符)   类名(){
        //构造方法体
}

2）默认的构造方法

JAVA语法规定，任何一个类都必须含有构造方法，假如源程序中没有定义，则编译器在编译时将为其添加一个无参的空构造方法（此方法称之为“默认的构造方法”）。

例如，之前我们所写的Cat类中并没有定义构造方法，但是也可以创建成功，这是因为它有默认的构造方法，而默认的构造方法的参数列表和方法体都是空的：
代码案例：

class Cat{
     Cat(){}
}
public class TestCat{
    public static void main(String[] args){
        new Cat();//在创建对象时会调用构造函数Cat()
    }
}

注意：但是有一个要注意的地方 ，一旦我们定义了类的构造方法，则编译器不再会给它添加默认的空构造方法

代码案例：

class Cat{
     Cat(){
        System.out.println("这是自己定义的构造函数！");
    }
}
public class TestCat{
    public static void main(String[] args){
        new Cat();//在创建对象时会调用构造函数Cat()
    }
}

运行结果如下：

这是自己定义的构造函数！

这个时候在创建Cat的对象时会执行我们自己写的构造函数，而这个构造函数里面有一个输出语句。

在创建对象时，首先就会执行这个类的构造方法！ 如果你没有定议任何构造方法的形式，则执行默认的构造方法。

3）构造方法的作用

构造方法作用就是对类进行初始化。 一般我们会通过构造方法初始化成员变量，就像我们定义Cat类的实例时，要定义一个name是“小芳”，age是“3”的cat,这时我们可以通过构造方法让它在创建对象时就得到这些值。
代码案例：

class Cat{
    String name;    
    int age;
     Cat(){
         name="小芳";
         age=3;
        System.out.println("这是自己定义的构造函数！");
    }
}
public class TestCat{
    public static void main(String[] args){
        Cat cat=new Cat();//在创建对象时会调用构造函数Cat()
        System.out.println("我叫"+cat.name+"，我今年"+cat.age+"岁了");
    }
}

运行结果：

这是自己定义的构造函数！//肯定是先执行构造方法
我叫小芳，我今年3岁了

注意：构造方法中的name和age是指这个类的成员变量name和age。

4）构造方法的重载

那么问题又来了，像刚才一样你会发现，不论你创建几个对象，那么这个对象的属性（成员变量）都已经直接赋值了，就像如果我们再创建一个对象，那么它的name还是小芳，而age还是3，那我们想创建另一个对象，它的名字是“小林”，age是“4”，怎么办呢？
我们上面已经学到了方法的重载，不错，我们的构造方法也可以重载，那么我们再写一个有参数的构造方法。
代码案例：

public class TestCat{
    public static void main(String[] args){
        Cat cat=new Cat("小李",4);//在创建对象时会调用构造函数Cat(String name1,int age1)
        System.out.println("我叫"+cat.name+"，我今年"+cat.age+"岁了");
    }
}
class Cat{
    String name;    
    int age;
     Cat(){
        System.out.println("这是Cat的无参函数！");
    }
     Cat(String name1,int age1){
         name=name1;
         age=age1;
        System.out.println("这是Cat的有参构造！");
    }
}

运行结果:

这是Cat的有参构造！
我叫小林，我今年4岁了

结果分析：就像我们说的方法的重载一样，编译器会根据我们传的参数执行相对的方法，所以这里它执行了有参的构造方法！

注意：
可以看出，在创建对象时，构造方法写在new关键字之后，可以理解为：
“new”创建了对象，而构造方法对该对象进行了初始化。

如果我们只写了有参构造，而没有写无参，则编译器不会添加默认的构造方法，也就是我们只能用我们写的构造方法来创建对象，例如：

public class TestCat{
    public static void main(String[] args){
        Cat cat=new Cat();//报错，因为类Cat中已经没有无参构造了
    }
}
class Cat{
     Cat(String name1,int age1){
        System.out.println("这是Cat的有参构造！");
    }
}

---

this关键字

this关键字用在方法体中，用于指代调用该方法的当前对象，简单的说：哪个对象调用方法，this指的就是哪个对象。严格来讲，在方法中需要通过this关键字指明当前对象。
例如,我们看下面这段代码：

class Cat{
    int age;
     Cat(){
        age=3;
    }
}

当我们要创建一个Cat类的实例时，首先要执行它的构造方法，而在构造方法里我们要给它的成员变量age赋值，那这个时候我们怎么知道这个age就是它的成员变量呢?我们之前说过，要访问对象的成员变量和方法要用 “引用.”点出来，但是在这里显然我们不可能在Cat类里面创建它自己的实例，所以我们用this来指代当前这个对象，所以上述代码中的age=3;其实是this.age=3;如下：

class Cat{
    int age;
     Cat(){
        this.age=3;
    }
}

只不过因为这个无参构造里面没有别的参数，所以不会出现歧义，就把this省去了，那想一下，如果我们定义一个有参的构造方法如下：

class Cat{
    int age;
     Cat(int age1){
        age=age1;
    }
}

这个时候我们参数中变量名是age1,这样显然是为了和它的成员变量age进行区分，这样显然并不是什么好方法，为了增加代码的可读性，我们依然希望给它定义为age,那怎么办呢？我们就可以用this来指定它的成员变量来进行区分，代码如下：

class Cat{
    int age;
     Cat(int age){
        this.age=age;
    }
}

代码分析：当我们创建对象时
Cat cat=new Cat(3);
首先执行这个有参的构造方法，我们传了一个参数（3），这是把这个参数传入了构造方法Cat中的局部变量age(参数)中，然后再把这个变量的值赋给它的成员变量this.age中

Cat(int age)这个构造方法中的age实际上就是一个局部变量(在方法中产生，存在栈中)，而this.age中的age是成员变量(在类中产生，存在对象中，而对象在堆里)
下一节我们会重点剖析this关键字，成员变量和局部变量