作者微信
微

java之构造方法精选

中游技术 2年前 (2022-08-23) 0 999+

关注

前言：

抱怨身处漆黑，不如提灯前行。愿你在自己存在的当地，成为一束光，照亮世界的一角！

我们上一篇聊到了static和final，这一片我们聊一下构造方法，针对于以下的概念，都会有实体例子配合着，给大家演示，希望给历险中的你带来一些帮助！！！

一.介绍

在Java中，任何变量在被使用前都必须先设置初值。Java提供了为类的成员变量赋初值的专门的方法称之为构造方法。

构造方法是一种特殊的方法，它是一个与类同名且返回值类型为同名类类型的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的初始化。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样也可以重载。

二.知识点介绍

1、概念与功能

2、构造方法特殊定义格式

3、默认构造方法

4、构造方法的习惯性定义

5、构造方法的使用解释

6、构造方法的注意事项

7、构造方法与set方法、显式初始化辨析

三.知识点详解

1、构造方法概念与功能

构造方法是正常开发中不可或缺的一部分，是语法上必须存在的。是一个具有特殊格式的方法，且有特殊的调用方式。

（1）用来创建实例对象的方法，给对象的数据进行初始化，如: Person p = new Person();

调用构造方法 Person();只是我们没有写这个方法，而是Java自动补齐了这个方法，是方法就可以传入参数。

（2）创建对象时，可以直接为成员变量赋值，无需再在对象产生后再赋值。

（3）核心功能创建对象：只要方法被调用，就已经创建了对象

（4）为成员变量赋值，在创建对象的同时，通过构造方法的方法体逻辑，为成员变量赋值，此时可以为带参构造

2、构造方法特殊定义格式

一般定义在其他方法前，成员变量后。

奇怪的方法定义格式：没有返回值类型定义，方法名与类名相同，参数依据需求而定。

结构格式：

public class Test {
            public 类名(参数类型 参数1，参数类型 参数2) {
                //创建对象时要执行的逻辑，经常为成员变量赋值
            }

            //如：
            public class Person {
                private String name;
                private int age;

                //两个构造方法为重载关系
                public Person() {
                } //空参的构造方法

                public Person(String name, int age) { //带参的构造方法
                    this.name = name;
                    this.age = age;
                }
            }
        }

代码演示：

调用主方法：

package com.Test;
public class Main {

       private  final  static  String name = "磊哥的java历险记-@51博客";

     /* 测试构造方法constructor*/
        public static void main(String[] args) {

           Person p = new Person();
           System.out.println(p.getName());
           System.out.println(p.getAge());

           System.out.println("============="+name+"=============");
           Person p2 = new Person("磊哥",25);
           System.out.println(p2.getName());
           System.out.println(p2.getAge());

               System.out.println("============="+name+"=============");
           Person p3 = new Person(3);
           System.out.println(p3.getName());
           System.out.println(p.getAge());
        }
        }

package com.Test;
    /* 自定义类型Person 类
     吃   睡
     构造方法
     核心功能创建对象  只要方法被调用，就已经创建了对象
     为成员变量赋值，在创建对象的同时，通过构造方法的方法体逻辑，为成员变量赋值，此时可以为带参构造
     定义格式 一般定义在其他方法前，成员变量后。

    public 类名(参数类型 参数1，参数类型 参数2){
       //创建对象时要执行的逻辑，经常为为成员变量赋值
      如果没有手动给出构造方法  java会为我们自动补齐一个空参的构造方法
      如果手动给出任意构造方法  java将不会为我们补齐空参构造

        public 代表公共的  任何包下都可以访问
        默认什么都不写  代表默认权限  当前包下可以访问

    private  代表私有  本类中可以访问
*/

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

        //定义无参构造方法
        Person(){
           //方法逻辑
           System.out.println("我是Person的无参构造");
        }

        //定义带参构造一般都是为了给成员变量赋值
        public Person(String name ,int age){
           System.out.println("我是Person带参构造给成员变量赋值");
           this.name = name;
           this.age = age;
        }

        public Person(int number){
           System.out.println("我是Person的带参构造，每次调用我打印n次***磊哥 love java***");
           for (int i = 0; i < number; i++) {
               System.out.println("磊哥 love java");
           }
        }

        public void eat(){
           System.out.println("吃");
        }
        public void sleep(){
           System.out.println("吃");
        }

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

3、默认构造方法

构造方法是必须存在的，如果没有手动给出构造方法，Java会自动为我们补齐一个空参的构造方法。这个过程我们是看不到的。

如果手动给出了构造方法，java则不会再自动补齐任何构造。

4、构造方法的习惯性定义

学习阶段一般我们会定义至少两个构造方法：空参构造与带参构造。

（1）空参构造是习惯上存在的。后期一些情况要求我们必须提供空参构造。

（2）带参的构造方法通常是为了给属性赋值的。

构造方法在定义时，有时还会完成一些初始化动作。

5、构造方法的使用解释

同其他方法相同，构造方法也是先定义再使用。而不同的是，其他方法的调用是为了这个方法对应的功能，而构造方法的功能就是创建对象，同时可以为属性赋值。我们在此之前创建对象的方式均是通过构造方法。
这样当对象创建出来后就已经具备了非默认值的初始值。

new 类型(实际参数);

//其结果就是产生了一个该类型的对象，具备一个地址值。

//可以赋值给一个这种类型的变量。

代码演示：

public class Main {

       private  final  static  String name = "磊哥的java历险记-@51博客";

     /* 测试构造方法constructor*/
        public static void main(String[] args) {
               //产生了Person的对象
               Person p = new Person();
               System.out.println(p);
               //打印结果为一个对象地址值，如0x9a64
               System.out.println(p.getName());
               //打印结果为null
               Person p2 = new Person("磊哥的java历险记",25); //产生了一个Person对象
               System.out.println(p2);
               //打印结果为一个对象地址值，如0252b2
               System.out.println(p2.getName());
              //打印结果为AngelaBaby
        }
        }

6、构造方法的注意事项

构造方法不能被继承。

父类叫person 子类叫student 继承构造方法分不清对象继承的构造方法是public person 要求构造方法和类名相同所以和类名冲突了

构造方法的public并不是固定不变的，我们在学习完四种访问权限后，可以使用其他格式修饰构造方法。

（看上面代码，接口没有构造方法，抽象类具有构造方法。）

7、构造方法与set方法、显式初始化辨析

构造方法是为了在创建的同时直接为属性赋值。

set方法时在创建对象之后，再重新为成员变量赋值，是修改值的过程。

显示初始化会将每个对象都提供相同的初始化值，这样的需求并不常见。

代码演示：

package com.Test;
    /*
    自定义类型 Animal 用来辨析 构造方法给成员变量赋值
    set方法给成员变量赋值  显示初始化赋值
     */
    public class Person {
        private String name = "磊哥的java历险记";
        private int age;
        //无参
        public Person(){

        }
        /**
         带参的构造方法  用来给成员变量赋值
         *
         @param name 第一个参数需要一个名字
         *
         @param age  第二个参数需要一个年龄
         */
        public Person(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;
        }
        public void setAge(int age) {
            this.age = age;
        }
    }

package com.Test;
public class Main {

       private final static String name = "磊哥的java历险记-@51博客";

       /*
     * 测试
     * 构造方法给成员变量赋值   set方法给成员变量赋值  显示初始化赋值
     * 显示初始化   所有对象一旦创建只要没有对成员变量重新赋值 就是显示初始化的值
     一般不这样使用
     * 构造方法为成员变量赋值  当对象一创建就为成员变量赋值了
     *
    set方法赋值   当创建好了一个对象后调用set方法赋值

        */
              public static void main(String[] args) {
                     Person person = new Person();
                     System.out.println(person.getName());
                     System.out.println(person.getAge());
                     System.out.println("============="+name+"=============");
                     Person person2 = new Person("@51OTC博客", 17);
                     person2.setName("@51OTC博客");
                     System.out.println(person2.getName());
                     System.out.println(person2.getAge());
              }
       }

父类对象，一定优于子类对象产生。

子类对象包含父类对象（private不包含，构造函数）

抽象类包含构造方法的原因是为了给成员变量赋值，供子类使用。

抽象类，不能直接开辟内存，通过子类开辟抽象类的内存空间

super调用父类的构造方法；super/super()/super(参数)；this/this()/this(参数) ；this与super不能同时调用构造方法

8、强训练习：

鸟类是我们经常会看见的动物，其中在鸟的子类鹰类中，除了继承父类翅膀、鸟喙、爪子之外，还在基础上翅膀扩大了，鸟喙更尖锐了。

分析：

（1）声明父类鸟类和子类鹰类。

（2）鸟类和鹰类都具有翅膀、鸟喙的属性。鹰类具有利爪的子类属性。

（3）通过翅膀可以构造出飞翔的动作。

（4）通过鸟喙可以构造出啄食的动作。

（5）鹰类的飞翔除了继承基本的飞翔之外，还可以翱翔。

（6）鹰类的爪子也可以用来做捕食。

（7）通过构造和继承构造实现上述动作。

开发步骤：

（1）定义一个鸟类：bird和鹰类hawk;鹰类继承鸟类

（2）定义属性爪子claw,翅膀wing,鸟喙beak;

（3）通过构造函数初始化claw,wing,beak。

（4）鸟类定义方法飞翔，通过赋值翅膀的进行构造。

（5）鸟类定义方法吃食，通过复制鸟喙beak；

（6）鹰类定义方法飞翔，调用父类飞翔方法的基础上，增加翱翔。

（7）鹰类定义方法吃食，调用本类捕食的方法，再进行父类的吃食。

代码演示：

package com.Test;

public class Bird {
        private String wing;
        private String beak;
        public Bird(){ }
        public Bird(String wing,String beak){
        this.setWing(wing);
        this.setBeak(beak);
        }
        public String getWing() {
        return wing;
        }
        public void setWing(String wing) {
        this.wing= wing;
        }
        public String getBeak() {
        return beak;
        }
        public void setBeak(String beak) {
        this.beak= beak;
        }

        public void fly(){
        System.out.println("通过"+this.getWing()+"飞");
        }

        public void eat(){
        System.out.println("通过"+this.getBeak()+"进行吃食");
        }

        }
class Hawk extends Bird{
    private String claw;
    public String getClaw() {
        return claw;
    }
    public void setClaw(String claw) {
        this.claw= claw;
    }
    public Hawk(){}
    public Hawk(String beak,String wing,String claw){
        super(wing,beak);
        this.setClaw(claw);
    }

    public void fly(){
        super.fly();
        System.out.println("我是老鹰，我还可以翱翔");
    }

    private void getEatThing(){
        System.out.println("通过爪子"+this.getClaw()+"进行捕食");
    }

    public void eat(){
        this.getEatThing();
        super.eat();
    }

}

主方法调用：

public class Test {
    publicstatic void main(String[] args) {
       Birdb = new Hawk("老鹰的嘴","老鹰的翅膀","老鹰的利爪");
       b.fly();
       b.eat();
    }
}