面向对象的四个基本特征

一、封装性

封装性是指将对象的属性和方法封装在一起，对外界隐藏对象的细节，使得对象对使用者来说更加简单易用和安全可靠。

例如，我们可以创建一个类Car来表示汽车，在类中定义汽车的属性和方法：

class Car {
  private String brand;
  private String color;
  private int price;

  public Car(String brand, String color, int price) {
    this.brand = brand;
    this.color = color;
    this.price = price;
  }

  public void run() {
    System.out.println("The car is running.");
  }
}

其中，属性brand、color、price被标记为私有(private)，只能在Car类内部访问，类外部无法直接访问。但我们可以通过给属性提供公有(public)的setter和getter方法来访问属性值：

public String getBrand() {
  return this.brand;
}

public void setBrand(String brand) {
  this.brand = brand;
}

通过封装，我们不仅可以保护对象内部的实现细节，同时也可以方便地控制访问方式，保证数据不会被错误地篡改。

二、继承性

继承性是指在一个已有类的基础上创建新类，新类可以继承已有类的属性和方法，并且可以在此基础上扩展新的特性。

例如，我们可以创建一个类Animal作为基类，然后创建两个子类Dog和Cat，这两个子类可以共享父类Animal的属性和方法，并且可以为自己添加新的特性，如下所示：

class Animal {
  private String name;
  private int age;

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

  public void eat() {
    System.out.println("The animal is eating.");
  }
}

class Dog extends Animal {
  private String breed;

  public Dog(String name, int age, String breed) {
    super(name, age);
    this.breed = breed;
  }

  public void bark() {
    System.out.println("The dog is barking.");
  }
}

class Cat extends Animal {
  private boolean isCute;

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

  public void sleep() {
    System.out.println("The cat is sleeping.");
  }
}

通过继承，我们可以提高代码的复用性，减少代码的重复编写。同时，继承也可以使得代码更加灵活扩展，便于引入新的特性。

三、多态性

多态性是指同一种行为或方法具有多种不同的表现形式，即不同的对象对同一种方法做出不同的响应。多态性主要基于继承和接口实现来实现。

例如，我们可以创建一个接口Shape，然后创建三个类Circle、Rectangle和Triangle，这三个类实现Shape接口，并且分别提供自己的面积计算方法：

interface Shape {
  public double area();
}

class Circle implements Shape {
  private double radius;

  public Circle(double radius) {
    this.radius = radius;
  }

  public double area() {
    return Math.PI * radius * radius;
  }
}

class Rectangle implements Shape {
  private double length;
  private double width;

  public Rectangle(double length, double width) {
    this.length = length;
    this.width = width;
  }

  public double area() {
    return length * width;
  }
}

class Triangle implements Shape {
  private double base;
  private double height;

  public Triangle(double base, double height) {
    this.base = base;
    this.height = height;
  }

  public double area() {
    return 0.5 * base * height;
  }
}

通过多态性，我们可以更加方便地扩展功能，而且代码更加灵活，易于维护。

四、抽象性

抽象性是指忽略实例的具体细节，而只关注它们的共同特征，将它们归纳为一个类或一组类的过程。

例如，我们可以创建一个抽象类Shape来表示形状，然后在Shape类中定义一个抽象方法area()，表示计算面积的方法，具体实现由子类去实现：

abstract class Shape {
  public abstract double area();
}

class Circle extends Shape {
  private double radius;

  public Circle(double radius) {
    this.radius = radius;
  }

  public double area() {
    return Math.PI * radius * radius;
  }
}

class Rectangle extends Shape {
  private double length;
  private double width;

  public Rectangle(double length, double width) {
    this.length = length;
    this.width = width;
  }

  public double area() {
    return length * width;
  }
}

class Triangle extends Shape {
  private double base;
  private double height;

  public Triangle(double base, double height) {
    this.base = base;
    this.height = height;
  }

  public double area() {
    return 0.5 * base * height;
  }
}

通过抽象性，我们可以将类归纳为更高层次的概念，使得代码更加优雅简洁，并且易于扩展。