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

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();
    }
}

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();
    }
}

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("接第二条");
    }
}

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+"岁了");
    }
}

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

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+"岁了");
    }
}

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

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

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

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

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

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

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

/**
 * 编译前代码
 */
@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;
    }
}