实验9 继承与多态(抽象类和接口)
【实验】java继承和多态实验报告
【关键字】实验java继承和多态实验报告篇一：Java实验五继承与多态实验五继承与多态一、实验目的1. 掌握抽象类的声明；2. 掌握多态的执行机理；3. 掌握上转型的使用；4. 掌握构造方法的执行机理；5. 面向抽象的编程；二、实验内容1. 假定根据学生的3门学位课程的分数决定其是否可以拿到学位，对于本科生，如果3门课程的平均分数超过60分即表示通过，而对于研究生，则需要平均超过80分才能够通过。
根据上述要求，请完成以下Java类的设计：（1）设计一个基类Student描述学生的共同特征。
（2）设计一个描述本科生的类Undergraduate，该类继承并扩展Student类。
（3）设计一个描述研究生的类Graduate，该类继承并扩展Student类。
（4）设计一个尝试类StudentDemo，分别创建本科生和研究生这两个类的对象，并输出相关信息。
2. 假定要为某个公司编写雇员(40个雇员)工资支付程序，这个公司有各种类型的雇员（Employee），不同类型的雇员按不同的方式支付工资：（1）经理（Manager）——每月获得一份固定的工资（2）销售人员（Salesman）——在基本工资的基础上每月还有销售提成。
（3）一般工人（Worker）——则按他每月工作的天数计算工资。
根据上述要求试用类的继承和相关机制描述这些功能，并编写一个Java Application程序，演示这些类的用法。
（提示：应设计一个雇员类（Employee）描述所有雇员的共图特性，这个类应该提供一个计算工资的抽象方法ComputeSalary( )，使得可以通过这个类计算所有雇员的工资。
经理、销售人员和一般工人对应的类都应该继承这个类，并重新定义计算工资的方法，进而给出它的具体实现。
（用对象数组）三、实验报告涉及以下内容1. 继承中父子构造方法的执行关系2. 重写3. super的应用4. 上转型5. 多态篇二：java实验报告2 继承多态封装实验报告学生姓名：学号：专业班级：实验类型：□ 验证□ 综合□ 设计□ 创新实验日期：实验成绩：一、实验项目名称抽象、封装与类（一）二、实验目的1. 掌握抽象、封装、继承和多态2. 熟练掌握如何自定义一个类。
实验报告5 继承与多态
实验名称：继承与多态一．实验目的：（（1）理解继承的含义，掌握派生类的定义方法和实现；（2）理解虚函数在类的继承层次中的作用，虚函数的引入对程序运行时的影响，能够对使用虚函数的简单程序写出程序结果。
（3）编写体现类的继承性（成员变量，成员方法，成员变量隐藏）的程序；（4）编写体现类多态性（成员方法重载，构造方法重载）的程序。
（5）理解接口和抽象类、抽象方法的定义和实现方法；（5）理解接口和抽象类的差别。
二．上机内容：（1）进行类的继承和基类构造方法的应用的练习；（2）进行类的多态性练习（3）进行抽象类和接口的练习（4）整理上机步骤，总结经验和体会。
（5）完成实验报告。
三．上机步骤：类的继承和基类构造方法的应用（1）编写一个学生和教师数据输入和显示程序，学生数据有编号、姓名、班级和成绩，教师数据有编号、姓名、职称和部门。
要求将编号、姓名输入和显示设计成一个类person，并作为学生数据操作类student和教师类数据操作类teacher的基类。
using System;using System.Collections.Generic;using System.Text;namespace ConsoleApplication2{class person{public string bh;//编号public string xm;//姓名public person(string bh, string xm){this.bh = bh;this.xm = xm;}public void show(){Console.WriteLine("姓名：{0}", xm);Console.WriteLine("编号：{0}", bh);}}class student : person{public string bj;//班级public int cj;//成绩public student(string sbh, string sxm, string sbj, int scj): base(sbh, sxm){bh = sbh;xm = sxm;bj = sbj;cj = scj;}public new void show(){Console.WriteLine("***student***");Console.WriteLine("姓名：{0}", xm);Console.WriteLine("编号：{0}", bh);Console.WriteLine("班级：{0}", bj);Console.WriteLine("成绩：{0}", cj);}}class teacher : person{public string zc;//职称public string bm;//部门public teacher(string tbh, string txm, string tzc, string tbm) : base(tbh, txm){bh = tbh;xm = txm;zc = tzc;bm = tbm;}public new void show(){Console.WriteLine("***teacher***");Console.WriteLine("姓名：{0}", xm);Console.WriteLine("编号：{0}", bh);Console.WriteLine("职称：{0}", zc);Console.WriteLine("部门：{0}", bm);}}class program{static void Main(string[] args){student st = new student("050013", "张三", "信管091", 91);st.show();teacher te = new teacher("046950", "范仲淹", "特级教师", "教务处"); te.show();Console.ReadLine();}}}运行结果：（2）将以上程序尝试改成通过调用基类构造方法的方式来初始化编号和姓名，并总结调用基类构造方法的应用要点。
Java继承与多态实验报告
西安邮电大学（计算机学院）课内实验报告实验名称：继承与多态ﻩﻩ专业名称：计算机科学与技术班级：计科1405班学生姓名：高宏伟学号：指导教师：刘霞林实验日期：２016、1０、13一、实验目得通过编程与上机实验理解Javａ语言得继承与多态特性，掌握变量得隐藏、方法得覆盖、重载，掌握抽象类与接口得使用。
二、实验要求１、编写体现类得继承性（成员变量、成员方法、成员变量隐藏)得程序。
2、编写体现类得多态性(成员方法重载）得程序.3、编写体现类得多态性(构造方法重载）得程序。
４、编写使用接口得程序。
三、实验内容(一)类得继承1、创建公共类Studeｎt、（１)编写程序文件Stｕｄｅｎt、jａｖa，源代码如下：pubｌiｃｃlａss Stuｄent｛ｐrotｅctｅd Stringｎame; /／具有保护修饰符得成员变量pｒotected int numbeｒ;vｏid setDaｔａ（Strinｇm，inｔh）//设置数据得方法｛name =m；numbｅr= ｈ;}public voｉd pｒint(）/／输出数据得方法{Systｅｍ、out、pｒintｌn（naｍe+"，"+numｂer)；｝}(2）编译Stuｄeｎt、ｊava,产生类文件Student、ｃlass.2．创建继承得类Unｄｅrgraｄuate（1）程序功能：通过Studｅnt类产生子类ｕndｅrgrａｄuaｔe,其不仅具有父类得成员变量ｎamｅ（姓名)、nuｍbeｒ（学号）,还定义了新成员变量acａdemy（学院)、dｅpartment(系）。
在程序中调用父类得prinｔ方法.（2）编写Uｎdｅrgraduate程序：claｓsＵｎdergrａdｕatｅextends Student{【代码1】/／定义成员变量acａdemy【代码2】／/定义成员变量depaｒtｍｅnｔpublｉc staｔic void ｍａｉｎ（Ｓtring aｒｇs［]）{【代码3】//创建一个学生对象s【代码4】//用父类得ｓetData方法初始化对象s【代码5】/／对象s调用priｎt方法【代码6】／/创建一个大学生对象u【代码7】／/调用父类得成员方法seｔDaｔa初始化对象ｕ【代码8】／/设置对象u得成员变量aｃaｄeｍｙ【代码9】//设置对象u得成员变量departmentSｙsｔem、out、print（u、ｎaｍe+”，”+u、ｎumbｅr+", ＂+u、acａdｅmy+”，＂＋u、de ｐａrｔmeｎt);}}（3)编译并运行程序注意：公共类Student 与uｎｄeｒgｒaduate类要在同一文件夹（路径)内.(二)方法得重载（１）程序功能：对不同得数进行排序输出。
Java实验报告继承、多态、接口和异常处理
Java实验报告继承、多态、接⼝和异常处理实验5 继承、多态、接⼝和异常处理⼀、实验⽬的1、掌握Java的类和对象的声明和使⽤⽅法；2、掌握Java的类的继承和实现⽅法；3、掌握多态性在类的继承中的运⽤；4、掌握接⼝的定义与使⽤；5、掌握基本异常的处理机制；6、熟悉try语句与catch语句的搭配使⽤；7、了解有异常处理与没有异常处理的差别；8、多重catch语句的使⽤；9、使⽤Throws声明异常和Throw抛出异常。
⼆、实验环境1、PC微机；2、DOS操作系统或 Windows 操作系统；3、Java sdk程序开发环境、eclipse集成环境。
三、实验内容1. 设计三个类，分别是学⽣类Student，本科⽣类UnderGraduate，研究⽣类Postjgraduate，其中Student类是⼀个抽象类，它包含学⽣的基本信息如姓名、所学课程、课程成绩等，⽽Undergraduate类和Postgraduate类都是Student类的⼦类，这两个类计算课程成绩等级的⽅法有所不同，如下表所⽰。
假设某班级⾥既有研究⽣⼜有本科⽣，编写程序统计出全班学⽣2. 和Mobilephone具体实现，并设计⼀个应⽤程序类来使⽤这些类。
3．要求设计⼀个GUI图形窗⼝程序，该程序让⽤户输⼊⼀个星期中的任意⼀天的数字1-7，然后输出该数字所对应的是星期⼏。
四、实验步骤实验内容⼀1.建⽴package experiment5_1，其最终⽬录结构如下：2.建⽴Student类：package experiment5_1;public abstract class Student {final static int CourseNo = 3;String name;String type;int[] courses;String courseGrade;public Student(String name) {/doc/1bd4a299a66e58fafab069dc5022aaea998f41e2.html = name; courses = new int[CourseNo];courseGrade = "" ;}public abstract void calculateGrade();public String getName( ) {return name;}public String getType( ) {return type ;}public String getCourseGrade( ) {return courseGrade;}public int getCourseScore(int courseNumber) {return courses[courseNumber];}public void setName(String name) {/doc/1bd4a299a66e58fafab069dc5022aaea998f41e2.html = name;}public void setType(String type) {this.type = type;}public void setCourseScore(int courseNumber, int courseScore) { //按课程索引号设置课程成绩this.courses[courseNumber] = courseScore ;}}3.建⽴外部类（1）研究⽣类Postjgraduatepackage experiment5_1;public class postgraduate extends Student {public postgraduate(String name) {super(name);type = "研究⽣";}public void calculateGrade() {// TODO Auto-generated method stubint total = 0;double average = 0;for (int i = 0; i < CourseNo; i++) {total += courses[i];};average = total / CourseNo;if (average>=90&&average<100) courseGrade = "优秀"; else if (average>=80&&average<90) courseGrade = "良好"; else if (average>=70&&average<80) courseGrade = "⼀般"; else if (average>=60&&average<70) courseGrade = "及格"; else courseGrade = "不及格";}}（2）本科⽣类UnderGraduatepackage experiment5_1;public class undergraduate extends Student {public undergraduate(String name ) {super(name);type = "本科⽣";}public void calculateGrade() {int total = 0;double average = 0;for (int i = 0; i < CourseNo; i++) {total += getCourseScore(i) ;};average = total / CourseNo;if (average>=80&&average<100) courseGrade = "优秀"; else if (average>=70&&average<80) courseGrade = "良好"; else if (average>=60&&average<70) courseGrade = "⼀般"; else if (average>=50&&average<60) courseGrade = "及格"; else courseGrade = "不及格";}}4.编写代码测试函数package experiment5_1;public class polymorphism {public static void main(String[] args) {Student[] students = new Student[5];students[0] = new undergraduate("陈建平");students[1] = new undergraduate("鲁向东");students[2] = new postgraduate("匡晓华");students[3] = new undergraduate("周丽娜");students[4] = new postgraduate("梁欣欣");for (int i=0; i<5 ;i++) {students[i].setCourseScore(0,87);students[i].setCourseScore(1,90);students[i].setCourseScore(2,78);}for (int i=0; i<5 ;i++) {students[i].calculateGrade();}System.out.println("姓名" + " 类型" +" 成绩");System.out.println("-----------------------");for (int i=0; i<5 ;i++) {System.out.println(students[i].getName( )+" "+students[i].getType( )+" "+students[i].getCourseGrade( ));}}}实验内容⼆1.建⽴package experiment5_2，其最终⽬录结构如下：2.写接⼝Soundable代码：package experiment5_2;public interface Soundable {public void increaseV olume( );public void decreaseV olume( );public void stopSound( );public void playSound( );}3.创建三个类Radio、Walkman和Mobilephone具体实现，分别添加代码：// Mobilephone类package experiment5_2;class Mobilephone implements Soundable{public void increaseV olume( ) {System.out.println("增⼤⼿机⾳量");}public void decreaseV olume( ) {System.out.println("减⼩⼿机⾳量");}public void stopSound( ) {System.out.println("关闭⼿机");}public void playSound( ) {System.out.println("⼿机发出来电铃声");}}// Walkman类package experiment5_2;class Walkman implements Soundable { public void increaseV olume( ) { System.out.println("增⼤随声听⾳量"); }public void decreaseV olume( ) { System.out.println("减⼩随声听⾳量"); }public void stopSound( ) {System.out.println("关闭随声听");}public void playSound( ) {System.out.println("随声听发出⾳乐"); }}// Radio类package experiment5_2;class Radio implements Soundable{ public void increaseV olume( ) { System.out.println("增⼤收⾳机⾳量"); }public void decreaseV olume( ) { System.out.println("减⼩收⾳机⾳量"); }public void stopSound( ) {System.out.println("关闭收⾳机");}public void playSound( ) {System.out.println("收⾳机播放⼴播"); }}4.创建people类及编写测试代码：//People类package experiment5_2;class People {public void listen(Soundable s) {s.playSound( );}}//测试代码package experiment5_2;import java.util.Scanner;public class InterfaceTest {public static void main(String[] args) {int i;People sportsman = new People( );Scanner scanner = new Scanner(System.in);Soundable[] soundDevice = new Soundable[3];//往声⾳设备数组中放⼊能发声的设备soundDevice[0] = new Radio( );soundDevice[1] = new Walkman( );soundDevice[2] = new Mobilephone();System.out.println("你想听什么? 请输⼊选择：0-收⾳机1-随声听2-⼿机");i = scanner.nextInt( );//开始听声⾳sportsman.listen(soundDevice[i]);soundDevice[i].increaseV olume( );soundDevice[i].stopSound();scanner.close();}}实验内容三1.建⽴package experiment5_3，其最终⽬录结构如下package experiment5_3;import java.awt.*;import java.awt.event.*;import javax.swing.*;public class DateTransf extends JFrame implements KeyListener{/****/private static final long serialVersionUID = 1L;private static DateTransf frm;private static JTextField txt;private static JTextField data;DateTransf() {setTitle("数字与星期转换");setLocation(700, 300);setSize(400,130);}public static void main(String[] args) {frm = new DateTransf();frm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);frm.setLayout(new GridLayout(2,2));txt = new JTextField(12);data = new JTextField(12);JLabel lable1 = new JLabel("输⼊数字:");JLabel lable2 = new JLabel("星期⼏:");frm.add(lable1);txt.addKeyListener(frm);frm.add(txt);frm.add(lable2);frm.add(data);frm.setVisible(true);}public void keyPressed(KeyEvent e) {if (e.getSource() == txt) {if (e.getKeyCode() == KeyEvent.VK_ENTER) // 判断按下的键是否是回车键{try {int number = Integer.parseInt(txt.getText());switch (number) {case 1:data.setText("Mon");break;case 2:data.setText("Tue");break;case 3:data.setText("Wen");break;case 4:data.setText("Thu");break;case 5:data.setText("Fri");break;case 6:data.setText("Sat");break;case 7:data.setText("Sun");break;default:JOptionPane.showMessageDialog(null, "您输⼊的数字不是1~7","⽆效⽇期",/doc/1bd4a299a66e58fafab069dc5022aaea998f41e2.html RMATION_MESSAGE); break;}}catch (Exception e1) {// TODO: handle exceptionJOptionPane.showMessageDialog(null, "您输⼊的不是整数","⽆效⽇期",/doc/1bd4a299a66e58fafab069dc5022aaea998f41e2.html RMA TION_MESSAGE); }}}}public void keyReleased(KeyEvent e) {}public void keyTyped(KeyEvent e) {}}2.编译运⾏五、实验结果●实验内容⼀结果：●实验内容⼆结果：●实验内容三结果：六、实验⼩结1.这次实验的内容⽐较多，需要掌握Java的类和对象的声明和使⽤⽅法、Java的类的继承和实现⽅法、多态性在类的继承中的运⽤、接⼝的定义与使⽤、基本异常的处理机制、try语句与catch语句的搭配使⽤等等；2. 在实验过程中，重点是要区分好实例和类，灵活掌握类的调⽤。
继承与多态、抽象类与接口
实验10 继承与多态、抽象类与接口一．实验目的（1）学习类的继承、子类在对象中调用父类定义的方法（2）学习类继承时方法的覆盖（3）学习java中抽象类的语法、子类中实现父类的抽象方法（4）学习java中接口的语法、接口的实现二．实验软件环境jdk1.6.0_18、windows 7三．实验内容1写程序运行结果：import java.io.*;class SuperClass{int x;SuperClass( ) {x=5;System.out.println("in SuperClass : x=" +x);}void doSomething( ) {System.out.println("in SuperClass.doSomething()");}}class SubClass extends SuperClass {int x;SubClass( ) {super( ); //调用父类的构造方法x=5;//super( ) 要放在方法中的第一句System.out.println("in SubClass :x="+x);}void doSomething( ) {super.doSomething( ); //调用父类的方法System.out.println("in SubClass.doSomething()");System.out.println("super.x="+super.x+" sub.x="+x);}}public class Inheritance {public static void main(String args[]) {SubClass subC=new SubClass();subC.doSomething();}}2、编写一个java程序，在程序中定义一个Animal类，再定义两个Animal类的子类Bird、Fish类，在子类中覆盖父类的play方法//Overriding.javaclass Animal{void play(){System.out.println("我是动物，我会很多本领");}}[代码1]//定义Animal类的子类Bird，覆盖Animal类的play方法，在play方法中输出“我是小鸟，我能飞翔”[代码2]//定义Animal类的子类Fish，覆盖Animal类的play方法，在play方法中输出“我是小鱼，我能游泳”class Overriding{public static void main(String args[]){Animal s1=new Animal();Bird s2=new Bird();Fish s3=new Fish();s1.play();s2.play();s3.play();}}3、创建类A1类，实现构造方法输出“this is A”,创建A1的子类B1，实现构造方法中输出“this is B”,创建B1类的子类C1，实现构造方法中输出“this is C”。
类的继承与多态性实验报告
类的继承与多态性实验报告目录1.介绍2.什么是多态3.多态在Java中的技术基础4.示例5.多态的好处6.总结介绍之前的文章介绍过类的封装性和继承性，现在是时候聊聊面向对象编程的三大特性之一的最后一个类的多态性了。
多态的基础是继承（包括了接口的实现）和方法的覆盖。
什么是多态多态对应的英文单词是polymorphism，百度翻译给出的翻译是：n.多型现象，多态性; 多机组合形式;按字面意思就是多种状态、形态、姿态等等，潜台词就是某个东西具有多种状态、形态、姿态等等。
那是什么东西呢？在面向对象的编程语言里面（当然就包括Java了）就是某个方法或函数。
那方法的多种状态、形态、姿态有是个什么意思呢？这其实是指同一个方法具有多个方法体，就是方法的实现。
而方法的相同与否是由方法签名决定的。
所以，多态其实本质上是指同一个类的同一个方法却具有不同的行为特征。
状态、形态、姿态指的就是行为特征。
多态在Java中的技术基础然而，在Java中，同一个类里面是不可能存在两个签名相同而实现不同的方法的，否则的话会导致无法判断该执行哪个方法，因此在编译时就会报错。
所以，肯定是在两个类中才有可能存在两个签名相同而实现不同的方法，一个实现在这个类，另一个实现在另一个类。
而如果这两个类毫无瓜葛，那么肯定就与多态的本质（同一个类的同一个方法却具有不同的行为特征）自相矛盾了。
所以，这两个类肯定是有某种联系的。
我们再想想，什么概念是能够让两个不同的类却又能称为同一个类的？答案就是类的继承/扩展，就是现实中的“某东西是某类东西”的概念，就是“具体和抽象”的思想。
比如，男人是人，女人也是人，男人类和女人类就借助于人类建立了某种联系，而人类具有的某个行为在男人类和女人类中是有着不同体现的，比如人类的吃饭这个行为，男人类的体现是狼吞虎咽，女人类的体现是细嚼慢咽。
例子不是很恰当，但意思就是这么个意思。
所以说，Java里面多态的技术基础就是方法的覆盖，当然，在Java中覆盖不仅仅发生在类的继承/扩展上，还可能发生在接口的实现上。
第6章 继承、抽象类、多态及接口
Visual C#程序设计与项目实践
二、抽象类
2. 声明抽象类
一个抽象类必须用关键字abstract明确地声明。声明一个抽象类 非常简单，甚至不需要任何抽象方法。通过abstract的声明就等于告 诉子类在功能上是不完整的，所以不能创建其实例。声明抽象类的格 式如下所示。 public abstract class 类名称 {
Visual C#程序设计与项目实践
二、 抽象类
3. 实现抽象类
因为抽象类是不能产生实例的类，所以不能使用new关键字对其进 行实例化。要实现抽象类中的抽象方法，就必须在派生类中重载抽象方 法。特别要强调的是，抽象类的派生类必须无条件实现抽象方法。重载 抽象类方法必须使用override关键字。重载抽象方法的格式如下所示。
class A{}
//声明类A
class B : A{}
//类B继承类A
class C : B{}
//类C继承类B
Visual C#程序设计与项目实践
一、 继承简介
2. 基类和派生类
定义派生类和创建派生类对象，在.NET类库中，有许多类可以作 为基类，这些基类可以被其他类继承，以产生派生类。例如，当创建 一个应用程序时，在窗体设计器中显示的窗体就是一个派生类，这个 窗体就是Form的派生类，而代码窗口则是这个派生类的定义。在这个 类定义中，很多代码都是由集成开发环境自动生成的。而C#程序设计 者所要做的是在这个派生类定义中添加自己的代码，实现所需的功能。 派生类定义的语法格式如下： public class 派生类名称：基类名称{类体}
实验2 面向对象(b[继承、多态]、c[抽象类、接口])
实验2 面向对象（继承、多态、抽象类、接口）注意：有些程序由于Word的关系，复制后，tab缩位可能会变成其它符号。
需要你去调整一下，删除缩位，重新Tab一、实验目的 (1)二、实验要求 (1)三、实验内容 (2)1. 类的继承与覆盖练习 (2)1.0 父类的哪些成员可以被继承？ (2)1.1 父类Student（学生）与子类HiStudent（大学生） (2)1.2 实例方法为什么需要覆盖 (4)1.3 验证成员方法的覆盖方式 (5)1.4 this、super和super()的使用 (6)1.5 变量、静态方法的隐藏。
(9)1.6 隐藏与覆盖的综合性实例 (10)2. 类的多态性练习 (11)2.1 普通方法的重载（实验3，本实验略） (11)2.2 构造方法的重载（实验3，本实验略） (11)2.3 运行时多态与动态绑定 (11)3. 抽象类 (13)4. 接口 (15)一、实验目的通过编程和上机实验理解Java语言的面向对象特性，了解类的继承性和多态性的作用，掌握它们的实现方法，了解数据域和静态方法的隐藏，了解抽象类和接口的作用。
二、实验要求1、编写体现类的继承性（成员变量、成员方法、成员变量隐藏）的程序；2、编写体现类的多态性的程序；3、编写体现抽象类和接口功能的程序。
三、实验内容1. 类的继承与覆盖练习例如，圆是一种形状。
圆类Circle是形状类Shape的子类。
父类也叫基类、超类，子类也叫次类、扩展类、派生类。
子类可从父类中产生，保留父类的成员变量和方法，并可根据需要对它们加以修改。
新类还可添加新的变量和方法。
这种现象就称为类的继承。
当建立一个父类时，不必写出全部成员变量和成员方法。
只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。
Java 提供了一个庞大的类库让开发人员继承和使用。
设计这些类是出于公用的目的，因此，很少有某个类恰恰满足你的需要。
你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，和父类一样，那样没什么用。
9多态抽象类、接口
多态多态的概述1.多态: 事物的多种形态polymorphic对象的多态性: 同一个对象,可能在不同环境下有不同名称例如:黎国祥: 在咱们班: 讲师回到北京出租房里: 老公回到河南老家: 对于父母: 儿子对于我的外甥们: 舅舅对于姐姐: 弟弟在java中,同一对象,指的是有不同类型的引用指向它, 本质: 同一个事物有不同的名称和描述MiddleStudent 继承自Student 继承自PersonMiddleStudent ms = new MiddleStudent(); 初中生对象MiddleStudent ms2 = ms;Student s = ms; 学生java中多态指的是,父类类型的引用可以指向子类对象;2.多态实现的前提1.要有父子类关系, 没有继承就没有多态2.方法的重写3.父类类型引用指向子类对象实例代码class 多态的概述_01 {public static void main(String[] args) {/*MiddleStudent ms = new MiddleStudent();Student s = ms;*/// Student <--- MiddleStudent 初中生是学生Student s = new MiddleStudent();s.study();}}// 学生class Student {public void study(){System.out.println("学习");}}// 初中生class MiddleStudent extends Student{@Overridepublic void study(){System.out.println("好好学习, 天天向上");}}在多态中成员变量的访问特点1.编译的时候看左边, 运行的时候也看左边;2.编译的时候,要看[=]左边的引用类型中,是否定义了该变量名,如果没有,编译就报错;如果有,编译就成功;3.运行的时候,要看[=]左边的引用类型,左边引用类型中如何的赋值的,取出的就是左边引用类中的值;实例代码class 在多态中成员变量的访问特点_02 {public static void main(String[] args) {// 什么是引用: 指的就是使用了一块空间的地址// 什么是引用类型变量: 存储着地址的变量就是引用类型变量// 创建多态关系Fu f = new Zi();System.out.println(f.i);// System.out.println(f.j);}}class Fu {int i = 10;}class Zi extends Fu {int i = 20;int j = 30;}多态访问成员方法的特点1.编译看左边,运行看右边2.编译的时候, 要看[=]左边的引用类型中,是否定义了该方法,如果有,就编译通过;如果没有,就编译失败;3.运行的时候,要看[=]右边,对象所属的类中,如果对这个方法进行实现,最终运行的就是子类对这个方法的实现;实例代码class 多态访问成员方法的特点_04 {public static void main(String[] args) {Fu f = new Zi();f.test();// f.test2();}}class Fu {public void test(){System.out.println("父类test方法被调用了");}}class Zi extends Fu {@Overridepublic void test(){System.out.println("子类test方法被调用了");}public void test2(){System.out.println("子类test2方法被调用了");}}多态访问静态方法的特点1.编译时看左,运行时看左2.编译的时候,要看[=]左边的引用类型中,是否有该静态方法名,如果有就编译通过,没有编译报错;3.运行的时候,要看[=]左边的引用类型中,如果对该静态方法进行的实现,调用父类中对该方法的实现;实例代码class 多态访问静态方法的特点_04 {public static void main(String[] args) {Fu f = new Zi();f.test();// f.test2();}}class Fu{public static void test(){System.out.println("父类静态test方法被调用了");}}class Zi extends Fu {// @Overridepublic static void test(){System.out.println("子类静态test方法被调用了");}public static void test2(){System.out.println("子类静态test2方法被调用了");}}向上向下转型1.向上转型使用子类的引用指向指向的子类的对象(正常情况)多态中,使用的是父类的引用指向子类的对象(向上转型)本质:缩小了对象本身的访问范围, 减少了它的访问权限,只能访问父类中的内容2.向下转型:概念: 让一个指向子类对象的父类引用,恢复成子类的引用格式: 子类类型引用名称= (子类类型)父类类型引用;例如: Zi z = (Zi)f;本质:恢复子类对象的访问权限,访问范围;3.注意: 不可以把指向父类对象的父类引用做向下转型,否则就会抛出异常cast: 转换Fu cannot be cast to Zi Fu类型不能转为Zi类型多态的内存理解图示实例代码class 向上向下转型_05 {public static void main(String[] args) {// 向上转型Fu f = new Zi();System.out.println();//System.out.println(f.age);f.eat();//f.drink();// 向下转型Zi z = (Zi)f;System.out.println();System.out.println(z.age);z.eat();z.drink();Fu f2 = new Fu();// 不能对f2向下转型Zi z2 = (Zi)f2;}}class Fu {String name = "豆豆";public void eat(){System.out.println("吃");}}class Zi extends Fu{String name = "花花";int age = 18;@Overridepublic void eat(){System.out.println("吃鸡腿...");}public void drink(){System.out.println("喝啤酒...");}}多态的好处1.可以提高代码的扩展性2.在方法中,如果形式参数类型是父类类型,将来在调用这个方法的时候,就可以把这个父类类型子类创建出来对象当做实参传递过去;3.如果一个方法的返回值是父类类型,那么可以在方法内将父类的子类对象当做方法的返回值使用; 调用者接受结果时,可以直接使用父类类型变量接受,也可以做向下转型(前提必须是知道返回的是什么类型的子类);饲养宠物案例1.有一个女类: 这个喜欢养宠物第一年: 女孩养个狗第二年: 女孩养个猫第三年: 女孩养个猴第四年: 女孩养个蛇实例代码class 女孩饲养宠物_06 {public static void main(String[] args) { /*Girl g = new Girl();Dog d = new Dog();g.feedDog(d);Cat c = new Cat();g.feedCat(c);*/Girl g = new Girl();//第一年: 女孩养个狗Dog d = new Dog();g.feedPet(d);//第二年: 女孩养个猫Cat c = new Cat();g.feedPet(c);//第三年: 女孩养个猴Monkey m = new Monkey();g.feedPet(m);//第四年: 女孩养个蛇Snake s = new Snake();g.feedPet(s);}}class Girl {/*// 第一年public void feedDog(Dog d){d.eat();}// 第二年public void feedCat(Cat c){c.eat();}// 第三年: 女孩养个猴// 第四年: 女孩养个蛇*/public void feedPet(Pet p){p.eat();}}class Pet {public void eat(){System.out.println("吃...");}}// public abstract void eat();class Dog extends Pet{@Overridepublic void eat(){System.out.println("吃大骨头...");}}class Cat extends Pet{@Overridepublic void eat(){System.out.println("吃小鱼...");}}class Monkey extends Pet {@Overridepublic void eat(){System.out.println("吃香蕉...");}}class Snake extends Pet {@Overridepublic void eat(){System.out.println("吃肉肉...");}}生产宠物的案例1.有一个工厂,可以帮助用户生产宠物,用户只需要告诉我他想要什么宠物,我就可以给她生产什么类型宠物对象; 实例代码class 生产宠物的案例_07 {public static void main(String[] args) {// 想要个猴ProductPet pp = new ProductPet();Pet p = pp.productPet(1);p.eat();// 想要个狗Pet p2 = pp.productPet(2);p2.eat();// 想要个猫Pet p3 = pp.productPet(3);p3.eat();// p3.play();// Cat c2 = (Cat)p3;// 想要个猫,就想用Cat类型接收// productPet返回的是父类类型, 真正对象是一个Cat对象// 使用向下转型获取Cat对象Cat c = (Cat)pp.productPet(3);c.eat();c.play();// 向下转型必须知道具体的数据类型才可以,否则抛出类型转换异常// Dog d2 = (Dog)pp.productPet(3);/*Monkey m = pp.productMonkey();m.eat();// 想要个狗Dog d = pp.productDog();d.eat();*/}}class ProductPet {// 1 猴子 2 狗 3 猫4 蛇public Pet productPet(int num){if(num == 1){return new Monkey();}else if(num == 2){return new Dog();}else if(num == 3){return new Cat();}else if(num == 4){return new Snake();}else{return null;}}/*// 生产猴子public Monkey productMonkey(){return new Monkey();}// 生产狗public Dog productDog(){return new Dog();}*/}class Pet {public void eat(){System.out.println("吃...");}}class Dog extends Pet{@Overridepublic void eat(){System.out.println("吃大骨头...");}}class Cat extends Pet{@Overridepublic void eat(){System.out.println("吃小鱼...");}public void play(){System.out.println("玩球...");}}class Monkey extends Pet {@Overridepublic void eat(){System.out.println("吃香蕉...");}}class Snake extends Pet {@Overridepublic void eat(){System.out.println("吃肉肉...");}}抽象类抽象方法1.抽象: 抽取像的, 相同的, 相似的内容2.抽象方法: 只有方法的声明,而没有方法的实现,那么这种方法就是抽象方法一旦有了继承关系,子类对父类中抽取出来公共方法,可能有不同的实现方式, 如果继续向上抽取公共的内容,只能把方法的声明部分提取出来,提取出来这部分内容就是抽象方法;3.抽象方法定义的格式:1.没有方法实现部分, 连大括号都不要写, 在最后面添加一个分号,表示方法定义结束2.为了便是他是抽象方法, 需要在方法的前面添加一个关键字: abstract例如: public abstract void eat();抽象类1.可以定义抽象方法的类,就是抽象类2.抽象类的定义格式:abstract class 类名{类体;}3.拥有抽象类的好处, 避免了父类对某个方法提供实现, 但是它所有子类们继承过去这个都要重写,那么父类就没必要提供这个方法的实现了,直接把这个方法定义为抽象方法即可;实例代码class 抽象方法_08 {public static void main(String[] args) {System.out.println("Hello World!");}}// 不是抽象类就不能存储抽象方法abstract class Pet {public abstract void eat();}class Dog extends Pet{@Overridepublic void eat(){System.out.println("吃大骨头...");}}class Cat extends Pet{@Overridepublic void eat(){System.out.println("吃小鱼...");}}class Monkey extends Pet {@Overridepublic void eat(){System.out.println("吃香蕉...");}}class Snake extends Pet {@Overridepublic void eat(){System.out.println("吃肉肉...");}}抽象类的特点1.抽象类和抽象方法都要使用abstract关键字修饰抽象类: abstract class 类名{}抽象方法: public abstract 返回值类型方法名(形参列表);2.抽象类和抽象方法的关系:抽象类中可以有抽象方法,也可以没有抽象方法;抽象方法必须存于抽象类中3.抽象类能否实例化(能否创建对象):抽象类不能实例化;可以定义抽象类子类,由子类去创建对象, 调用方法;4.抽象子类的分类:如果抽象类的子类,实现了抽象类中抽象方法,难么这个子类就是一个普通子类,就可以创建对象;如果抽象类的子类,没有完全实现抽象类中抽象方法,此时这个子类还是一个抽象类, 必须使用abstract类名, 子类无法实例化;实例代码class 抽象类的特点_09 {public static void main(String[] args) {//Demo d = new Demo();Zi z = new Zi();z.test1();// 多态Demo d = new Zi();d.test1();}}abstract class Demo{public abstract void test1();public abstract void test2();}// 一个类继承自抽象类之后,必须要抽象方法实现了class Zi extends Demo {public void test1(){System.out.println("实现抽象方法test1");}public void test2(){System.out.println("实现抽象方法test2");}}abstract class Zi2 extends Demo{public void test1(){System.out.println("实现抽象方法test1");}}抽象类的特点1.抽象类能不能有成员变量: 抽象类中可以定义成员变量, 也可以定义常量, 因为抽象类不能实例化,不能被抽象类使用2.抽象类能不能有构造方法:可以有构造方法, 虽然抽象类不能实例化, 但是抽象类一般都是有子类的,子类会访问抽象父类的构造方法,来完成对抽象父类中成员变量的初始化;是否能有构造方法,和是不是能创建对象没有关系,就是是否要给成员变量赋值,如果一个类中可以定义成员变量,那么这个类中就可以有构造方法;3.抽象类中能否有成员方法抽象类中可以有成员方法;这里定义方法内容一般子类不会去重写;抽象类中也可以有抽象方法,目的是为了让子类重写;实例代码class 抽象类的特点_10 {public static void main(String[] args) {// Fu f = new Fu();Zi z = new Zi(100);System.out.println(z.i);z.sayHi();z.eat();}}abstract class Fu {int i = 10;final int VERSION = 1;public Fu(int i){this.i = i;}public Fu(){}public void sayHi(){System.out.println("你好世界");}public abstract void eat();}class Zi extends Fu {public Zi(int i){super(i);}public void eat(){System.out.println("吃小龙虾的季节又到了");}}练习1.定义宠物类: 属性姓名, 性别行为: 吃, 喝, 睡定义狗:属性姓名, 性别行为: 吃, 喝, 睡猫类: 属性姓名, 性别行为: 吃, 喝, 睡, 抓老鼠实例代码class 练习_11 {public static void main(String[] args) {Cat c = new Cat(); = "点点";c.color = "黑色";c.eat();c.drink();c.sleep();c.catchMouse();Dog d = new Dog(); = "屁屁";d.color = "棕色";d.eat();d.drink();d.sleep();}}abstract class Pet {String name;String color;public abstract void eat();public abstract void drink();public void sleep(){System.out.println("闭眼睡觉...");}}class Dog extends Pet {public void eat(){System.out.println("吃骨头...");}public void drink(){System.out.println("喝奶茶...");}}class Cat extends Pet {public void eat(){System.out.println("吃鲸鱼...");}public void drink(){System.out.println("喝牛奶...");}public void catchMouse(){System.out.println("拿耗子...");}}接口接口的思想1.电脑有很多的接口, 接口中可以插入响应的设备, 这些设备为什么能插在这些接口上呢?主要原因是这些设备的生产厂商按照这些接口的规则来生产设备的,如果不按照规则生产设备,这些设备就无法插在电脑上了;接口的本质:就是规则接口的好处: 可以扩展一个事物的功能可以达到高内聚低耦合的作用方便后期维护接口在程序中好处:规则的定义者和规则实现者实现分离;规则: 对应就是方法,都是抽象方法;实现者:对应的就是方法的具体实现, 本质一个对象Java中接口1.广义的讲: 一切规则都是接口2.狭义的讲: java中定义的方法名就是接口java中的接口,全是方法的声明, 都是抽象方法3.好处接口定义者只需要说明应该有哪些方法,不需要管具体谁来实现这些方法, 实现了[规则的定义]和[规则实现的分离]4 . java定义接口的格式:要是用一个关键字interfaceinterface 接口名{方法的声明;}5.接口中只能定义抽象方法6. 如何实现接口: java中接口是有类来实现的类实现接口的格式:class 类名implements 接口名{重写接口定义的所有抽象方法;}实例代码class java中接口_12 {public static void main(String[] args) {Mouse m = new Mouse();m.powerOn();m.powerOff();m.sendData();}}/*定义一个USB接口:通电传输数据断电*/interface USB {// 通电public abstract void powerOn();// 断电public abstract void powerOff();// 传输数据public abstract void sendData();}// 鼠标class Mouse implements USB {// 通电public void powerOn(){System.out.println("通电了...");}// 断电public void powerOff(){System.out.println("关闭鼠标");}// 传输数据public void sendData(){System.out.println("传递坐标");}}接口的特点1.接口是不能实例化的可以被类实现, 它的实现类可以实例化;2.接口本质还是类, 发现接口编译之后生成的是.class文件3.接口的实现类,可以看做是接口的子类, 可以使用接口类型引用指向实现类对象4.接口实现类的分类:一个类如果实现了接口中所有的抽象方法,那么它就是一个普通类;一个类如果没有完全实现接口的抽象方法,那么它必须是一个抽象类;5.接口中能不能有成员变量:接口中不能定义成员变量, 定义的属性都是静态常量属性;定义属性是默认前面会加: public static final建议手动加上这些修饰符6.接口中能不能有构造方法:接口不能定义构造方法, 因为接口中就没有成员变量, 就没有定义构造方法的意义了, 所以接口中不能有构造方法;7.接口中能不能有成员方法不能定义成员方法, 因为接口中只能定义抽象方法;定义抽象方法是: 可以只写返回值类型方法名(参数列表): 默认会在前面加上public abstract建议加上实例代码class 接口的特点_13 {public static void main(String[] args) {// Inter1 i = new Inter1();Demo1 d = new Demo1();d.test();System.out.println(d.i);//d.i = 100;System.out.println(Inter1.i);System.out.println(Demo1.i);// 接口的实现类可以看做是接口子类Inter1 i = new Demo1();i.test();}}interface Inter1 {// 接口中不能定义成员变量, 定义的属性都是静态常量属性public static final int i = 10;public abstract void test();// 这也是一个抽象方法void test2();/*public Inter1(){}*//*public void haha(){System.out.println("哈哈哈...");}*/}// Demo1 实现了Inter1接口class Demo1 implements Inter1{public void test(){System.out.println("实现了接口Inter1的方法test1");}public void test2(){System.out.println("实现了接口Inter1的方法test2");}}abstract class Demo2 implements Inter1{}类与类, 类与接口, 接口与接口之间的关系1.类与类继承的关系, 使用extends可以单继承, 不可以多继承, 可以多层继承2.类与接口实现的关系,使用implements可以单实现,可以多实现, 不能多层实现(一旦实现接口就必须是一个类)多实现格式1:class 类名implements 接口1, 接口2, 接口3,... {重写所有接口中抽象方法;}多实现是没有安全隐患的:即使两个接口中一样抽象方法,但是类中只需要提供一个实现就够了;多实现的格式2: 一个类可以继承自某个类后继续实现其他接口class 类名extends 父类名implements 接口1, 接口2, 接口3,... {重写所有接口中抽象方法;}3.接口与接口继承的关系: 使用extends可以单继承, 可以多继承, 可以多层继承单继承: 接口1 extends 接口2 { }多继承: 接口1 extends 接口2, 接口3, 接口4 { }多层继承: 接口1 extends 接口2{ } 接口2 extends 接口3{}4.父类和接口区别父类: 定义的都是事物中本来就具有的属性和行为接口: 定义事物可以通过后天学习,自己拓展出来的行为父类狗: 属性姓名, 颜色行为:吃饭, 喝水, 睡觉哈士奇: 姓名, 颜色行为: 拆家, 吃饭, 喝水, 睡觉金毛: 姓名, 颜色行为: 吃饭, 喝水, 睡觉缉毒接口: 会区分毒品, 会报警缉毒犬金毛extends 狗implements 缉毒接口{}实例代码class 类与类_类与接口_接口与接口之间的关系_13 {public static void main(String[] args) {Imple1 i = new Imple1();i.test();i.test2();i.test3();Zi z = new Zi();z.test();z.test2();z.hehe();}}interface Inter1{public abstract void test();}interface Inter2{public abstract void test();public abstract void test2();}interface Inter3{public abstract void test3();}class Imple1 implements Inter1, Inter2, Inter3{public void test(){System.out.println("实现Inter1的test");}public void test2(){System.out.println("实现Inter2的test2");}public void test3(){System.out.println("实现Inter3的test3");}}class Fu {public void hehe(){System.out.println("儿子你好累啊,实现好多接口");}}class Zi extends Fu implements Inter1, Inter2{public void test(){System.out.println("Zi实现了Inter1的test方法");}public void test2(){System.out.println("Zi实现了Inter2的test2方法");}}// 接口的多继承interface SubInter extends Inter1, Inter2, Inter3{}class Imple2 implements SubInter{public void test(){System.out.println("实现Inter1的test");}public void test2(){System.out.println("实现Inter2的test2");}public void test3(){System.out.println("实现Inter3的test3");}}。
Java继承与多态实验报告.doc
Java继承与多态实验报告.doc
Java的继承与多态实验报告
本报告致力于分析Java继承与多态的概念、原理和作用，以及相关实验过程及其结果。
继承，又称为分类，是Java面向对象程序设计语言中定义类之间关系的重要技术。
它使一个类可以使用另一个基类中定义的方法和属性，在基类中已经定义了一些功能，子
类可以对基类功能进行拓展与定制。
《Java技术手册》得出结论，继承可以有效提高软件的复用性、可维护性和可重用性，使大型的、复杂的程序有条理层次。
多态是Java中一种特殊的程序结构，允许不同类的对象对相同的消息作出不同的响应，由程序的消息而不是对象的类型来决定对象的行为。
它是Java多态性的基础，使程
序能够在不同对象上进行操作，统一实现。
从实验中，可以明显看出Java继承与多态之间的联系：多态必须依赖于继承，当子
类被创建时，它继承了母类的方法以及特性，这样，它才能以逐渐上升的方式处理所有消息，而多态给了子类独特-->性的功能。
同时，多态也方便了代码重用，因为子类会继承
母类的方法和属性。
此外，结果表明，多态的优点使程序可以提高可重用性，它也减少了代码的重复编写，同时允许特定类之外的类可以得到适用。
它促进了软件不断更新，因为多态给开发人员提
供了以对象层次组织代码的方法。
本练习涉及到Java继承与多态概念的整体概述和实现细节，为完全理解多态的概念
打下了坚实的基础。
它提供了一个理解和使用这些概念的有用方式和指导。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验9 继承与多态
一、实验目的
(1) 理解类的继承，掌握变量隐藏、方法覆盖的概念。
(2）理解引用类型的变量的赋值转换原则。
(3）理解多态概念，掌握方法的匹配调用原则；
(4）理解抽象类的使用；
(5）理解this和super的含义及使用。
(6）理解访问控制符的使用
二、知识要点
1、继承的概念
通过类的继承，祖先类的所有成员均将成为子类拥有的“财富”。
但是能否通过子类对象直接访问这些成员则取决于访问权限设置。
Object类是所有类的祖先。
2、构造方法与继承关系
构造方法不存在继承关系，子类中是如何给父类继承的属性赋初值呢？
子类通过调用父类的构造方法给父类的属性赋值，在子类的构造方法的第1行可以通过super去调用父类的构造方法，如果没有super调用，则默认调用父类的无参构造方法。
所以，在父类中编写构造方法通常均要提供无参构造方法。
3、对象引用变量赋值原则
可以将子类的对象引用赋值给父类引用变量，由于父类能操作访问属性和方法的子类已全部继承。
但将父类引用变量的值赋给子类引用变量就受到限制，必须进行强制转换，编译总是认可强制转换，但运行程序时如果不能正确转换就会报错。
4、多态的两种表现形式
（1）同一类中的方法多态（方法重载）：同一类中允许多个同名方法，通过参数的数量、类型的差异进行区分。
（2）子类对父类方法的重新定义（方法覆盖）：方法名、返回值和参数形态完全一样。
（3）方法调用的匹配原则。
首先查找有否有参数一致的方法，也就是精确匹配；如果没有，再检查实参是否能自动转换为形参类型，能转换也可以匹配调用，这种匹配称为转换匹配。
5、继承关系中对成员的访问（最近匹配原则）
由于继承关系的存在，一个对象的属性和方法中有自己新定义的，也有从祖先类继承的。
允许子类对父类定义的属性和方法重新定义，一个对象查找其属性和方法时按什么原则查找呢，实际也是“最近匹配原则”。
（1）在子类中访问属性和方法时将优先查找自己定义的属性和方法。
如果该成员在本类存在，则使用本类的，否则，按照继承层次的顺序到其祖先类查找，如图8-1所示。
（2）this关键字特指本类的对象引用，使用this访问成员则首先在本类中查找，如果没有，则到父类逐层向上找。
（3）super特指访问父类的成员，使用super首先到直接父类查找匹配成员，如果未找到，再逐层向上到祖先类查找。
6、抽象类
定义形式：
abstract class 类名称 {
成员变量；
方法（）{……} //定义一般方法
abstract 方法（）；//定义抽象方法
}
●在抽象类中可以包含一般方法和抽象方法。
●抽象类表示的是一个抽象概念，不能被实例化为对象。
●继承抽象类的具体类必须将抽象类中抽象方法覆盖实现。
７、接口
定义形式：
interface 名称 {
静态常量；
抽象方法（）;
}
●接口中包含静态常量和抽象方法．
●类继承接口，实现接口中的所有方法．
三、上机练习
1.编写程序，在程序中定义一个抽象类Area、两个Area类的派生子类RectArea和
RoundArea类，以及一个实现类ImpleArea类（main方法所在的类）.程序的实现如下：
（1）抽象类Area类中只包含一个抽象方法：double area()。
（2）子类RoundArea类通过覆盖父类中的抽象方法area来求圆的面积，另一个类RectArea类通过覆盖父类中的抽象方法area求长方形的面积
（3）圆的半径和长方形的边分别定义为子类RoundArea类和RectArea类的域，都为double类型。
（4）ImpleArea类中接收键盘输入（Scanner），输入内容分别为长方形的边和圆的半径，求出长方形和圆的面积，并在屏幕上显示。
2.某公司有3种不同的雇员，分为A，B，C3个级别。
公司的总雇员数目因月份的不同可
能发生变化。
每个级别的月薪是不同的。
编写一个程序计算公司一个月需要支付的全部薪水。
要求有一个abstract类，类名为Employee。
Employee的子类有Aemployee, Bemployee, Cemployee. Employee类必须有一个abstract方法
注意：Aemployee, Bemployee, Cemployee声明的对象表示的是一个员工，而不是一类员工。
成员变量没有要求的，不能乱加。
public abstract double earnings();//返回级别工资
子类必须重写父类的earnings方法（必须的，继承抽象类必须实现抽象方法），给出各自的月薪水的具体数额。
（数据随便，自己编好了）
编写一个Company类，该类用Employee数组作为成员，Employee数组的单元可以是Aemployee, Bemployee, Cemployee的子类对象。
Company类提供计算月薪总和的方法，使得程序能输出Company对象需要支付的月薪总额。
编写一个类，来检验该Company. 要求不同等级员工的人数由用户来决定（使用Scanner 类）。
根据人数，来求出该月公司支付月薪对象
程序效果如图：
3．火车要装载一批货物和乘客，货物由3种商品：电视、计算机和洗衣机组成。
火车需要计算出所装载的货物和乘客的总重量。
要求：有一个SetAndGetWeight接口，该接口中有2个方法：
public double getWeight();
public void setWeight(double weight);
有四个实现该接口的类：Television、Computer、WashMachine、People类。
这四个类通过实现接口设置各对象的自重和获取对象的自重。
有一个Train类，该类用SetAndGetWeight接口类型的数组作为成员，那么该数组的单元就可以存放Television、Computer、WashMachine、People对象的引用。
程序能输出Train对象所装载的货物和乘客的总重量。
程序的效果图如下：
注：上交２，３两题。