[java]java构造器

古城微笑少年丶 2022-06-14 03:18 212阅读 0赞

构造器这个概念，各种语言都有出现，虽然为了考试或者其他学了好多遍，但是自己一直不能理解这个概念，前几天又学了一遍，突然就明白了，下面随小编来一起学习一下吧。

## 什么是构造器？ ##

在类别基础的面向对象程序设计中，构造器（英语： Constructor；别称：构造方法、构造函数、建构子）是一个类里用于建立对象的特殊子程序。它能初始化一个新建的对象，并时常会接受参数用以设定实例变量。

构造器跟一般的实例方法十分相似；但是与其它方法不同，构造器没有返回类型，不会被继承，且不会有范围修饰符。构造器的函数名称一般与它所属的类的名称相同。 它承担着初始化对象数据成员并建立类不变象的任务；在类不变象无效的时候它会失败。一个正确编写的构造器会使它生成的对象保持在一个有效状态。不可变物件必须在构造器内完成所有初始化。

多数编程语言允许构造器重载 - 一个类被允许拥有多个接受不同参数种类的构造器同时存在。一些编程语言允许某些特殊种类的构造器。使用单个类来具体地建立和返回新实例的构造器，时常被抽象为工厂方法 - 一种同样用来建立新对象，但会同时使用多个类，或者一些诸如对象池的分配方案来完成这一过程的子程序。

简而言之，当我们实例化一个对象的时候，就回去调用它的构造器，比如  
String cons = new String();就调用了String的构造器。

## 构造器的特点 ##

构造器有如下几个特点：  
1.没有返回类型  
2.没有范围修饰符  
3.任何一个类都有构造器，当我们没有写构造器的时候，系统会给这个类分配一个默认的构造器。  
4.构造器可以重载。  
5.当我们重载构造器时，系统不再为该类分配默认构造器。

## 构造器的使用 ##

下面我们可以从几个例子中来学习构造器的使用。  
第一个例子：

package com.javatest.lang;
    
    import org.junit.jupiter.api.Test;
    
    /**
     * Created by L on 2017-05-31.
     */
    public class Constructor {
        public String name;
        public int count;
    
    //自定义木有参数的构造器
    //该构造器即默认构造器
    public Constructor(){
        //this.name="默认";
        //this.count=23;
    }
    //main方法
    public static void main(String[] args){
        //使用不带参数的构造器来创建Constructor对象
        Constructor constructor = new Constructor();
    
        System.out.println(constructor.name);
        System.out.println(constructor.count);
    
    }
    }

运行main方法，将会打印  
默认  
23

第二个例子

import org.junit.jupiter.api.Test;
    
        /**
         * Created by L on 2017-05-31.
         */
        public class Constructor {
            public String name;
            public int count;
    
            //自定义木有参数的构造器
            public Constructor(){
                //this.name="默认";
                //this.count=23;
            }
            自定义一个有一个参数的构造器
            public Constructor(String name){
                //初始化name
                this.name=name;
            }
            public static void main(String[] args){
                //使用不带参数的构造器来创建Constructor对象
                //Constructor constructor = new Constructor();
                //使用带一个参数的构造器来创建Constructor对象
                Constructor constructor = new Constructor("一个参数");
    
                System.out.println(constructor.name);
                System.out.println(constructor.count);
    
            }
        }

将会打印  
一个参数  
0

第三个例子

package com.javatest.lang;
    
        import org.junit.jupiter.api.Test;
    
        /**
         * Created by L on 2017-05-31.
         */
        public class Constructor {
            public String name;
            public int count;
    
            //自定义木有参数的构造器
            public Constructor(){
                this.name="默认";
                this.count=23;
            }
            自定义一个有一个参数的构造器
            public Constructor(String name){
                //初始化name
                this.name=name;
            }
            自定义一个有两个参数的构造器
            public Constructor(String name,int count){
                //初始化这两个值
                this.name=name;
                this.count=count;
            }
    
            public static void main(String[] args){
                //使用不带参数的构造器来创建Constructor对象
                //Constructor constructor = new Constructor();
                //使用带一个参数的构造器来创建Constructor对象
                //Constructor constructor = new Constructor("一个参数");
                //使用带两个参数的构造器来创建Constructor对象
                Constructor constructor = new Constructor("两个参数",80);
                System.out.println(constructor.name);
                System.out.println(constructor.count);
    
            }
        }

打印出来结果是  
两个参数  
80

## 初始化块 ##

学习构造器，还应该了解初始化块这个东西，初始化块的执行顺序在构造器之前，如果重复赋值，构造器的值将覆盖初始化块的内容。  
初始化块有以下特点：  
1.静态初始化块的优先级最高，也就是最先执行，并且仅在类第一次被加载时执行；  
2.非静态初始化块和构造函数后执行，并且在每次生成对象时执行一次；  
3.非静态初始化块的代码会在类构造函数之前执行。因此若要使用，应当养成把初始化块写在构造函数之前的习惯，便于调试；  
4.静态初始化块既可以用于初始化静态成员变量，也可以执行初始化代码；  
5.非静态初始化块可以针对多个重载构造函数进行代码复用。  
所以看一下第四个例子

package com.javatest.lang;
    
        import org.junit.jupiter.api.Test;
    
        /**
         * Created by L on 2017-05-31.
         */
        public class Constructor {
            public String name;
            public int count;
    
            //初始化块
            {
                this.name="初始化块";
                this.count=51;
            }
            //自定义木有参数的构造器
            public Constructor(){
                this.name="默认";
                this.count=23;
            }
            自定义一个有一个参数的构造器
            public Constructor(String name){
                //初始化name
                this.name=name;
            }
            自定义一个有两个参数的构造器
            public Constructor(String name,int count){
                //初始化这两个值
                this.name=name;
                this.count=count;
            }
    
            //public void testCon(){
            //    this.name="测试";
            //    this.count=14;
            //}
    
            public static void main(String[] args){
                //使用不带参数的构造器来创建Constructor对象
                //Constructor constructor = new Constructor();
                //使用带一个参数的构造器来创建Constructor对象
                //Constructor constructor = new Constructor("一个参数");
                //使用带两个参数的构造器来创建Constructor对象
                Constructor constructor = new Constructor("两个参数",80);
                //调用普通方法
                //constructor.testCon();
                System.out.println(constructor.name);
                System.out.println(constructor.count);
    
            }
        }

此时如果使用默认构造器来实例化constructor，将打印  
默认  
23  
如果使用带一个参数的来实例化constructor，将打印  
一个参数  
51  
如果使用带两个参数的来实例化constructor，将打印  
两个参数  
80

## 总结 ##

总的来说，构造器的概念还是很好理解的，在初期，可以将其理解为实例化时会默认调用的方法，这个方法将会帮助我们完成类的实例化。动动手，敲几个例子，很好理解的，有什么问题可以给我留言，帮助我进步~