public class Animal { protected final String name; public Animal(String name) { this.name = name; } public void eat() { System.out.println("Animal is eating."); }}public class Dog extends Animal { public Dog(String name) { super(name); } @Override public void eat() { super.eat(); System.out.println("Dog is also eating."); }}

这段代码展示了一个父类 Animal 和一个子类 Dog。Dog 继承自 Animal，即 Dog 是 Animal 的子类，Animal 是 Dog 的父类。在这里，Animal 类中有一个构造方法和一个 eat() 方法，Dog 类通过 super(name) 调用 Animal 类中的构造方法，然后重写了 eat() 方法，在方法中调用了父类的 eat() 方法并添加了自己的行为。这个例子展示了面向对象的继承特性，子类可以继承父类的属性和方法，并且可以在此基础上添加自己的行为。

相关问题

abstract class 和 interface 有什么区别?用案例演示

抽象类（Abstract Class）和接口（Interface）都是 Java 中用于实现多态的重要工具，它们的区别主要体现在以下几个方面：

1. 实现方式：
- **抽象类**：可以包含抽象方法（无实现的方法，只有方法声明），也可以有非抽象方法和字段。抽象类一般用来定义类族的共同属性和行为的模板。
- **接口**：只包含常量（static final修饰的变量）和抽象方法（默认无方法体）。接口不能包含字段，只能定义方法的行为规范。

2. 访问权限：
- **抽象类**：成员（包括字段和方法）的访问权限可以根据需要设置为 public、protected 或者 default（包内可见）。
- **接口**：所有方法默认为 public，除非另有说明。

3. 子类约束：
- **抽象类**：一个类可以继承一个抽象类，并可以选择是否实现其抽象方法。如果实现了全部抽象方法，该类可以不用声明为抽象类。
- **接口**：类只能实现接口，一旦实现，则必须实现接口的所有抽象方法（除非它也声明为abstract）。

4. 示例：

// 抽象类示例
public abstract class Animal {
    private String name;
    
    // 非抽象方法
    public void eat() {
        System.out.println(name + " is eating");
    }
    
    // 抽象方法，没有实现
    public abstract void makeSound();
}

// 接口示例
public interface Flyable {
    void fly();
}

// 子类实现
public class Dog extends Animal { // 狗不是飞行动物
    @Override
    public void makeSound() {
        System.out.println(name + " barks");
    }
}

public class Bird implements Flyable { // 鸟类实现了fly方法
    @Override
    public void fly() {
        System.out.println(name + " flies");
    }
}

（1）包含类的封装，get/set方法。 (10分) （2）包含构造方法和构造方法的重载。 （10分） (3)包含继承，方法重写。(10分) (4)包含抽象类和接口。(10分) （5）包含异常处理机制。（10分） （6）包含自定义异常。 (10分） （7)包含super，final关键字。 (10分) (8)包含多态。(10分) (9)包含4个字符串处理方法。(10分) (10)包含选择语句和循环语句。(10分)

非常感谢您的提问！我是一个人工智能语言模型，可以回答您的编程问题。根据您的问题，我将回答您的每一个问题如下：

1. 包含类的封装，get/set方法。

public class Student {
    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;
    }
}

2. 包含构造方法和构造方法的重载。

public class Student {
    private String name;
    private int age;

    public Student() {
        this.name = "";
        this.age = 0;
    }

    public Student(String name) {
        this.name = name;
        this.age = 0;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

3. 包含继承，方法重写。

public class Person {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

    public void sleep() {
        System.out.println("Person is sleeping.");
    }
}

public class Student extends Person {
    private String major;

    public Student(String name, int age, String major) {
        super(name, age);
        this.major = major;
    }

    @Override
    public void eat() {
        System.out.println("Student is eating.");
    }

    @Override
    public void sleep() {
        System.out.println("Student is sleeping.");
    }
}

4. 包含抽象类和接口。

public abstract class Shape {
    public abstract double getArea();
}

public interface Drawable {
    void draw();
}

public class Rectangle extends Shape implements Drawable {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double getArea() {
        return width * height;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a rectangle.");
    }
}

5. 包含异常处理机制。

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            int a = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("ArithmeticException occurred.");
        }
    }
}

6. 包含自定义异常。

public class InvalidAgeException extends Exception {
    public InvalidAgeException() {
        super("Age must be between 0 and 120.");
    }
}

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) throws InvalidAgeException {
        if (age < 0 || age > 120) {
            throw new InvalidAgeException();
        }
        this.name = name;
        this.age = age;
    }
}

7. 包含super，final关键字。

public class Animal {
    protected final String name;

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

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

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

    @Override
    public void eat() {
        super.eat();
        System.out.println("Dog is also eating.");
    }
}

8. 包含多态。

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 AnimalSound {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        animal1.makeSound();
        animal2.makeSound();
    }
}

9. 包含4个字符串处理方法。

public class StringExample {
    public static void main(String[] args) {
        String str1 = "Hello world!";
        String str2 = "HELLO WORLD!";
        String str3 = "Hello Java!";
        String str4 = "Java is a programming language.";

        System.out.println(str1.charAt(6)); // Output: w
        System.out.println(str1.equals(str2)); // Output: false
        System.out.println(str1.compareTo(str3)); // Output: -5
        System.out.println(str4.contains("programming")); // Output: true
    }
}

10. 包含选择语句和循环语句。

public class LoopExample {
    public static void main(String[] args) {
        int num = 5;

        if (num > 0) {
            System.out.println("Positive number.");
        } else if (num < 0) {
            System.out.println("Negative number.");
        } else {
            System.out.println("Zero.");
        }

        for (int i = 0; i < 5; i++) {
            System.out.println("i = " + i);
        }

        int j = 0;
        while (j < 5) {
            System.out.println("j = " + j);
            j++;
        }
    }
}

以上就是我对于每一个问题的回答，希望能够对您有所帮助！