Java 中的类和对象

原创朱雀 2021-08-14 09:53 13690阅读 2赞

# Java 中的类和对象

类和对象是面向对象编程的基本概念，它们围绕现实生活中的实体展开。

### 班级

类是用户定义的蓝图或原型，从中创建对象。它表示一种类型的所有对象共有的一组属性或方法。通常，类声明可以按顺序包含这些组件：

1. **修饰符**：一个类可以是公共或具有默认访问。
2. **class 关键字：** class 关键字用于创建类。
3. **类名：** 名称应以首字母开头（按惯例大写）。
4. **超类（如果有）：**类的父类（超类）的名称，如果有的话，以关键字 extends 开头。一个类只能扩展（子类）一个父类。
5. **接口（如果有）：**类实现的接口的逗号分隔列表**（如果有）**，前面是关键字实现。一个类可以实现多个接口。
6. **主体：**用大括号 { } 包围的类主体。

构造函数用于初始化新对象。字段是提供类及其对象状态的变量，方法用于实现类及其对象的行为。
实时应用程序中使用了各种类型的类，例如 [嵌套类](https://www.geeksforgeeks.org/inner-class-java/)、[匿名类](https://www.geeksforgeeks.org/anonymous-inner-class-java/)、[lambda 表达式](https://www.geeksforgeeks.org/lambda-expressions-java-8/)。

### 目的

它是面向对象编程的基本单元，代表现实生活中的实体。一个典型的 Java 程序会创建许多对象，如您所知，它们通过调用方法进行交互。一个对象包括：

1. **状态**：它由对象的属性表示。它还反映了对象的属性。
2. **行为**：它由对象的方法表示。它还反映了一个对象对其他对象的响应。
3. **身份**：它为对象提供唯一的名称，并使一个对象能够与其他对象交互。

对象示例：Dog

![空白图 - 第 1 页](/images/20210814/1628934673157.png "空白图 - 第 1 页")

对象对应于在现实世界中发现的事物。例如，图形程序可能具有诸如“圆形”、“方形”、“菜单”之类的对象。在线购物系统可能具有诸如“购物车”、“客户”和“产品”之类的对象。

### 声明对象（也称为实例化类）

当一个类的对象被创建时，这个类就被称为**实例化了**。所有实例共享类的属性和行为。但是这些属性的值，即状态对于每个对象都是唯一的。一个类可以有任意数量的实例。

例子：

![空白图 - 第 1 页 ](/images/20210814/1628934632605.png "空白图 - 第 1 页 ")

当我们声明像（类型名称；）这样的变量时。这会通知编译器我们将使用 name 来引用类型为 type 的数据。对于原始变量，此声明还为变量保留了适当的内存量。所以对于引用变量，类型必须严格是一个具体的类名。一般来说，我们**不能**创建抽象类或接口的对象。

```
Dog tuffy;
```

如果我们像这样声明引用变量(tuffy)，它的值将是不确定的(null)，直到一个对象被实际创建并分配给它。简单地声明一个引用变量不会创建一个对象。

### 初始化一个对象

new 运算符通过为新对象分配内存并返回对该内存的引用来实例化一个类。new 运算符还调用类构造函数。

```
// Class Declaration
 
public class Dog
{
    // Instance Variables
    String name;
    String breed;
    int age;
    String color;
 
    // Constructor Declaration of Class
    public Dog(String name, String breed,
                   int age, String color)
    {
        this.name = name;
        this.breed = breed;
        this.age = age;
        this.color = color;
    }
 
    // method 1
    public String getName()
    {
        return name;
    }
 
    // method 2
    public String getBreed()
    {
        return breed;
    }
 
    // method 3
    public int getAge()
    {
        return age;
    }
 
    // method 4
    public String getColor()
    {
        return color;
    }
 
    @Override
    public String toString()
    {
        return("Hi my name is "+ this.getName()+
               ".\nMy breed,age and color are " +
               this.getBreed()+"," + this.getAge()+
               ","+ this.getColor());
    }
 
    public static void main(String[] args)
    {
        Dog tuffy = new Dog("tuffy","papillon", 5, "white");
        System.out.println(tuffy.toString());
    }
}
```

**输出：**

```
Hi my name is tuffy.
My breed,age and color are papillon,5,white
```

- 此类包含一个构造函数。我们可以识别构造函数，因为它的声明使用与类相同的名称，并且没有返回类型。Java 编译器根据参数的数量和类型区分构造函数。*Dog*类中的构造函数接受四个参数。以下语句提供“tuffy”、“papillon”、5、“white”作为这些参数的值：

```
Dog tuffy = new Dog("tuffy","papillon",5, "white");
```

- 执行该语句的结果可以表示为：

![无标题](/images/20210814/1628934570547.png "无标题")

**注意：**所有类至少有**一个**构造函数。如果一个类没有显式声明，Java 编译器会自动提供一个无参数构造函数，也称为默认构造函数。这个默认构造函数调用类父类的无参数构造函数（因为它只包含一个语句，即 super();），或者如果类没有其他父类，则调用*Object*类构造函数（因为 Object 类是所有类的父类，直接或间接）。

### 创建类对象的方法

java中创建对象有四种方式，严格来说只有一种方式（使用*new*关键字），其余内部使用*new*关键字。

- **使用 new 关键字：**是 Java 中创建对象最常见、最通用的方式。例子：

```
// creating object of class Test
Test t = new Test();
```

- **使用 Class.forName(String className) 方法：**在 java.lang 包中有一个名为 Class 的预定义类。forName(String className) 方法返回与具有给定字符串名称的类相关联的 Class 对象。我们必须为类提供完全限定的名称。在此 Class 对象上调用 new Instance() 方法时，将返回具有给定字符串名称的类的新实例。

```
// creating object of public class Test
// consider class Test present in com.p1 package
Test obj = (Test)Class.forName("com.p1.Test").newInstance();
```

- **使用 clone() 方法：** clone() 方法存在于 Object 类中。它创建并返回对象的副本。

```
// creating object of class Test
Test t1 = new Test();

// creating clone of above object
Test t2 = (Test)t1.clone();
```

- **反序列化：反**序列化是从文件中保存的状态读取对象的技术。

```
  FileInputStream file = new FileInputStream(filename);
  ObjectInputStream in = new ObjectInputStream(file);
  Object obj = in.readObject();
  ```

### 仅通过一种类型创建多个对象（一种好的做法）

- 在实时中，我们需要不同方法中的类的不同对象。创建多个用于存储它们的引用不是一个好习惯，因此我们声明一个静态引用变量并在需要时使用它。在这种情况下，内存的浪费较少。不再引用的对象将被java的[垃圾收集器](https://www.geeksforgeeks.org/garbage-collection-java/)销毁。例子：

```
  Test test = new Test();
  test = new Test();
  ```

- 在继承系统中，我们使用父类引用变量来存储子类对象。在这种情况下，我们可以使用相同的引用变量切换到不同的子类对象。例子：

```
class Animal {}

class Dog extends Animal {}
class Cat extends Animal {}

public class Test
{
    // using Dog object
    Animal obj = new Dog();

// using Cat object
    obj = new Cat();
} 
```

### 匿名对象

匿名对象是实例化但未存储在引用变量中的对象。

- 它们用于立即调用方法。
- 它们将在方法调用后被销毁。
- 它们被广泛用于不同的图书馆。例如，在 AWT 库中，它们用于在捕获事件（例如按键）时执行某些操作。
- 在下面的例子中，当一个键是按钮（由 btn 引用）被按下时，我们只是创建 EventHandler 类的匿名对象来调用 handle 方法。

```
btn.setOnAction(new EventHandler()
{
    public void handle(ActionEvent event)
    {
        System.out.println("Hello World!");
    }
});
```