实验名称：实验4：Java 中的类继承机制
一、实验目的
熟悉Java 中的类继承机制，体会继承的好处：重用和封装。
二、实验内容与结果
（说明：按实验任务分别填写任务描述、处理思路及关键技术说明、程序源码和运行结果截图，不要心得与体会。）
任务1：声明一个Person类，有name(String类型)、age(int类型)、sex(char类型)属性。通过构造方法进行赋值。一个show方法，返回String类型，内容如下：某某 男（女） 年龄
处理思路
如题，在主类中用构造方法进行赋值，调用对应show方法输出对应值
关键技术说明
返回String型数值可以return name+" "+sex+" "+age;
程序源码
package q1;
public class test {
public static void main(String args[]){
Person a =new Person("小红",18,'女');
Person b =new Person("小明",19,'男');
Person c =new Person("小黑",17,'女');
System.out.print(a.show());
System.out.print('\n');
System.out.print(b.show());
System.out.print('\n');
System.out.print(c.show());
}
}
package q1;
public class test {
public static void main(String args[]){
Person a =new Person("小红",18,'女');
Person b =new Person("小明",19,'男');
Person c =new Person("小黑",17,'女');
System.out.print(a.show());
System.out.print('\n');
System.out.print(b.show());
System.out.print('\n');
System.out.print(c.show());
}
}
package q1;
public class Person {
public String name;
public int age;
public char sex;
//构造方法赋值
Person(String name, int age, char sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
//show方法返回某某 性别 年龄
public String show() {
return name+" "+sex+" "+age;
}
}
运行结果截图
任务2：声明一个Student类，继承Person类，增加id(int，学号)属性，通过构造方法，利用super调用父类构造方法来进行变量赋值。Override父类的show方法，返回String类型，内容如下：某某 男（女） 年龄 学号
处理思路
如题，在主类里用子类构造方法构造Student对象，并使用子类重写的show方法进行返回，输出结果
关键技术说明
用super(name,age,sex);进行父类有参构造方法的调用，并记得要在父类里创建无参的构造方法（避免调用出错）。
程序源码
package q1;
public class test {
public static void main(String args[]){
Student a =new Student("小红",18,'女',1);
Student b =new Student("小明",19,'男',2);
Student c =new Student("小黑",17,'女',3);
System.out.print(a.show());
System.out.print('\n');
System.out.print(b.show());
System.out.print('\n');
System.out.print(c.show());
}
}
package q1;
public class Person {
public String name;
public int age;
public char sex;
//构造方法赋值
Person(String name, int age, char sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
//无参数构造方法
Person() {}
//show方法返回某某 性别 年龄
public String show() {
return name+" "+sex+" "+age;
}
}
class Student extends Person{
int id;
Student(String name, int age, char sex,int id){
super(name,age,sex);
this.id=id;
}
public String show() {
return name+" "+sex+" "+age+" "+id;
}
}
运行结果截图
任务3：声明一个Shape抽象类，其中有计算面积（area）、周长（perimeter）的方法，有以下几个实现：Circle(圆)，Rectangle(矩形)，Triangle(三角形)，都 有计算面积、周长的方法，并以多态的方式表示出来。
处理思路
跟题目一样
关键技术说明
抽象类的实现；
常量的定义；
程序源码
package p4;
import java.util.Scanner;
public class exp4 {
public static void main(String args[]){
Scanner sc=new Scanner(System.in);
System.out.println("请输入矩形长、宽");
rectangle first=new rectangle(sc.nextDouble(),sc.nextDouble());
System.out.println("周长："+first.perimeter());
System.out.println("面积："+first.area());
System.out.println("请输入三角形底、高、其他两个边");
triangle second=new triangle(sc.nextDouble(),sc.nextDouble(),sc.nextDouble(),sc.nextDouble());
System.out.println("周长："+second.perimeter());
System.out.println("面积："+second.area());
System.out.println("请输入圆形半径");
circle third=new circle(sc.nextDouble());
System.out.println("周长："+third.perimeter());
System.out.println("面积："+third.area());
}
}
package p4;
abstract class Shape {
abstract double area();
abstract double perimeter();
}
class rectangle extends Shape{
double a;
double b;
rectangle(double a, double b){
this.a=a;
this.b=b;
}
@Override
double area() {
double s=a*b;
return s;
}
@Override
double perimeter() {
double l=2*(a+b);
return l;
}
}
class triangle extends Shape{
double a;
double b;
double c;
double h;
triangle(double a, double h, double c, double b){
this.a=a;//底边
this.h=h;//高
this.b=b;
this.c=c;
}
@Override
double area() {
double s=1.0/2*a*h;
return s;
}
@Override
double perimeter() {
double l=a+b+c;
return l;
}
}
class circle extends Shape{
public static final double PI = 3.14;
double a;
circle(double a){
this.a=a;
}
@Override
double area() {
double s=PI*a*a;
return s;
}
@Override
double perimeter() {
double c=2*PI*a;
return c;
}
}
运行结果截图
任务4：设计一个动物声音“模拟器”，希望模拟器可以模拟许多动物的叫声。要求如下：
- 编写抽象类Animal
Animal抽象类有2个抽象方法cry()和getAnimaName()，即要求各种具体的动物给出自己的叫声和种类名称。
- 编写模拟器类Simulator
该类有一个playSound(Animal animal)方法，该方法的参数是Animal类型。即参数animal可以调用Animal的子类重写的cry()方法播放具体动物的声音、调用子类重写的getAnimalName()方法显示动物种类的名称。
- 编写Animal类的子类：Dog，Cat类
图是Simulator、Animal、Dog、Cat的UML图。
编写主类Application（用户程序）
在主类Application的main方法中至少包含如下代码：
Simulator simulator = new Simulator();
simulator.playSound(new Dog());
simulator.playSound(new Cat());
处理思路
如题，只是注意在mian里将Simulator类的参数animal改为对应子类上转型对象即可以调用对应子类的重写方法
关键技术说明
Animal animal=new Dog();//animal是Dog（）类上转型对象
simulator.playSound(animal);
simulator.playSound(new Cat());//这样写也是一样的效果
程序源码
package q2;
public class Application {
public static void main(String[] args) {
Simulator simulator=new Simulator();
Animal animal=new Dog();//animal是Dog（）类上转型对象
simulator.playSound(animal);
simulator.playSound(new Cat());//这样写也是一样的效果
}
}
package q2;
public abstract class Animal {
//叫声
abstract void cry();
//种类名称
abstract String getAnimalName();
}
class Dog extends Animal{
String name="狗";
void cry(){
System.out.println("汪汪汪");
}
String getAnimalName(){
return name;
}
}
class Cat extends Animal{
String name="猫";
void cry(){
System.out.println("喵喵喵");
}
String getAnimalName(){
return name;
}
}
package q2;
public class Simulator {
void playSound(Animal animal){
System.out.print(animal.getAnimalName()+":");
animal.cry();
}
}
运行结果截图
任务5：编写一个Java程序：（1）设计一个abstract类Employee，其中有一个abstract方法earnings()；（2）设计Employee的二个子类YearWorker和MonthWorker，分别对应按年领取薪水（年薪为100000元）、按月领取薪水（月薪为5000元），子类必须重写父类的earnings()方法；（3）设计一个Company类，该类用Employee对象数组作为成员，Employee对象数组中的元素可以是YearWorker对象或MonthWorker对象的上转型对象；（4）编写一个测试类，假设某公司共有10名员工，两种类型的员工各为5人（其中数组下标为奇数的员工为MonthWorker，其他为YearWorker），计算并输出该公司一年需要支付的薪水总额。
处理思路
如题，在Company类里构造带Employee数组参数
Employee[] em;
Company(Employee[] em){
this.em=em;
}
在主类main里用
Employee[] em = new Employee[10];
Company a=new Company(em);建立带Employee数组参数的Company类对象
a.em[i] = new YearWorker();//使Company类里的Employee数组元素为YearWorker对象或MonthWorker对象的上转型对象，后使上转型对象调用子类重写方法
关键技术说明
类里带数组参构造方法，数组元素为上转型对象进行子类重写方法调用。
程序源码。
package q3;
public class test {
public static void main(String[] args) {
Employee[] em = new Employee[10];
Company a=new Company(em);
double sum=0;
for (int i = 0; i < 10; i++) {
if (i % 2 == 0)
{a.em[i] = new YearWorker(); //上转型对象调用子类重写方法
sum=sum+a.em[i].earnings();}
else {em[i] = new MonthWorker();
sum=sum+12*a.em[i].earnings();}
}
System.out.println("一年需要支付的薪水总额:"+sum);
}
}
package q3;
public abstract class Employee {
abstract int earnings();
}
class YearWorker extends Employee{
int earnings(){
int money=100000;
return money;
}
}
class MonthWorker extends Employee{
int earnings(){
int money=5000;
return money;
}
}
package q3;
public class Company {
Employee[] em;
Company(Employee[] em){
this.em=em;
}
}
运行结果截图
任务6：假定根据学生的3门学位课程的分数决定是否可以拿到学位，对于本科生，如果3门课程的平均分数超过60分即表示通过，而对于研究生，则需要平均超过80分才能通过。请完成以下java类的设计：（1）设计一个基类student描述学生的共同特征；（2）设计一个描述本科生的类Undergraduate，该类继承并扩展Student类；（3）设计一个描述研究生的类Graduate，该类继承并扩展Student类；（4）设计一个测试类StudentDemo，分别创建本科生和研究生这两个对象，并输出相关信息。
处理思路
如题
关键技术说明
子类方法调用；
方法数组参数、定义类型数组时一般直接[]里面无实数，除非new时
程序源码
package q4;
import java.util.Scanner;
public class StudentDemo {
public static void main(String[] args){
double g1[]=new double[3];
double g2[]=new double[3];
Scanner sc=new Scanner(System.in);
System.out.println("请输入研究生成绩");
g1[0]=sc.nextDouble();
g1[1]=sc.nextDouble();
g1[2]=sc.nextDouble();
Graduate a=new Graduate(g1);
System.out.println("是否通过："+a.judge());
System.out.println("请输入本科生成绩");
g2[0]=sc.nextDouble();
g2[1]=sc.nextDouble();
g2[2]=sc.nextDouble();
Undergraduate b=new Undergraduate(g2);
System.out.println("是否通过："+b.judge());
}
}
package q4;
public class student {
String sort;//是研究生还是本科生
double grades[];//存3门学位课程的分数
}
class Undergraduate extends student{
String sort="本科生";
Undergraduate(double grades[]){
this.grades=grades;
}
public String judge(){
double a;
a=(grades[0]+grades[1]+grades[2])/3;
if(a>60){
return "通过";
}
return "不通过";
}
}
class Graduate extends student{
String sort="本科生";
Graduate(double grades[]){
this.grades=grades;
}
public String judge(){
double a;
a=(grades[0]+grades[1]+grades[2])/3;
if(a>80){
return "通过";
}
return "不通过";
}
}
运行结果截图
任务7：定义一个复数类Complex，要求（1）显示该复数；（2）求两个复数的和，返回复数类对象；（3）求两个复数的差，返回复数类对象；（4）求两个复数的乘积，返回复数类对象；（5）判断两个复数是否相等，返回布尔类型。
处理思路
如题
关键技术说明
可以直接用Complex类返回、做参数；
Complex(int i,int j){
x=i;
y=j;
}
用自定义方法进行复数显示：
public void showComp(){//控制显示格式
if(y>=0)
System.out.println(x+"+"+y+"i");
else
System.out.println(x+"-"+(-y)+"i");
}
程序源码
package q6;
import java.util.Scanner;
public class test{
private static Scanner input;
public static void main(String[] args){
input=new Scanner(System.in);
System.out.println("输入两复数实部虚部");
int i=input.nextInt();//分别是两个复数的x,y值
int j=input.nextInt();
int m=input.nextInt();
int n=input.nextInt();
Complex C;//新建一个对象的引用,用于接受函数的返回的对象
Complex C1=new Complex(i,j);
Complex C2=new Complex(m,n);
boolean b;//用于接受判断是否相等时返回的boolean值
System.out.println("相加");
C=Complex.addComp(C1,C2);
C.showComp();
System.out.println("相减");
C=Complex.subComp(C1,C2);
C.showComp();
System.out.println("相乘");
C=Complex.multiComp(C1,C2);
C.showComp();
System.out.println("是否相等");
b=Complex.equalComp(C1,C2);
if(b)
System.out.println("相等");
else
System.out.println("不相等");
}
}
package q6;
import java.util.Scanner;
class Complex{
public int x;
public int y;
Complex(){
x=0;
y=0;
}
Complex(int i,int j){
x=i;
y=j;
}
public void showComp(){//控制显示格式
if(y>=0)
System.out.println(x+"+"+y+"i");
else
System.out.println(x+"-"+(-y)+"i");
}
static Complex addComp(Complex C1,Complex C2){//复数相加 注意:同上题,函数返回值类型是对象;对象作形参;
Complex C=new Complex();
C.x=C1.x+C2.x;
C.y=C1.y+C2.y;
return C;
}
static Complex subComp(Complex C1,Complex C2){//复数相减
Complex C=new Complex();
C.x=C1.x-C2.x;
C.y=C1.y-C2.y;
return C;
}
static Complex multiComp(Complex C1,Complex C2){//复数相乘
Complex C=new Complex();
C.x=C1.x*C2.x;
C.y=C1.y*C2.y;
return C;
}
static boolean equalComp(Complex C1,Complex C2){//判断复数是否相等
if(C1.x==C2.x&&C1.y==C2.y)
return true;
else
return false;
}
}
运行结果截图
