Day31--构造器详解

Day31--构造器详解

使用 new 关键字创建对象。使用 new 关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：

1. 必须和类的名字相同；
   \2. 必须没有返回类型，也不能写 void。

构造器必须要掌握！！！！！！！！！！！！！！！！！！！！！！！！！！！！！

构造器的快捷键：alt+insert ------>构造函数

​ 如果想要定义无参构造器，就是alt+insert ------>构造函数------->无选择

举例理解：

我在下面的代码里面，创建了Person方法，方法和类名相同，没有参数

package com.liu.oop.demo02;

public class Person {

    //一个类即使什么都不写，也会存在一个方法
    //显示的定义构造器
    //无参构造； 没有参数的构造
    public Person(){}
}

在同一个包的Application类里面，就可以调用这个方法了

package com.liu.oop.demo02;

//一个项目只应该有一个main方法，我们在这里把他放在Application里
public class Application {
    public static void main(String[] args) {
        //new实例化了一个对象
        Person person = new Person();
    }
}

上面讲的是无参构造器

下面是有参构造器：

//有参构造
    public Person(String name){
            this.name=name;
    }

this.name=name;

在右边的name，是传入的name，

左边的name，指的是属性name

一旦定义了有参构造，无参构造就必须要显示定义，否则就会报错

可以这样看：

当无参构造删除掉之后，Application就立刻报错了

package com.liu.oop.demo02;

public class Person {

        String name;
    //一个类即使什么都不写，也会存在一个方法
    //显示的定义构造器
    //无参构造； 没有参数的构造


    //无参构造
    //实例化初始值
    //使用new关键字，本质是在调用构造器
//    public Person() {
//        this.name = "哈哈";
//    }

    //有参构造
    //一旦定义了有参构造，无参构造就必须要显示定义，否则就会报错
    public Person(String name){
            this.name=name;
    }
}

package com.liu.oop.demo02;

//一个项目只应该有一个main方法，我们在这里把他放在Application里
public class Application {
    public static void main(String[] args) {
        //new实例化了一个对象
        Person person = new Person();

        System.out.println(person.name);//哈哈

    }
}

错误原因：java: 无法将类 com.liu.oop.demo02.Person中的构造器 Person应用到给定类型;
需要: java.lang.String
找到: 没有参数
原因: 实际参数列表和形式参数列表长度不同

解决方法：

当我们定义了一个实参构造器之后，就再定义一个空的无参构造器，就像这样

public Person() {
    }

构造器

//1.使用new关键字，本质是在调用构造器
//2.初始化值

好奇怪啊， public Person(){}

类的首字母可以大写了吗？在java里面，方法的名称可以与类的名称一样吗？

深入理解：

1. 代码分析

   • 在你的代码中，你并没有创建一个名为Person的方法，而是创建了一个名为Person的类，并且这个类中有一个无参构造器。在Java中，构造器是一种特殊的方法，用于创建和初始化对象。它的名字必须与类名相同，并且没有返回类型（甚至不能写void）。你的public Person(){}就是这样一个构造器，它用于创建Person类的对象，当你使用new Person()来实例化一个Person对象时，就会调用这个无参构造器。这就是为什么在IDEA中没有显示错误的原因。

2. 方法名称与类名是否可以相同

   • （1）构造器：构造器的名称必须与类名相同。构造器用于初始化类的新对象，这是Java语法的规定。例如，对于类Student，其构造器可以是public Student()或者public Student(int age, String name)等形式，名字必须是Student。

   • （2）普通方法：普通方法的名称可以与类名相同，但这可能会引起混淆。不过在一些特定的设计模式或者代码结构中，这种命名方式是被允许的。例如，在一些工厂方法模式的实现中，可能会有一个与类名相同的静态工厂方法，用于创建该类的对象。例如：

     • class MyClass {
           public static MyClass MyClass() {
               return new MyClass();
           }
       }
       

       • 这里定义了一个名为MyClass的静态方法，它返回一个MyClass类型的对象。这种用法虽然不太常见，但在某些情况下是合理的。

3. 方法名称首字母是否可以大写

   • 方法名称首字母可以大写。在Java中，方法名遵循标识符命名规则，即可以包含字母、数字、下划线（_）和美元符号（$），并且不能以数字开头。虽然通常建议方法名采用小写字母开头的驼峰命名法（如calculateSum），但大写字母开头的方法名也是合法的。例如，public void CalculateTax()这样的方法定义是合法的，不过这种命名方式不符合Java的常见命名习惯，可能会让其他开发者在阅读代码时产生误解。

在构造器里面进行赋值：

package com.liu.oop.demo02;

public class Person {

        String name;
    //一个类即使什么都不写，也会存在一个方法
    //显示的定义构造器
    //无参构造； 没有参数的构造

    //构造器的作用：实例化初始值
    public Person(){
        this.name="哈哈";
    }
}

package com.liu.oop.demo02;

//一个项目只应该有一个main方法，我们在这里把他放在Application里
public class Application {
    public static void main(String[] args) {
        //new实例化了一个对象
        Person person = new Person();

        System.out.println(person.name);//哈哈

    }
}

一个小拓展：

在Person类里面创建了name属性

package com.liu.oop.demo02;

public class Person {

        String name;
    //一个类即使什么都不写，也会存在一个方法
    //显示的定义构造器
    //无参构造； 没有参数的构造
    public Person(){}
}

在Application类里输出name属性：

快捷键：people.name.sout System.out.println(person.name);

package com.liu.oop.demo02;

//一个项目只应该有一个main方法，我们在这里把他放在Application里
public class Application {
    public static void main(String[] args) {
        //new实例化了一个对象
        Person person = new Person();
        
        System.out.println(person.name);
    }
}

总结：

构造器：

1. 和类名相同。

2. 没有返回值。

作用：

1. new 本质在调用构造方法。
2. 初始化对象的值。

注意点：

1. 定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造。
   Alt + Insert。

再详细学一下

1. 构造器的基本概念

   • 构造器（Constructor）是一种特殊的方法，用于创建和初始化对象。它的主要作用是在创建对象时，为对象的成员变量赋初始值，确保对象在使用前处于一个合理的初始状态。构造器的名称必须与类名相同，并且没有返回类型（不能写void）。

2. 无参构造器示例

   • 以下是一个简单的Person类，包含一个无参构造器：

     • class Person {
           private String name;
           private int age;
           //无参构造器
           public Person() {
               name = "未命名";
               age = 0;
           }
       }
       

     • 在这个例子中，Person类有两个私有成员变量name和age。无参构造器public Person()在创建Person对象时被调用，它将name初始化为“未命名”，age初始化为0。例如，你可以这样创建Person对象：

       • public class Main {
             public static void main(String[] args) {
                 Person person = new Person();
                 System.out.println("姓名：" + person.name + "，年龄：" + person.age);
             }
         }
         

       • 输出结果为：“姓名：未命名，年龄：0”。

3. 有参构造器示例

   • （1）基本使用

     • 可以为Person类添加有参构造器，用于根据传入的参数初始化对象。例如：

       • class Person {
             private String name;
             private int age;
             //有参构造器
             public Person(String name, int age) {
                 this.name = name;
                 this.age = age;
             }
         }
         

     • 这里的有参构造器public Person(String name, int age)接受两个参数，一个是String类型的name，另一个是int类型的age。在构造器内部，使用this关键字来区分成员变量和参数。this.name表示对象的成员变量name，name（没有this）表示传入的参数。现在可以使用有参构造器创建Person对象：

       • public class Main {
             public static void main(String[] args) {
                 Person person = new Person("张三", 20);
                 System.out.println("姓名：" + person.name + "，年龄：" + person.age);
             }
         }
         

       • 输出结果为：“姓名：张三，年龄：20”。

   • （2）构造器的重载

     • 在一个类中可以有多个构造器，只要它们的参数列表不同（参数个数、参数类型或者参数顺序不同），这就是构造器的重载。例如，为Person类添加另一个有参构造器：

       • class Person {
             private String name;
             private int age;
             //有参构造器1
             public Person(String name, int age) {
                 this.name = name;
                 this.age = age;
             }
             //有参构造器2
             public Person(String name) {
                 this.name = name;
                 this.age = 18;
             }
         }
         

     • 第二个有参构造器public Person(String name)只接受一个String类型的参数name，并将age默认设置为18。这样就可以根据不同的需求选择不同的构造器来创建对象：

       • public class Main {
             public static void main(String[] args) {
                 Person person1 = new Person("李四", 22);
                 System.out.println("姓名：" + person1.name + "，年龄：" + person1.age);
                 Person person2 = new Person("王五");
                 System.out.println("姓名：" + person2.name + "，年龄：" + person2.age);
             }
         }
         

       • 输出结果为：“姓名：李四，年龄：22”和“姓名：王五，年龄：18”。

4. 默认构造器

   • 如果一个类没有显式地定义构造器，Java编译器会自动为这个类生成一个默认构造器。这个默认构造器是无参的，并且它会将对象的成员变量初始化为默认值（例如，对于基本数据类型，int类型初始化为0，boolean类型初始化为false等；对于引用数据类型，初始化为null）。例如：

     • class Book {
           private String title;
           private int pageCount;
       }
       

     • 虽然这里没有定义构造器，但Java编译器会自动生成一个默认构造器。可以像这样使用：

       • public class Main {
             public static void main(String[] args) {
                 Book book = new Book();
                 System.out.println("书名：" + book.title + "，页数：" + book.pageCount);
             }
         }
         

         • 输出结果为：“书名：null，页数：0”。不过，一旦你在类中显式地定义了任何一个构造器，Java编译器就不会再为你自动生成默认构造器。