重生之我在deepseek中学习java 第四天-Java-E先生的博客

Java学习指南-第四天：继承与多态

　　1.继承

　　继承是面向对象编程的一个重要特性，允许一个类（子类）继承另一个类（父类）的属性和方法。通过继承，可以实现代码的重用和扩展。

　　1.1定义父类和子类

// 父类
public class Animal {
    String name;

    public void eat() {
        System.out.println(name + " is eating.");
    }
}

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

　　1.2使用继承

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.name = "Buddy";
        myDog.eat();  // 继承自Animal类
        myDog.bark(); // Dog类自己的方法
    }
}

　　2.方法重写

　　子类可以重写（Override）父类的方法，以提供不同的实现。

　　2.1方法重写示例

public class Animal {
    String name;

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

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println(name + " is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.name = "Buddy";
        myDog.makeSound();  // 输出: Buddy is barking.
    }
}

　　3.super关键字

　　 super关键字用于引用父类的属性和方法。

　　3.1使用super调用父类构造方法

public class Animal {
    String name;

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

public class Dog extends Animal {
    public Dog(String name) {
        super(name);  // 调用父类构造方法
    }

    public void bark() {
        System.out.println(name + " is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog("Buddy");
        myDog.bark();  // 输出: Buddy is barking.
    }
}

　　3.2使用super调用父类方法　　

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

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

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat();  // 输出: Animal is eating. Dog is also eating.
    }
}

　　4.多态

　　多态是指同一个方法在不同对象中有不同的实现。多态可以通过方法重写和接口实现来实现。

　　4.1多态示例

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

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

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat is meowing.");
    }
}

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

        myAnimal.makeSound();  // 输出: Animal is making a sound.
        myDog.makeSound();     // 输出: Dog is barking.
        myCat.makeSound();     // 输出: Cat is meowing.
    }
}

　　5.今日任务

定义一个Vehicle父类，包含属性brand和方法start。
定义两个子类Car和Motorcycle，分别重写start方法。
使用多态创建Vehicle类型的对象数组，调用start方法。

　　6.示例代码

public class Vehicle {
    String brand;

    public Vehicle(String brand) {
        this.brand = brand;
    }

    public void start() {
        System.out.println(brand + " is starting.");
    }
}

public class Car extends Vehicle {
    public Car(String brand) {
        super(brand);
    }

    @Override
    public void start() {
        System.out.println(brand + " car is starting.");
    }
}

public class Motorcycle extends Vehicle {
    public Motorcycle(String brand) {
        super(brand);
    }

    @Override
    public void start() {
        System.out.println(brand + " motorcycle is starting.");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle[] vehicles = new Vehicle[2];
        vehicles[0] = new Car("Toyota");
        vehicles[1] = new Motorcycle("Honda");

        for (Vehicle vehicle : vehicles) {
            vehicle.start();
        }
    }
}

　　7.总结

　　今天的内容涵盖了继承、方法重写、super关键字和多态。这些是面向对象编程的核心概念，务必熟练掌握。明天我们将深入学习抽象类和接口。

　　提示：多动手编写代码，尝试定义不同的父类和子类，使用方法重写和多态。这将帮助你更好地理解面向对象编程的概念。

　　祝你学习愉快！