你好！今天我们将讨论一个与我们的对象有关的非常重要的主题。在这里，我们可以毫不夸张地说，你每天都会在实际工作中运用到这些知识！我们将讨论构造函数。您可能是第一次听到这个术语，但实际上您可能使用过构造函数，只是您自己没有注意到:) 我们稍后会看到这一点。
![Java-университет]()
控制台输出：
![为什么需要构造函数？ - 2]()
你还记得在讲座开始时我们说过你已经使用过构造函数，但你只是没有注意到它吗？这是真实的。事实上，Java 中的每个类都有一个所谓的默认构造函数。它没有任何参数，但每次创建任何类的任何对象时都会触发它。
Java 中的构造函数是什么以及为什么需要它？
让我们看两个例子。public class Car {
String model;
int maxSpeed;
public static void main(String[] args) {
Car bugatti = new Car();
bugatti.model = "Bugatti Veyron";
bugatti.maxSpeed = 407;
}
}public class Car {
String model;//model
int maxSpeed;//max speed
int wheels;// disk width
double engineVolume;//engine capacity
String color;//color
int yearOfIssue;//year of issue
String ownerFirstName;//Owner's name
String ownerLastName;//owner's last name
long price;//price
boolean isNew;//new or not
int placesInTheSalon;//number of seats in the cabin
String salonMaterial;// interior material
boolean insurance;//is it insured
String manufacturerCountry;//manufacturer country
int trunkVolume;// trunk volume
int accelerationTo100km;//acceleration to 100 km/h in seconds
public static void main(String[] args) {
Car bugatti = new Car();
bugatti.color = "blue";
bugatti.accelerationTo100km = 3;
bugatti.engineVolume = 6.3;
bugatti.manufacturerCountry = "Italy";
bugatti.ownerFirstName = "Amigo";
bugatti.yearOfIssue = 2016;
bugatti.insurance = true;
bugatti.price = 2000000;
bugatti.isNew = false;
bugatti.placesInTheSalon = 2;
bugatti.maxSpeed = 407;
bugatti.model = "Bugatti Veyron";
}
}public class Car {
String model;//model
int maxSpeed;//max speed
int wheels;// disk width
double engineVolume;//engine capacity
String color;//color
int yearOfIssue;//year of issue
String ownerFirstName;//Owner's name
String ownerLastName;//owner's last name
long price;//price
boolean isNew;//new or not
int placesInTheSalon;//number of seats in the cabin
String salonMaterial;// interior material
boolean insurance;//is it insured
String manufacturerCountry;//manufacturer country
int trunkVolume;// trunk volume
int accelerationTo100km;//acceleration to 100 km/h in seconds
public static void main(String[] args) {
Car bugatti = new Car();
bugatti.color = "blue";
bugatti.accelerationTo100km = 3;
bugatti.engineVolume = 6.3;
bugatti.manufacturerCountry = "Italy";
bugatti.ownerFirstName = "Amigo";
bugatti.yearOfIssue = 2016;
bugatti.insurance = true;
bugatti.price = 2000000;
bugatti.isNew = false;
bugatti.placesInTheSalon = 2;
bugatti.maxSpeed = 407;
bugatti.model = "Bugatti Veyron";
System.out.println("Model Bugatti Veyron. Engine size - " + bugatti.engineVolume + ", trunk - " + bugatti.trunkVolume + ", salon is made of" + bugatti.salonMaterial +
", disc width - " + bugatti.wheels + ". Was acquired in 2018 by Mr. " + bugatti.ownerLastName);
}
}
布加迪威龙模型。发动机排量 - 6.3，后备箱 - 0，内饰由 null 制成，轮圈宽度 - 0。由 null 先生于 2018 年购买
你的买家花了 200 万美元买了一辆车，显然不喜欢被称为“空先生”！但说真的，最后我们的程序最终得到了一个错误创建的对象 - 一辆轮辋宽度为 0（即根本没有轮辋）的汽车，一个丢失的行李箱，由未知材料制成的内饰，甚至属于未知的人。可以想象，在程序运行时怎么会出现这样的错误！我们需要以某种方式避免这种情况。我们需要我们的程序有一个限制：例如，当创建一个新的车辆对象时，必须始终为其指定模型和最大速度。否则，不允许创建对象。构造函数可以轻松应对这项任务。他们的名字是有原因的。构造函数创建类的一种“骨架”，类的每个新对象都必须与其相对应。为了方便起见，让我们回到具有两个字段的Car类的简单版本。根据我们的要求， Car类的构造函数将如下所示：
public Car(String model, int maxSpeed) {
this.model = model;
this.maxSpeed = maxSpeed;
}public static void main(String[] args) {
Car bugatti = new Car("Bugatti Veyron", 407);
}public Car(String model, int maxSpeed) {
this.model = model;
this.maxSpeed = maxSpeed;
}public class Car {
String model;
int maxSpeed;
public Car(String model, int maxSpeed) {
this.model = model;
this.maxSpeed = maxSpeed;
}
public static void main(String[] args) {
Car bugatti = new Car("Bugatti Veyron", 407);
System.out.println(bugatti.model);
System.out.println(bugatti.maxSpeed);
}
}
布加迪威龙 407
构造函数成功分配了所需的值。您可能已经注意到构造函数与常规方法非常相似！就是这样：构造函数是一个方法，只是有点具体:) 就像在方法中一样，我们将参数传递给构造函数。就像调用方法一样，如果不指定构造函数，调用构造函数将不起作用：
public class Car {
String model;
int maxSpeed;
public Car(String model, int maxSpeed) {
this.model = model;
this.maxSpeed = maxSpeed;
}
public static void main(String[] args) {
Car bugatti = new Car(); //error!
}
}public class Cat {
String name;
int age;
//for the first cat
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
//for the second cat
public Cat(String name) {
this.name = name;
}
public static void main(String[] args) {
Cat barsik = new Cat("Barsik", 5);
Cat streetCatNamedBob = new Cat("Bob");
}
}
你还记得在讲座开始时我们说过你已经使用过构造函数，但你只是没有注意到它吗？这是真实的。事实上，Java 中的每个类都有一个所谓的默认构造函数。它没有任何参数，但每次创建任何类的任何对象时都会触发它。
public class Cat {
public static void main(String[] args) {
Cat barsik = new Cat(); //this is where the default constructor worked
}
}public class Cat {
public Cat() {
System.out.println("Created a cat!");
}
public static void main(String[] args) {
Cat barsik = new Cat(); //this is where the default constructor worked
}
}
他们创造了一只猫！
这是确认！默认构造函数始终不可见地存在于您的类中。但您还需要了解它的另一项功能。当您创建带有参数的构造函数时，默认构造函数将从类中消失。这一点的证明，其实我们在上面已经看到了。在此代码中：
public class Cat {
String name;
int age;
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat barsik = new Cat(); //error!
}
}public class Cat {
String name;
int age;
//for domestic cats
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
//for street cats
public Cat() {
}
public static void main(String[] args) {
Cat barsik = new Cat("Barsik", 5);
Cat streetCat = new Cat();
}
}public class Cat {
String name;
int age;
public Cat(int age, String name) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat barsik = new Cat("Barsik", 10); //error!
}
}public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public Cat(int age, String name) {
this.age = age;
this.name = name;
}public class CarFactory {
String name;
int age;
int carsCount;
public CarFactory(String name, int age, int carsCount) {
this.name = name;
this.age = age;
this.carsCount = carsCount;
System.out.println("Our car factory is called" + this.name);
System.out.println("She was founded" + this.age + " years ago" );
System.out.println("During this time it was produced" + this.carsCount + "cars");
System.out.println("On average she produces" + (this.carsCount/this.age) + "cars per year");
}
public static void main(String[] args) {
CarFactory ford = new CarFactory("Ford", 115 , 50000000);
}
}
我们的汽车厂叫福特，成立已有115年了，这段时间生产了50,000,000辆汽车，平均每年生产434,782辆汽车。
但事实上，我们已经埋下了定时炸弹。而且这样的代码很容易导致错误。让我们想象一下，现在我们谈论的不是福特，而是新工厂“Amigo Motors”，该工厂成立不到一年，已生产了 1000 辆汽车：
public class CarFactory {
String name;
int age;
int carsCount;
public CarFactory(String name, int age, int carsCount) {
this.name = name;
this.age = age;
this.carsCount = carsCount;
System.out.println("Our car factory is called" + this.name);
System.out.println("She was founded" + this.age + " years ago" );
System.out.println("During this time it was produced" + this.carsCount + "cars");
System.out.println("On average she produces" + (this.carsCount/this.age) + "cars per year");
}
public static void main(String[] args) {
CarFactory ford = new CarFactory("Amigo Motors", 0 , 1000);
}
}
我们的汽车工厂名为 Amigo Motors 异常，位于线程“main” java.lang.ArithmeticException: / by Zero 它成立于 0 年前 在此期间，它在 CarFactory.<init>(CarFactory.java:15) 生产了 1000 辆汽车CarFactory.main(CarFactory.java:23) 进程完成，退出代码 1</init>
我们到了！程序因一些奇怪的错误而结束。你会试着猜猜原因是什么吗？原因是我们放置在构造函数中的逻辑。具体来说，在这一行中：
System.out.println("On average she produces" + (this.carsCount/this.age) + "cars per year");
GO TO FULL VERSION