Java构造方法的姿势与易错点

《Java基础复习》—类与对象&初始化

关于类和对象的基本理念，就不再赘述（如果你学习过还忘了，就是一种特殊的本领了），没有学习过的可以去搜索一下OOP或者类和对象，百科的知识就已经足够了，不必重复。

这里的讲解由浅入深，我会在分块前做好标注，区分初学者与复习者所需要了解的部分，有基础的可以不再看（基础部分）标注的部分

随着计算机革命的发展，“不安全”的编程方式已逐渐成为编程代价高昂的主要原因之一。——《Java编程思想》

这是一句揭示了Java为什么能稳居排行第一（目前2020年）的原因之一。也就是Java虚拟机与GC（垃圾回收）的神奇之处。本文不深入探讨虚拟机相关知识

一、Java类的最基础的结构

这里先说最基础的结构，随着文章的叙述，会不断扩充这个类

Java使用关键字class来定义一个类，如下

首先你要养成良好的习惯，使用驼峰式命名，开头要大写

注意Java中只有Class的开头才是大写的，其他的标识符都为小写。

class Aclass{
    int num1;
    void function(num){
        num1=num;
        System.out.println(num1);
    }
}

在Java中，类中包含的信息，如这个num1，被称为属性，类中的函数被称为方法

该函数的返回类型是void，当然也可以为其他类型，Java还允许返回值为对象，集合。

这就是一个类的基本结构了，那如何使用这个类？

二、初始化

**===================================**

（基础部分）

如上我们编写了一个类，但是有一点你需要知道的是，你所编写的只是一个模板，要想投入你的程序使用，需要生成对应的对象。也就是，在内存中创建属于这个类的空间（位于堆上）。

现在，你需要生成一个对象，按照上面的思路，你至少需要一个能分配内存空间的初始化方法，我们假设为initialize()方法。

正如这个方法的名称，我们在调用一个类之前，都需要调用initialize()方法。通过调用initialize()方法，我们可以搭建一个构造器，保证所有的对象都会得到初始化。

所以我们需要一个独特的方法，不能与成员名称冲突，可被编译器识别。故Java采用了与C++类似的方案：构造器采用与类相同的名称。

注意要与类名完全相同！

现在为之前的类加上构造器

class Aclass{
    int num1;
    void function(num){
        num1=num;
        System.out.println(num1);
    }
    Aclass(){
        System.out.println("初始化了Aclass类");
    }
}

如何操作实现初始化呢？

new Aclass();
/*
out:
初始化了Aclass类
*/

Java本质上只有一种初始化的方法—构造器初始化，这与C++不同

上述的语句初始化了一个Aclass类的对象并返回。

即new Aclass()的返回类型为一个新的对象。

不接受参数的构造器叫无参构造器（Java文档中的叫法），也有人叫做默认构造器（C++的叫法）

上面的例子中就是一个无参构造器，注意，构造器只有小括号，不要用大括号yy了，Java用到大括号的地方只有函数块的划分。

我们稍加修改，修改为一个有参数的构造器

class Aclass{
    int num1;
    void function(num){
        num1=num;
        System.out.println(num1);
    }
    Aclass(int num){
        System.out.println("初始化了Aclass类，参数为"+num);
    }
}

Aclass t = new Aclass(3);
//out: 初始化了Aclass类，参数为3

这里我们接触到了一个新语句

Aclass t = new Aclass(3);

Aclass t 是Aclass类的一个引用，表示我们将要用到Aclass的一个对象，名为t,但是还没有被初始化。我们使用new Aclass()构造一个新的对象，并返回，通过赋值语句，赋值给Aclass类的一个引用t。此时t就表示了新建的这个对象

**===================================**

（易错点）

如果没有定义构造器，Java编译器会生成一个默认的无参构造器，该构造器创建的类中，属性为0或null。

如果Aclass(int num)是Aclass类唯一的构造器，那么编译器将不会允许你以其他任何方式创建Aclass对象。

举例

class Aclass{
    int num1;
    void function(num){
        num1=num;
        System.out.println(num1);
    }
    Aclass(int num){
        System.out.println("初始化了Aclass类，参数为"+num);
    }
}

Aclass t = new Aclass();
//out: 编译器报错：找不到构造器Aclass()

（重要）

三、方法重载

在上面的例子中，我们定义了有参数的构造方法后，Java创建对象似乎就只能永远使用这个构造方法了，我们希望他同时也能使用默认构造方法，怎么办？

为了让方法名相同参数不同的方法同时存在，必须使用方法重载

下面是例子

class Aclass{
    int num1;
    void function(num){
        num1=num;
        System.out.println(num1);
    }
    Aclass(){
        System.out.println("无参构造器，参上！");
    }
    Aclass(int num){
        System.out.println("初始化了Aclass类，参数为"+num);
    }
}

Aclass t = new Aclass(3);
Aclass another = new Aclass();
/* out:
初始化了Aclass类，参数为3
无参构造器，参上！
*/

方法重载确确实实的解决了我们的需要，那这么多名字相同的方法，编译器如何区分？

3.1区分重载的方法

答案：每个重载的构造必须有一个独一无二的参数类型列表

只要参数不同，编译器就会视作不同的方法。

对于普通方法，返回类型也是一个作为划分的办法

即：返回类型，参数、参数的顺序 完全相同的方法才是同一个重复的方法，否则就为重载

（重点）

3.2涉及基本类型的重载

基本类型可能从“较小”的类型自动提升至一个“较大的类型”，此过程如果涉及重载，可能会造成混淆。

这里的大小，指的是范围的大小

在不使用重载的情况下，向一个接受float的方法传入一个int类型，该实参会被自动提升到float类型。

在使用重载的情况下，我们先看下面的例子

void f1(int num) { println("int");}
void f1(char num) { println("char");}
void f1(float num) { println("float");}

f1(5);
/*
out: int
*/

我们看到编译器选择了对应int的方法，但是我们如果没有这个int呢？

void f1(long num) { println("long");}
void f1(char num) { println("char");}
void f1(float num) { println("float");}

f1(5);
/*
	out: long
*/

我们看到选择使用了long类型的方法

总结一下：

如果有某个方法接受int型参数，他就会被调用。如果传入的数据类型（实际参数类型）小于方法中声明的形式参数类型，实际数据类型就会被提升。提升到可用的最小的等级，如float、long中选择了long。

另外，char 类型略有不同，如果无法找到恰好接受char类型参数的方法，就会把char直接提升到int型

这是小数据填入了接受较大数据的方法中，那如果传入的实际参数大于重载方法声明的形式参数，会出现声明情况？

答案：编译器报错！！，如果你非要这么干，你需要使用类型装换操作符，同时会可能伴有精度的损失

四、this关键字

简单来说，this关键字是当前对象的引用

（重要）

若有同一类型的两个对象，分别是a,b他们都有一个方法是fun()，它如何知道被a还是被b所调用的呢？

下面是一个例子

class Father{
	void fun(int num){
        System.out.println("abc"+num);
    }
}
public class UseC {
    public static void main(String[] args){
        Father a = new Father(),b = new Father();
        a.peel(1);
        b.peel(2);
    }
}

你可能要杠了，我调用的是a对象的方法，与b对象何干？

这里学习了Java的虚拟机你会了解的更多。你可以暂时这样理解：

Java在存储对象的时候，存储的是这个对象独有的信息（值等），而共有的信息（如方法，静态常量）则作为类的信息存储在方法区中，这两种信息存储的位置完全不同。

为了达到“发送消息给对象”的目的，编译器在幕后做了一系列操作。它暗自将“所操作对象的引用”作为第一个参数传递给peel()。

所以，代码中的方法调用就变成了这样:

Father.peel(a,1);
Father.peel(b,2);

this关键字只能在方法内部使用，表示“调用方法的对象”的引用。

但是在方法内部调用同一个类中的另一个方法，就不必使用this。

另外this关键字可以作为返回值，用来传递当前的对象给其他方法很好用。

4.1构造器中调用构造器

情景：我们希望在当前的构造器中使用到其他构造器的功能

解决方案：利用this

在构造器中，如果为this添加了参数列表，那么this将产生对符合此参数列表的某个构造器的明确调用。

使用this调用构造参数的注意

1. 只能在构造器中调用
2. 只能调用一次
3. 只能在方法的开始调用

下面是标准demo

public class Test(){
    Test(int num){
        System.out.println(num);
    }
    Tset(){
		this(num);
        System.out.print("function2");
    }
}

4.2static含义

static就是没有this的方法

static内部不能调用非静态的方法，而非静态的方法能调用static方法。

Java禁止使用全局方法，但置入static方法就可以问其他static方法和static域，使用时是不符合面向对象的（“向对象发消息”）。