深入探讨Java面向对象编程（OOP）

引言

在上一篇文章中，我们介绍了Java的基础语法和概念，包括数据类型、条件语句、循环语句和基本的类与对象。在本篇文章中，我们将深入探讨Java的面向对象编程（OOP）特性。这些特性包括继承、封装、多态和抽象，它们是OOP的四大支柱。通过理解和应用这些概念，你将能够编写更具结构性和可维护性的Java程序。

继承（Inheritance）

继承是面向对象编程中的一个重要概念，它允许我们基于现有类创建新类，从而实现代码的重用。新类称为子类（或派生类），现有类称为父类（或基类）。

示例

// 父类
class Animal {String name;void eat() {System.out.println(name + " is eating.");}
}// 子类
class Dog extends Animal {void bark() {System.out.println(name + " is barking.");}
}public class InheritanceExample {public static void main(String[] args) {Dog dog = new Dog();dog.name = "Buddy";dog.eat();dog.bark();}
}

在这个例子中，Dog 类继承自 Animal 类，因此 Dog 类可以访问 Animal 类的属性和方法。

方法重写

子类可以重写父类的方法，以便提供特定的实现。

class Animal {void makeSound() {System.out.println("Animal is making a sound");}
}class Dog extends Animal {@Overridevoid makeSound() {System.out.println("Dog is barking");}
}public class MethodOverrideExample {public static void main(String[] args) {Animal myDog = new Dog();myDog.makeSound();  // 输出 "Dog is barking"}
}

封装（Encapsulation）

封装是将对象的状态（属性）和行为（方法）封装在一个类中，并提供受控的访问。通过使用访问修饰符（如 private、public 和 protected），我们可以控制哪些属性和方法是对外可见的。

示例

class Person {private String name;private int age;// Getter 方法public String getName() {return name;}// Setter 方法public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {if (age > 0) {this.age = age;}}
}public class EncapsulationExample {public static void main(String[] args) {Person person = new Person();person.setName("John");person.setAge(25);System.out.println("Name: " + person.getName());System.out.println("Age: " + person.getAge());}
}

在这个例子中，Person 类的属性被声明为 private，只能通过公共的 getter 和 setter 方法访问，从而实现了封装。

多态（Polymorphism）

多态性允许我们使用相同的接口来调用不同的实际方法。这可以通过方法重载（编译时多态）和方法重写（运行时多态）实现。

方法重载

方法重载是指在同一个类中定义多个方法，它们具有相同的名字但参数不同。

class MathUtils {// 两个参数的 add 方法int add(int a, int b) {return a + b;}// 三个参数的 add 方法int add(int a, int b, int c) {return a + b + c;}
}public class MethodOverloadExample {public static void main(String[] args) {MathUtils math = new MathUtils();System.out.println("Sum of 2 numbers: " + math.add(10, 20));System.out.println("Sum of 3 numbers: " + math.add(10, 20, 30));}
}

方法重写

方法重写允许子类提供其自己的实现版本，而不是使用父类的方法。

class Animal {void makeSound() {System.out.println("Animal is making a sound");}
}class Cat extends Animal {@Overridevoid makeSound() {System.out.println("Cat is meowing");}
}public class PolymorphismExample {public static void main(String[] args) {Animal myCat = new Cat();myCat.makeSound();  // 输出 "Cat is meowing"}
}

抽象（Abstraction）

抽象是指将对象的复杂实现隐藏起来，只对外暴露必要的接口。Java 使用抽象类和接口来实现抽象。

抽象类

抽象类不能实例化，可以包含抽象方法（没有实现的方法）和具体方法。

abstract class Animal {abstract void makeSound();void sleep() {System.out.println("Animal is sleeping");}
}class Dog extends Animal {@Overridevoid makeSound() {System.out.println("Dog is barking");}
}public class AbstractClassExample {public static void main(String[] args) {Dog dog = new Dog();dog.makeSound();dog.sleep();}
}

接口

接口是一个纯粹的抽象类，只能包含抽象方法（Java 8 以后可以包含默认方法和静态方法）。

interface Animal {void makeSound();
}class Cat implements Animal {@Overridepublic void makeSound() {System.out.println("Cat is meowing");}
}public class InterfaceExample {public static void main(String[] args) {Cat cat = new Cat();cat.makeSound();}
}