java 方法重写与权限修饰符以及多态和抽象类详解概念和用法

Java方法重写与权限修饰符以及多态和抽象类是面向对象编程中非常重要的概念和用法。下面将详细讲解。

Java方法重写与权限修饰符

什么是方法重写

方法重写是指在子类中重新定义继承自父类的同名方法，其方法签名（即方法的名称、参数类型和数量）必须与父类方法相同，但方法体可以不同。方法重写的目的是为了实现方法的多态性，即同一种方法，在不同的子类中所表现出的行为不同。

方法重写的规则

• 子类方法与父类方法具有相同的名称、参数列表和方法返回类型；
• 子类方法的访问权限不能低于父类方法的访问权限；
• 子类方法不能抛出比父类方法更多的异常；
• 子类方法不能重写父类方法中被 final 修饰的方法；

下面通过示例说明方法重写的使用：

class Animal {
    public void move() {
        System.out.println("动物可以移动");
    }
}

class Dog extends Animal {
    public void move() {
        super.move();
        System.out.println("狗可以跑和走");
    }
}

public class TestDog {
    public static void main(String args[]) {
        Animal animal = new Animal(); // Animal 对象
        Animal dog = new Dog(); // Dog 对象

        animal.move();// 执行 Animal 类的方法
        dog.move();//执行 Dog 类的方法
    }
}

输出结果为：

动物可以移动
动物可以移动
狗可以跑和走

权限修饰符

Java中的访问权限修饰符主要有public、private、protected和默认（即不加修饰符）。它们的具体含义如下：

• public：表示该类、方法或成员变量对所有类可见，不论是同一个包中的类还是不同包中的类；
• private：表示该类、方法或成员变量仅对该类内部、同一个包中的类及其子类可见；
• protected：表示该类、方法或成员变量仅对该类内部、同一个包中的类及其子类和其他包中的子类可见；
• 默认（不加修饰符）：表示该类、方法或成员变量仅对同一个包中的类可见。

下面通过示例说明权限修饰符的使用：

class Animal {
    private String name;  // 私有成员变量

    public void setName(String name) {  // 公有成员方法
        this.name = name;
    }

    public String getName() {   // 公有成员方法
        return name;
    }
}

public class Cat extends Animal {
    private String color;  // 私有成员变量

    public void setColor(String color) {  // 公有成员方法
        this.color = color;
    }

    public String getColor() {   // 公有成员方法
        return color;
    }
}

在上面的示例中，Animal类中的成员变量name和Cat类中的成员变量color都使用了private修饰符，因此它们仅对各自的类内部可见。Animal类中的成员方法setName和getName使用了public修饰符，在类的外部可以通过对象调用这两个方法。Cat类中的成员方法setColor和getColor也使用了public修饰符，在类的子类和类的外部都可以通过对象调用这两个方法。

多态和抽象类

什么是多态

多态是指同一种类型的对象，在不同的情况下表现出不同的行为，即同一种对象在不同的场景下具有不同的状态和行为。多态分为编译时多态和运行时多态。

编译时多态

编译时多态是指在编译时确定方法的调用对象和方法的实现体，即在编译时就确定方法的行为。编译时多态主要通过方法的重载来实现。

运行时多态

运行时多态是指在运行时确定方法的调用对象和方法的实现体，即在运行时根据对象的实际类型来确定方法的行为。运行时多态主要通过方法的重写和接口来实现。

什么是抽象类

抽象类是一种不能被实例化的类，该类主要用于作为其他类的父类，为子类提供统一的接口和行为。抽象类中可以包含抽象方法和非抽象方法，其中抽象方法必须由子类来实现。

下面通过示例说明多态和抽象类的使用：

abstract class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

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

    public void sayHello() {    // 非抽象方法
        System.out.println("我是一只" + name);
    }
}

class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    public void eat() {   // 实现抽象方法
        System.out.println(name + "喜欢吃鱼");
    }
}

class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    public void eat() {   // 实现抽象方法
        System.out.println(name + "喜欢吃骨头");
    }
}

public class TestAnimal {
    public static void main(String args[]) {
        Animal animal1 = new Cat("小猫");  // 使用父类引用变量存储子类对象
        animal1.sayHello();
        animal1.eat();  // 执行子类的实现方法

        Animal animal2 = new Dog("小狗");  // 使用父类引用变量存储子类对象
        animal2.sayHello();
        animal2.eat();  // 执行子类的实现方法
    }
}

在上面的示例中，Animal类是一个抽象类，其中包含一个抽象方法eat和一个非抽象方法sayHello。Cat类和Dog类继承自Animal类，并实现了抽象方法eat。TestAnimal类中创建了Animal类的对象animal1和animal2，它们分别存储了Cat类和Dog类的对象。由于Cat类和Dog类继承自Animal类，因此可以使用Animal类的引用变量来存储它们的对象。当调用animal1.eat()时，实际上是调用了Cat类中的eat方法；当调用animal2.eat()时，实际上是调用了Dog类中的eat方法。这体现了运行时多态的特性。