下面是关于面向对象编程（OOP）的详细教程，涵盖了Java中面向对象的关键概念和实践方法。此部分将帮助你理解类和对象、继承、多态以及接口与抽象类等核心知识：

---

Java教程之：面向对象编程（OOP）

1. 类和对象

• 类的定义
  类是创建对象的蓝图，定义了对象的属性和行为。在Java中，类是使用class关键字声明的。

  public class Car {
      String color;
      int speed;

      public void drive() {
          System.out.println("Driving the car...");
      }
  }

• 对象的创建与使用
  对象是类的实例，可以通过new关键字创建。

  Car myCar = new Car();
  myCar.color = "Red";
  myCar.speed = 100;
  myCar.drive();

• 构造函数
  构造函数是类的特殊方法，用于初始化对象的状态。若没有显式定义构造函数，Java会提供默认构造函数。

  public class Car {
      String color;
      int speed;

      public Car(String color, int speed) {
          this.color = color;
          this.speed = speed;
      }
  }
  Car myCar = new Car("Blue", 120);

• this关键字
  this关键字指代当前对象的引用，用于区分成员变量和参数或局部变量的名称相同的情况。

  public class Car {
      String color;
      int speed;

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

2. 封装

• 成员变量的访问控制
  Java通过访问修饰符（public, private, protected）来控制类的成员变量的访问权限。
• private：只允许在当前类中访问。
• protected：允许在同包内或子类中访问。
• public：任何地方都可以访问。

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

      public String getName() {
          return name;
      }

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

• getter和setter方法
  使用getter和setter方法来访问和修改对象的私有属性，封装了直接访问变量的方式。

  public class Person {
      private String name;

      public String getName() {
          return name;
      }

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

3. 继承

• super关键字
  super关键字用来访问父类的构造函数、方法和属性。

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

  public class Dog extends Animal {
      @Override
      public void sound() {
          super.sound();  // 调用父类方法
          System.out.println("Dog barks");
      }
  }

• 方法重写（Override）
  子类可以重写父类的方法，提供自己的实现。

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

• 父类构造函数的调用
  子类构造函数默认调用父类的无参构造函数。若父类没有无参构造函数，必须显式调用父类的构造函数。

  public class Dog extends Animal {
      public Dog() {
          super();  // 显式调用父类构造函数
      }
  }

4. 多态

• 方法重载（Overloading）
  在同一个类中，允许多个方法名相同，但参数列表不同（参数个数或类型不同）。

  public class Calculator {
      public int add(int a, int b) {
          return a + b;
      }

      public double add(double a, double b) {
          return a + b;
      }
  }

• 动态方法分派
  多态的一个重要特征，通过父类引用指向子类对象时，调用的方法是动态绑定的，取决于对象的实际类型。

  Animal animal = new Dog();
  animal.sound();  // 会调用Dog类中的sound()方法

5. 接口与抽象类

• 接口的定义与实现
  接口是纯粹的抽象类，只能包含方法的声明，没有实现。类通过implements关键字实现接口。

  interface Animal {
      void sound();
  }

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

• 抽象类的定义与继承
  抽象类可以包含抽象方法和具体方法，不能实例化，只能被继承。子类必须实现抽象方法。

  abstract class Animal {
      abstract void sound();

      public void eat() {
          System.out.println("Eating");
      }
  }

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

• 多重继承的替代（接口的使用）
  Java不支持类的多重继承，但可以通过接口实现多重继承。

  interface A {
      void methodA();
  }

  interface B {
      void methodB();
  }

  class C implements A, B {
      public void methodA() {
          System.out.println("Method A");
      }

      public void methodB() {
          System.out.println("Method B");
      }
  }

6. 内部类

• 静态内部类
  静态内部类可以不依赖外部类的实例来创建。

  class Outer {
      static class Inner {
          void show() {
              System.out.println("Static inner class");
          }
      }
  }
  Outer.Inner inner = new Outer.Inner();
  inner.show();

• 成员内部类
  成员内部类可以访问外部类的所有成员（包括私有成员）。

  class Outer {
      private String msg = "Hello from Outer";
      class Inner {
          void display() {
              System.out.println(msg);
          }
      }
  }
  Outer outer = new Outer();
  Outer.Inner inner = outer.new Inner();
  inner.display();

• 匿名内部类
  匿名内部类是一种没有名字的内部类，常用于实现接口或继承类时，简化代码。

  Animal animal = new Animal() {
      @Override
      public void sound() {
          System.out.println("Anonymous animal sound");
      }
  };
  animal.sound();

---

总结：

本部分介绍了Java中面向对象编程（OOP）的关键概念，包括类与对象的基本操作、继承、多态、封装的实现方式以及如何使用接口和抽象类。在实际开发中，这些概念是构建灵活、高效和可维护代码的基础。掌握这些核心技术，将为你在Java开发中的进阶打下坚实的基础。