Java知识大全 - 三、Java 中的面向对象编程

1. 类和对象

类和对象是 Java 中面向对象编程 （OOP） 的构建块。类是用于创建对象的蓝图或模板，而对象是类的实例。

在 Java 中，使用“class”关键字定义类，后跟类名和一对包含类定义的大括号。例如：

public class Person {
  // Class definition goes here
}

定义类后，可以使用“new”关键字和类构造函数创建该类的对象。例如：

Person john = new Person();

这将创建 Person 类的新对象，并将其分配给名为“john”的变量。然后，可以使用点表示法访问对象的属性和方法。例如：

john.name = "John Smith";
john.age = 30;
john.sayHello();

这将设置“john”对象的“name”和“age”属性，并调用其“sayHello”方法。

Java 中的类可以包含属性（也称为字段）和方法。属性是存储对象状态的类的数据成员，而方法是定义对象行为的函数。例如：

public class Person {
  String name;
  int age;

  public void sayHello() {
    System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
  }
}

这定义了一个具有两个属性（名称和年龄）和一个将消息打印到控制台的方法（sayHello）的 Person 类。

理解类和对象是Java中OOP的基础，熟悉掌握它有利于将代码组织为可重用和可维护的单元，从而更轻松地管理和扩展程序。

2.继承和多态性

继承和多态性是Java中面向对象编程（OOP）的两个基本概念。这将有利于创建更高效、更灵活且更易于维护的代码。

继承是一种允许基于现有类创建新类的机制，新类（称为派生类或子类）继承基类或超类的属性和方法。这使得你能够重用超类中的代码，从而避免在子类中复制代码的需要。要在 Java 中创建子类，使用“extends”关键字，后跟超类的名称。例如：

public class Car {
  public void start() {
    System.out.println("Starting the car...");
  }
}

public class ElectricCar extends Car {
  public void charge() {
    System.out.println("Charging the electric car...");
  }
}

这将定义一个具有“start”方法的 Car 类和一个继承自Car 类并添加“charge”方法的 ElectricCar 类。ElectricCar 类可以使用 Car 类的“start”方法，并且无需重新定义它。

• 多态性是对象根据其使用的上下文采取多种形式或以不同方式表现的能力。
• 在 Java 中，多态性是通过方法覆盖和方法重载实现的。
• 方法重写允许在子类中定义与超类中的方法具有相同名称和参数的方法。
• 在子类的对象上调用该方法时，将执行子类方法而不是超类方法。
• 方法重载允许定义多个名称相同但参数不同的方法。

调用该方法时，Java 会根据传递给它的参数选择要执行的方法。例如：

public class Animal {
  public void makeSound() {
    System.out.println("The animal makes a sound.");
  }
}

public class Cat extends Animal {
  @Override
  public void makeSound() {
    System.out.println("The cat meows.");
  }

  public void makeSound(int num) {
    for (int i = 0; i < num; i++) {
      System.out.println("The cat meows.");
    }
  }
 }

这将定义一个具有“makeSound”方法的 Animal 类和一个重写“makeSound”方法并添加采用整数参数的重载方法的Cat 类。当在 Cat 对象上调用“makeSound”方法时，将根据传递给它的参数执行相应的方法。

继承和多态性是强大的概念，这将有利于在 Java 中创建更灵活且可维护的代码，以及能够重用代码，更轻松地更改代码，并创建更高效、更有效的程序。

3. 接口和抽象类

接口和抽象类是Java中面向对象编程（OOP）的两个重要特性。这将允许定义可在多个类之间共享的常见行为（方法），但它们的方式略有不同。

Java 中的接口是抽象方法和常量的集合，这些方法和常量为一组相关类定义协定。接口不提供任何实现，但它定义了实现类必须提供的方法。这允许定义可在多个类之间共享的常见行为，而无需指定如何实现该行为。要在 Java 中实现接口，使用“implements”关键字，后跟接口的名称。例如：

public interface Drawable {
  void draw();
}

public class Circle implements Drawable {
  public void draw() {
    // Draw the circle
  }
}

public class Rectangle implements Drawable {
  public void draw() {
    // Draw the rectangle
  }
}

这定义了一个具有“draw”方法的 Drawable 接口和两个实现接口并提供自己的“draw”方法实现的类。

Java 中的抽象类是无法实例化的类，可能包含抽象方法和具体方法。抽象方法是没有实现具体细节的方法，由子类实现具体细节。而具体方法具有实现，并且可以由子类继承。抽象类提供了一种定义可在多个类之间共享的常见行为和状态的方法，但它们比接口具有更大的灵活性，因为它们可以同时包含抽象方法和具体方法。要在 Java 中定义抽象类，在类定义之前使用 “abstract” 关键字。例如：

public abstract class Shape {
  public abstract double getArea();

  public void draw() {
    // Draw the shape
  }
}

public class Circle extends Shape {
  public double getArea() {
    // Calculate the area of the circle
  }
}

public class Rectangle extends Shape {
  public double getArea() {
    // Calculate the area of the rectangle
  }
}

这定义了一个具有抽象“getArea”方法和具体“draw”方法的Shape抽象类，以及两个扩展继承自Shape类并提供自己的“getArea”方法实现的类。

接口和抽象类都是在 Java 中创建更灵活和可维护代码的有用工具。它们提供了一种定义可在多个类之间共享的方法，但它们以略有不同的方式执行此操作，具体取决于程序的需要。

4. 封装和信息隐藏

封装和信息隐藏是面向对象编程中的两个相关概念，用于组织和保护类内的数据和行为。

封装是指将数据和行为捆绑在一个单元（例如一个类）中，并限制从外部世界访问该单元的内部工作的做法。 在 Java 中，这通常是通过将类字段声明为私有的来实现的，因此它们不能直接从类外部访问，并提供允许对字段进行受控访问的公共方法（getter 和 setter）。 这样，类的内部对用户是隐藏的，并且类可以以受控方式维护其内部状态和行为。

信息隐藏是一个相关的概念，指的是隐藏类中数据和行为如何实现的细节，这样类的用户就不需要知道它们了。 在 Java 中，这通常是通过将数据和行为封装在一个类中，并提供一个干净简单的接口来访问它们来实现的。 这样，该类的使用者可以专注于使用该类，而不必担心实现细节。

封装和信息隐藏是面向对象编程中的重要概念，因为它们有助于创建更健壮和可维护的代码。 通过对外部世界隐藏类的内部工作，只要公共接口保持不变，就可以通过更改类的实现而不影响使用它的代码。 随着时间的推移，这可以让代码更灵活、更容易维护。