9. 编写一个程序,定义一个Shape类,包含属性double类型的width和height,以及一个计算面积的方法area()。然后定义一个Rectangle类和一个Triangle类继承Shape类,并分别实现它们自己的area()方法。在主函数中创建一个Rectangle对象和一个Triangle对象,并分别调用它们的area()方法。
时间: 2024-03-12 11:49:37 浏览: 92
好的,以下是代码实现:
```python
class Shape:
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
pass
class Rectangle(Shape):
def area(self):
return self.width * self.height
class Triangle(Shape):
def area(self):
return self.width * self.height / 2
# 在主函数中测试
rectangle = Rectangle(5, 6)
triangle = Triangle(5, 6)
print("矩形面积为:", rectangle.area())
print("三角形面积为:", triangle.area())
```
输出结果:
```
矩形面积为: 30
三角形面积为: 15.0
```
以上就是实现一个Shape类,以及Rectangle类和Triangle类继承Shape类,并分别实现它们自己的area()方法的完整代码。
相关问题
12 形状类 设计一个形状 Shape 类和它的两个实现类圆 Circle 和矩形 Rectangle ,并编写测试程序。按如下要求完成程序的编写: 1、添加一个类 Shape ,该类中编写一个方法 area ,方法无参数,返回值为 double 类型,默认返回0。 2、 Circle 类的编写:(1)添加一个类 Circle ,从 Shape 类继承;(2)定义一个 double 类型的字段 r ,代表圆的半径;(3)定义一个构造函数,该构造函数接受一个 double 类型的参数,并保存到字段 r 中; (4)覆写 area ()方法,并编写程序计算圆的面积。π取3.14。 3、 Rectangle 类的编写 (1)添加一个类 Rectangle ,从 Shape 类继承;(2)定义两个 double 类型的字段 width 和 height ,分别代表矩形的宽和高; (3)定义一个构造函数,该构造函数接受两个 double 类型的参数,并分别保存到字段 width 和 height 中; (4)覆写 area ()方法,并编写程序计算矩形的面积。 5、测试类的编写 main 方法中编写测试程序: (1)创建一个 Circle 类对象,半径为2,调用 Area 方法计算面积,并输出。 (2)创建一个 Rectangle 类对象,长3,宽5,调用 Area 方法计算面积,并输出。
以下是代码实现:
```java
// Shape 类
class Shape {
public double area() {
return 0;
}
}
// Circle 类
class Circle extends Shape {
private double r;
public Circle(double r) {
this.r = r;
}
@Override
public double area() {
return 3.14 * r * r;
}
}
// Rectangle 类
class Rectangle extends Shape {
private double width;
private double height;
public Rectangle(double width, double height) {
this.width = width;
this.height = height;
}
@Override
public double area() {
return width * height;
}
}
// 测试类
public class Test {
public static void main(String[] args) {
// 创建 Circle 类对象并计算面积
Circle circle = new Circle(2);
System.out.println("圆的面积为:" + circle.area());
// 创建 Rectangle 类对象并计算面积
Rectangle rectangle = new Rectangle(3, 5);
System.out.println("矩形的面积为:" + rectangle.area());
}
}
```
输出结果为:
```
圆的面积为:12.56
矩形的面积为:15.0
```
1、(类的继承)编写一个Java程序,要求在程序中定义一个Person类,包含属性name、ssex、age及其相关的方法,再定义一个Student类继承自Person类,Student类中增加属性sdept(所在系)及其相关的方法,然后再定义一个主类MainClass,在main()方法中,生成Student类的对象stu,并用stu调用相应的方法设置与输出相应类的成员变量; 2、(继承关系中构造方法的调用顺序)编写一个具有F01、F02和F03三个类的Java程序,F01继承自F02,F02继承自F03,每个类都有自己的无参构造方法,实例化某一个类,验证继承关系中构造方法的调用顺序; 3、(方法的覆盖)编写一个Java程序,在程序中定义一个水果类Fruit,再定义Fruit类的两个子类Apple类和Banana类,在子类中重写父类的 disp() 方法,设计一个程序,验证方法的覆盖效果; 4、(抽象类)编写一个Java程序,在程序中定义一个抽象类Shape,包含两个抽象方法,一个是计算面积 area() ,一个是显示面积 showArea(),再定义Shape类的两个子类 Rectangle 类和 Circle 类,设计一个程序,输出矩形和圆的面积; 5、(接口的定义与类实现接口)编写一个Java程序,在程序中定义一个接口 Shape,包含两个抽象方法,一个是计算面积 area(),一个计算体积volume(),再定义一个类 Cylinder,实现这个Shape接口,设计一个程序,输出面积和体积; 6、(接口实现类多重继承及名字冲突)编写一个Java程序,要求定义两个接口Face01 和Face02,在接口Face01中定义一个抽象方法 getName() 和一个默认方法 getNum() ,在接口Face02中定义一个同名的默认方法 getNum();再定义NameConflict 类实现这两个接口,实现抽象方法 getName() 和默认方法getNum(),并在其中委托父接口Face01中的同名默认方法;
1、Person类和Student类的代码如下:
```
public class Person {
private String name;
private String sex;
private int age;
public void setName(String name) {
this.name = name;
}
public void setSex(String sex) {
this.sex = sex;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public String getSex() {
return sex;
}
public int getAge() {
return age;
}
}
public class Student extends Person {
private String sdept;
public void setSdept(String sdept) {
this.sdept = sdept;
}
public String getSdept() {
return sdept;
}
}
```
在MainClass类中实例化Student类的对象,并调用相应的方法设置和输出相应类的成员变量:
```
public class MainClass {
public static void main(String[] args) {
Student stu = new Student();
stu.setName("张三");
stu.setSex("男");
stu.setAge(20);
stu.setSdept("计算机科学与技术");
System.out.println("姓名:" + stu.getName());
System.out.println("性别:" + stu.getSex());
System.out.println("年龄:" + stu.getAge());
System.out.println("所在系:" + stu.getSdept());
}
}
```
2、F01、F02和F03三个类的代码如下:
```
public class F03 {
public F03() {
System.out.println("F03");
}
}
public class F02 extends F03 {
public F02() {
System.out.println("F02");
}
}
public class F01 extends F02 {
public F01() {
System.out.println("F01");
}
}
```
在MainClass类中实例化F01类的对象,验证继承关系中构造方法的调用顺序:
```
public class MainClass {
public static void main(String[] args) {
F01 f01 = new F01();
}
}
```
输出结果为:
```
F03
F02
F01
```
3、Fruit类、Apple类和Banana类的代码如下:
```
public class Fruit {
public void disp() {
System.out.println("水果的颜色是红色或黄色");
}
}
public class Apple extends Fruit {
@Override
public void disp() {
System.out.println("这是一个红色的苹果");
}
}
public class Banana extends Fruit {
@Override
public void disp() {
System.out.println("这是一个黄色的香蕉");
}
}
```
在MainClass类中实例化Apple类和Banana类的对象,验证方法的覆盖效果:
```
public class MainClass {
public static void main(String[] args) {
Fruit apple = new Apple();
Fruit banana = new Banana();
apple.disp();
banana.disp();
}
}
```
输出结果为:
```
这是一个红色的苹果
这是一个黄色的香蕉
```
4、Shape类、Rectangle类和Circle类的代码如下:
```
public abstract class Shape {
public abstract double area();
public abstract void showArea();
}
public class Rectangle extends Shape {
private double length;
private double width;
public Rectangle(double length, double width) {
this.length = length;
this.width = width;
}
@Override
public double area() {
return length * width;
}
@Override
public void showArea() {
System.out.println("矩形的面积为:" + area());
}
}
public class Circle extends Shape {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
@Override
public double area() {
return Math.PI * radius * radius;
}
@Override
public void showArea() {
System.out.println("圆的面积为:" + area());
}
}
```
在MainClass类中实例化Rectangle类和Circle类的对象,并输出矩形和圆的面积:
```
public class MainClass {
public static void main(String[] args) {
Rectangle rectangle = new Rectangle(3, 4);
Circle circle = new Circle(5);
rectangle.showArea();
circle.showArea();
}
}
```
输出结果为:
```
矩形的面积为:12.0
圆的面积为:78.53981633974483
```
5、Shape接口和Cylinder类的代码如下:
```
public interface Shape {
public double area();
public double volume();
}
public class Cylinder implements Shape {
private double radius;
private double height;
public Cylinder(double radius, double height) {
this.radius = radius;
this.height = height;
}
@Override
public double area() {
return 2 * Math.PI * radius * radius + 2 * Math.PI * radius * height;
}
@Override
public double volume() {
return Math.PI * radius * radius * height;
}
}
```
在MainClass类中实例化Cylinder类的对象,并输出面积和体积:
```
public class MainClass {
public static void main(String[] args) {
Cylinder cylinder = new Cylinder(3, 5);
System.out.println("圆柱的面积为:" + cylinder.area());
System.out.println("圆柱的体积为:" + cylinder.volume());
}
}
```
输出结果为:
```
圆柱的面积为:150.79644737231007
圆柱的体积为:141.3716694115407
```
6、Face01接口、Face02接口和NameConflict类的代码如下:
```
public interface Face01 {
public String getName();
default public int getNum() {
return 1;
}
}
public interface Face02 {
default public int getNum() {
return 2;
}
}
public class NameConflict implements Face01, Face02 {
@Override
public String getName() {
return "张三";
}
@Override
public int getNum() {
return Face01.super.getNum();
}
}
```
在MainClass类中实例化NameConflict类的对象,并调用getName()方法和getNum()方法:
```
public class MainClass {
public static void main(String[] args) {
NameConflict nameConflict = new NameConflict();
System.out.println("姓名:" + nameConflict.getName());
System.out.println("编号:" + nameConflict.getNum());
}
}
```
输出结果为:
```
姓名:张三
编号:1
```
阅读全文