构造方法

Posted 2020-10-20

构造方法

其实在写好一个自定义的类时，这个类本身就有一个默认的空参数构造方法，只是不用自己去写出来，但是在有些时候，需要对它的成员变量在创建对象的时候就进行初始化值，这时就需要重写构造方法，也就是构造器。

构造方法的作用就是对成员变量进行默认初始化值。

构造方法的定义格式

修饰符 方法名(参数列表){

}

修饰符：也就是它的权限问题

方法名：定义必须和类名完全一致

参数列表：如果需要对成员变量在创建对象的时候就进行赋值，就写参数，如果不需要，不需要写参数列表。

构造方法在创建对象的时候就运行了，具体代码演示如下：

l  Person类

package cn.itcast.ConstructorMethod;
/*
 * 构造方法的创建
 */
public class Person {
   //定义姓名，年龄，将其私有化
   private String name;
   private int age;
   
   //构造方法，实验这个构造方法是在什么时候被运行的
   public Person(){
      System.out.println("我是一个空参数的构造方法");
   }
   //get方法set方法
   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;
   }
   
}

l  测试类

package cn.itcast.ConstructorMethod;
/*
 * 测试构造方法是在什么时候被运行的
 */
public class Test {
   public static void main(String[] args) {
      //创建Person类对象
      Person p = new Person();
   }
}

运行结果：

在创建对象的时候就对成员变量进行初始化值，具体的代码演示如下：

l  PersonName类

package cn.itcast.ConstructorMethod;
/*
 * 创建构造方法
 */
public class PersonName {
   //定义姓名
   private String name;
   //重写构造方法，对其传入有参的参数，也就是姓名
   public PersonName(String name){
      this.name = name;
   }
   //get方法set方法
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   
}

l  测试类

package cn.itcast.ConstructorMethod;
/*
 * 测试构造方法是否在创建对象时初始化姓名值
 */
public class TestName {
   public static void main(String[] args) {
      //创建PersonName类的对象，对构造方法初始化值，其实就是在调用这个构造方法
      PersonName pm = new PersonName("王杰");
      //查看一下是否在创建对象时对姓名进行初始化值
      System.out.println(pm.getName());
   }
}

构造方法的重载

类中的构造方法可以有重载，只要其参数列表不同即可，下面用一段代码来演示构造方法的重载：

l  Person类

package cn.itcast.ConstructorMethodOverLoad;
/*
 * 构造方法的重载
 */
public class Person {
   //定义姓名，年龄
   private String name;
   private int age;
   //构造方法的重载，空参构造方法
   public Person(){
      
   }
   //构造方法的重载，有参构造方法
   public Person(String name,int age){
      this.name = name;
      this.age = age; 
   }
   //get方法set方法
   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;
   }
   
}

l  测试类

package cn.itcast.ConstructorMethodOverLoad;
/*
 * 测试构造方法的重载
 */
public class Test {
   public static void main(String[] args) {
      //创建Person类对象，调用空参构造方法
      Person p = new Person();
      p.setName("张三");
      p.setAge(18);
      System.out.println(p.getName());
      System.out.println(p.getAge());
      //创建对象，调用有参的构造方法
      Person p2 = new Person("李四", 19);
      System.out.println(p2.getName());
      System.out.println(p2.getAge());
   }
}

运行结果：

构造方法和一般方法的区别：

构造方法在创建对象的时候就被调用了，并且只能执行一次，而一般方法在创建对象后，需要被使用才会被对象所进行调用，一般方法可以被调用多次。

构造方法中this的作用

构造方法中this的作用就是将两个构造方法进行连接，在一个空参构造方法中通过this的方式对成员进行赋值，可以和有参的构造方法进行联系，调用有参的构造方法，传递实际参数，具体的使用细节如下：

注意，this的使用必须写在构造方法中的第一行。

l  Person类

package cn.itcast.This;
/*
 * 构造方法中this 的用法
 */
public class Person {
   //定义姓名，年龄
   private String name;
   private int age;
   //空参构造方法
   public Person(){
      this("张三",20);
   }
   //有参构造方法
   public Person(String name,int age){
      this.name = name;
      this.age = age;
   }
   //get方法和set方法
   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;
   }
   
}

l  测试类

package cn.itcast.This;
/*
 * 测试类，测试构造方法中this的用法
 */
public class Test {
   public static void main(String[] args) {
      //创建对象，调用空参构造方法
      Person p = new Person();
      System.out.println(p.getName());
      System.out.println(p.getAge());
   }
}

构造方法中super关键字的用法

在子类中，可以使用super去调用父类的构造方法

super()调用的是父类空参数的构造方法

super(参数)调用的是父类中有参数的构造方法

注意：super必须写在构造方法中的第一行，super和this，两者有一个就可以了，如果子类继承父类，子类都必须直接或间接访问父类的构造方法。代码演示如下：

l  人类

package cn.itcast.ConstructorMethodSuper;
/*
 * 父类构造方法
 */
public class Person {
   public Person(int a){
      
   }
}

l  学生类

package cn.itcast.ConstructorMethodSuper;
/*
 * 子类继承父类
 * 子类构造方法直接或间接访问父类构造方法
 */
public class Student extends Person{
   public Student(){
      this(5);//调用本类构造方法，参数为int的构造方法
   }
   public Student(int a){
      super(4);//调用父类的构造方法
   }
}

super的实例演示

l  Person类

package cn.itcast.ConstructorMethodSuper实例;
/*
 * 需求：有学生和工人两个类，有其共有的属性name和age，要求在创建这两个对象时就对name和age赋值
 * Person父类，学生和工人抽取的共有内容
 * 成员变量私有，重写构造方法，接收传递变量的值
 * get，set方法用于获取私有变量的值
 */
public class Person {
   //私有变量name，age
   private String name;
   private int age;
   //重写构造方法
   public Person(String name,int age){
      this.name = name;
      this.age = age;
   }
   //get，set方法
   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;
   }
   
}

l  Student类

package cn.itcast.ConstructorMethodSuper实例;
/*
 * 学生类，继承Person类，重写构造方法，将创建学生对象后赋的值传递给父类的构造方法
 */
public class Student extends Person{
   //重写构造方法，创建Student对象时直接赋值name，age
   public Student(String name,int age){
      //将值传递给父类的构造方法
      super(name,age);
   }
}

l  Worker类

package cn.itcast.ConstructorMethodSuper实例;
/*
 * 工人类，继承Person类，重写构造方法，将值传递给父类的构造方法中
 */
public class Worker extends Person{
   //重写构造方法，创建Worker对象时直接赋值name，age
   public Worker(String name,int age){
      //将值传递给父类构造方法
      super(name, age);
   }
}

l  Test测试类

package cn.itcast.ConstructorMethodSuper实例;
/*
 * 测试类
 * 创建学生，工人对象时就对name，age赋值，获取name，age的值
 */
public class Test {
   public static void main(String[] args) {
      //创建Student对象并赋值
      Student s = new Student("张三",30);
      //获取name，age的值
      System.out.println(s.getName());
      System.out.println(s.getAge());
      //创建Worker对象并赋值
      Worker w = new Worker("李四",20);
      System.out.println(w.getName());
      System.out.println(w.getAge());
   }
}

运行结果：