Java多态与抽象类详解总结

多态和抽象类是Java中重要的概念，在程序设计中经常被使用。这个总结将介绍Java中多态和抽象类的实现机制和使用场景。

多态

多态是指一个对象可以通过多种方式进行引用。Java中多态实现的机制是方法重写（override）和方法重载（overload）。

方法重写（Override）

当子类继承父类时，如果子类需要重写父类中的方法（方法名、返回值类型、参数列表都相同），则可以在子类中使用@Override注解重写父类方法，并在子类中实现不同的逻辑，实现多态。

示例一：

class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat(); // 输出"猫吃鱼"
    }
}

在这个示例中，Cat类继承了Animal类，并重写了eat()方法。在Main类中，用Animal类类型的变量来引用Cat类的实例对象，利用方法重写实现了多态。

方法重载（Overload）

方法重载是指一个类中可以有多个同名方法，但是它们的参数列表不同。方法重载可以实现不同的逻辑方法，实现多态。

示例二：

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

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

public class Main {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        System.out.println(calculator.add(1, 2)); // 输出3
        System.out.println(calculator.add(1.2, 2.3)); // 输出3.5
    }
}

在这个示例中，Calculator类中有两个同名方法add()，但是参数不同，一个是int类型，返回值是int类型，另一个是double类型，返回值是double类型。在Main类中，分别使用这两个方法，利用方法重载实现了多态。

抽象类

抽象类是指不能被实例化的类，它可以用来实现多态、封装和模板方法。

如何实现

当一个类中存在抽象方法时，这个类也必须是抽象类。抽象方法是指没有具体实现的方法，只有方法签名。子类必须实现抽象方法才能被使用。

标记一个类为抽象类需要使用abstract关键字。抽象类可以有普通方法，也可以有成员变量。

示例三：

abstract class Person {
    public abstract void eat();
}

class Student extends Person {
    @Override
    public void eat() {
        System.out.println("学生在吃饭");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Student();
        person.eat(); // 输出"学生在吃饭"
    }
}

在这个示例中，Person类是一个抽象类，它只有一个抽象方法eat()，没有具体实现。Student类继承Person类，并实现了eat()方法。在Main类中，使用Person类类型的变量来引用Student类的实例对象，实现了多态。

封装

抽象类还可以实现数据封装。抽象类中的成员变量和方法可以设置不同的访问修饰符，实现不同的访问权限控制，达到数据封装的效果。

示例四：

abstract class Shape {
    protected int x;
    protected int y;

    public Shape(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public abstract void draw();  // 抽象方法

}

class Circle extends Shape {
    protected int r;

    public Circle(int x, int y, int r) {
        super(x, y);
        this.r = r;
    }

    @Override
    public void draw() {
        System.out.println("圆形的半径是：" + r);
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle(0, 0, 5);
        circle.draw(); // 输出"圆形的半径是：5"
        System.out.println("圆心坐标为：(" + circle.x + ", " + circle.y + ")");
    }
}

在这个示例中，Shape类是一个抽象类，它有两个成员变量x和y，分别表示图形的横坐标和纵坐标。成员变量x和y的访问修饰符是protected，表示它们在子类中可以访问，但是在其他地方不能直接访问，达到了数据封装的效果。

Circle类继承Shape类，使用super(x, y)调用Shape类的构造方法来初始化x和y，Circle类还有一个成员变量r，表示圆形的半径。Circle类实现了draw()方法，输出圆形的半径。

在Main类中，创建一个Circle类的实例对象，调用draw()方法输出圆形的半径，同时输出圆形的圆心坐标，由于x和y是被protected修饰的成员变量，在Main类中不能直接调用，只能通过Circle类或者Shape类的子类来调用。

模板方法

抽象类还可以实现模板方法模式。模板方法模式是指在抽象类中定义一个操作中的算法骨架，其中的某些步骤可以由具体子类来实现。在模板方法中，用抽象方法定义了一些基本操作的步骤，具体操作由子类实现。

示例五：

abstract class AbstractCalculator {
    public final int sum(int[] numbers) {
        int sum = 0;
        for (int i : numbers) {
            sum += i;
        }
        return getResult(sum);
    }

    public abstract int getResult(int sum);
}

class Adding extends AbstractCalculator {
    @Override
    public int getResult(int sum) {
        return sum;
    }
}

class Subtraction extends AbstractCalculator {
    @Override
    public int getResult(int sum) {
        return -sum;
    }
}

public class Main {
    public static void main(String[] args) {
        AbstractCalculator calculator;
        int[] numbers = {1, 2, 3, 4, 5};
        calculator = new Adding();
        System.out.println("Adding模板计算结果为：" + calculator.sum(numbers)); // 输出"Adding模板计算结果为：15"
        calculator = new Subtraction();
        System.out.println("Subtraction模板计算结果为：" + calculator.sum(numbers)); // 输出"Subtraction模板计算结果为：-15"
    }
}

在这个示例中，AbstractCalculator类是一个抽象类，它有一个sum()方法，接收一个整型数组作为参数，计算数组中所有元素的和，并将结果传递到getResult()方法中，由子类来实现具体的操作，抽象方法getResult()定义了基本操作的步骤，由具体子类来实现操作逻辑。

Adding和Subtraction类继承AbstractCalculator类，并重写getResult()方法，具体实现加法和减法操作。在Main类中，分别使用Adding类和Subtraction类，调用其sum()方法计算数组中所有元素的和，并输出计算结果。

总结

多态实现的基本机制是方法重写和方法重载，可以同时使用。

抽象类是一种特殊的类，不能被实例化，可以实现多态、封装和模板方法。

多态和抽象类是Java中重要的概念，在程序设计中经常被使用。程序员必须对多态和抽象类有深入的理解，才能写出可读性好、维护性高的代码。