类简介：编写自己的类、构造函数

你好！今天我们来谈谈Java中的类。 类可以说是Java编程的核心。当您成为一名程序员时，您的主要任务将是编写自己的具有不同功能的类。 让我们弄清楚这个东西是什么以及它是如何工作的:) 正如您所知，Java 是一种面向对象的编程语言。所有程序都由以某种方式相互连接的对象组成。类本质上是对象的模板。它决定了一个物体的外观和功能。每个对象都是某个类的对象。让我们看一个最简单的例子：

public class Cat {

    String name;
    int age;

}

假设我们正在编写一个程序，在这个程序中我们需要猫来做某事（例如，我们有一个能够在线预约的兽医诊所）。我们创建了一个类Cat并为其指定了两个变量 - 一个字符串name和一个数字age。这样的类变量称为字段。本质上，这是我们将来创建的所有猫的模板。每只猫（类对象Cat）都有两个变量 - 名字和年龄。

public class Cat {

    String name;
    int age;

    public static void main(String[] args) {
        Cat barsik = new Cat();
        barsik.age = 3;
        barsik.name = "Barsik";

        System.out.println("We created a cat named" + barsik.name + ", his age - " + barsik.age);
    }

}

就是这样运作的！我们创建了一只猫，给它起了名字和年龄，并将其全部输出到控制台。没什么复杂的:) 类通常描述周围世界的对象和现象。一只猫、一张桌子、一个人、闪电、书页、轮子——所有这些都将在您的程序中使用单独的类创建。现在让我们看一下我们在类中创建的变量Cat。这些称为字段或实例变量。事实上，这个名字揭示了它们的全部本质。类的每个实例（对象）都会有这些变量Cat。我们创建的每只猫都有自己的变量name和自己的age。一般来说，这是合乎逻辑的：对于真正的猫来说，一切都是一样的:)除了实例变量之外，还有其他变量 - 类变量或静态变量。让我们添加到我们的示例中：

public class Cat {

    String name;
    int age;

    static int count = 0;

    public static void main(String[] args) {
        Cat barsik = new Cat();
        barsik.age = 3;
        barsik.name = "Barsik";
        count++;

        Cat vasia = new Cat();
        vasia.age = 5;
        vasia.name = "Vasya";
        count++;

        System.out.println("We created a cat named" + barsik.name + ", his age - " + barsik.age);
        System.out.println("We created a cat named" + vasia.name + ", his age - " + vasia.age);

        System.out.println("Total number of cats = " + count);
    }
}

控制台输出：

Мы создали кота по имени Барсик, его возраст - 3
Мы создали кота по имени Вася, его возраст - 5
Общее количество котов = 2

现在我们的类中有一个新变量 - count（数量）。她负责计算所创造的猫。每次我们在 main 方法中创建一只猫时，我们都会将该变量加 1。该变量由static关键字指定。这意味着它属于该类，而不属于该类的特定对象。当然，这是合乎逻辑的：如果每只猫都应该有自己的名字，那么我们就需要一个适合所有猫的计数器。这正是静态这个词可以让你实现的目标——count所有猫都有相同的变量。请注意：当我们将其打印到控制台时，我们不写barsik.count或vasia.count。她既不属于Barsik，也不属于Vasya——她属于整个班级Cat。所以，很简单count。你也可以写Cat.count——这也是正确的。name这不适用于 将变量输出到控制台：

public class Cat {

    String name;
    int age;

    static int count = 0;

    public static void main(String[] args) {
        Cat barsik = new Cat();
        barsik.age = 3;
        barsik.name = "Barsik";
        count++;

        System.out.println("We created a cat named" + name + ", his age - " + barsik.age);

        System.out.println("Total number of cats = " + count);
    }
}

错误！name每只猫都有自己的。这就是编译器感到困惑的地方。"将名字输出到控制台？是谁的名字？:/"

方法

除了变量之外，每个类还有方法。我们将在单独的讲座中更详细地讨论它们，但一般要点非常简单。 方法是类的功能；这个类的对象可以做什么。您已经熟悉其中一种方法 - 这就是main(). 但正如您所记得的，该方法main是静态的 - 也就是说，它属于整个类（逻辑与变量相同）。普通的非静态方法只能在我们创建的特定对象上调用。例如，如果我们想为一只猫编写一个类，我们需要了解猫在我们的程序中应该具有哪些功能。基于此，我们为它写几个方法：

public class Cat {

    String name;
    int age;

    public void sayMeow() {
        System.out.println("Meow!");
    }

    public void jump() {
        System.out.println("Jumping gallop!");
    }

    public static void main(String[] args) {
        Cat barsik = new Cat();
        barsik.age = 3;
        barsik.name = "Barsik";

        barsik.sayMeow();
        barsik.jump();

    }
}

好吧，现在我们的课更像是对一只真正的猫的描述了！现在我们不仅有一只叫 Barsik 的猫，它有名字和年龄。他还会喵喵叫和跳跃！没有这种“功能”的猫是什么样的:)我们采用一个特定的对象 - barsik，并调用它的方法sayMeow()和jump()。我们看一下控制台：

Мяу!
Прыг-скок!

一只真正的猫！:)

创建您自己的课程。抽象

将来你将不得不编写自己的类。写的时候要注意什么？如果我们谈论变量，您需要使用称为抽象的东西。 抽象是面向对象编程的四个基本原则之一。它涉及突出对象的主要、最重要的特征，反之亦然——丢弃次要的、无关紧要的特征。例如，我们正在创建公司员工的档案。为了创建员工对象，我们编写了一个类Employee。在公司档案中描述员工的哪些特征很重要？全名、出生日期、社会安全号码、纳税识别号码。但我们不太可能在公司员工卡上需要他的身高、眼睛和头发颜色。该公司不需要这些信息。因此，对于类，Employee我们将设置变量String name、int age、int socialInsuranceNumber和int taxNumber，并且我们将放弃对我们来说不必要的信息（例如眼睛颜色）并将其抽象出来。但如果我们为模特经纪公司创建照片模特文件，情况就会发生巨大变化。为了描述一个时装模特，身高、眼睛颜色和头发颜色对我们来说非常重要，但 TIN 号码对我们来说绝对不重要。因此，在类中Model我们需要创建变量int height, String hair, String eyes。这就是抽象的工作原理，很简单！:)

构造函数

让我们回到猫的例子。

public class Cat {

    String name;
    int age;

    public static void main(String[] args) {
        Cat barsik = new Cat();

        System.out.println("Something has been happening in the program for 2 hours...");

        barsik.age = 3;
        barsik.name = "Barsik";

    }
}

查看这段代码并尝试猜测我们的程序出了什么问题。在我们的节目中的两个小时里，有一只没有名字或年龄的猫！当然，这是完全错误的。兽医诊所的数据库中不应该有没有猫信息的猫。现在我们把它留给程序员。如果他没有忘记注明自己的名字和年龄，一切都会好起来的。如果他忘记了，数据库中就会出现错误，未知的猫。我们该如何解决这个问题呢？有必要以某种方式禁止创造没有名字和年龄的猫。这就是构造函数为我们提供帮助的地方。这是一个例子：

public class Cat {

    String name;
    int age;

    //constructor for class Cat
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat barsik = new Cat("Barsik", 5);
    }
}

构造函数本质上是类对象的模板。在本例中，我们指定必须为每个对象cat指定两个参数 - 字符串和数字。如果我们现在尝试创造一只无名的猫，我们将不会成功。

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

既然类已经有了构造函数，Java 编译器就知道对象应该是什么样子，并且不允许在没有指定参数的情况下创建对象。现在让我们看看this在构造函数中看到的关键字。对他来说一切都很简单。“this”在英语中的意思是“这个，这个”。也就是说，这个词表示一个特定的对象。构造函数中的代码

public Cat(String name, int age) {
    this.name = name;
    this.age = age;
}

几乎可以按字面翻译：“这只猫的名称（我们正在创建）=在构造函数中指定的名称参数。这只猫的年龄（我们正在创建）=在构造函数中指定的年龄参数。” 构造函数触发后，您可以检查我们的猫是否已分配了所有必需的值：

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("Barsik", 5);
        System.out.println(barsik.name);
        System.out.println(barsik.age);
    }
}

控制台输出：

Барсик
5

当构造函数完成时：

Cat barsik = new Cat("Barsik", 5);

里面实际发生了以下事情：

this.name = "Barsik";
this.age = 5;

并且该对象barsik（它是this）从构造函数参数中分配了值。事实上，如果你没有在类中指定构造函数，它仍然会触发构造函数！但这怎么可能呢？O_O 事实上，在 Java 中，所有类都有一个所谓的默认构造函数。它没有任何参数，但每次创建任何类的任何对象时都会触发它。

public class Cat {

    public static void main(String[] args) {

        Cat barsik = new Cat(); //this is where the default constructor worked
    }
}

乍一看这并不明显。好了，我们创建了一个对象并创建了它，设计师的工作在哪里呢？为了看到这一点，让我们Cat亲手为该类编写一个空的构造函数，并在其中向控制台输出一些短语。如果显示出来，那么构造函数已经工作了。

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

我们无法创建没有名字和年龄的猫，因为我们定义了一个构造函数Cat：字符串+数字。此后，默认构造函数立即从类中消失。因此，一定要记住：如果你的类中需要多个构造函数，包括一个空的构造函数，那么你需要单独创建它。例如，我们的兽医诊所想要做好事，帮助无家可归的猫，但我们不知道它们的名字和年龄。那么我们的代码应该是这样的：

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;

    static int count = 0;

    public Cat() {
        count++;
        this.name = "Street cat number" + count;
    }

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat streetCat1 = new Cat();
        Cat streetCat2 = new Cat();
        System.out.println(streetCat1.name);
        System.out.println(streetCat2.name);
    }
}

我们有一个变量count是街头猫计数器。每次运行默认构造函数时，我们都会将其加 1 并将该数字指定为猫的名字。 对于构造函数来说，参数的顺序非常重要。 让我们在构造函数中交换名称和年龄参数。

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

错误！构造函数清楚地描述了：创建对象时，Cat必须按顺序传递一个数字和一个字符串。这就是为什么我们的代码不起作用。请务必记住这一点，并在创建自己的类时牢记这一点：

public Cat(String name, int age) {
    this.name = name;
    this.age = age;
}

public Cat(int age, String name) {
    this.age = age;
    this.name = name;
}

这是两个完全不同的设计师！ 现在解决几个问题来巩固材料:)

• 古物博物馆。

你的任务是设计类Artifact。博物馆内收藏的文物分为三种类型。第一个是除了博物馆分配的序列号（例如：212121）之外一无所知。第二个是已知序列号和创建它的文化（例如：212121、“阿兹特克人”）。第三种类型是已知序列号、创建它的文化以及创建它的确切年龄（例如：212121，“Aztecs”，12）。创建一个类Artifact来描述博物馆中存储的古物，并为其编写所需数量的构造函数。在该方法中main()，为每种类型创建一个工件。

public class Artifact {

    public static void main(String[] args) {
    }
}

• 会议网站

您正在为约会网站创建用户数据库。但问题是你忘记了它们需要按什么顺序指定，而且你手头也没有技术规范。设计一个User包含字段的类 - 姓名 ( String)、年龄 ( short) 和身高 ( int)。为其创建所需数量的构造函数，以便可以按任意顺序指定名称、年龄和身高。

public class User {

    String name;
    short age;
    int height;

    public static void main(String[] args) {

    }
}