java构造器：
构造器定义：
在 Java 中，构造器（Constructor）是一种特殊的方法，用于创建和初始化对象。
构造器的名称与类名相同，它没有返回类型（包括 void），也不需要使用 return 命令来返回值。在创建对象时，new 关键字会自动调用对应类的构造器来创建对象并执行初始化操作。
下面是一个 Java 构造器的基本语法：
class ClassName {
// 成员变量
private int num;
// 构造器
public ClassName(int num) {
this.num = num;
}
}在上面的示例中，ClassName 类有一个私有成员变量 num，并定义了一个构造器 ClassName(int num)，它接受一个整数参数，并在对象创建时将其赋值给成员变量 num。
需要注意以下几点：
- 构造器的名称必须与类名相同，包括大小写。
- 构造器没有返回类型，不需要使用
void关键字。 - 构造器可以有多个重载版本，只要它们的签名（即参数类型、参数数量、参数顺序）不同即可。
- 构造器可以使用
this()关键字调用其他构造器，也可以与成员变量进行初始化。 - 如果没有定义任何构造器，则编译器会默认生成一个无参构造器，它什么也不做。
如果一个类需要进行特殊处理的初始化操作，就需要定义相应的构造器来完成这些操作。
在调用构造器创建对象时，如果传入了与任何一个构造器的签名都不匹配的参数，就会导致编译错误。需要注意，如果子类继承了父类的构造器，则子类必须显式调用父类的构造器，或者通过 super() 方法调用，否则会导致编译错误。
构造器可以有多个重载版本：
当构造器的签名（参数类型、参数数量、参数顺序）不同时，可以定义多个重载版本的构造器。下面是一个示例代码
public class MyClass {
private int x;
private int y;
// 构造器1：无参构造器
public MyClass() {
this.x = 0;
this.y = 0;
}
// 构造器2：接受一个参数的构造器
public MyClass(int x) {
this.x = x;
this.y = 0;
}
// 构造器3：接受两个参数的构造器
public MyClass(int x, int y) {
this.x = x;
this.y = y;
}
// 其他方法...
}在上面的示例中，MyClass 类定义了三个构造器：
- 构造器1是无参构造器，它在创建对象时不传入任何参数，将
x和y初始化为 0。 - 构造器2接受一个参数
x，将其赋值给x，并将y初始化为 0。 - 构造器3接受两个参数
x和y，分别赋值给x和y。
通过重载构造器，我们可以根据不同的情况来创建对象，提供更多的实例化选项，以满足不同的需求。
需要注意的是，当创建对象时调用构造器时，根据实际传入的参数的类型、数量、顺序来匹配对应的构造器，编译器会选择与之匹配的构造器来创建对象。
外部如何使用这多个构造器：
- 使用无参构造器：
MyClass obj1 = new MyClass();
- 使用带一个参数的构造器：
MyClass obj2 = new MyClass(10);
- 使用带两个参数的构造器：
MyClass obj3 = new MyClass(20, 30);
通过传递不同的参数，我们可以选择使用合适的构造器来创建对象，以满足不同的实例化需求。
需要注意的是，构造器的选择依赖于传递的参数类型、数量和顺序与构造器的定义是否匹配。如果没有与之匹配的构造器定义，编译器将无法找到合适的构造器并报错。所以在使用时需要确保传递的参数与构造器的定义相匹配。
私有构造器的意义：
私有构造器的主要作用是限制该类的实例化。
当一个类的构造器被声明为私有访问权限时，其他类就无法通过 new 关键字来创建该类的对象，只有该类内部的方法才能创建该类的对象。这种设计模式称为单例模式，保证了该类在整个程序中只有一个实例存在，对于全局共享的类来说，这种设计模式非常有用。
以下是一个使用私有构造器实现单例模式的示例：
public class Singleton {
// final: 表示该常量的值不能被修改，是一个常量。
private static final Singleton INSTANCE = new Singleton();
private Singleton() {
// 私有构造器
}
public static Singleton getInstance() {
return INSTANCE;
}
// 其他方法
}在这个示例中，Singleton 类使用私有构造器来限制该类的实例化，并定义一个静态常量 INSTANCE 来存储该类的唯一实例。通过静态方法 getInstance() 来获取该实例。
需要注意如下：
- 私有构造器意味着其他类无法打破默认的行为通过
new关键字创建该类的对象。 - 对象的初始化在该类内部完成，由于只有一个实例存在，因此只需要在对象初始化时做一次即可，这也保证了对象的全局唯一性。
- 该类的实例只能通过预定义的静态方法
getInstance()来获取。
因此，使用私有构造器可以有效地控制特定类型的创造性，帮助程序员实现有关可变性、可扩展性和安全性的需求。
私有构造器保证了项目所有的地方用的都是一个对象：
私有构造器确保了该类的实例化控制仅限于该类内部，其他类无法通过 new 关键字实例化该类，因此保证了该类在整个程序中只有一个实例存在。
在实际应用中，有些类需要保证只有一个实例存在，这种设计模式称为单例模式。单例模式是面向对象编程中最基本的模式之一，也是最常用的设计模式之一。通过使用私有构造器，可以将类的实例限制为一个，从而实现单例模式，确保在整个程序中只有一个实例存在，这对于全局共享的类来说非常有用。
需要注意的是，单例模式应谨慎使用。因为单例模式对整个程序的架构产生了影响，其实现可能会造成代码的耦合度过高、测试困难、对象间关系不清晰等问题，需要根据具体的场景和需求进行决策。
super的使用：
在Java中，super 是一个关键字，用于引用父类的成员，包括实例变量、方法和构造方法。它可以用于以下几个方面：
-
访问父类的实例变量和方法：
super.variable：通过super关键字可以访问父类的实例变量。super.method()：通过super关键字可以调用父类的方法。
-
在子类的构造方法中调用父类的构造方法：
- 通过
super()关键字可以在子类的构造方法中调用父类的构造方法（调用父类的无参构造方法或带参构造方法）。 - 若没有显式调用，Java编译器会默认在子类的构造方法中插入
super()，以调用父类的无参构造方法。
- 通过
下面是一个使用 super 的示例代码：
class Vehicle {
private String brand;
public Vehicle(String brand) {
this.brand = brand;
}
public void start() {
System.out.println("Vehicle starting...");
}
}
class Car extends Vehicle {
private String model;
public Car(String brand, String model) {
super(brand); // 调用父类的构造方法
this.model = model;
}
@Override
public void start() {
super.start(); // 调用父类的方法
System.out.println("Car starting...");
}
}
public class Main {
public static void main(String[] args) {
Car car = new Car("BMW", "X5");
car.start();
}
}在上述示例中，Vehicle 是父类，Car 是子类，Car 类继承了 Vehicle 类。通过使用 super 关键字，我们可以在子类的构造方法中调用父类的构造方法来初始化父类的实例变量。同时，在子类中重写父类的方法时，可以使用 super 关键字调用父类的方法，并在其基础上添加额外的逻辑。
以上是 super 关键字的基本使用方式，通过这些用法，我们可以方便地访问父类的成员和在子类中调用父类的构造方法。