一.构造方法<span style="color: gray; font-size: small;">(构造器/构造函数)</span>的格式

<span style="color: green;">1.格式:</span>

public class ==类名=={ 修饰符 ==方法名=类名==<span style="color: gray; font-size: 12;">(要跟类名完全一样)</span>(参数){ 方法体 } }

• 格式示例

public class Student{
   private String name;
   private int age;

   public Student(){
      //空参构造方法
   }

   public Student (String name,int age){
      //（带全部参数的）实参构造方法
   }
}

<span style="color: green;">2.特点:</span>

1. ==方法==名与==类名==要==完全一致==
2. 没有返回值类型,连==void==也没有
3. 不能写==return==
4. 创建对象时由虚拟机调用,不能手动调用构造方法
5. 每创建一次对象,就会调用一次构造方法

<span style="color: green;">3.代码示例:</span>

1.构造方法示例

public class Student1 {  
    private String name;  
    private  int age;  
  
    //空参构造  
    //******如果我们自己没有写任何构造方法***********  
    //******那么虚拟机就会给我们加一个空参构造方法*****  
    public Student1(){  
       //下面这段代码是检验空参对象是否执行
       System.out.println("看看我执行了吗");  
    }  
  
    //有参构造 （并且是全参数构造） 
    public Student1(String name,int age){  
        this.name = name;  
        this.age = age;  
    }  
  
  
    public String getName(){  
        return name;  
    }  
  
    public void setName(String name){  
        this.name = name;  
    }  
  
    public  int getAge(){  
        return age;  
    }  
}

2.测试代码

public class StudentTest {  
    public static void main(String[] args) {  
        //创建对象  
        //调用空参构造  
        Student1 s = new Student1();  
        System.out.println(s.getName());  

        //调用有参构造
        Student1 s1 = new Student1("张三",21);  
        System.out.println(s1.getName());  
        System.out.println(s1.getAge());  
    }  
}

<span style="color: green;">4.注意事项:</span>

1. 构造方法的定义

• 如果没有定义构造方法,系统会给出一个==默认==的==无参构造方法==
• 如果定义了构造方法,系统将不再默认提供无参构造方法

2. 构造方法的==重载==

• 带参的构造方法和无参数的构造方法,两者方法名相同,但是参数不同,这种方法叫做方法重载

3. 推荐使用方式

• <span style="color: red;"> 无论是否使用,全都写</span>

二.构造方法注意

1. ==作用==:在创建对象时初始化(<span style="color: gray; font-size: small;">赋值</span>)成员变量

2. 父类的构造方法会在子类的构造方法之前被调用。

这是因为==子类的构造方法中默认会隐式调用父类的无参构造方法==（super()），除非你在子类的构造方法中显式调用了其他构造方法或者使用super关键字指定了父类构造方法的调用方式。

例子

class Parent {
    private int value;

    public Parent() {
        System.out.println("父类无参构造方法");
        value = 0;
    }

    public Parent(int value) {
        System.out.println("父类有参构造方法");
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

class Child extends Parent {
    private String name;

    public Child() {
        super(); // 显式调用父类的无参构造方法
        System.out.println("子类无参构造方法");
        name = "Default";
    }

    public Child(int value, String name) {
        super(value); // 显式调用父类的有参构造方法
        System.out.println("子类有参构造方法");
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

4. 构行顺序是造方法的执从父类到子类，即先执行父类的构造方法，然后再执行子类的构造方法。

5. 构造方法中的初始化代码会按照它们在构造方法中的顺序执行

例如

class Parent {
    public Parent() {
        System.out.println("父类构造方法");
    }
}

class Child extends Parent {
    public Child() {
        System.out.println("子类构造方法");
    }
}

Child child = new Child();

输出的执行顺序将是：

• 父类构造方法会首先被调用，输出 "父类构造方法"。
• 然后子类构造方法被调用，输出 "子类构造方法"。

6. FClass obj1=new SubClass(1) （可访问父类方法属性，以及子类方法重写）

• obj1 的类型是 FClass，即基类的引用，但它引用了一个 SubClass 对象。
• 通过 obj1 只能访问到 FClass 类中定义的方法和属性，==而无法直接访问 SubClass 特有的方法和属性。==
• 但由于多态性的特性，如果 FClass 类中有一个被子类重写的方法，那么通过 obj1 调用这个方法时会调用子类的版本。

6.1关于重写

==子类重写父类方法时必须保持方法名称、参数类型和返回类型完全一致==。以下是方法重写必须满足的条件：

1. 方法名称必须与父类中被重写的方法名称一致。
2. 方法的参数类型（包括参数的数量和顺序）必须与父类中被重写的方法的参数类型一致。
3. 方法的返回类型可以与父类中被重写的方法的返回类型一致，也可以是其子类型（也叫协变返回类型），但不能是父类方法返回类型的超类型。
4. 子类方法不能降低访问权限，也就是说，如果父类方法是 public，那么子类方法也必须是 public，不能降级为 protected 或 private。

7. SubClass obj1 = new SubClass(1)（可访问子类方法属性，继承父类方法属性）

• 这里 obj1 的类型是 SubClass，即子类的引用，它引用了一个 SubClass 对象。
• 因此，通过 obj1 可以访问到 SubClass 类中定义的方法和属性，包括继承自父类的方法和属性。
• 这种情况下，你可以直接访问 SubClass 特有的方法和属性。

三例子

例题

class FClass {  
public FClass(){//空参构造  
System.out.println("基类构造方法");  
m1(1);  
}  
public void m1(double d){  
System.out.println("基类m1(double)"+d);  
m2(d);  
}  
public void m2(int i){  
System.out.println("基类m2(int)" + i);  
}  
public void m2(double d){  
System.out.println("基类m2(double)" + d);  
}  
}  
class SubClass extends FClass {  
public SubClass(int i){  
System.out.println("子类构造方法");  
m1(i);  
}  
public void m1(int i){  
System.out.println("子类m1(int)" + i);  
m2(i);  
}  
public void m2(double d){  
System.out.println("子类m2(double)" + d);  
}  
}  
public class E24B {  
public static void main(String[] args){  
FClass obj1=new SubClass(1);//不明白  
/*在构造方法中，首先会调用父类 FClass 的构造方法，  
因为子类的构造方法默认会调用父类的构造方法，除非显式指定调用另一个构造方法*/  
System.out.println("******");  
((SubClass)obj1).m2(4);  
obj1.m2(2);  
((SubClass)obj1).m1(3);  
obj1.m1(1);  
}  
}

输出

基类构造方法
基类m1(double)1.0
子类m2(double)1.0
子类构造方法
子类m1(int)1
基类m2(int)1
******
基类m2(int)4
基类m2(int)2
子类m1(int)3
基类m2(int)3
基类m1(double)1.0
子类m2(double)1.0