java实验五 多态性
Java接口多态实验

实验9:接口、多态性一、实验目的与要求1、多态性的概念、技术基础2、构造方法的调用顺序3、总结接口的应用二、内容概要1、多态性概念是指不同类型的对象可以响应相同的消息。
从相同的基类派生出来的多个类型可被当作同一种类型对待,可对这些不同的类型进行同样的处理,由于多态性,这些不同派生类对象响应同一方法时的行为是有所差别的。
例如●Cat行为是吃鱼,Dog行为是吃骨头●所有的Object类的对象都响应toString()方法2、多态性的技术基础●向上塑型技术:一个父类的引用变量可以指向不同的子类对象●动态绑定技术:运行时根据父类引用变量所指对象的实际类型执行相应的子类方法,从而实现多态性3、多态性的好处应用程序不必为每一个派生类(子类)编写功能调用,只要对基类(特别是抽象基类)或接口处理即可,“以不变应万变”,大大提高程序的可复用性。
例如:下面代码Waiter类中的callPersonEat方法参数是Person 类型,所以利用向上塑性技术可以给其传参数China和USA类型。
而该方法体p.eat(); ,利用动态邦定技术运行时候根据p引用的具体对象调用创建对象时所属类的eat方法interface Person{public void eat();}class China implements Person{public void eat(){System.out.println("chinese use chopsticks");}}class USA implements Person{public void eat(){System.out.println("usa use forks");}}class Waiter{static void callPersonEat(Person p){p.eat(); //实例方法调用,动态绑定}public static void main(String a[]){Person p1=new China();//向上塑性Person p2=new USA();//向上塑性Waiter.callPersonEat(p1);Waiter.callPersonEat(p2);/*Person p[]=new Person[2];p[0]=new China();p[1]=new USA();for(int i=0;i<2;i++)Waiter.callPersonEat(p[i]);*/}}例如,Ball类。
Java中的多态性及其应用篇

Java中的多态性及其应用篇Java作为一种面向对象的编程语言,多态性是其核心特性之一。
通过多态性,Java程序能够根据对象的实际类型来执行不同的行为,实现代码的灵活性和可扩展性。
本文将深入探讨Java中的多态性以及其在实际应用中的运用。
一、多态性的基本概念多态性意味着一个对象可以具有多种形态。
在Java中,多态性通过继承和方法重写来实现。
它允许父类引用指向子类对象,并根据实际对象的类型来调用相应的方法。
例如,假设我们有一个动物类Animal,它具有一个eat()方法。
然后我们派生出狗类Dog和猫类Cat,并在它们中分别重写eat()方法。
利用多态性,我们可以创建一个Animal类型的引用,然后根据实际对象的类型调用不同子类的eat()方法。
二、多态性的应用场景及优势1. 代码复用和扩展性:通过多态性,我们可以编写通用的代码,使得它适用于多种不同类型的对象。
当需要新增一个新类型时,只需要创建相应的子类并重写相关方法,而不需要修改原有的代码,实现了代码的复用和可扩展性。
2. 方法的统一调用:利用多态性,我们可以使用统一的方法调用方式来处理不同类型的对象,而不需要逐一针对每个子类编写不同的方法调用。
3. 多态性能提高代码的灵活性和可维护性,使程序更加可读性和易于理解。
三、实例演示:汽车销售系统下面我们通过一个实例来演示多态性在实际应用中的运用:汽车销售系统。
1. 定义父类Vehicle,包含一个方法run(),并提供默认的实现。
```javapublic class Vehicle {public void run() {System.out.println("This is a vehicle.");}}```2. 派生出子类Car和Motorbike,分别重写run()方法。
```javapublic class Car extends Vehicle {@Overridepublic void run() {System.out.println("This is a car.");}}public class Motorbike extends Vehicle {@Overridepublic void run() {System.out.println("This is a motorbike.");}}```3. 创建销售系统类SalesSystem,其中包含一个sell(Vehicle vehicle)方法,用于销售不同类型的车辆。
多态性实验报告

多态性实验报告一、实验目的本次实验的主要目的是深入研究和理解多态性这一重要的概念,并通过实际操作和观察来验证多态性在不同情境下的表现和作用。
二、实验原理多态性是面向对象编程中的一个关键特性,它允许不同的对象对相同的消息或操作做出不同的响应。
这种特性基于类的继承和方法的重写机制。
当一个父类的引用指向子类对象时,通过该引用调用方法时,实际执行的是子类中重写的方法,从而实现了多态性。
三、实验材料与环境1、编程语言:选择了 Java 作为实验的编程语言。
2、开发工具:使用了 IntelliJ IDEA 作为集成开发环境。
3、实验设备:一台配置良好的计算机,操作系统为 Windows 10。
四、实验步骤1、创建父类`Shape````javaclass Shape {public void draw(){Systemoutprintln("Drawing a shape");}}```2、创建子类`Circle` 和`Square` 继承自`Shape````javaclass Circle extends Shape {@Overridepublic void draw(){Systemoutprintln("Drawing a circle");}}class Square extends Shape {@Overridepublic void draw(){Systemoutprintln("Drawing a square");}}```3、在主函数中进行测试```javapublic class PolymorphismTest {public static void main(String args) {Shape shape1 = new Circle();Shape shape2 = new Square();shape1draw();shape2draw();}}```五、实验结果运行上述代码,输出结果为:```Drawing a circleDrawing a square```这表明,通过父类的引用调用`draw` 方法时,实际执行的是子类中重写的方法,实现了多态性。
java论文--对Java多态性的理解

多态性一、什么是多态性1、多态性的定义术语“多态性”可以理解为“有许多形式”,一个“多态性引用”是可以在不同的时间指向不同类型的引用变量。
利用多态性调用的方法能够由一个调用改变为另一个调用。
分析下面的代码:obj.doIt(); 若obj引用是多态性的,它就可以在不同时刻指向不同类型的对象。
若将这行代码写在循环中或者写在一个调用多次的方法中,其结果是每次执行时可调用不同版本的doIt方法。
现实中,关于多态的例子不胜枚举,比方说按下F1 键这个动作,如果当前在Flash 界面下弹出的就是AS 3 的帮助文档;如果当前在Word 下弹出的就是Word 帮助;在Windows 下弹出的就是Windows 帮助和支持。
同一个事件发生在不同的对象上会产生不同的结果。
汽车的方向盘就是一个简单的多态性示例。
无论实际的方向控制机制是什么类型的,方向盘(也就是接口)都是一样的。
也就是说,无论你的汽车是手动操纵、电力操纵还是齿轮操纵,方向盘使用起来都是一样的。
因此,只要你知道如何操作方向盘,那么就可以驾驶任何类型的汽车。
2、多态的好处:(1)可替换性(substitutability)。
多态对已存在代码具有可替换性。
例如,多态对圆Circle类工作,对其他任何圆形几何体,如圆环,也同样工作。
(2)可扩充性(extensibility)。
多态对代码具有可扩充性。
增加新的子类不影响已存在类的多态性、继承性,以及其他特性的运行和操作。
实际上新加子类更容易获得多态功能。
例如,在实现了圆锥、半圆锥以及半球体的多态基础上,很容易增添球体类的多态性。
(3)接口性(interface-ability)。
多态是超类通过方法签名,向子类提供了一个共同接口,由子类来完善或者覆盖它而实现的。
(4).灵活性(flexibility)。
它在应用中体现了灵活多样的操作,提高了使用效率。
(5)简化性(simplicity)。
多态简化对应用软件的代码编写和修改过程,尤其在处理大量对象的运算和操作时,这个特点尤为突出和重要。
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. 在实验过程中,重点是要区分好实例和类,灵活掌握类的调⽤。
实验报告多态性

一、实验目的1. 理解多态性的概念及其在面向对象编程中的重要性。
2. 掌握多态性的实现方式,包括方法重载和方法覆盖。
3. 学习如何利用多态性提高代码的可读性和可维护性。
4. 通过实例分析,加深对多态性在实际编程中的应用理解。
二、实验背景多态性是面向对象编程中的一个核心概念,它允许同一个接口(或方法)根据不同的数据类型执行不同的操作。
在Java、C++等面向对象编程语言中,多态性主要通过方法重载和方法覆盖来实现。
三、实验内容1. 方法重载方法重载是指在同一个类中,允许存在多个同名方法,但参数列表不同。
编译器通过参数列表的匹配来确定调用哪个方法。
(1)实验步骤1)创建一个名为“Animal”的类,包含一个方法名为“makeSound”。
2)在“Animal”类中,添加三个重载的“makeSound”方法,分别接受不同类型的参数(如int、String、double)。
3)创建一个名为“Dog”的类,继承自“Animal”类,并重写“makeSound”方法,使其输出“Woof! Woof!”。
4)创建一个名为“Cat”的类,继承自“Animal”类,并重写“makeSound”方法,使其输出“Meow! Meow!”。
(2)实验结果当创建“Dog”和“Cat”对象时,调用“makeSound”方法会根据对象类型输出相应的声音。
2. 方法覆盖方法覆盖是指在子类中重写父类的方法,使子类的方法具有与父类方法相同的签名,但具有不同的实现。
(1)实验步骤1)创建一个名为“Vehicle”的类,包含一个方法名为“move”,该方法无参数。
2)创建一个名为“Car”的类,继承自“Vehicle”类,并重写“move”方法,使其输出“Car is moving”。
3)创建一个名为“Bike”的类,继承自“Vehicle”类,并重写“move”方法,使其输出“Bike is moving”。
(2)实验结果当创建“Car”和“Bike”对象时,调用“move”方法会根据对象类型输出相应的移动信息。
Java继承与多态实验报告

西安邮电大学(计算机学院)课内实验报告实验名称:继承与多态专业名称:计算机科学与技术班级:计科1405班学生姓名:高宏伟学号:04141152指导教师:刘霞林实验日期:2016.10.13一、实验目的通过编程和上机实验理解Java 语言的继承和多态特性,掌握变量的隐藏、方法的覆盖、重载,掌握抽象类和接口的使用。
二、实验要求1.编写体现类的继承性(成员变量、成员方法、成员变量隐藏)的程序。
2.编写体现类的多态性(成员方法重载)的程序。
3.编写体现类的多态性(构造方法重载)的程序。
4.编写使用接口的程序。
三、实验内容(一)类的继承1.创建公共类Student.(1)编写程序文件Student.java,源代码如下:public class Student{protected String name; //具有保护修饰符的成员变量protected int number;void setData(String m,int h) //设置数据的方法{name =m;number= h;}public void print() //输出数据的方法{System.out.println(name+", "+number);}}(2)编译Student.java,产生类文件Student.class。
2.创建继承的类Undergraduate(1)程序功能:通过Student 类产生子类undergraduate,其不仅具有父类的成员变量name(姓名)、number(学号),还定义了新成员变量academy(学院)、department (系)。
在程序中调用父类的print 方法。
(2)编写Undergraduate 程序:class Undergraduate extends Student{【代码1】//定义成员变量academy【代码2】//定义成员变量departmentpublic static void main(String args[]){【代码3】//创建一个学生对象s【代码4】//用父类的setData方法初始化对象s【代码5】//对象s调用print方法【代码6】//创建一个大学生对象u【代码7】//调用父类的成员方法setData初始化对象u【代码8】//设置对象u的成员变量academy【代码9】//设置对象u的成员变量departmentSystem.out.print(+", "+u.number+", "+u.academy+", "+u.department);}}(3)编译并运行程序注意:公共类Student 与undergraduate 类要在同一文件夹(路径)内。
Java多态性

Java多态性阅读次数: 673次发布时间: 2010-07-23 09:14:28发布人: 网络转载来源: 网络转载我在这里公开和我dennisboys的学习交流信件,我们主要在谈java中多态性问题。
这里感谢我的好朋友能给我一个结合自己能力解释问题的机会,在解释中有出错或者需要讨论的部分希望能通知我一声。
上篇关于多态性的文章请参阅我前面写的<>.******************************************************************************* 网友dennisboys的提问部分开始******************************************************************************* 从头到尾把你的代码看了n次,画了n个图(关于父类和子类的函数地址图),有以下一些迷惑test t=new test();base b=new base();b=t;/*问题一:这里是把父类的引用指向子类,那是不是说调用父类的方法就等于调用子类的方法呢?就是如果b.display2()不是调用子类的display2()方法吗?而子类有display2()方法,为什么不能调用呢?(我试过写代码了,果然如你所说是出错的。
)对于以上的问题,你有一段文字好像是对其作解译的。
不过我不太清楚。
不知是不是以下这段。
引用原文:同时可能有人要问,子类中那个函数地址不是也在虚拟函数表中吗?很高兴你问这样的问题,但是父类引用看到的虚拟函数表是没有那个函数项目的,因为他对于父类引用绝对是不可见。
我现在理解是如果在子类中如对方法作了更改或新增的方法,对父类来说是不可见的?理解对吗??*/问题二:((test)b).display();另一个迷感就是你说的强制转换类型的语法到底是怎样的??我不明白为((test)b)代表什么?不过说回来(我怎么觉得这个例子是在说继承??),这个例子使我对继承有了很深的认识,我倒是觉得对多态性还是一知半解,(别说我笨笨)可能我还没清楚到底哪用到了多态性,不过请先回复了我以上两个问题,希望你回复了我以上两个问题(结合我研究你的代码)使我对多态性有更好更深的认识。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验五多态性
一.实验目的和要求
目的:
1、掌握方法重载和类的多态性。
要求:
1、加减运算能够接收不同类型的参数既可以实现复数与实数的加减、复数与复数
的加减运算。
2、两游戏角色决斗。
角色1交手次数+1,生命值-1,经验值+2;角色2交手次
数+1,生命值-2,经验值+3。
经验值每增加50时,生命值+1;生命值<0判为负。
生命值初始为1000,经验值初始为0。
3、给定二个不同的角色,判定交手的胜负关系。
4、实验报告给出决斗结果和交手次数
5、实验报告给出所有源代码。
二.实验内容
1、编写一个名为“复数”的类,包含复数的实部和虚部(数据成员),以及复数之间的
基本算术运算:加、减(方法成员),并要求复数加减运算,程序运行中能对给定的复数进行运算,并打印运算的结果。
2、用类来描述游戏角色的交手次数、经验值、生命值之间的关系,并断定角色决斗的
胜负。
三.实验环境
硬件:
(1)学生用微机
(2)多媒体实验教室
软件:
(1)Windows XP中文操作系统
(2)JDK控制台
四.算法描述及实验步骤
实验步骤:
内容一:
1、创建“复数”类Complex,定义实部、虚部成员
2、定义构造函数接收二个double参数用来初始化数据成员
3、定义二个复数运算函数plus()以及minus()各接收一个复数类型以实现复数与复数
的加减运算。
4、定义二个复数运算函数plus()以及minus()各接收一个double类型以实现复数与与
实数的加减运算。
4、定义一个打印方法。
5、在main()方法中创建复数对象并调用相关方法来验证。
内容二:
1、建立角色类Role,给出相应的成员,并能以生命值、经验值初始化角色对象。
2、在角色类中建立fight方法,接收一个角色类型的参数并与之“战斗”,返回胜者信
息。
3、在主函数中初始化二个角色,调用fight方法。
五.调试过程
1.根据要求写出程序并调试运行,得:
当出现负数时,不需要我们外加一个负号,同时为什么会多出那么长的一串零呢?搞不懂为什么。
于是我将程序改为当出现负数时,不外加一个负号。
修改后的程序见附录1,结果见实验结果1。
2.根据实验步骤,写出程序并调试运行:
500次,不对啊,角色2经验上升时生命会增加啊,怎么会只有500次呢。
仔细检查,修改程序得实验结果(见实验结果2,程序见附录2)。
六.实验结果
1.程序一运行结果:
2.程序二运行结果:
七.总结
这次的程序好长,不过都是自己写的,发了两节课,出现了不少问题(只是没好意思截出来),和同学老师讨论了一下,对普通函数和构造函数有了更深刻的认识,这次的程序也不如之前的完美,很多本来想做的东西,如用Scanner类从键盘键入自己想要的数字、如何读取自己输入的复数、只进行自己想要进行的运算、对运算结果进行说明等,最终由于时间的原因,也由于自己自身能力的限制,没能如自己所愿,是一大憾事。
不过也不能太灰心,至少可能写一些简单的程序,其实我很得意的是我用了一个三元运算符(?:),呵呵,也不
能算没有收获。
附录:
1.程序一:
public class fsys//复数运算主类
{ static void print( complex c)//打印复数函数
{ System.out.print((c.em==0)?(c.re+"\n"):(c.re+((c.em>0)?("+"):(""))+c.em+"i\n" ));
}
public static void main(String ar[])
{ complex a=new complex();
complex b=new complex();
complex c=new complex();
double d=4.30;//要进行运算的实数
a.re=1.02;//加数(被减数)的实部
a.em=2.34;// 加数(被减数)的虚部
b.re=3.105;// 被加复数(减数)的实部
b.em=5.4317;// 被加复数(减数)的虚部
c=a.plus(b);
print(c);
c=a.minus(b);
print(c);
c=a.plus(d);
print(c);
c=a.minus(d);
print(c);
}
}
class complex
{ double re;//复数实部
double em; //复数部
complex plus(complex other)//复数相加
{ complex result=new complex();
result.re=this.re+other.re;
result.em=this.em+other.em;
return result;
}
complex minus(complex other)//复数相减
{ complex result=new complex();
result.re=this.re-other.re;
result.em=this.em-other.em;
return result;
}
complex plus(double other)//复数加实数
{ complex result=new complex();
result.re=this.re+other;
result.em=this.em;
return result;
}
complex minus(double other)//复数减实数
{ complex result=new complex();
result.re=this.re-other;
result.em=this.em;
return result;
}
}
2.程序二:
class role
{ String name;//角色姓名
int life=1000;//角色生命初值为1000
int exp=0;//角色经验初值为0
int count=0;//角色交战场次初值0
role fight(role role2)//定义生死搏斗函数
{ int n,E1,E2,i=0,j=0;
while(this.life>0&&role2.life>0)
{ this.life=this.life-1;
role2.life=role2.life-2;
this.exp=this.exp+2;
role2.exp=role2.exp+3;
E1=this.exp;
E2=role2.exp;
this.count++;
role2.count++;
if(E1-50*i>=50)
{ this.life=this.life+1;
i++;
}
if(E2-50*j>=50)
{ role2.life=role2.life+1;
j++;
}
}
return ((this.life<0)?role2:this);//生命值<0判为负 }
}
public class game
{ public static void main(String ar[])
{ role role1=new role();
role role2=new role();
="role1";
="role2";
role winner=new role();
winner=role1.fight(role2);
System.out.print(+"经过"+winner.count+"次的努力,终于赢得了胜利!");
}
}。