JavaSE-类和对象

类和对象的概念

目录

• 类和对象的概念
  • • 类的定义
      • 写一个类要包含以下部分（类的结构）：
    • 对象的创建
      • 成员变量（属性）
      • 成员方法（函数、方法）
    • 对象的实例化
      • 构造器
      • 构造器的使用
      • 构造器重载
      • 构造器链（Constructor Chaining）
      • 私有构造器
      • 匿名对象
        • 如何识别匿名对象
      • Java中对象的销毁
    • 总结

类的定义

类是一种用户自定义的数据类型，它是创建对象的蓝图，定义了一组属性（称为“字段”）和方法（称为“函数”）。类是面向对象编程的基本构建块，它封装了数据和行为。

在 Java 中编写一个类需要遵循一定的结构和语法规则。以下是一个基本的 Java 类的结构示例以及它所包含的部分：

// 包声明，用于组织类
package com.example;

// 导入语句，用于导入其他包中的类或接口
import java.util.List;

// 类的声明，关键字 class 后跟类名
public class MyClass {
    // 类的属性（成员变量）
    private int id;
    private String name;

    // 类的构造函数
    public MyClass(int id, String name) {
        this.id = id;
        this.name = name;
    }

    // 类的方法
    public void displayInfo() {
        System.out.println("ID: " + id + ", Name: " + name);
    }

    // getter 和 setter 方法
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    // 类可以包含其他方法、内部类、枚举、注解等

    // 主方法（如果类是一个应用程序的入口）
    public static void main(String[] args) {
        // 创建 MyClass 的实例
        MyClass myObject = new MyClass(1, "Example");

        // 调用方法
        myObject.displayInfo();
    }
}

写一个类要包含以下部分（类的结构）：

1. 包声明（Package Declaration）：

   • 使用 package 关键字声明，用于组织类和接口。

2. 导入语句（Import Statements）：

   • 使用 import 关键字导入其他包中的类或接口。

3. 类声明（Class Declaration）：

   • 使用 class 关键字后跟类名。

4. 访问修饰符（Access Modifiers）：

   • 如 public, protected, private 等，定义类或类的成员的可见性。

5. 类属性（Class Fields）：

   • 定义类的成员变量，可以是任何数据类型。

6. 构造函数（Constructor）：

   • 类的构造函数用于创建类的实例。

7. 方法（Methods）：

   • 类的行为通过方法实现，可以包含业务逻辑。

8. getter 和 setter 方法（Accessors and Mutators）：

   • 提供访问和更新类属性的方式。

9. 主方法（Main Method）（如果类是应用程序的入口）：

   • 使用 public static void main(String[] args) 作为程序的入口点。

10. 文档注释（Documentation Comments）：

    • 使用 /** ... */ 为类和方法提供文档注释。

11. 代码注释（Code Comments）：

    • 使用 // 或 /* ... */ 为代码添加注释，提高代码可读性。

12. 异常处理（Exception Handling）：

    • 使用 try, catch, finally, throw, throws 等关键字进行异常处理。

13. 内部类（Inner Classes）：

    • 如果需要，类可以包含内部类定义。

14. 枚举（Enums） 和 注解（Annotations）：

    • 类内部可以定义枚举类型和使用注解。

编写类时，应确保遵循良好的编程实践，如使用有意义的命名、保持方法的单一职责、确保代码的可读性和可维护性。

对象的创建

对象是类的实例，它是类的具体化。对象具有类定义的属性（字段）和方法（函数），并且可以访问和修改这些属性。通过“new”关键字创建对象。

成员变量（属性）

成员变量是类的属性，它们可以是静态变量（静态成员变量）或非静态变量（非静态成员变量）。

/*类的定义和对象的创建*/
// 类的定义
public class MyClass {
    // 成员变量
    private int myVar;
// 构造器（无参）
public MyClass() {
    this.myVar = 0;
}

// 构造器（有参）
public MyClass(int var) {
    this.myVar = var;
}

// 成员方法
public int getMyVar() {
    return myVar;
}

public void setMyVar(int var) {
    this.myVar = var;
}
}
// 对象的创建（无参）
MyClass obj1 = new MyClass();

// 对象的创建（有参）
MyClass obj2 = new MyClass(10);

• 静态变量：静态变量属于类，而不是特定的对象。它们在类加载时创建，而不是在创建对象时创建。静态变量可以使用类名直接访问。

• 非静态变量：非静态变量属于类的实例，而不是类。它们在创建对象时创建，而不是在类加载时创建。要访问非静态变量，需要创建类的实例并使用实例名访问。

  // 类的定义
  public class MyClass {
      // 静态变量
      private static int staticVar;
  // 非静态变量
  private int nonStaticVar;
  
  // 构造器
  public MyClass(int var) {
      this.nonStaticVar = var;
  }
  
  // 静态方法（获取静态变量）
  public static int getStaticVar() {
      return staticVar;
  }
  
  // 静态方法（设置静态变量）
  public static void setStaticVar(int var) {
      staticVar = var;
  }
  
  // 非静态方法（获取非静态变量）
  public int getNonStaticVar() {
      return nonStaticVar;
  }
  
  // 非静态方法（设置非静态变量）
  public void setNonStaticVar(int var) {
      this.nonStaticVar = var;
  }
  }
  
  // 访问静态变量
  int staticVarValue = MyClass.getStaticVar();
  
  // 访问非静态变量
  MyClass obj = new MyClass(10);
  int nonStaticVarValue = obj.getNonStaticVar();
  

成员方法（函数、方法）

成员方法是类的函数，它们可以静态方法（静态成员方法）或非静态方法（非静态成员方法）。

• 静态方法：静态方法属于类，而不是特定的对象。它们可以直接使用类名调用，而不需要创建类的实例。静态方法通常用于操作静态变量或执行与对象无关的操作。

• 非静态方法：非静态方法属于类的实例，而不是类。要调用非静态方法，需要创建类的实例并使用实例名调用。非静态方法通常用于操作对象的属性和执行与对象相关的操作。

  // 类的定义
  public class MyClass {
      // 静态方法
      public static void staticMethod() {
          System.out.println("This is a static method.");
      }
  
      // 非静态方法
      public void nonStaticMethod() {
          System.out.println("This is a non-static method.");
      }
  
  }
  
  // 调用静态方法
  MyClass.staticMethod();
  
  // 创建对象
  MyClass obj = new MyClass();
  
  // 调用非静态方法
  obj.nonStaticMethod();
  

对象的实例化

构造器

构造器是一种特殊的方法，用于在创建对象时初始化对象。构造器的名称与类名相同，没有返回类型，并且通常包含对成员变量的初始化。

构造器的使用

使用“new”关键字创建对象，并在括号中传递参数（如果有）。例如：

MyClass obj = new MyClass(param1, param2);

构造器重载

构造器重载是指在同一个类中定义多个构造器，每个构造器具有不同的参数列表。这允许创建具有不同初始状态的对象。

构造器链（Constructor Chaining）

• 构造器可以通过this()调用同一类中的另一个构造器，这称为构造器链。
• this()调用必须是构造器中的第一条语句。

私有构造器

• 构造器可以是私有的（private），这意味着它不能被外部类直接访问。

• 私有构造器常用于单例模式（Singleton Pattern）或枚举类型（Enums）

• 示例

  public class Person {
      private String name;
      private int age;
  
      // 无参构造器
      public Person() {
          this.name = "Unknown";
          this.age = 0;
      }
  
      // 带参数的构造器
      public Person(String name, int age) {
          this.name = name;
          this.age = age;
      }
  
      // 构造器链
      public Person(String name) {
          this(name, 0); // 调用带两个参数的构造器
      }
  }
  

  • 构造器用于初始化对象的状态。
  • 构造器名称必须与类名相同，并且没有返回类型。
  • 可以通过构造器重载提供多种对象初始化方式。
  • 默认情况下，如果没有显式定义构造器，Java会提供一个默认无参构造器。
  • 构造器可以通过this()实现链式调用。
  • 构造器可以是私有的，用于控制对象的创建

匿名对象

匿名对象是不具有名称的对象，它们通常用于一次性使用。例如，当传递一个对象作为参数，但不需要该对象在其他地方使用时，可以使用匿名对象。例如：

someFunction(new MyClass(param1, param2));

如何识别匿名对象

要识别一个对象是否是匿名对象，可以查看代码中是否有类似以下的语法结构：

new ClassName().methodName(); //第一种方式

new ClassName().fieldName; //第二种方式

这里，ClassName是类名，methodName是方法名，fieldName是字段名。这种语法表示创建了一个ClassName的实例，并且立即调用了其上的方法或访问了其上的字段，而没有将这个实例赋给任何变量。

示例

假设有一个Person类，其中有一个方法sayHello：

public class Person {
    public void sayHello() {
        System.out.println("Hello, I am an anonymous object.");
    }
}

以下是如何使用匿名对象调用sayHello方法的示例：

new Person().sayHello(); // 创建一个Person的匿名对象，并调用其sayHello方法

注意

• 匿名对象因为没有引用名称，所以只能使用一次。一旦完成了对其方法或属性的访问，就无法再次使用这个对象。
• 匿名对象适用于轻量级操作，尤其是当对象的创建成本不高，并且确信不需要多次复用这个对象时。

总结

• 匿名对象是没有被显式赋给变量的对象。
• 可以通过检查代码中是否有new ClassName().methodName()或new ClassName().fieldName的语法结构来识别匿名对象。
• 匿名对象特别适合于一次性使用场景。

Java中对象的销毁

在Java中，当一个对象不再被引用时，它将被垃圾回收器（GC）销毁。垃圾回收器会自动检测不再使用的对象，并释放其内存。

总结

类是一种用户自定义的数据类型，用于创建具有属性和行为的对象。对象是类的实例，它们具有类定义的属性和方法。成员变量是类的属性，可以是静态变量或非静态变量。成员方法是类的函数，可以是静态方法或非静态方法。

对象通过构造器进行实例化，构造器用于初始化对象的属性。可以对构造器进行重载以创建具有不同初始状态的对象。在Java中，当一个对象不再被引用时，它将被垃圾回收器销毁。

匿名对象是不具有名称的对象，它们通常用于一次性使用。