Java面向对象

Java 面向对象

什么是面向对象

面向对象是一种以“对象”为中心的编程思想，将程序中的数据和操作 组织起来，形成一个对象。对象之间可以相互交互，通过调用彼此的方法来实现功能。面向对象就是把现实世界中的事物抽象成程序中的对象，通过对象之间的交互来完成任务。

什么是面向过程

面向过程是一种以事件为中心的编程思想。把解决的问题的步骤分析出来，然后用函数把这些步骤实现，在一步一步的具体步骤中再按顺序调用函数。

举个例子：将大象放入冰箱

按照面向过程的设计思路是先分析这个问题的步骤：（1）打开冰箱门 （2）将大象放入 （3）关闭冰箱门

按照面向对象的设计思路是 将分为三个对象：（1）大象 （2）冰箱
然后赋予对象一些属性和行为：第一类对象（大象）有 大小，颜色等。第二类对象（冰箱）有：大小，品牌，方法有：打开冰箱门、关闭冰箱门等。

面向对象的三大核心特征

1. 可重用性 ，代码重复使用，减少代码量，提高开发效率。面向对象的三大基本特征（继承、封装和多态）都围绕这个核心；
2. 可拓展性 ，指新的功能可以很容易地加入到系统中来，便于软件的修改；
3. 客观理性 ，能够将功能与数据结合，方便管理；

Java抽象类

抽象类

抽象类是一种在编程中用来表示概念上的共性的东西，它本身不能被实例化，只能被其他类继承。抽象类定义了一些方法和属性，但并没有提供具体的实现，而是留下了一些抽象的部分，需要由子类去实现。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

想象一下，如果类是一种模板，抽象类就是一个更高级别的模板，它规定了一些共同的特征，但没有给出具体的形态。子类需要根据这个抽象模板提供具体的实现，填补抽象部分，使得抽象类变得具体而可实例化。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。

在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

举个例子，假设有一个抽象类叫做“动物”，它定义了一个抽象方法叫做“发出声音”。具体的动物，比如狗、猫，都可以继承这个抽象类，并实现自己的“发出声音”方法，因为每种动物发出声音的方式是不同的。这样，“动物”作为抽象类就提供了一种通用的框架，让不同的子类根据自身特点来完善这个框架。

抽象方法

如果你想设计一个类，该类包含一个特别的成员方法，该方法的具体实现由它的子类确定，那么你可以在父类中声明该方法为抽象方法。

抽象方法只包含一个方法名，而没有方法体。

声明抽象方法会造成以下两个结果：

1. 如果一个类包含抽象方法，那么该类必须是抽象类。
2. 任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

继承抽象方法的子类必须重写该方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象。

Java接口

Java接口是一种抽象的数据类型，用于定义一组方法的规范，但不提供这些方法的具体实现。接口充当了一种契约或合同的角色，规定了一个类应该具备哪些行为，而具体的实现则由实现该接口的类来完成。

一个接口可以有多个方法。
接口不能用于实例化对象。
接口没有构造方法。
接口不是被类继承了，而是要被类实现。
接口支持多继承。
接口不能用于实例化对象。
一个类只能继承一个抽象类，而一个类却可以实现多个接口。

接口实现

通过实现接口，一个类可以遵循接口规范并提供自己的具体实现。一个类可以实现多个接口，从而具备多种行为。接口在Java中提供了一种灵活的方式来实现多重继承，因为类只能单继承，但可以实现多个接口。

类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。

接口继承

一个接口能继承另一个接口，和类之间的继承方式比较相似。接口的继承使用extends关键字，子接口继承父接口的方法。

举个例子 如下

// 定义一个接口
interface Shape {
    // 接口中的抽象方法（方法没有具体实现）
    double calculateArea();

    // 接口中的默认方法（有默认实现，子类可以选择性覆盖）
    default void displayInfo() {
        System.out.println("This is a shape.");
    }
}

// 实现接口的类：圆形
class Circle implements Shape {
    double radius;

    // 构造方法
    public Circle(double radius) {
        this.radius = radius;
    }

    // 实现接口中的抽象方法
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }

    // 可选地覆盖接口中的默认方法
    @Override
    public void displayInfo() {
        System.out.println("This is a circle.");
    }
}

// 实现接口的类：正方形
class Square implements Shape {
    double side;

    // 构造方法
    public Square(double side) {
        this.side = side;
    }

    // 实现接口中的抽象方法
    @Override
    public double calculateArea() {
        return side * side;
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建圆形对象并调用方法
        Circle circle = new Circle(5.0);
        System.out.println("Circle Area: " + circle.calculateArea());
        circle.displayInfo();

        // 创建正方形对象并调用方法
        Square square = new Square(4.0);
        System.out.println("Square Area: " + square.calculateArea());
        square.displayInfo();
    }
}

类和对象的理解

类(Class)和对象(Object)是面向对象的核心概念。

类是对一类事物的描述，是抽象的。
对象是实际存在的该类事物的每个个体，所以也被称为实例。
比如人会说话、唱歌、吃饭；
这里的人其实就是一个“类”，
小明会说话、唱歌；这里小明就是对象，是”人“的实例化，或者叫类的对象。

举个例子，如下

class Car {
    // 成员变量
    String brand;
    String model;
    int year;

    // 构造方法
    public Car(String brand, String model, int year) {
        this.brand = brand;
        this.model = model;
        this.year = year;
    }

    // 成员方法
    public void displayInfo() {
        System.out.println("Brand: " + brand);
        System.out.println("Model: " + model);
        System.out.println("Year: " + year);
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建对象实例
        Car myCar = new Car("Toyota", "Camry", 2022);

        // 调用对象的方法
        myCar.displayInfo();
    }
}
//Car 类定义了一个汽车的模板，包括了三个属性，以及一个显示信息的方法。
//main 方法中创建了一个 Car 类的对象 myCar，并通过构造方法初始化其属性。调用了 myCar 对象的 displayInfo 方法，显示了汽车的信息。
//这个例子中，Car 类就是一个类的定义，而 myCar 对象则是根据这个类创建的实例。类定义了对象的结构和行为，而对象则是类的具体体现。

三大特性

封装

它指的是将一个对象的内部细节隐藏起来，只暴露对外必要的接口和功能。在Java中，封装通过使用访问修饰符（如private、protected、public）来实现。

继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
1.父类和子类父类是被继承的类，子类是进行继承的类。子类可以继承父类的属性和方法，并且可以在此基础上扩展或修改。

// 父类
public class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

// 子类
public class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking");
    }
}

2.拓展和重写 子类可以通过继承来获取父类的方法，也可以在需要时进行扩展或者重写。扩展是指在原有方法的基础上添加新的功能，而重写是指子类提供了与父类同名但实现不同的方法。

// 父类
public class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

// 子类扩展父类方法
public class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking");
    }

    // 重写父类方法
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
}

3.super关键字 子类可以使用 super 关键字调用父类的方法或者属性。这是在子类中访问父类成员的一种方式。

// 父类
public class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

// 子类使用super调用父类方法
public class Dog extends Animal {
    public void eat() {
        super.eat(); // 调用父类的eat方法
        System.out.println("Dog is eating");
    }
}

多态

多态是同一个行为具有多个不同表现形式或形态的能力。
具体来说，多态有以下两种形式：
1.编译时多态 通过方法重载实现，根据参数个数顺序等来选择调用哪个方法。

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

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

2.运行时多态 通过方法重写实现，根据对象的实际类型来确定调用哪个版本的方法。

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

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

Animal myPet = new Dog();
myPet.makeSound(); // 运行时选择Dog版本的makeSound