Java中的 构造方法

我们之前在创建一个对象的时候，通过一个new关键字就可以把一个类实例化变成对象。

Telphone telphone = new Telphone();

其实我们上面的说法并不严禁，new后面跟的并不是类名，而是构造方法。

1.使用new+构造方法，创建一个新的对象

构造方法：是定义在Java类中的一个用来初始化对象的方法。
和我们普通方法有什么不同：普通方法只是代表对象可以干什么；而构造方法可以创建一个对象，并且可以初始化对象的值。

构造方法还有一个特点：构造方法与类名相同，并且没有返回值的。

1、我们演示一下：如果使用一个构造方法

打开ide工具，创建一个项目，如图：

有一个类Telphone.java，代码如下：

package com.mydev;


public class Telphone {
}

然后我们在InitTelphone.java 中来使用这个类

package com.mydev;


public class InitTelphone {

    /**
     * 入口函数
     * @param args
     */
    public static void main(String[] args){
        Telphone telphone = new Telphone();
    }
}

编译OK，我们可以证明：一开始Telphone 类中并没有方法，我们在InitTelphone 中还是可以new一个对象。

有些同学可能会感到奇怪，里面没有这个方法，为什么我们还可以调用呢？

Telphone telphone = new Telphone();

主要原因就是：如果我们没有指定一个无参的构造方法，那么系统会自动的帮我们生成一个无参的构造方法。

为了证明这一点，我们要在Telphone.java中动手啦，改造代码如下：

package com.mydev;


public class Telphone {
    public Telphone(){
        System.out.println("无参的构造方法执行了");
    }
}

写了一个和类名相同的没有参数的构造方法。
我们现在InitTelphone中调用执行，查看是否会打印。

有参的构造方法
在Telphone.java 里我们再写一个带有参数带构造方法，然后文件全部代码如下：

package com.mydev;


public class Telphone {

    float screen;
    float cpu;
    float mem;

    /**
     * 无参的构造方法
     */
    public Telphone(){
        System.out.println("无参的构造方法执行了");
    }

    /**
     * 有参的构造方法
     * @param s
     * @param c
     * @param m
     */
    public Telphone(float s,float c,float m){
        // 给成员变量赋值
        screen = s;
        cpu = c;
        mem = m;

        System.out.println("有参的构造方法执行了");
    }
}

在调用的时候，就可以带上参数了：

Telphone telphone = new Telphone(5.0f,1.4f,2.0f);

注意：当我定义了一个构造方法(不论上有参还是无参)，系统就不会给我们自动创造那个无餐的构造方法了。

意思就是如果我们的Telphone类

package com.mydev;


public class Telphone {

    float screen;
    float cpu;
    float mem;

    /**
     * 有参的构造方法
     * @param s
     * @param c
     * @param m
     */
    public Telphone(float s,float c,float m){
        // 给成员变量赋值
        screen = s;
        cpu = c;
        mem = m;

        System.out.println("有参的构造方法执行了");
    }
}

我们自己定义了一个构造方法了。
这个时候我们还来调用那个没有参数的构造方法，就会报错了：

Telphone telphone = new Telphone();

构造方法的重载：方法名相同，但上参数不同的多个方法，调用时会自动根据不同的参数选择对应的方法

    /**
     * 无参的构造方法
     */
    public Telphone(){
        System.out.println("无参的构造方法执行了");
    }

    /**
     * 有参的构造方法
     * @param s
     * @param c
     * @param m
     */
    public Telphone(float s,float c,float m){
        // 给成员变量赋值
        screen = s;
        cpu = c;
        mem = m;

        System.out.println("有参的构造方法执行了");
    }

我们写了一个有参的构造方法和一个无参的构造方法，其实就相当于方法的重载。

构造方法不但可以给对象的属性赋值，还可以保证给对象的属性赋一个合理的值

比如我们的手机对象，现在手机基本上都是3.5寸屏幕以上的，如果我们实例化的时候

Telphone telphone = new Telphone(1.5f,1.4f,2.0f);

传入的参数，是1.5的屏幕大小，这显然是不合理的。
那么如果利用我们的构造函数来规避这个问题呢？

    public Telphone(float s,float c,float m){
        // 给成员变量赋值
        if (s < 3.5f){
            screen = 3.5f;

            System.out.println("你输入的参数有问题，自动赋值3.5");
        }else{
            screen = s;
        }

        cpu = c;
        mem = m;

        System.out.println("有参的构造方法执行了");
    }