java学习003

**Java 学习之旅003**

在前两篇文章中，我们已经了解了 Java 的基本概念、变量的使用以及控制结构的应用。今天，我们将继续深入探讨 Java 的面向对象编程（OOP）特性。

### 面向对象编程（OOP）

面向对象编程是一种编程范式，强调对程序中的数据和过程进行抽象、封装和继承等概念的使用。Java 是一种支持 OOP 的语言，它提供了类、对象、继承、多态、封装和抽象等关键特性。

#### 类和对象在 Java 中，类是用来描述一个事物或实体的模板，而对象则是根据这个模板创建出来的具体实例。例如，我们可以定义一个 `Person` 类来描述一个人，然后创建多个 `Person` 对象，每个对象都具有自己的属性（如姓名、年龄等）。

javapublic class Person {
 private String name;
 private int age;

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

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

 public void setAge(int age) {
 this.age = age;
 }

 public String getName() {
 return name;
 }

 public int getAge() {
 return age;
 }
}

public class Main {
 public static void main(String[] args) {
 Person person1 = new Person("John",30);
 Person person2 = new Person("Alice",25);

 System.out.println(person1.getName()); // John System.out.println(person1.getAge()); //30 System.out.println(person2.getName()); // Alice System.out.println(person2.getAge()); //25 }
}

#### 继承继承是 OOP 中的一个重要概念，它允许一个类（子类）继承另一个类（父类）的属性和方法。这样可以减少代码的重复，并且使得程序更加易于维护。

javapublic class Animal {
 private String name;

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

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

public class Dog extends Animal {
 public Dog(String name) {
 super(name);
 }

 @Override public void sound() {
 System.out.println("The dog barks.");
 }
}

public class Main {
 public static void main(String[] args) {
 Dog dog = new Dog("Max");
 dog.sound(); // The dog barks.
 }
}

#### 多态多态是 OOP 中的一个重要概念，它允许一个类（子类）重写另一个类（父类）的方法。这样可以使得程序更加灵活和易于维护。

javapublic class Shape {
 public void draw() {
 System.out.println("Drawing a shape.");
 }
}

public class Circle extends Shape {
 @Override public void draw() {
 System.out.println("Drawing a circle.");
 }
}

public class Rectangle extends Shape {
 @Override public void draw() {
 System.out.println("Drawing a rectangle.");
 }
}

public class Main {
 public static void main(String[] args) {
 Shape shape = new Circle();
 shape.draw(); // Drawing a circle.

 shape = new Rectangle();
 shape.draw(); // Drawing a rectangle.
 }
}

#### 封装封装是 OOP 中的一个重要概念，它允许一个类（子类）隐藏其内部实现细节，而只暴露必要的接口。这样可以使得程序更加易于维护和扩展。

javapublic class BankAccount {
 private double balance;

 public void deposit(double amount) {
 balance += amount;
 }

 public void withdraw(double amount) {
 if (balance >= amount) {
 balance -= amount;
 } else {
 System.out.println("Insufficient funds.");
 }
 }

 public double getBalance() {
 return balance;
 }
}

public class Main {
 public static void main(String[] args) {
 BankAccount account = new BankAccount();
 account.deposit(1000);
 account.withdraw(500);
 System.out.println(account.getBalance()); //500 }
}

#### 抽象抽象是 OOP 中的一个重要概念，它允许一个类（子类）定义一个接口，而不关心其具体实现细节。这样可以使得程序更加易于维护和扩展。

javapublic abstract class Animal {
 public abstract void sound();
}

public class Dog extends Animal {
 @Override public void sound() {
 System.out.println("The dog barks.");
 }
}

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

public class Main {
 public static void main(String[] args) {
 Dog dog = new Dog();
 dog.sound(); // The dog barks.

 Cat cat = new Cat();
 cat.sound(); // The cat meows.
 }
}

以上就是本篇文章的内容。通过这些例子，我们可以看到 Java 的面向对象编程特性是如何应用于实际问题中的。希望这些例子能够帮助你更好地理解和掌握 Java 的 OOP 特性。