用简单的java代码演示继承，封装，多态

当然可以！下面是一个简单的Java代码示例，演示了继承、封装和多态的概念：

// 父类：动物类
class Animal {
    private String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void eat() {
        System.out.println(name + "正在进食");
    }
}

// 子类：狗类，继承自动物类
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    
    public void bark() {
        System.out.println("汪汪汪");
    }
}

// 子类：猫类，继承自动物类
class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
    
    public void meow() {
        System.out.println("喵喵喵");
    }
}

// 主函数入口
public class Main {
    public static void main(String[] args) {
＊＊＊

相关问题

用Java实现继承多态封装代码

下面是一个简单的Java代码示例，演示了如何使用继承、多态和封装：

// 定义一个Animal类
class Animal {
    private String name;
    private int age;

    public Animal(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(name + " is eating.");
    }
}

// 定义一个Dog类，继承自Animal类
class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }

    // 重写eat方法
    @Override
    public void eat() {
        System.out.println(getName() + " is eating bones.");
    }

    // 新增方法
    public void bark() {
        System.out.println("Woof! Woof!");
    }
}

// 定义一个Cat类，继承自Animal类
class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }

    // 重写eat方法
    @Override
    public void eat() {
        System.out.println(getName() + " is eating fish.");
    }

    // 新增方法
    public void meow() {
        System.out.println("Meow! Meow!");
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Animal("Animal", 5);
        animal1.eat(); // 输出：Animal is eating.

        Dog dog1 = new Dog("Dog", 3);
        dog1.eat(); // 输出：Dog is eating bones.
        dog1.bark(); // 输出：Woof! Woof!

        Cat cat1 = new Cat("Cat", 2);
        cat1.eat(); // 输出：Cat is eating fish.
        cat1.meow(); // 输出：Meow! Meow!

        // 使用多态
        Animal animal2 = new Dog("Poodle", 1);
        animal2.eat(); // 输出：Poodle is eating bones.
        // animal2.bark(); // 编译错误，Animal类没有bark方法

        Animal animal3 = new Cat("Siamese", 2);
        animal3.eat(); // 输出：Siamese is eating fish.
        // animal3.meow(); // 编译错误，Animal类没有meow方法
    }
}

在上面的代码中，我们定义了一个Animal类，它有私有的name和age属性，以及公有的getName、getAge和eat方法。然后我们定义了一个Dog类和一个Cat类，它们都继承自Animal类，并且分别重写了eat方法，并新增了各自的方法bark和meow。

在测试类Main中，我们分别创建了一个Animal、一个Dog和一个Cat对象，并调用了它们的方法。然后我们使用多态，将一个Dog对象和一个Cat对象分别赋值给Animal类型的变量，然后调用它们的eat方法。可以看到，它们分别调用了Dog和Cat类中重写的eat方法，而不是Animal类中的eat方法。此外，由于Animal类没有bark和meow方法，我们无法在animal2和animal3对象上调用这些方法。

java抽象封装继承多态

Java中的四大特性是抽象、封装、继承和多态。其中，抽象类和接口是实现抽象的两种方式，而封装则是将数据和方法包装在一起，以保护数据不被外部直接访问和修改。继承则是通过子类继承父类的属性和方法，实现代码的复用和扩展。多态则是同一种行为具有多种不同表现形式或形态的能力。

具体来说，抽象类是一种不能被实例化的类，其中可以包含抽象方法和非抽象方法。抽象方法没有具体的实现，需要在子类中被实现。而非抽象方法则有具体的实现，可以被子类继承和重写。抽象类可以作为其他类的父类，子类需要实现其中的抽象方法才能被实例化。

封装则是将数据和方法包装在一起，以保护数据不被外部直接访问和修改。Java中可以使用private、protected和public三种访问修饰符来实现封装。private修饰的属性和方法只能在类内部访问，protected修饰的属性和方法可以在类内部和子类中访问，而public修饰的属性和方法可以在任何地方访问。

继承则是通过子类继承父类的属性和方法，实现代码的复用和扩展。Java中使用extends关键字来实现继承。子类可以继承父类的public和protected属性和方法，但不能继承private属性和方法。子类可以重写父类的方法，也可以使用super关键字调用父类的方法。

多态则是同一种行为具有多种不同表现形式或形态的能力。Java中通过继承和接口实现多态。具体来说，子类可以重写父类的方法，实现不同的行为表现形式。而接口则可以让不同的类实现相同的方法，实现不同的行为表现形式。

下面是一个简单的Java代码示例，演示了抽象、封装、继承和多态的使用：

// 抽象类
abstract class Animal {
    // 封装
    private String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    // 抽象方法
    public abstract void makeSound();
    
    // 非抽象方法
    public void eat() {
        System.out.println(name + " is eating.");
    }
}

// 继承
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    
    // 重写父类方法
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

// 多态
class AnimalSound {
    public static void makeSound(Animal animal) {
        animal.makeSound();
    }
}

public class Main {
    public static void main(String[] args) {
        // 多态
        Animal dog = new Dog("Buddy");
        dog.makeSound(); // 输出：Woof!
        dog.eat(); // 输出：Buddy is eating.
        
        // 多态
        AnimalSound.makeSound(dog); // 输出：Woof!
    }
}