@Data
@Builder
@NoArgsConstructor
public class ResourceDetailsResVO {
    private Integer stat;
    private String msg;
}

如果同时使用了@Data、@Builder，则无法添加此类的无参构造方法。无论是使用@NoArgsConstructor还是直接手动添加无参构造器，在编译时都会报错。(图片是盗来的*……*)


    解决方案：

    同时使用：@NoArgsConstructor、@AllArgsConstructor，如下

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ResourceDetailsResVO {
    private Integer stat;
    private String msg;
}

具体原因还未深究。

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

掌握构造方法

1.不写： 默认有一个无参构造方法，只不过隐藏起来了

2.构造方法支持重载

3.只定义了有参构造方法，默认一个无参构造方法会消失，如果无参构造方法要用到，记得写出来

4.构造方法名字与类名一样

 

 

package cn.sg.up;

/**

 * 掌握封装的概念以及应用

            把内容都private（封装）起来，只提供对外调用

 * 

 * @author Administrator

 *

 */

public class Person {

    

    //对数据进行封装提供外部使用

    private String name;

    private int age;

    private char sex;

    private String address;

    private String job;

    

    

    

        //默认无参构造方法

        //构造方法的使用可以进行初始化操作

        

    //有参构造方法

    //构造方法支持重载

    //只定义了有参构造方法，默认一个无参构造方法会消失，如果无参构造方法要用到，记得写出来

    

  public Person(String name, int age, char sex, String address, String job) {

        super();

        this.name = name;

        this.age = age;

        this.sex = sex;

        this.address = address;

        this.job = job;

    }

  

    public Person() {

            super();

            

            

        }

    //鼠标右键Source - Generate Getter and Setter

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public char getSex() {

        return sex;

    }

    public void setSex(char sex) {

        this.sex = sex;

    }

    public String getAddress() {

        return address;

    }

    public void setAddress(String address) {

        this.address = address;

    }

    public String getJob() {

        return job;

    }

    public void setJob(String job) {

        this.job = job;

    }

    @Override

    public String toString() {

        return "Person [name=" + name + ", age=" + age + ", sex=" + sex + ", address=" + address + ", job=" + job + "]";

    }//鼠标右键Source - Generate toString

    

    

    

}

 

 

 

package cn.sg.up;

public class Demo02 {

    public static void main(String[] args) {

        //调用有参构造方法

        Person person = new Person("www",123,'男',"12344","154");

        System.out.println(person);

        

        

        //调用无参构造方法

        Person person1 = new Person();

        person1.setName("7444444");

        System.out.println(person1.getName());

    }

    

 

程序运行：

 

 

 

Author：枫叶

一、无参构造方法

1、定义：

如果编写一个javaBean时没有添加无参构造方法，那么编译器会自动添加无参构造方法；

但是如果编写时添加了有参构造方法而未添加无参构造方法，那么编译器只认有参构造方法而不会默认添加无参构造方法,

所以，如果需要使用无参构造方法，一定要在类里面添加.




2、举例：


(1)有4个javaBean --------> Person1.java、 Person2.java、 Person3.java、 Person4.java




public void 
Person1{

private String name;

private String adrress;

}






public void 
Person1{

private String name;

private String adrress;

//无参构造方法


public

Person(){} 

}




public void Person1{

private String name;

private String adrress;

//有参构造方法

public NoParamInfo(String name,String address){

this.name=name;

this.address=address;

}

}

public void Person1{

private String name;

private String adrress;

 //无参构造方法


public 
Person(){}

//有参构造方法

public 
Person(String name,String address){

this.name=name;

this.address=address;

}

}


(2)测试




@Test

public void testNoParamInfo(){

//这样写，编译器不会报错


Person1 p1=new 
Person1();

//这样写，编译器也不会报错


Person2
p2=new 
Person2 ();

//这样写，编译器会报错，原因是无参构造方法被有参构造方法覆盖，编译器不能提供无参构造方法


Person3
p3=new 
Person3 ();

//这样写，编译器不会报错


Person4
p4=new 
Person4();

//这样写，编译器不会报错


Person4
p4=new 
Person4 (“tom”"地球');

}


总结: 

1. 在没有构造方法时,系统默认调用无参构造方法

2. 一旦定义有参构造方法,系统不再提供默认构造方法.

3. 如果定义了有参,最好在定义一个无参.