一：有参数构造方法
 
在之前我们要为一个对象赋值，先要创建好对象之后然后“对象名.属性名”或者调用属性的setter为属性赋值。但是在很多时候觉得这样做很麻烦，最好的做法是在创建对象的时候完成属性的初始化操作，此时需要使用到有参数构造方法方能完成该功能(有人把构造方法叫做构造器)。
 
 
 
DEMO:定义有参数构造方法
 
 
 
 
上面定义了四个有参数构造方法，发现了构造方法可以重载，
 
书写的习惯是重载的构造方法按照参数的个数进行升序排序。但是如何去调用有参数的构造方法呢?
 
 
 
DEMO:调用有参数构造方法
 
 
此时发现了我们不需要像之前一样,要为对象的属性赋值就必须先创建对象再使用“对象名.属性名”或者使用setter 方法去实现了，而是直接使用有参数的构造方法去实现。
 
 
 
DEMO:继续观察代码
 
 
此时提示“这个无参数构造Student()方法未定义”，在之前我们说了JVM会默，认为类提供无参数构造方法，但是这只能是在没有任何有参构造方法的条件下，现在我们定义了四个有参数构造方法(JVM认为你不需要无参数构造方法了)，所以JVM不再提供无参数的构造的构造方法了。
 
所以我们定义 了有参数构造方法那么也需要显示的定义出无参数构造方法。
 
 
 
DEMO:显示定义无参数构造方法
 
 
 
 
 
 
总结:
 
1、构造方法的出现是为了方便为对象的属性初始化值
 
2、一般在类中构造方法的顺序都是按照参数的个数去升序排序的
 
3、如果定义了有参构造方法那么JVM就不会在提供无参数构造了，所以如果我们定义了有参构造那么无参构造也要显示的定义出来。
 
 
 
二：Java无参构造方法
 
 
 
一：构造方法给的概念
 
在之前我们使用过方法，在调用的方法的是时候需要在方法名称之后加.上小括号,括号里面可以传递实参,那么我们在创建一个对象的时候使用的是“new类名()”的方式去实现，其实上这也是一种方法，但是这个方法我们没有明确的去定义，那为什么可以调用呢?观察代码。
 
DEMO:观察代码
 
 
以上的代码在创建的对象的时候使用“Student()”，发现了在“Student”之后使用小括号，这和方法的调用很相似，其实“Student()”就是-一个方法，是一个特殊的方法-构造方法，发现了构造方法的名称和类名一样，而且一定是在new关键字之后调用的。但是我们没有在Student类中看到这个方法依然能够调用，原因是JVM(Java的虚拟机，暂时不用管，你就认为是系统，后面我们讲解JVM内存模型的时候会分析)系统默认为该类提供了无参数构造方法，所以我们才能调用。
 
我们也可以显示的将该方法定义出来。
 
DEMO:显示的定 义构造方法
 
 
 
 
此时我们显示的定义了一个五参数构造方法，构造方法是在什么时候调用的呢?如何很明显的看出调用了构造方法?
 
DEMO:观察构造方法调用的时机
 
 
 
总结:
 
1、构造方法的概念(构造方法的出现是为了在实例化对象的时候可以为对象的属性初始化值)。
 
2、默认jvm会为每个类提供一个无参数构造方法。
 
3、构造方法的特征和它与普通方法的区别你要清楚。
 
 
 
 
 
 
学习不要走马观花的学，每个知识重点大纲，就是学习路线都是根据每一天市场上多数公司用到的新技术整理，在学习的时候还需要结合练习题来做这里的话我也将我之前在学习过程中用到的一些学习资料整理成了文档，以及我自身之前的一个面试文案和知识点补充，有需要的朋友可以加我的QQ群   697888503   ，这里也希望大家最终都能够学有所成，学习编程不是一天两天的功夫，勤能补拙才是硬道理，祝大家最终都能成为一名合适开发攻城狮。 

Java有参构造方法和无参构造方法
 
 
1**、定义：**
 
编写一个类时没有添加无参构造方法，那么编译器会自动添加无参构造方法；(如果自己添加构造函数，无论有参数或是没参数，默认构造函数都将无效)
编写时添加了有参构造方法而未添加无参构造方法，那么编译器只认有参构造方法而不会默认添加无参构造方法！
如果需要使用无参构造方法，一定要在类里面添加
  
 
2、举例：
 
定义四个类（说明四种情况）：
 
 
 
类Person1 自己不手动添加任何无参或有参数构造方法            （实例化对象时：编译通过）
 
 
类Person2 自己添加无参的构造方法                                        （实例化对象时：编译通过）
 
 
类Person3 有参数的构造方法                                                   （实例化对象时：不通过）
 
 
类Person4 自己添加无参的构造方法,和有参数的构造方法        （实例化对象时：编译通过）
 
 
//定义类Person1   自己不手动添加任何无参或有参数构造方法

class Person1{
    private int age;
    private String name;
    private String sex;

}


//定义类Person2   自己添加无参的构造方法

class Person2{
    private int age;
    private String name;
    private String sex;
    
    public Person2(){
        System.out.println("无参构造方法被调用");
    }
}


//定义类Person3   有参数的构造方法

class Person3{
    private int age;
    private String name;
    private String sex;
    
    public Person3(String name, String sex, int age ){
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
}


//定义类Person4   自己添加无参的构造方法,和有参数的构造方法

class Person4{
    private int age;
    private String name;
    private String sex;
    
    //不带参数的构造函数，可以被重载
    public Person4(){
        System.out.println("无参构造方法被调用");
    }
    
    //带参数对的构造函数
    public Person4(String name, String sex, int age ){
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
}


public class ObjectInit_2 {
    public static void main(String[] args) {
        Person1 person1 = new Person1();//编译通过；①实例化Person对象    ②自动调用构造方法Person( )

        Person2 person2 = new Person2();//编译通过；打印: 无参构造方法被调用


        // 这样写，编译器会报错，原因是系统默认的无参构造方法被有参构造方法覆盖，编译器不能再提供无参构造方法
        Person3 person3 = new Person3();

        //Person4 person4 = new Person4();//编译通过；打印: 无参构造方法被调用

        Person4 person4 = new Person4("qzz", "man", 18);//编译通过；
    

    }
}

 
                                                 2018.10.29/周一
                                                 by 922

看到这篇文章的时候 说明大家还是java的初学者，有了一点点的入门知识。java的构造器主要分为两类，无参和有参，那么如何在
无参中调用有参的构造器呢? 我们来看一下。
 
注意：参数的扩展和构造方法的调用都是有一定的规律的。
有参调无参，多参调少参。。扩展参数的时候，最好保持原来的顺序。除非为了实现特殊的功能效果
 
 注意：无参调有参需要传实参！！
 
 
 
public class Person {
    private String name;
    private int age;
    // 无参
  /*  public Person() {
        this.name = "张三";
        this.age = 20;
    }
    */

    // 有参
    public Person(String name) {
        this.name = name;
    }

    // 多参
    public Person(String name, int age) {
        this(name);// 调用有一个参数的构造方法
        this.age = age;
    }

    // 调用有参构造方法。设置默认值。和第一种方法功能一样
    public Person() {
        this("张三", 20);
    }

    /*public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    */
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
 
    //程序的入口
    public static void main(String[] args){
        /*
          我们创建了一个简单的Person对象，调用的是Person类无参的构造器
          在构造器内完成了对成员变量的赋值
         */
        Person p = new Person();
        //输出的结果是  Person{name='张三', age=20}
        System.out.println(p);
    }
}
 
//输出效果
 
一个小小的demo 希望能帮助到你，如果手里有双击 请老铁点个关注。想要获取更多的学习资料 加 qq:1184905186

在对对象成员变量初始化时，有输入时，通过有参构造方法进行赋值。当没有输入时，可以给个初始值，就通过无参写入默认的，无参调有参完成赋值。
 
 
// main方法中 new调用无参构造方法，再完成上面的无参调有参
 
new 类名();