面向对象三大特征

面向对象的三大基本特征是：封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）。这三个特征共同构成了面向对象编程（OOP）的基石。

1. 封装（Encapsulation）：
   封装是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象的内部信息（属性），而是通过该类所提供的方法来实现对内部信息的操作和访问。封装是面向对象编程的核心思想之一，它有助于隐藏复杂性，提高程序的安全性和可维护性。通过封装，对象可以对其内部状态进行精细的控制，同时对外提供一套清晰、可控的接口。
   下面是一个简单的Student类，展示了如何使用封装来保护类的内部数据：

   public class Student {  
       // 私有成员变量，外部无法直接访问  
       private String name;  
       private int age;  
     
       // 构造方法  
       public Student(String name, int age) {  
           this.name = name;  
           this.age = age;  
       }  
     
       // Getter和Setter方法，提供对私有成员变量的访问  
       public String getName() {  
           return name;  
       }  
     
       public void setName(String name) {  
           this.name = name;  
       }  
     
       public int getAge() {  
           return age;  
       }  
     
       public void setAge(int age) {  
           if (age > 0) { // 简单的验证，防止设置不合理的年龄  
               this.age = age;  
           } else {  
               System.out.println("年龄必须大于0");  
           }  
       }  
     
       // 其他方法...  
   }  
     
   // 使用Student类  
   public class Test {  
       public static void main(String[] args) {  
           Student student = new Student("张三", 20);  
           System.out.println("学生姓名：" + student.getName());  
           student.setAge(-1); // 尝试设置不合理的年龄，但会被setAge方法内部验证阻止  
           System.out.println("学生年龄：" + student.getAge()); // 输出原始年龄，因为设置失败  
       }  
   }

2. 继承（Inheritance）：
          继承是面向对象编程中实现代码复用的重要手段之一。通过继承，子类可以自动拥有父类（基类）的属性和方法，并可以根据需要添加或覆盖（Override）自己的属性和方法。继承有助于建立类的层次结构，促进代码的模块化和重用。在继承关系中，子类是一个特殊的父类，它可以继承父类的特征和行为，但也可以有自己的特性和行为。
          继承是面向对象编程中实现代码复用的主要方式之一。子类可以继承父类的属性和方法，并可以添加或覆盖自己的属性和方法。下面是一个简单的继承例子，其中GraduateStudent类继承自Student类。

   // 父类  
   public class Student {  
       // ...（与上面相同的成员变量和方法）  
   }  
     
   // 子类，继承自Student类  
   public class GraduateStudent extends Student {  
       // 添加额外的成员变量  
       private String thesisTitle;  
     
       // 构造方法，可以调用父类的构造方法  
       public GraduateStudent(String name, int age, String thesisTitle) {  
           super(name, age); // 调用父类的构造方法  
           this.thesisTitle = thesisTitle;  
       }  
     
       // Getter和Setter方法  
       public String getThesisTitle() {  
           return thesisTitle;  
       }  
     
       public void setThesisTitle(String thesisTitle) {  
           this.thesisTitle = thesisTitle;  
       }  
     
       // 其他方法...  
   }  
     
   // 使用GraduateStudent类  
   public class TestInheritance {  
       public static void main(String[] args) {  
           GraduateStudent gradStudent = new GraduateStudent("李四", 23, "面向对象编程研究");  
           System.out.println("研究生姓名：" + gradStudent.getName());  
           System.out.println("研究生论文题目：" + gradStudent.getThesisTitle());  
       }  
   }

3. 多态（Polymorphism）：
          多态指的是同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。多态性是通过方法的重写（Override）和重载（Overload）来实现的。在继承中，子类可以重写父类的方法，从而提供特定的实现。而在同一个类中，可以定义多个同名但参数不同的方法，实现方法的重载。多态性使得程序更加灵活和可扩展，提高了代码的可读性和可维护性。
          多态是指允许不同类的对象对同一消息作出响应。在Java中，多态通常通过方法的重写（Override）和接口实现来体现。以下是一个简单的多态例子，展示了如何通过接口实现多态。

   // 定义一个接口  
   public interface Animal {  
       void speak();  
   }  
     
   // Dog类实现Animal接口  
   public class Dog implements Animal {  
       @Override  
       public void speak() {  
           System.out.println("汪汪汪");  
       }  
   }  
     
   // Cat类实现Animal接口  
   public class Cat implements Animal {  
       @Override  
       public void speak() {  
           System.out.println("喵喵喵");  
       }  
   }  
     
   // 使用多态  
   public class TestPolymorphism {  
       public static void main(String[] args) {  
           Animal myDog = new Dog();  
           Animal myCat = new Cat();  
     
           // 使用相同的speak方法调用，但根据对象的不同，执行不同的操作  
           myDog.speak(); // 输出：汪汪汪  
           myCat.speak(); // 输出：喵喵喵  
       }  
   }

        这三个特征相互关联、相互支持，共同构成了面向对象编程的基础。封装提供了对象的基本保护，继承实现了代码的重用，而多态则增强了程序的灵活性和可扩展性。通过合理使用这些特征，可以编写出更加高效、易于维护和扩展的程序。