请写示例代码 抽象类具体实现,子类继承抽象类 java
时间: 2023-10-31 17:51:04 浏览: 63
好的,以下是示例代码:
// 定义一个抽象类
abstract class Animal {
String name;
// 定义一个抽象方法
public abstract void sound();
// 定义一个具体方法
public void setName(String name) {
this.name = name;
}
}
// 定义一个继承自Animal的子类
class Dog extends Animal {
@Override
public void sound() {
System.out.println("汪汪汪");
}
}
// 定义一个继承自Animal的子类
class Cat extends Animal {
@Override
public void sound() {
System.out.println("喵喵喵");
}
}
// 使用Animal和它的子类
public class Main {
public static void main(String[] args) {
Animal dog = new Dog();
Animal cat = new Cat();
dog.setName("旺财");
cat.setName("淘气");
dog.sound(); // 输出:汪汪汪
cat.sound(); // 输出:喵喵喵
}
}
相关问题
Java的抽象类和python的抽象类实现方法一样吗,请写出代码比较
Java和Python在实现抽象类的方式上有一些差异。下面是一个比较 Java 和 Python 中抽象类的实现方法的示例代码:
Java 示例代码:
```java
// 抽象类
abstract class Animal {
// 抽象方法
public abstract void sound();
}
// 继承抽象类
class Dog extends Animal {
// 实现抽象方法
public void sound() {
System.out.println("汪汪汪!");
}
}
// 继承抽象类
class Cat extends Animal {
// 实现抽象方法
public void sound() {
System.out.println("喵喵喵!");
}
}
public class Main {
public static void main(String[] args) {
Animal dog = new Dog();
Animal cat = new Cat();
dog.sound(); // 输出:汪汪汪!
cat.sound(); // 输出:喵喵喵!
}
}
```
Python 示例代码:
```python
from abc import ABC, abstractmethod
# 抽象类
class Animal(ABC):
# 抽象方法
@abstractmethod
def sound(self):
pass
# 继承抽象类
class Dog(Animal):
# 实现抽象方法
def sound(self):
print("汪汪汪!")
# 继承抽象类
class Cat(Animal):
# 实现抽象方法
def sound(self):
print("喵喵喵!")
dog = Dog()
cat = Cat()
dog.sound() # 输出:汪汪汪!
cat.sound() # 输出:喵喵喵!
```
在 Java 中,使用 `abstract` 关键字来定义抽象类和抽象方法。抽象类不能被实例化,只能作为其他类的父类被继承。子类必须实现父类中的所有抽象方法。
而在 Python 中,通过继承 `ABC` 类,并使用 `@abstractmethod` 装饰器来定义抽象类和抽象方法。与 Java 类似,抽象类不能被实例化,只能作为其他类的父类被继承。子类必须实现父类中的所有抽象方法。
尽管 Java 和 Python 在语法上有一些差异,但它们的抽象类的实现方法的思想是相似的:提供一个抽象的基类,子类必须实现基类中的抽象方法。这样可以确保子类在继承时具有一致的行为和接口。
Java抽象类继承抽象类
Java中的抽象类可以继承其他抽象类。当一个抽象类继承另一个抽象类时,它可以选择实现父类中的抽象方法,也可以将这些方法保留为抽象方法,由子类来实现。
以下是一个示例代码:
```java
abstract class AbstractClass1 {
abstract void method1();
}
abstract class AbstractClass2 extends AbstractClass1 {
abstract void method2();
}
class ConcreteClass extends AbstractClass2 {
void method1() {
// 实现抽象方法method1
}
void method2() {
// 实现抽象方法method2
}
}
public class Main {
public static void main(String[] args) {
ConcreteClass obj = new ConcreteClass();
obj.method1();
obj.method2();
}
}
```
在上面的示例中,AbstractClass1是一个抽象类,它定义了一个抽象方法method1。AbstractClass2继承了AbstractClass1,并定义了另一个抽象方法method2。最后,ConcreteClass继承了AbstractClass2,并实现了所有的抽象方法。