Java 面向对象编程（OOP）

Java 中的 OOP 概念

面向对象编程（OOP）是一种结构化的软件开发方法。在 Java 中，四个核心原则定义了面向对象编程。它们包括：

抽象（Abstraction）
封装（Encapsulation）
继承（Inheritance）
多态（Polymorphism）

1. 抽象（Abstraction）

抽象是指隐藏复杂实现的细节，只向用户展示必要的信息。在 Java 中，抽象通过接口和抽象类来实现。

接口（Interface）

接口是一种仅包含方法签名的容器，不包含数据成员和方法的实现。使用接口可以减少代码的复杂性，提高代码的可读性。

语法：

java 复制代码

<访问修饰符> interface <接口名> {
    <方法签名>;
}

示例：

java 复制代码

package simplilearn;

public interface Area {
    public void Square();
    public void Circle();
    public void Rectangle();
    public void Triangle();
}

package simplilearn;

import java.util.Scanner;

public class ShapeArea implements Area {
    @Override
    public void Circle() {
        Scanner kb = new Scanner(System.in);
        System.out.println("输入圆的半径");
        double r = kb.nextDouble();
        double areaOfCircle = 3.142 * r * r;
        System.out.println("圆的面积是: " + areaOfCircle);
    }

    @Override
    public void Square() {
        Scanner kb2 = new Scanner(System.in);
        System.out.println("输入正方形的边长");
        double s = kb2.nextDouble();
        double areaOfSquare = s * s;
        System.out.println("正方形的面积是: " + areaOfSquare);
    }

    @Override
    public void Rectangle() {
        Scanner kb3 = new Scanner(System.in);
        System.out.println("输入矩形的长度");
        double l = kb3.nextDouble();
        System.out.println("输入矩形的宽度");
        double b = kb3.nextDouble();
        double areaOfRectangle = l * b;
        System.out.println("矩形的面积是: " + areaOfRectangle);
    }

    @Override
    public void Triangle() {
        Scanner kb4 = new Scanner(System.in);
        System.out.println("输入三角形的底边");
        double base = kb4.nextDouble();
        System.out.println("输入三角形的高");
        double h = kb4.nextDouble();
        double areaOfTriangle = 0.5 * base * h;
        System.out.println("三角形的面积是: " + areaOfTriangle);
    }

    public static void main(String[] args) {
        ShapeArea geometry = new ShapeArea();
        geometry.Circle();
        geometry.Square();
        geometry.Rectangle();
        geometry.Triangle();
    }
}

抽象类（Abstract Class）

抽象类类似于接口，但不同的是，抽象类可以包含数据成员和方法的实现。

语法：

java 复制代码

<访问修饰符> abstract class <类名> {
    <数据成员>;
    <方法>;
}

示例：

java 复制代码

package Simplilearn;

public abstract class Person {
    private String name;
    private String gender;

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

    public abstract void work();

    @Override
    public String toString() {
        return "Name=" + this.name + ", Gender=" + this.gender;
    }

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

    public void exam() {
        // 方法实现
    }
}

package abstraction;

public class Employee extends Person {
    private int empId;

    public Employee(String name, String gender, int empId) {
        super(name, gender);
        this.empId = empId;
    }

    @Override
    public void work() {
        System.out.println("员工正在工作");
    }

    public static void main(String[] args) {
        Person employee = new Employee("张三", "男", 1094826);
        employee.work();
        employee.changeName("李四");
        System.out.println(employee.toString());
    }
}

2. 封装（Encapsulation）

封装是指将数据成员和方法绑定在一起，并将它们声明为私有，以保护对象的内部状态。

语法：

java 复制代码

<访问修饰符> class <类名> {
    private <数据成员>;
    private <方法>;
}

示例：

java 复制代码

package Simplilearn;

public class Emp {
    public static void main(String[] args) {
        Encapsule emp = new Encapsule();
        emp.setName("Robert");
        System.out.println(emp.getName());
    }
}

package Simplilearn;

public class Encapsule {
    private String empName;

    public String getName() {
        return empName;
    }

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

3. 继承（Inheritance）

继承是 OOP 中简化软件开发的一种方法。它允许通过继承已定义类的数据成员和方法来创建新的类。

继承的类称为子类或派生类，被继承的类称为父类或基类。继承可以通过多种方式实现。

单继承（Single Inheritance）

单继承包含一个父类和一个子类。子类继承父类的方法和数据成员。

示例：

java 复制代码

package inheritance;

class Student {
    void play() {
        System.out.println("踢足球...");
    }
}

class Bob extends Student {
    void study() {
        System.out.println("学习物理...");
    }
}

public class Single {
    public static void main(String[] args) {
        Bob bob = new Bob();
        bob.study();
        bob.play();
    }
}

多级继承（Multi-Level Inheritance）

多级继承也是父类-子类的关系，但不同的是，另一个子类继承前一个子类。

示例：

java 复制代码

package inheritance;

class Bike {
    public Bike() {
        System.out.println("排量: 1000cc");
    }

    public void bikeType() {
        System.out.println("车型: 运动型");
    }
}

class Ninja extends Bike {
    public Ninja() {
        System.out.println("型号: Ninja");
    }

    public void brand() {
        System.out.println("制造商: Kawasaki");
    }

    public void speed() {
        System.out.println("最高速度: 290公里/小时");
    }
}

public class Ninja1000R extends Ninja {
    public Ninja1000R() {
        System.out.println("型号: 1000R");
    }

    @Override
    public void speed() {
        System.out.println("最高速度: 280公里/小时");
    }

    public static void main(String[] args) {
        Ninja1000R obj = new Ninja1000R();
        obj.bikeType();
        obj.brand();
        obj.speed();
    }
}

多重继承（Multiple Inheritance）

Java 不支持多重继承，因为它会导致严重的歧义问题。接口可以解决菱形问题。

层次继承（Hierarchical Inheritance）

层次继承是一种父类-子类关系，不同的是，多个子类继承同一个父类。

示例：

java 复制代码

package inheritance;

class Employee {
    double leaves = 25.00;
}

class PEmployee extends Employee {
    float totalHoursPerDay = (float) 8.00;
}

class TEmployee extends Employee {
    float totalHoursPerDay = (float) 10.50;
}

public class EmployeeSalary {
    public static void main(String[] args) {
        PEmployee permanent = new PEmployee();
        TEmployee temporary = new TEmployee();
        System.out.println("正式员工总假期数: " + permanent.leaves);
        System.out.println("正式员工每天工作小时数: " + permanent.totalHoursPerDay);
        System.out.println("临时员工总假期数: " + temporary.leaves);
        System.out.println("临时员工每天工作小时数: " + temporary.totalHoursPerDay);
    }
}

混合继承（Hybrid Inheritance）

混合继承可以是单继承、多级继承和层次继承的组合。

示例：

java 复制代码

package inheritance;

class C {
    public void print() {
        System.out.println("C 是所有 A, B, D 的父类");
    }
}

class A extends C {
    @Override
    public void print() {
        System.out.println("A 与 C 有单继承关系，并与 B 共享层次结构");
    }
}

class B extends C {
    @Override
    public void print() {
        System.out.println("B 与 C 有单继承关系，并与 A 共享层次结构");
    }
}

public class D extends A {
    @Override
    public void print() {
        System.out.println("D 与 A 有单继承关系，并与 C 有多级继承关系");
    }

    public static void main(String[] args) {
        A w = new A();
        B x = new B();
        C y = new C();
        D z = new D();

        y.print();
        w.print();
        x.print();
        z.print();
    }
}

HAS-A 关系

当一个类继承另一个类的实例或其自身的实例时，这种关系称为 HAS-A 关系。

示例：

java 复制代码

package inheritance;

class School {
    private String name;

    School(String name) {
        this.name = name;
    }

    public String schoolName() {
        return this.name;
    }
}

class Student {
    private String name;

    Student(String name) {
        this.name = name;
    }

    public String studentName() {
        return this.name;
    }
}

public class HasARelation {
    public static void main(String[] args) {
        School schl = new School("St.John's School");
        Student candidate = new Student("Tobey Marshall");

        System.out.println(candidate.studentName() + " 是 " + schl.schoolName() + " 的前学生");
    }
}

IS-A 关系

当一个类继承其他类的方法和成员时，这种关系称为 IS-A 关系。

示例：

java 复制代码

package inheritance;

import java.util.*;

class Customer {
    public String name;
    public String city;

    Customer(String name, String city) {
        this.name = name;
        this.city = city;
    }
}

class Bank {
    private final List<Customer> customers;

    Bank(List<Customer> customers) {
        this.customers = customers;
    }

    public List<Customer> totalAccountsInBank() {
        return customers;
    }
}

public class IsARelation {
    public static void main(String[] args) {
        Customer C1 = new Customer("Raju", "Bangalore");
        Customer C2 = new Customer("Shiva", "Hyderabad");
        Customer C3 = new Customer("Sachin", "Mumbai");
        Customer C4 = new Customer("Prashanth", "Vizag");
        Customer C5 = new Customer("John", "Goa");

        List<Customer> customers = new ArrayList<>();
        customers.add(C1);
        customers.add(C2);
        customers.add(C3);
        customers.add(C4);
        customers.add(C5);

        Bank ABCBank = new Bank(customers);

        List<Customer> cust = ABCBank.totalAccountsInBank();
        for (Customer cst : cust) {
            System.out.println("客户姓名: " + cst.name + "\n" + "城市: " + cst.city);
        }
    }
}

4.多态（Polymorphism）

多态是指一个对象可以有多种形态的能力。在 Java 中，多态主要通过方法重载（Overloading）和方法重写（Overriding）来实现。

方法重载（Method Overloading）

方法重载是指在一个类中定义多个同名方法，但方法的参数列表不同。

示例：

java 复制代码

package polymorphism;

public class Addition {
    public int add(int x, int y) {
        return (x + y);
    }

    public double add(double d, double e, double f, double g) {
        return (d + e + f + g);
    }

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

    public static void main(String[] args) {
        Addition a = new Addition();
        System.out.println(a.add(25, 30));
        System.out.println(a.add(10.0, 15.0, 20.0, 25.0));
        System.out.println(a.add(127.5, 123.5));
    }
}

方法重写（Method Overriding）

方法重写是指子类重新实现父类中的方法。

示例：

java 复制代码

package polymorphism;

public class SuperKeyword {
    public static void main(String[] args) {
        Triangle two = new Triangle();
        two.countSides();
    }
}

class Square {
    int sides = 4;
}

class Triangle extends Square {
    int sides = 3;

    public void countSides() {
        System.out.println("正方形的边数: " + sides);
        System.out.println("三角形的边数: " + super.sides);
    }
}

静态多态性和动态多态性

静态多态性（编译时多态性）：在编译阶段执行，方法重载是典型的静态多态性。
动态多态性（运行时多态性）：在程序执行阶段处理，方法重写是典型的动态多态性。

总结

Java 是一种广泛使用的面向对象编程语言，其核心概念围绕着四个基本原则：抽象（Abstraction）、封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）。下面是对这些概念的详细总结：

1. 抽象（Abstraction）

定义：抽象是指隐藏复杂的实现细节，只向用户展示必要的信息。
实现方式 ：
- 抽象类 ：使用 abstract 关键字定义的类，可以包含抽象方法（没有实现的方法）。
- 接口：使用 interface 关键字定义的完全抽象类，所有方法都是抽象的。

示例：

java 复制代码

abstract class Animal {
    abstract void makeSound();
}

interface Flyable {
    void fly();
}

2. 封装（Encapsulation）

定义：封装是指将数据成员和方法绑定在一起，并将它们声明为私有，以保护对象的内部状态。
实现方式 ：
- 访问修饰符 ：使用 private、protected 和 public 控制类成员的访问权限。
- getter 和 setter 方法：提供方法来访问和修改私有成员。

示例：

java 复制代码

class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

3. 继承（Inheritance）

定义：继承是 OOP 中简化软件开发的一种方法。它允许通过继承已定义类的数据成员和方法来创建新的类。
实现方式 ：
- 单继承：一个类只能继承一个父类。
- 多级继承：一个类可以继承另一个类，后者又可以继承另一个类。
- 层次继承：多个类可以从同一个父类继承。
- 混合继承：结合单继承、多级继承和层次继承。

示例：

java 复制代码

class Animal {
    void eat() {
        System.out.println("Animal eats");
    }
}

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

class Puppy extends Dog {
    void weep() {
        System.out.println("Puppy weeps");
    }
}

4. 多态（Polymorphism）

定义：多态是指一个对象可以有多种形态的能力。在 Java 中，多态主要通过方法重载（Overloading）和方法重写（Overriding）来实现。
实现方式 ：
- 方法重载（Overloading）：在一个类中定义多个同名方法，但方法的参数列表不同。
- 方法重写（Overriding）：子类重新实现父类中的方法。

示例：

java 复制代码

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

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

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

public class PolymorphismDemo {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myAnimal.sound(); // Animal makes a sound
        myDog.sound();    // Dog barks
        myCat.sound();    // Cat meows
    }
}