类

概念

Java中的类是面向对象编程的基本构建块，它是一种抽象数据类型，用于描述具有相同属性和行为的对象集合。类由字段（属性）和方法（行为）组成，可以用来创建对象（实例化）以及定义对象的行为和状态。通过封装、继承和多态等特性，类提供了一种结构化的方式来组织和管理代码，使得代码更易于理解、扩展和维护。

定义类

 public class Animal {
     private String name;
     private int age;
 ​
     public Animal(String name, int age) {
         this.name = name;
         this.age = age;
     }
 ​
     public void makeSound() {
         // 此处留空，等待具体动物的实现
     }
 ​
     // Getters and setters
     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;
     }
 }

在这个Java示例中，我们定义了一个名为Animal的类。类中有两个私有属性name和age，用于表示动物的名称和年龄。

构造函数Animal(String name, int age)用于初始化动物对象的名称和年龄。

方法makeSound()目前为空，它将用于之后根据具体动物来实现发出声音的行为。

我们还提供了一系列getter和setter方法来访问和修改动物的属性。

现在，我们可以使用这个类来创建不同的动物对象，比如：

 // 创建一个名为"狗狗"，年龄为3岁的动物对象
 Animal dog = new Animal("狗狗", 3);
 ​
 // 创建一个名为"猫咪"，年龄为5岁的动物对象
 Animal cat = new Animal("猫咪", 5);

这样，我们就创建了两个动物对象，一个是狗狗，一个是猫咪，它们都有自己的名称和年龄属性。

成员变量

Java中的成员变量是指定义在类中的变量，它们用于描述类的属性或状态。成员变量可以是基本数据类型（如int、double、boolean等），也可以是引用类型（如对象、数组等）。

Java的成员变量有以下特点：

  1. 作用域：成员变量的作用域是整个类，可以在类的任何方法中使用。这使得成员变量在类中的所有方法中都可以共享和访问。

  2. 默认值：如果没有显式地对成员变量进行初始化，Java会为其赋予默认值。例如，int类型的默认值是0，boolean类型的默认值是false，对象引用类型的默认值是null。

  3. 访问修饰符：成员变量可以使用不同的访问修饰符来控制其访问权限，包括public、private、protected以及默认（即不指定访问修饰符）。

  4. 静态变量：使用static关键字声明的成员变量是静态变量，它们属于类而不是对象。静态变量在类加载时被初始化，并且只有一份副本，所有该类的对象共享同一份静态变量。

  5. 实例变量：没有使用static关键字声明的成员变量是实例变量，它们属于类的每个对象，每个对象都有自己的一份实例变量副本。

  6. 可见性：私有成员变量只能在声明它们的类内部访问，公有成员变量可以在任何地方访问。

通过声明和使用成员变量，Java类能够描述对象的属性，并且可以在类的各个方法中共享和操作这些属性。

成员变量是Java类中声明的变量，它们用于描述类的特征或属性。比如，考虑一个简单的Java类 Person：

 public class Person {
     // 成员变量
     String name;
     int age;
     double height;
     
     // 构造方法
     public Person(String name, int age, double height) {
         this.name = name;
         this.age = age;
         this.height = height;
     }
     
     // 方法
     public void displayInfo() {
         System.out.println("Name: " + name);
         System.out.println("Age: " + age);
         System.out.println("Height: " + height);
     }
     
     // 主方法
     public static void main(String[] args) {
         // 创建一个Person对象
         Person person1 = new Person("Alice", 25, 1.75);
         // 调用方法显示信息
         person1.displayInfo();
     }
 }

在这个例子中，Person 类有三个成员变量：name、age 和 height，它们分别表示人的姓名、年龄和身高。在构造方法 Person() 中，这些成员变量被初始化。在 displayInfo() 方法中，我们使用这些成员变量来展示一个人的信息。在 main() 方法中，我们创建了一个 Person 对象，并调用了 displayInfo() 方法来显示这个人的信息。

成员方法

在Java中，成员方法是类中定义的函数，用于执行特定的操作或返回特定的数值。这些方法被称为“成员”方法，因为它们属于类的实例，可以通过类的对象来调用。

以下是关于Java成员方法的一些重要特点：

  1. 定义位置：成员方法被定义在类的内部。它们在类的大括号 {} 中声明，并且可以包含在类的任何部分中。

  2. 访问修饰符：成员方法可以使用不同的访问修饰符来控制对它们的访问权限，如public、private、protected和默认访问修饰符（当方法没有显式声明修饰符时使用）。

  3. 方法签名：方法的签名由方法的名称和参数列表组成。参数列表指定方法接受的输入。如果两个方法具有相同的名称但参数列表不同，那么它们被认为是不同的方法，这称为方法的重载。

  4. 返回类型：成员方法可以返回一个值，也可以是void，表示它不返回任何值。如果方法返回一个值，那么返回值的类型必须与方法声明中的返回类型匹配。

  5. 方法调用：要调用一个成员方法，需要使用点符号（.）将方法名连接到对象实例上。例如，如果有一个名为myObject的对象，并且该对象有一个名为myMethod的方法，则可以通过myObject.myMethod()来调用它。

  6. this关键字：在成员方法中，this关键字可以用来引用当前对象的引用。这在需要明确指定当前对象时非常有用，特别是在方法参数与对象属性具有相同名称时。

例如，以下是一个简单的Java类，其中包含一个成员方法：

 public class MyClass {
     private int value;
 ​
     // 成员方法，用于设置值
     public void setValue(int newValue) {
         this.value = newValue;
     }
 ​
     // 成员方法，用于获取值
     public int getValue() {
         return this.value;
     }
 }

在这个类中，setValue方法用于设置value属性的值，而getValue方法用于获取value属性的值。这两个方法都是成员方法，因为它们属于MyClass类的实例。

私有成员

当我们说到私有成员时，我们通常指的是类中被声明为私有的成员变量和方法。这意味着这些成员只能在声明它们的类内部被访问，而无法在外部类或对象中直接访问。这种访问限制有助于维护类的封装性，提高代码的安全性和可维护性。

私有成员变量示例：

 public class Person {
     private String name; // 私有成员变量
 ​
     // 构造方法
     public Person(String name) {
         this.name = name;
     }
 ​
     // 公有方法用于设置姓名
     public void setName(String name) {
         this.name = name;
     }
 ​
     // 公有方法用于获取姓名
     public String getName() {
         return name;
     }
 }

在这个例子中，name 被声明为私有成员变量，因此外部类无法直接访问它。但是，我们提供了公有的 setName 和 getName 方法来允许外部类间接地访问和修改 name 的值。

私有成员方法示例：

 public class Calculator {
     private int add(int a, int b) { // 私有成员方法
         return a + b;
     }
 ​
     public int performAddition(int x, int y) {
         // 外部类调用私有成员方法
         return add(x, y);
     }
 }

在这个例子中，add 方法被声明为私有成员方法，因此无法在外部类中直接调用它。但是，我们在 Calculator 类中提供了 performAddition 方法，通过它来间接地调用 add 方法来执行加法操作。

这些例子展示了私有成员在Java中的使用，它们帮助我们隐藏类的内部实现细节，只暴露必要的接口给外部使用，从而提高了代码的安全性和可维护性。

公有成员

在Java中，公有成员是指被声明为public访问修饰符的类成员，可以被任何其他类访问。这意味着公有成员可以在不同的类中被直接访问和使用，而不需要通过继承或其他方式。公有成员对于构建模块化和可重用的代码非常重要，因为它们允许其他类与其交互而不暴露内部实现细节。

举个例子，假设我们有一个名为Person的类，其中包含了一个公有成员变量name和一个公有成员方法sayHello()。下面是一个简单的Java代码示例：

 public class Person {
     public String name;
 ​
     public Person(String name) {
         this.name = name;
     }
 ​
     public void sayHello() {
         System.out.println("Hello, my name is " + name + "!");
     }
 }

在这个例子中，name是一个公有成员变量，它可以被其他类直接访问。同样，sayHello()方法也是一个公有成员方法，其他类可以通过创建Person对象并调用该方法来与Person类交互。例如：

 public class Main {
     public static void main(String[] args) {
         Person person1 = new Person("Alice");
         Person person2 = new Person("Bob");
 ​
         System.out.println("Person 1's name: " + person1.name);
         person2.sayHello();
     }
 }

在这个示例中，我们创建了两个Person对象，分别设置了它们的name属性，并通过调用sayHello()方法来展示公有成员方法的使用。

重载

在Java中，方法的重载是指在同一个类中可以有多个方法，它们具有相同的名称但参数列表不同的特性。这些不同的参数可以是参数的数量、类型或顺序。

举个例子，假设有一个类叫做Calculator，它包含了两个名为add的方法：

 public class Calculator {
     // 第一个add方法，接受两个整数参数
     public int add(int a, int b) {
         return a + b;
     }
 ​
     // 第二个add方法，接受三个整数参数
     public int add(int a, int b, int c) {
         return a + b + c;
     }
 }

这里的两个add方法就展示了方法重载的概念。虽然它们都叫做add，但是它们的参数列表不同。第一个add方法接受两个整数参数，而第二个add方法接受三个整数参数。当你调用add方法时，Java会根据你提供的参数数量和类型来决定调用哪个版本的add方法。

方法重载使得代码更具灵活性和可读性，因为它允许我们使用相同的方法名来完成不同的操作，只要参数列表不同即可。

对象

概念

在Java中，对象是指程序中的实体，它可以代表现实世界中的任何东西，如人、车、动物等。对象是类的实例化，类是定义对象的模板或蓝图。每个对象都有其自身的属性（也称为状态或字段）和行为（也称为方法或函数）。

举个例子，假设有一个类叫做"Car"（汽车），它描述了汽车的属性和行为。在程序中创建一个具体的汽车对象时，该对象就具有了Car类定义的属性和行为。汽车对象的属性可能包括颜色、品牌、型号等，而行为则可能包括启动、加速、刹车等操作。

Java中的对象具有以下特点：

  1. 封装性（Encapsulation）：对象封装了其状态和行为，可以隐藏内部实现细节，只暴露必要的接口给外部使用。

  2. 继承性（Inheritance）：一个类可以从另一个类继承属性和行为，这样可以重用代码并构建层次结构。

  3. 多态性（Polymorphism）：允许使用统一的接口来操作不同类型的对象，提高了灵活性和可扩展性。

通过使用对象，Java程序可以更好地模拟现实世界中的情景，并实现复杂的功能。

创建对象

当在Java中创建对象时，你通常会使用关键字 new 加上构造函数来实现。构造函数是一个特殊的方法，用于初始化对象的实例变量。这里有一个简单的例子：

 public class Car {
     // 实例变量
     String brand;
     String model;
     int year;
 ​
     // 构造函数
     public Car(String brand, String model, int year) {
         this.brand = brand;
         this.model = model;
         this.year = year;
     }
 ​
     public static void main(String[] args) {
         // 使用 new 关键字创建 Car 对象，并传入参数调用构造函数
         Car myCar = new Car("Toyota", "Corolla", 2020);
 ​
         // 访问对象的属性并打印输出
         System.out.println("My car is a " + myCar.year + " " + myCar.brand + " " + myCar.model + ".");
     }
 }

在这个例子中，我们定义了一个 Car 类，其中包含了品牌、型号和生产年份等实例变量。通过定义 public Car(String brand, String model, int year) 构造函数，我们可以在创建对象时传入这些参数，并通过 new Car("Toyota", "Corolla", 2020) 来实例化一个 Car 对象。然后我们可以通过访问对象的属性来获取和操作对象的状态信息。

构造方法

构造方法是在创建对象时调用的特殊方法，用于初始化对象的状态。在Java中，构造方法的名称必须与类名相同，但没有返回类型，甚至不返回void。它们通常用于执行对象的初始化任务，例如设置对象的初始状态或分配资源。

构造方法在以下情况下被调用：

  1. 当使用new关键字创建对象时。

  2. 在创建对象数组时。

构造方法可以被重载，这意味着同一个类可以有多个构造方法，只要它们的参数列表不同即可。

这是一个简单的Java类和构造方法的例子：

 public class Car {
     // 定义类的成员变量
     String brand;
     String color;
     int year;
 ​
     // 构造方法，用于初始化Car对象的状态
     public Car(String brand, String color, int year) {
         this.brand = brand;
         this.color = color;
         this.year = year;
     }
 ​
     // 另一个构造方法，重载了上面的构造方法
     public Car(String brand) {
         this.brand = brand;
         this.color = "Unknown";
         this.year = 0;
     }
 ​
     // 方法用于打印Car对象的信息
     public void displayInfo() {
         System.out.println("Brand: " + brand + ", Color: " + color + ", Year: " + year);
     }
 ​
     // 主方法用于演示如何使用构造方法创建对象
     public static void main(String[] args) {
         // 使用构造方法创建Car对象
         Car myCar1 = new Car("Toyota", "Red", 2022);
         Car myCar2 = new Car("Honda");
 ​
         // 调用对象的方法显示信息
         myCar1.displayInfo();
         myCar2.displayInfo();
     }
 }

在这个例子中，我们定义了一个Car类，它有两个构造方法：一个接受品牌、颜色和年份参数，另一个只接受品牌参数。我们在main方法中使用这些构造方法创建了两个Car对象，并调用了displayInfo方法来显示每个对象的信息。

构造方法的重载

当你在Java中创建一个类时，你可以定义一个或多个构造方法。构造方法是一种特殊的方法，用于在创建类的新实例时初始化对象。构造方法的重载是指在同一个类中定义多个构造方法，它们具有相同的名称但是参数列表不同。

让我们以一个简单的例子来说明Java构造方法的重载。假设我们有一个名为Car的类，我们想为其定义不同类型的构造方法。

 public class Car {
     private String brand;
     private String model;
     private int year;
 ​
     // 构造方法1：无参构造方法
     public Car() {
         brand = "Unknown";
         model = "Unknown";
         year = 0;
     }
 ​
     // 构造方法2：接受品牌参数的构造方法
     public Car(String brand) {
         this.brand = brand;
         model = "Unknown";
         year = 0;
     }
 ​
     // 构造方法3：接受品牌、型号和年份参数的构造方法
     public Car(String brand, String model, int year) {
         this.brand = brand;
         this.model = model;
         this.year = year;
     }
 ​
     // 其他类成员和方法...
 }

在这个示例中，我们定义了三个构造方法，它们实现了构造方法的重载。

  1. 第一个构造方法是无参构造方法，它会将brand、model和year初始化为默认值。

  2. 第二个构造方法接受一个brand参数，并将brand设置为指定值，同时将model和year初始化为默认值。

  3. 第三个构造方法接受brand、model和year三个参数，并分别将它们设置为指定的值。

通过这种方式，我们可以根据不同的需求来选择使用合适的构造方法来创建Car类的实例。

公有构造方法以及私有构造方法

在Java中，构造方法是用来创建对象的特殊类型的方法。公有构造方法（Public Constructor）和私有构造方法（Private Constructor）是两种常见的构造方法类型。

  1. 公有构造方法：

    • 公有构造方法是通过关键字 public 声明的构造方法。

    • 公有构造方法可以被任何类访问和调用，包括类的外部。

    • 当我们希望外部代码能够直接创建类的对象时，就会使用公有构造方法。

    • 公有构造方法通常用于提供对象的初始化功能，并且可以在实例化对象时传入参数来初始化对象的状态。

 public class MyClass {
     // 公有构造方法
     public MyClass() {
         // 构造方法体
     }
 }

  1. 私有构造方法：

    • 私有构造方法是通过关键字 private 声明的构造方法。

    • 私有构造方法只能在同一个类中被调用，外部类无法直接访问私有构造方法。

    • 私有构造方法通常用于控制对象的创建方式，限制外部代码对对象的创建。

    • 私有构造方法通常与静态工厂方法一起使用，以实现单例模式、工厂模式等设计模式。

 public class MyClass {
     // 私有构造方法
     private MyClass() {
         // 构造方法体
     }
 ​
     // 静态工厂方法
     public static MyClass createInstance() {
         return new MyClass();
     }
 }

通过以上例子，你可以看到公有构造方法和私有构造方法的区别，以及它们在Java中的用途。