java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Java父类没有无参构造方法

关于Java父类没有无参构造方法子类处理方法

作者:Baiyi_destroyer

父类无参构造方法,子类不写,其实会默认调用父类的无参构造方法也就是用super(),编译运行后,会打印出"子类会调用Father的第一个构造方法,这篇文章给大家介绍关于Java父类没有无参构造方法子类处理方法,感兴趣的朋友一起看看吧

关于父类没有无参构造方法,子类如何处理

1.父类无参构造方法,子类不写,其实会默认调用父类的无参构造方法也就是用super()。 编译运行后,会打印出"子类会调用Father的第一个构造方法"

class Father{
    Father(){
        System.out.println("子类会调用Father的第一个构造方法");
    }
}
class Son extends Father{
    //我没在这写子类的构造方法,但是编译器默认补上子类构造方法,这里相当于有个Son(){super(); }方法,当然这个super()不写也一样
}
class Demo{
    public static void main(String[] args)
    {
               Son s = new Son();
    }
}

2.但是注意了,下面代码无法通过编译。 因为父类重写了构造方法,编译器是不会补上无参构造方法的。子类不重写构造方法,系统会为子类默认补上无参构造方法Son(){super(); } ,注意这个super()调用的是父类的无参构造方法。 这正好和第一句矛盾了,父类没有无参数构造方法子类无法调用到的。怎么解决,看第三条。

class Father{
    //父类的有参数构造方法
    Father(String name){
        System.out.println("子类会调用Father的有参数构造方法");
    }
}
class Son extends Father{
}
class Demo{
    public static void main(String[] args)
    {
        Son s = new Son();
    }
}

3.在第二条基础上,子类重写构造方法传入的string字串,并且显式的用super(name);调用父类的构造方法,既然你都显式用super(name);了编译器就不会多事给子类补上super(); 这回就编译运行正常了。

class Father{
    Father(String name){
        System.out.println("子类会调用Father的第二个构造方法");
    }
}
class Son extends Father{
    Son(String name){
         super(name);
    }
}
class Demo{
    public static void main(String[] args)
    {
        Son s = new Son("接第二条");
    }
}

4.总之:

 a.涉及构造方法,你不写构造方法,编译器会默认写上无参构造方法,你写编译器就完全不管事了。

b.执行子类的构造方法前一定是执行父类构造方法的(构造方法用来初始化的,没爸爸怎么来儿子),所以子类的构造方法中一定是先执行父类的构造方法用super()。

c.这个super和a说的一样,你不显式写出来,编译器默认用super(),也就是调用父类的无参构造方法,那你父类肯定得有无参构造方法吧。所以我们写上一个父类带参构造方法的时候,另外手动补上个无参构造方法要好些。 

补充:

Java有参构造方法与无参构造方法

前言

遇到了就简单写一下吧,如果能够对你有帮助,点个赞吧。首先清晰明了的了解到有参构造方法与无参构造方法、以及应用,然后实战项目一般会使用的Lombok,不会手动再生成get、set。
定义:
在编写一个类时没有添加无参构造方法,那么编译器会自动添加无参构造方法;(如果自己手动添加构造函数,无论有参数或是没参数,默认构造函数都将无效)
编写时添加有参构造方法而未添加无参构造方法,那么编译器只认有参构造方法而不会默认添加无参构造方法。
如果需要使用无参构造方法,一定要在类里面添加。

有参构造方法

在之前我们要为一个对象赋值,先要创建好对象之后然后“对象名.属性名”或者调用属性的setter为属性赋值。但是在很多时候觉得这样做很麻烦,最好的做法是在创建对象的时候完成属性的初始化操作,此时需要使用到有参数构造方法方能完成该功能(有人把构造方法叫做构造器)。
例子:(idea快捷键Alt+insert生成构造方法和get、set等)
1、定义一个Student类

package com.hn.yuan.common;
/**
 * 有参构造方法
 */
public class Student {
    private String name;
    private String age;
    public Student(String name, String age) {
        this.name = name;
        this.age = age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(String age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public String getAge() {
        return age;
    }
    public void start(){
        System.out.println("我叫"+name+"今年"+age+"岁了");
    }
}

2、定义一个Test类,来进行查看运行效果

package com.hn.yuan.common;
public class Test {
    public static void main(String[] args) {
        //使用有参数的构造方法实例化对象
        Student st=new Student("张三","18");
        st.start();
    }
}

运行效果

此时发现了我们不需要像之前一样,要为对象的属性赋值就必须先创建对象再使用“对象名.属性名”或者使用setter 方法去实现了,而是直接使用有参数的构造方法去实现。
3、定义原理呈现
在编写一个类时没有添加无参构造方法,那么编译器会自动添加无参构造方法;(如果自己手动添加构造函数,无论有参数或是没参数,默认构造函数都将无效)
编写时添加有参构造方法而未添加无参构造方法,那么编译器只认有参构造方法而不会默认添加无参构造方法。
如果需要使用无参构造方法,一定要在类里面添加。

无参构造方法

作用:无参构造方法一般是用来初始化:如为变量赋初值、初始化对象等。
在之前我们使用过方法,在调用的方法的是时候需要在方法名称之后加.上小括号,括号里面可以传递实参,那么我们在创建一个对象的时候使用的是“new类名()”的方式去实现,其实上这也是一种方法,但是这个方法我们没有明确的去定义,那为什么可以调用呢?观察代码。
例子:
1、首先,我们定义一个Student类

package com.hn.yuan.common;
/**
 * 无参构造方法
 */
public class Student {
    private String name;
    private String age;
    //含有 无参构造方法
    public Student() {
        System.out.println("调用了无参构造方法");
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(String age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public String getAge() {
        return age;
    }
    public void start(){
        System.out.println("我叫"+name+"今年"+age+"岁了");
    }
}

2、定义一个Test类,来进行查看运行效果

package com.hn.yuan.common;
public class Test {
    public static void main(String[] args) {
        //使用有参数的构造方法实例化对象
        Student st=new Student();
        System.out.println(st);
    }
}

运行效果

定义四个类说明情况(如果还不清晰请看)

类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);//编译通过;
    }
}

使用构造器时
1、构造器必须与类同名(如果一个源文件中有多个类,那么构造器必须与公共类同名)
2、每个类可以有一个以上的构造器
3、构造器可以有0个、1个或1个以上的参数
4、构造器没有返回值
5、构造器总是伴随着new操作一起调用
父类有有参构造方法有两种情况,一只有有参构造,那么子类的构造方法中的第一句必须调用父类的有参构造方法,也就是“super(…);”,…为你传入的参数如:

class Father {
    public Father(String lastname) {
    }
}
class Son extends Father {
    public Son() {
        super("aaaa");// 这句必须有
// 可以写其他代码
    }
}

二有有参也有无参构造方法,这时子类不显示调用super,这会默认自动调用父类无参的构造方法,

class Father {
    public Father() {
    }
    public Father(String lastname) {
    }
}
class Son extends Father {
    public Son() {
        super();// 这句可以有也可以没有,没有写的话会自动调用
        // 可以写其他代码
    }
}

Lombok的基本使用

首先我们要了解的信息:
IntelliJ IDEA 2020.3及以上版本已经内置Lombok plugin了,所以不需要安装插件,只需要在项目添加Lombok依赖就能用了。(如果按照其它人给的办法通过非官方渠道安装Lombok plugin,反而可能出现版本兼容问题,所以IDEA 2020.3及以上版本的不要瞎搞去安装Lombok plugin了)
同时:lombok在2020.2就开始断更了,所以idea2021及之后的marketplace就不开始支持lombok了
信息来源1(IDEA 2020.3的更新说明):https://www.jetbrains.com/idea/whatsnew/2020-3/#page__content-other

image.png

开始应用:
注意:下载的版本要与idea版本对应,要不然可能会报错
1、官方下载之前对应idea版本的lombok
第一种:直接lombok官方:lombok各个版本下载地址

image.png

第二种:打开IDEA的File——setting——Plugins,搜索lombok,应用即可。
(一般内网状态下,会给你个Lombok压缩包,引入-应用-即可)

image.png

2、使用Lombok
第一种引入方式:直接在maven中添加依赖

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <!--这里由于采用springboot管理version,所以没有version标签-->
        </dependency>

第二种引入方式:在需要的类上面加注解@Data,会爆红
爆红之后,鼠标移到爆红位置,选择添加add ‘lombok’ to classpath即可,maven会自动帮我们添加依赖。

例子:

package com.hn.yuan.common;
import lombok.AllArgsConstructor;
import lombok.Data;
/**
 *  lombok的使用
 */
@Data
@AllArgsConstructor
public class Student {
    private String name;
    private String age;
}

常用注解作用:
@Data
等价于@Setter、@Getter、@RequiredArgsConstructor、@ToString、@EqualsAndHashCode

@NoArgsConstructor
@NoArgsConstructor在类上使用,这个注解可以生成无参构造方法,如下所示:

/**
 * 编译前代码
 */
@RequiredArgsConstructor
public class Student() {
    private String name;
    private String age;
}
/**
 * 编译后代码
 */
public class Student() {
    private String name;
    private String age;
    public Student() {
    }
}

@AllArgsConstructor
@AllArgsConstructor在类上使用,这个注解可以生成全参构造函数,且默认不生成无参构造函数。
不过需要注意的是,这里所说的全参并不包括已经被初始化的被final关键字修饰的字段,因为字段一旦被final关键字修饰被赋值后就不能再被修改,如下所示:

/**
 * 编译前代码
 */
@RequiredArgsConstructor
public class Student() {
    private final String gender;
    private final Integer ages = 18;
    private String name;
    private String age;
}
/**
 * 编译后代码
 */
public class Student() {
    private final String gender;
    private final Integer ages = 18;
    private String name;
    private String age;
    public Student(String gender, String name, String age) {
        this.gender = gender;
        this.name = name;
        this.age = age;
    }
}

@AllArgsConstructor :注在类上,提供类的全参构造
@NoArgsConstructor :注在类上,提供类的无参构造
@Setter :注在属性上,提供 set 方法
@Getter :注在属性上,提供 get 方法
@EqualsAndHashCode :注在类上,提供对应的 equals 和 hashCode 方法
@Log4j/@Slf4j :注在类上,提供对应的 Logger 对象,变量名为 log

到此这篇关于Java有参构造方法与无参构造方法(完全理解)的文章就介绍到这了,更多相关Java有参构造方法与无参构造方法内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

您可能感兴趣的文章:
阅读全文