实验三 继承、多态和图形用户界面
实验三 继承和多态
实验三继承和多态一、实验目的1.熟练掌握封装性,多态性的概念。
2.熟练掌握抽象类abstract的概念。
3.熟练掌握接口interface的概念。
4.熟练包package的概念以及编译运行的方法。
二、实验内容1.编写一个Java Application程序,该程序有个点Point类,它包含横坐标x和纵坐标y 两个属性,再给Point定义两个构造方法和一个打印点坐标的方法Show。
定义一个圆Circle 类,它继承Point类(它是一个点,圆心(Center)),除此之外,还有属性半径Radius,再给圆定义2个构造方法、一个打印圆的面积的方法PrintArea和一个打印圆中心、半径的方法Show(其中显示圆心可以用super.Show()的方式)。
package实验三;public class Point {double x,y;public Point(){x=0;y=0;}public Point(double x,double y){this.x=x;this.y=y;}public String Show(){return"横坐标为:"+this.x+",纵坐标为:"+this.y;}/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubPoint a=new Point(3.0,4.0);System.out.println(a.Show());}}package实验三;public class Circle extends Point {double Radius;public Circle(){super(0,0);Radius=0;}public Circle(double x,double y,double z){super(x,y);Radius=z;}public String Show(){System.out.println("圆心的"+super.Show()+"半径为:"+Radius);return"圆心的"+super.Show()+"半径为:"+Radius;}public String PrintArea(){System.out.println("圆的面积为:"+Math.PI*Radius*Radius);return"圆的面积为:"+Math.PI*Radius*Radius;}/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubCircle a=new Circle(3,4,5);a.Show();a.PrintArea();}}2.编写一测试类,对其进行编译、运行。
实验三_类的重载继承和多态
课程名称面向对象程序设计实验名称实验三、类的重载继承和多态日期2015.10.23学生学号班级实验目的:1.编写一个单一继承的C#程序2.编写一个抽象类,并用一个类继承这个抽象类实验要求:1.认真阅读、掌握和本实验相关的教材内容。
2.设计并编写代码完成题目要求的任务。
3.撰写实验报告。
实验内容与步骤:1.在学校教务管理系统中,有三种用户,一种是系统管理员,一种是学生,一种是教师,编写C#类实现该继承关系。
系统管理员/学生/教师都有用户名和密码属性,并都有Login和显示自身信息的方法,另外,学生拥有班级和成绩两个特殊属性以及查询成绩这一方法,教师拥有部门和工资两个特殊属性以及查询工资这一方法,系统管理员可以添加学生和教师信息。
由于教师和学生个人信息不同,所以学生和教师重载基类的DisplayInfo方法。
(本例和教材一致,再次出现的目的是通过反复训练,理解继承的作用)1)类的继承关系可以表示如下:2)创建控制台应用程序,命名为SchoolManagement3)创建名为User的基类,基类定义了用户名和密码属性,以及Login和DisplayInfo方法using System;//显示教师信息,查询工资teacher.DisplayPersonInfo();teacher.checkSalary();Console.WriteLine("------------------------------");//显示学生信息,查询成绩stu.DisplayPersonInfo();stu.CheckScore();Console.WriteLine("------------------------------");}}}6)最终运行效果如下2.建立名为Shape的基类,要求是抽象类,在该类中提供一个public abstract double Area()的抽象方法,建立名为Circle的派生类,包括半径属性,实现面积计算,再建立一个名为Rectangle的派生类,包括长和宽两个属性,实现面积的计算。
实验3(Java)(2011)(图形用户界面)
实验3 图形用户界面1、编程程序实现如图1所示的计算器,并实现全部功能。
图1计算器2、设计一个Java程序,显示修改密码界面,并实现“确定”与“取消”按钮的功能。
Mima.javapublic class Mima {public static void main(String args[]){PasswordWindow win = new PasswordWindow();win.setTitle("带密码框的窗口");}}PasswordWindow.javaimport java.awt.*;import javax.swing.*;import java.awt.event.*;public class PasswordWindow extends JFrame {JTextField area;JPasswordField inputPassword;JTextField textShow;PasswordListener listener;JButton getNumber,c1,c2;Box baseBox,boxV1,boxV2;public PasswordWindow(){setLayout(new java.awt.FlowLayout());init();setBounds(10,10,330,150);setVisible(true);setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}void init(){inputPassword = new JPasswordField(16);textShow=new JTextField(16);textShow.setEditable(false);listener = new PasswordListener();listener.setJTextField(textShow);area= new JTextField(25);c1.addFocusListener(this);add(c1);inputPassword.addActionListener(listener);boxV1= Box.createVerticalBox();boxV1.add(new JLabel("请输入密码"));boxV1.add(Box.createVerticalStrut(8));boxV1.add(new JLabel("您所输入的密码是:"));boxV1.add(Box.createVerticalStrut(8));boxV2=Box.createVerticalBox();boxV2.add(inputPassword);boxV2.add(Box.createVerticalStrut(8));boxV2.add(textShow);boxV2.add(Box.createVerticalStrut(8));baseBox=Box.createHorizontalBox();baseBox.add(boxV1);baseBox.add(Box.createHorizontalStrut(10));baseBox.add(boxV2);add(baseBox);c1=new JButton("确定");add(c1);c2=new JButton("取消");add(c2);}public void actionPerformed(ActionEvent e){if ( e.getSource()==c1){area.setText("fdas");}}}PasswordListener.javaimport java.awt.event.*;import javax.swing.*;public class PasswordListener implements ActionListener{ JTextField textShow;public void setJTextField(JTextField t){textShow= t;}public void actionPerformed(ActionEvent e){JPasswordField passwordText =(JPasswordField)e.getSource();char []password =passwordText.getPassword();String str= new String(password);textShow.setText(str);}}3、设计一个Java程序,显示用户登录界面,并根据登录情况显示相应的提示信息。
软件设计模型中的继承与多态应用
软件设计模型中的继承与多态应用在软件设计模型中,继承与多态是两种非常重要的概念。
它们能够帮助我们更高效地编写面向对象的代码,从而提高我们的开发效率和代码质量。
本文将简要介绍继承和多态的概念,以及它们在软件设计模型中的应用。
继承是一种面向对象编程中的基本概念。
它允许我们从一个类中派生出另一个类,使得子类能够继承父类的属性和方法。
子类可以重写父类的方法,并且还可以定义自己的属性和方法。
通过使用继承,我们可以更好地组织和管理代码,从而使代码更容易被复用和维护。
多态是指对象能够表现出多种形态。
在面向对象编程中,多态的实现有两种方式:虚函数和模板。
虚函数可以通过函数指针实现,在类的定义中将函数声明为虚函数,派生类中重写父类的虚函数,就可以使得对象在运行时表现出多种不同的行为。
模板则允许我们定义一种通用的类型,能够接受多种不同的参数类型,从而在运行时实现多态。
继承和多态在软件设计模型中的应用非常广泛。
例如,在图形用户界面编程中,一个按钮可以作为一个基类,派生出多个不同的子类,每个子类都有自己的样式和行为。
这种继承关系可以非常好地组织和管理代码,并且使得不同的按钮可以共享相同的基本属性和方法。
另一个例子是在游戏编程中,一个游戏角色可以作为一个基类,派生出多个不同的子类,每个子类都有自己独特的特性和能力。
通过使用继承和多态,可以使得游戏开发更加高效和灵活。
总之,继承和多态是软件设计模型中极其重要的概念。
它们不仅能够使得代码更容易被组织和管理,还能够提高代码的可重用性和可维护性。
当我们在进行面向对象的编程时,一定要注意继承和多态的使用,从而使我们的代码更加优雅和高效。
实验三图形用户界面设计(汽院含答案解析)
实验三图形⽤户界⾯设计(汽院含答案解析)实验三图形⽤户界⾯设计实验⽬的1.掌握Java语⾔中GUI编程的基本⽅法2.掌握Java语⾔中AWT组件的基本⽤法3.掌握Java语⾔中Swing组件的基本⽤法实验导读1.通过图形⽤户界⾯(GUI:Graphics User Interface),⽤户和程序之间可以⽅便地进⾏交互。
AWT(Abstract Windowing Toolkit),中⽂译为抽象窗⼝⼯具包,是Java提供的⽤来建⽴和设置Java的图形⽤户界⾯的基本⼯具。
AWT由Java中的java.awt包提供,⾥⾯包含了许多可⽤来建⽴与平台⽆关的图形⽤户界⾯(GUI)的类,这些类⼜被称为组件(components)。
Swing是⼀个⽤于开发Java应⽤程序⽤户界⾯的开发⼯具包。
它以抽象窗⼝⼯具包(AWT)为基础使跨平台应⽤程序可以使⽤任何可插拔的外观风格。
Swing开发⼈员只⽤很少的代码就可以利⽤Swing丰富、灵活的功能和模块化组件来创建优雅的⽤户界⾯。
JDK写程序所有功能都是靠虚拟机去操作本地操作系统。
⽐如window下,就是JDK ⽤windows API实现功能。
⽽awt包中很多组件是组件⾃⾝去调⽤本地操作系统代码swing包中的组件采⽤的是调⽤本地虚拟机⽅法,由虚拟机再调⽤本地操作系统代码。
意思就是中间多了⼀层,这样就加强了swing包的移植性,与本地关系不那强了。
图3.1 AWT常⽤组件继承关系图Container为容器,是⼀个特殊的组件,该组件中可以通过add⽅法添加其他组件进来。
2.布局,容器中的组件的排放⽅式。
常见的布局管理器:FlowLayout(流式布局管理器):从左到右的顺序排列。
Panel默认的布局管理器。
BorderLayout(边界布局管理器):东,南,西,北,中。
Frame默认的布局管理器。
GridLayout(⽹格布局管理器):规则的矩阵CardLayout(卡⽚布局管理器):选项卡GridBagLayout(⽹格包布局管理器):⾮规则的矩阵3.类JFrame是java.awt.Frame 的扩展版本,该版本添加了对JFC/Swing 组件架构的⽀持,常⽤⽅法如下:1)JFrame() 该构造⽅法可以创建⼀个⽆标题的窗⼝,窗⼝的默认布局为BorderLayout布局。
类的继承与多态性实验报告
类的继承与多态性实验报告目录1.介绍2.什么是多态3.多态在Java中的技术基础4.示例5.多态的好处6.总结介绍之前的文章介绍过类的封装性和继承性,现在是时候聊聊面向对象编程的三大特性之一的最后一个类的多态性了。
多态的基础是继承(包括了接口的实现)和方法的覆盖。
什么是多态多态对应的英文单词是polymorphism,百度翻译给出的翻译是:n.多型现象,多态性; 多机组合形式;按字面意思就是多种状态、形态、姿态等等,潜台词就是某个东西具有多种状态、形态、姿态等等。
那是什么东西呢?在面向对象的编程语言里面(当然就包括Java了)就是某个方法或函数。
那方法的多种状态、形态、姿态有是个什么意思呢?这其实是指同一个方法具有多个方法体,就是方法的实现。
而方法的相同与否是由方法签名决定的。
所以,多态其实本质上是指同一个类的同一个方法却具有不同的行为特征。
状态、形态、姿态指的就是行为特征。
多态在Java中的技术基础然而,在Java中,同一个类里面是不可能存在两个签名相同而实现不同的方法的,否则的话会导致无法判断该执行哪个方法,因此在编译时就会报错。
所以,肯定是在两个类中才有可能存在两个签名相同而实现不同的方法,一个实现在这个类,另一个实现在另一个类。
而如果这两个类毫无瓜葛,那么肯定就与多态的本质(同一个类的同一个方法却具有不同的行为特征)自相矛盾了。
所以,这两个类肯定是有某种联系的。
我们再想想,什么概念是能够让两个不同的类却又能称为同一个类的?答案就是类的继承/扩展,就是现实中的“某东西是某类东西”的概念,就是“具体和抽象”的思想。
比如,男人是人,女人也是人,男人类和女人类就借助于人类建立了某种联系,而人类具有的某个行为在男人类和女人类中是有着不同体现的,比如人类的吃饭这个行为,男人类的体现是狼吞虎咽,女人类的体现是细嚼慢咽。
例子不是很恰当,但意思就是这么个意思。
所以说,Java里面多态的技术基础就是方法的覆盖,当然,在Java中覆盖不仅仅发生在类的继承/扩展上,还可能发生在接口的实现上。
实验三 继承和多态
实验三继承和多态一、实验目的1.熟练掌握封装性,多态性的概念。
2.熟练掌握抽象类abstract的概念。
3.熟练掌握接口interface的概念。
4.熟练包package的概念以及编译运行的方法。
二、实验内容1.编写一个Java Application程序,该程序有个点Point类,它包含横坐标x和纵坐标y 两个属性,再给Point定义两个构造方法和一个打印点坐标的方法Show。
定义一个圆Circle 类,它继承Point类(它是一个点,圆心(Center)),除此之外,还有属性半径Radius,再给圆定义2个构造方法、一个打印圆的面积的方法PrintArea和一个打印圆中心、半径的方法Show(其中显示圆心可以用super.Show()的方式)。
编写一测试类,对其进行编译、运行。
结果如何?如去掉语句“super.Show();”,再看看运行结果。
理解程序中重载和多态性的运用。
2.完成以下步骤要求:(1)设计一个表示二维平面上点的类Point,包含有表示坐标位置的protected类型的成员变量x和y,获取和设置x和y值的public方法。
(2)设计一个表示二维平面上圆的类Circle,它继承自类Point,还包含有表示圆半径的protected类型的成员变量r,获取和设置r值的public方法、计算圆面积的public 方法。
(3)设计一个表示圆柱体的类Cylinder,它继承自类Circle,还包含有表示圆柱体高的protected类型的成员变量h、获取和设置h值的public方法、计算圆柱体体积的public 方法。
(4)建立若干个Cylinder对象,输出其轴心位置坐标、半径、高及其体积的值。
3.学校中有老师和学生两类人,而在职研究生既是老师又是学生,对学生的管理和对教师的管理在他们身上都有体现。
(1)设计两个信息管理接口StudentInterface和TeacherInterfaceo其中,StudentInterface接口包括setFee方法和getFee方法,分别用于设置和获取学生的学费;TeacherInterface接口包括setPay方法和getPay方法,分别用于设置和获取教师的工资。
C++-实验报告3
C++-实验报告3C++实验报告 3一、实验目的本次 C++实验的主要目的是深入理解和掌握 C++中类与对象、继承与多态等重要概念,并通过实际编程练习来提高编程能力和问题解决能力。
二、实验环境操作系统:Windows 10编译器:Visual Studio 2019三、实验内容1、类与对象的定义和使用定义一个名为`Student`的类,包含学生的姓名、学号、年龄和成绩等属性,并实现相应的成员函数来设置和获取这些属性的值。
创建`Student`类的对象,并对其属性进行赋值和输出。
2、继承与多态定义一个基类`Person`,包含姓名和年龄等属性,以及一个虚函数`displayInfo`用于输出个人信息。
从`Person`类派生一个子类`Student`,添加学号和成绩等属性,并重写`displayInfo`函数以输出学生的详细信息。
创建`Person`类和`Student`类的对象,并通过基类指针调用`displayInfo`函数,观察多态性的实现。
3、运算符重载为`Student`类重载加法运算符`+`,实现两个学生对象成绩的相加。
重载小于运算符`<`,用于比较两个学生对象的成绩大小。
四、实验步骤及代码实现1、类与对象的定义和使用```cppinclude <iostream>include <string>class Student {private:std::string name;int id;int age;double score;public://设置属性值的函数void setName(std::string n) {name = n;}void setId(int i) {id = i;}void setAge(int a) {age = a;}void setScore(double s) {score = s;}//获取属性值的函数std::string getName(){return name;}int getId(){return id;}int getAge(){return age;}double getScore(){return score;}//输出学生信息的函数void display(){std::cout <<"姓名:"<< name <<",学号:"<< id <<",年龄:"<< age <<",成绩:"<< score << std::endl;}};int main(){Student s1;s1setName("张三");s1setId(1001);s1setAge(20);s1setScore(855);Student s2;s2setName("李四");s2setId(1002);s2setAge(19);s2setScore(900);s1display();s2display();return 0;}```2、继承与多态```cppinclude <iostream> include <string>class Person {protected:std::string name;int age;public://构造函数Person(std::string n, int a) {name = n;age = a;}//虚函数,用于输出个人信息virtual void displayInfo(){std::cout <<"姓名:"<< name <<",年龄:"<< age << std::endl;}};class Student : public Person {private:int id;double score;public://构造函数Student(std::string n, int a, int i, double s) : Person(n, a) {id = i;score = s;}//重写 displayInfo 函数void displayInfo() override {std::cout <<"姓名:"<< name <<",年龄:"<< age <<",学号:"<< id <<",成绩:"<< score << std::endl;}};int main(){Person p1 = new Student("张三", 20, 1001, 855);Person p2 = new Student("李四", 19, 1002, 900);p1->displayInfo();p2->displayInfo();delete p1;delete p2;return 0;}```3、运算符重载```cppinclude <iostream> include <string> class Student {private:std::string name;int id;int age;double score; public://设置属性值的函数void setName(std::string n) {name = n;}void setId(int i) {id = i;}void setAge(int a) {age = a;}void setScore(double s) {score = s;}//获取属性值的函数std::string getName(){return name;}int getId(){return id;}int getAge(){return age;}double getScore(){return score;}//输出学生信息的函数void display(){std::cout <<"姓名:"<< name <<",学号:"<< id <<",年龄:"<< age <<",成绩:"<< score << std::endl;}//重载加法运算符Student operator+(const Student& other) {Student result;resultsetName(this>name);resultsetId(this>id);resultsetAge(this>age);resultsetScore(this>score + otherscore);return result;}//重载小于运算符bool operator<(const Student& other) {return this>score < otherscore;}};int main(){Student s1;s1setName("张三");s1setId(1001);s1setAge(20);s1setScore(855);Student s2;s2setName("李四");s2setId(1002);s2setAge(19);s2setScore(900);Student s3 = s1 + s2;s3display();if (s1 < s2) {std::cout <<"s1 的成绩小于 s2" << std::endl;} else {std::cout <<"s1 的成绩大于等于 s2" << std::endl;}return 0;}```五、实验结果与分析1、类与对象的定义和使用在运行上述代码时,成功创建了`Student`类的对象`s1`和`s2`,并通过成员函数对其属性进行了赋值和输出。
《Java程序设计》上机实验报告 实验三 面向对象程序设计的继承、多态等特性的练习
信息科学与工程学院《Java程序设计》上机实验报告专业班级姓名学号实验时间指导教师成绩主要实验记录及个人小结(包括部分实验源程序、调试结果及实验结果分析等)Student(String name,String sex,int age,String sno,String classno) {super(name,sex,age);this.sno=sno;this.classno=classno;}public String toString(){ return("姓名:"+name+" 性别:"+sex +" 年龄:"+age+ " 学号:"+sno+" 班号:"+classno+" ");}}public class TestStudentPerson {public static void main(String[] args){int i;Student stu[]=new Student[3];stu[1]=new Student("小明","男",20,"200912135138","2班");stu[2]=new Student("小木","女",23,"200912135136","5班");stu [1].updateAge(25);stu [2].updateAge(26);for(i=1;i<3;i++){System.out.println(stu[i]);}}}2)调试结果:主要实验记录及个人小结(包括部分实验源程序、调试结果及实验结果分析等)调试结果:2)将Shape类定义为abstact class Shape{……}public class TestVirtualInvoke {static void doStuff(Shape s){s.draw();}public static void main(String[] args) {Circle c=new Circle();Triangle t=new Triangle();Line l=new Line();doStuff(c); //作为实参,调用对象是3个类对象,上溯造型使其隐藏.doStuff(t);doStuff(l);}}abstract class Shape{abstract void draw();}class Circle extends Shape{void draw(){System.out.println("Draw Circle");}} //定义Shape抽象类的派生类Circleclass Triangle extends Shape{void draw(){System.out.println("Draw Three Triangle");}}//定义Shape抽象类的派生类Triangleclass Line extends Shape{void draw(){System.out.println("Draw Line");}}//定义Shape抽象类的派生类Line主要实验记录及个人小结(包括部分实验源程序、调试结果及实验结果分析等)调试结果:3)将Shape定义为interface Shape{……}public class TestVirtualInvoke {static void doStuff(Shape s){s.draw();}public static void main(String[] args) {Circle c=new Circle();Triangle t=new Triangle();Line l=new Line();doStuff(c); //作为实参,调用对象是3个类对象,上溯造型使其隐藏.doStuff(t);doStuff(l);}}interface Shape{public void draw();} //定义一个Shape接口class Circle implements Shape{public void draw(){System.out.println("Draw Circle");}} //基于Shape接口利用implements实现类Circleclass Triangle implements Shape{public void draw(){System.out.println("Draw Three Triangle");}}class Line implements Shape{public void draw(){System.out.println("Draw Line");}}调试结果:3.思考题:某小型公司,主要有三类人员:经理、兼职技术人员和兼职推销员。
Java继承与多态实验报告.doc
Java继承与多态实验报告.doc
Java的继承与多态实验报告
本报告致力于分析Java继承与多态的概念、原理和作用,以及相关实验过程及其结果。
继承,又称为分类,是Java面向对象程序设计语言中定义类之间关系的重要技术。
它使一个类可以使用另一个基类中定义的方法和属性,在基类中已经定义了一些功能,子
类可以对基类功能进行拓展与定制。
《Java技术手册》得出结论,继承可以有效提高软件的复用性、可维护性和可重用性,使大型的、复杂的程序有条理层次。
多态是Java中一种特殊的程序结构,允许不同类的对象对相同的消息作出不同的响应,由程序的消息而不是对象的类型来决定对象的行为。
它是Java多态性的基础,使程
序能够在不同对象上进行操作,统一实现。
从实验中,可以明显看出Java继承与多态之间的联系:多态必须依赖于继承,当子
类被创建时,它继承了母类的方法以及特性,这样,它才能以逐渐上升的方式处理所有消息,而多态给了子类独特-->性的功能。
同时,多态也方便了代码重用,因为子类会继承
母类的方法和属性。
此外,结果表明,多态的优点使程序可以提高可重用性,它也减少了代码的重复编写,同时允许特定类之外的类可以得到适用。
它促进了软件不断更新,因为多态给开发人员提
供了以对象层次组织代码的方法。
本练习涉及到Java继承与多态概念的整体概述和实现细节,为完全理解多态的概念
打下了坚实的基础。
它提供了一个理解和使用这些概念的有用方式和指导。
实验三 图形界面程序的界面设计
实验三图形界面程序的界面设计一、实验目的1、掌握Java图形界面程序设计的基本思想和步骤。
2、掌握JDK中A WT包和Swing包的基本使用方法和区别。
3、掌握容器和布局的概念和使用。
4、掌握图形界面程序的界面设计方法和步骤。
二、实验内容自己编写所有代码,设计一个程序的界面。
其中界面设计时的顶层容器要求使用JFrame(或Frame),界面上的“简易计算器”、“运算数一”、“运算数二”、“运算结果”这些提示标签使用组件JLable(或Lable),输入运算数和输出运算数结果使用JTextField(TextField),“相加”、“相减”和“全部清零”使用按钮JButton(或Button)。
请注意查阅JDK的API文档中这些相关的类,看看它们具有哪些构造函数可以用来生成所需的对象,它们具有哪些方法用来进行调用。
注意保存好本次实验代码,下一次实验将会要求实现其事件处理以继承完善。
四、分析设计过程首先,利用建立一个JFrame容器,设计容器的大小,并且用setVisible(true)设为可视,定义界面上的“简易计算器”、“运算数一”、“运算数二”、“运算结果”的标签,并且定义“相加”、“相减”和“全部清零”使用按钮,并且要用setSize()和setLocation()排布好这些按钮以及标签的位置,并且一定要用要用add()方法把这些标签和按钮添加到容器中。
这样子就行了。
五、测试数据和程序运行的结果六、问题与总结整个逻辑思路并不困难,因为只要是懂得Frame容器的定义,JButton,Label等些知识,而老师在例子中给了很多相似的例子,就比较容易。
在我做这个实验的时候,遇到比较困难的地方就是,给标签、按钮的排布,之前一直不是这个按钮不见就是这个标签看不到,而具体的原因是我不懂得各个标签、按钮的比例。
导致,很多东西都无法在界面上显示出来。
七、附录import java.awt.*;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.*;public class Jiemian extends JFrame implements ActionListener{JFrame jfr=new JFrame("Basic Application");//定义一个Frame容器的对象jfrLabel l1=new Label("简易计算器");//定义各个标签Label l2=new Label("运算数一");Label l3=new Label("运算数二");Label l4=new Label("运算结果");JTextField tf1=new JTextField(15);//定义各个JTextField类型的组件,并生成对象实例JTextField tf2=new JTextField(15);JTextField tf3=new JTextField(15);JButton b1=new JButton("相加");//定义各个按钮JButton b2=new JButton("相减");JButton b3=new JButton("全部清零");public Jiemian(){j fr.setSize(260,350);//设计界面的大小jfr.setLayout(null);//设计为null布局l1.setSize(90,30);//设计11的宽度和高度l1.setLocation(80,20);//设计11在界面上左上角的位置坐标l2.setSize(60,30);l2.setLocation(30,70);l3.setSize(60,30);l3.setLocation(30,120);l4.setSize(60,30);l4.setLocation(30,170);tf1.setSize(100,30);tf1.setLocation(120,70);tf2.setSize(100,30);tf2.setLocation(120,120);tf3.setSize(100,30);tf3.setLocation(120,170);b1.setSize(60,30);b1.setLocation(50,220);b2.setSize(60,30);b2.setLocation(140,220);b3.setSize(100,30);b3.setLocation(80,270);jfr.add(l1);//添加到容器上jfr.add(l2);jfr.add(l3);jfr.add(l4);jfr.add(tf1);jfr.add(tf2);jfr.add(tf3);jfr.add(b1);jfr.add(b2);jfr.add(b3);jfr.setLocation(500,150);jfr.setVisible(true);}public static void main(String args[]) { Jiemian ja=new Jiemian();}}。
实验三 继承、多态和图形用户界面
实验三字符串与文本(上课被教师验收的同学不用提交实验结果,并注意在教师处签名。
未完成的同学请提交实验结果,即将程序直接粘贴至本DOC文件,并在邮件名的标题中注明:学号+姓名+实验三)1.给出下面程序的输出:2.直接给出下面程序的运行结果:B's constructor is invokedA's constructor is invoked2. 下面的说法对的注明“True”,错的注明“False”(1)子类是父类的一个子集。
( F )(2)当从子类调用一个构造函数时,它的父类的无参构造方法总是被调用。
( f )(3)可以覆盖定义在父类中的私有方法。
( f ) (4)可以覆盖定义在父类中的静态方法。
( F )(5) 如果子类中的一个方法和它的父类中的方法具有完全相同的方法头,但返回值类型不同,也可以构成覆盖。
F(6) 可以给面板添加一个框架。
f(7) 可以给框架添加一个面板。
t3. 指出下面程序中的问题:This.radius=radiusThis.length=lengthSuper.getArea()*length4.下面的程序是要在框架中显示一个按钮,但是什么也没有显示出来。
这个程序有什么问题?Test frame=new Test();5.填空:(1)在类上使用public,protected,(default) 修饰符,才能使同一个包中的类可以访问它,而不同包中的类不能访问它。
(2)在类上使用public 修饰符,才能使不同包中的类不能访问这个类,而任何包中的子类可以访问它。
6. 在程序清单11-9中,MyStack是用组合实现的,现请扩展ArrayList,利用继承来实现MyStack。
编写一个测试程序,提示用户输入五个字符串,然后以逆序显示这些字符串。
7. 编写程序,创建一个ArrayList,然后向这个线性表中添加一个Object对象、一个Date 对象、一个字符串、一个JFrame对象,然后使用循环调用对象的toString( )方法,来显示线性表中所有的元素。
java 图形用户界面编程实验报告
实验3 图形用户界面编程(设计性实验)一、实验目的1、熟悉Swing的基本组件,包括文本输入框、多行文本输入框、按钮、列表框等;2、熟悉常用的布局管理器3、了解GUI图像用户界面的设计方法4、掌握Java组件的事件处理机制5、熟悉基于内部类和匿名类的事件处理方式二、实验要求1、学生应做到独立上机操作2、编程前应将程序的设计构想完成,主要包括所要创建的类的结构及属性和行为。
3、上机输入和调试自己所编的程序,并存在自己的软盘上。
4、检查实验结果是否正确。
5、上机结束后,写出实验报告,要求附运行界面、源代码。
实验报告中应对实验结果进行分析,尤其是针对错误输出的分析。
三、实验内容1. 选做:编写程序,显示一个窗口,窗口中包含一个按钮。
当单击按钮时将弹出另一个窗口。
2. 编写一个简单的计算器程序,实现两个数相加。
在文本框输入两个实数,点击“相加”按钮实现两个实数相加,并在标签中显示相加结果。
点击“清除”完成对文本框和运行结果的清除。
四、实验代码及结果1、import javax.swing.*;import java.awt.event.*;import java.awt.*;public class TestFrame{public static void main(String args[]){JFrame f=new JFrame("Test");f.setSize(400,200);f.setLayout(new FlowLayout(FlowLayout.CENTER));f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);JButton b=new JButton("确定");b.addActionListener(new ButtonHandler());f.add(b);f.setVisible(true);}}class ButtonHandler implements ActionListener{public void actionPerformed(ActionEvent e){JFrame fr=new JFrame("Hello");fr.setSize(200,100);fr.setVisible(true);}}import javax.swing.*;import java.awt.event.*;import java.awt.*;public class TestCalculator implements ActionListener{JFrame f;JTextField t1;JTextField t2;JTextField t3;JButton b1;JButton b2;public TestCalculator(){f=new JFrame("Calculate");f.setSize(400,200);f.setLayout(new GridLayout(2,3));f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);t1=new JTextField();t2=new JTextField();t3=new JTextField();b1=new JButton("add");b2=new JButton("clear");b1.addActionListener(this);b2.addActionListener(this);f.add(t1);f.add(t2);f.add(t3);f.add(b1);f.add(b2);f.setVisible(true);}public void actionPerformed(ActionEvent e){if(e.getSource()==b1){String s1=t1.getText();String s2=t2.getText();int a=Integer.valueOf(s1).intValue();int b=Integer.valueOf(s2).intValue();int c=a+b;t3.setText(Integer.toString(c));}else{t1.setText(" ");t2.setText(" ");t3.setText(" ");}}public static void main(String args[]){ TestCalculator test=new TestCalculator(); }}。
实习课题14:面向对象——继承与多态
实习课题14:面向对象思想——继承与多态实训目的●会使用继承的方式编写子类●会使用多态的方式编写程序●会使用super调用父类构造方法实训目标使用editplus编写主题类、回复类具有如下功能:●主题类继承帖子类,并增加属性:主题id,版块id●回复类继承帖子类,并增加属性:回复id,主题id●在帖子类中实现多态●使用super调用父类构造方法实训内容练习一:创建主题类需求说明:创建主题类,继承帖子类(如图所示)实现思路:1.创建主题类:Topic,继承帖子类:Tip2.增加以下属性:主题id:int topicId版块id:int boarded3.添加setter/getter方法4.使用从帖子类继承来的getInfo()方法,输出主题信息、练习二:创建回复类需求说明:1. 创建回复类:Reply ,继承帖子类:Tip2. 增加以下属性:a) 回复id :int replyIdb) 主题id :int topicId3. 添加setter/getter 方法4. 使用从帖子类继承来的getInfo ()方法,输出回复信息练习三:多态需求说明:主题类、回复类重写帖子类输出信息的方法继承实现思路:1、主题类重写getInfo()方法,输出主题信息2、回复类重写getInfo()方法,输出回复信息3、创建测试类,在测试类中使用多态的方式调用getInfo()方法练习四:super关键字需求说明:1、为主题类添加无参构造方法,在该方法中使用super(),并输出“主题类的无参构造方法”2、为主题类添加有参构造方法,参数同Tip类有参构造方法,在该方法中使用super(pTitle,pContent,pTime),并输出“主题类的有参构造方法”3、创建测试类,使用测试类测试主题类构造方法。
实验三类的重载继承和多态
2)创建控制台应用程序,命名为SchoolManagement3)创建名为User的基类,基类定义了用户名和密码属性,以及Login和DisplayInfo方法using System;using System.Collections.Generic;using System.Text;namespace SchoolManagement{public class User{private string userName;//用户名public string Name{get { return userName; }set { userName = value; }}private string password;//密码public string Password{get { return password; }set { password = value; }}private string userType;//用户类型2.建立名为Shape的基类,要求是抽象类,在该类中提供一个public abstract double Area()的抽象方法,建立名为Circle的派生类,包括半径属性,实现面积计算,再建立一个名为Rectangle 的派生类,包括长和宽两个属性,实现面积的计算。
using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace GetArea{class Program{static void Main(string[] args){Console.WriteLine("请?输º?入¨?圆2的Ì?半ã?径?:");double r=double.Parse (Console.ReadLine ());shape s = new Circle(r);}public Rectangle(double side, double high){this.side = side;this.high = high;}public override double Area(){return side * high;}}}}最终运行效果如下实验总结(结论或问题分析):本次实验我对基类、抽象类、派生类有了近一步的了解,知道了怎么建立这些类,还有在抽象类中创建抽象方法。
《面向对象程序设计》实验指导书
《⾯向对象程序设计》实验指导书《⾯向对象程序设计》实验指导书郭⽟柱⼴东商学院信息学院⼆0⼀0 年⼗⼆⽉⽬录实验⼀ Java基础实验实验⼆ Java⾯向对象特性试验--Java中的类、对象和⽅法实验三类的继承、多态、接⼝、访问控制符与修饰符实验四 Java资源及其利⽤实验五 Java 语⾔的异常处理实验六输⼊输出流实验七图形⽤户界⾯设计实验⼋ Java Applet及多线程试验附录1 实验报告格式实验⼀ Java 基础实验⼀、实验⽬的与要求1. 学习编写简单的Java 程序。
2. 学习掌握Java 基本数据类型及其基本运算。
3. 学习掌握Java 的基本流程控制语句。
⼆、相关知识1. 了解JDK 的⼯作环境,以及如何使⽤JDK 进⾏编程。
2. 熟悉集成软件 eclipse3.5及其使⽤。
⼆、实验内容1. 编写Hello.java 程序并运⾏。
2. ⽤Java 语⾔编写⼀个应⽤程序在屏幕上输出1000之内的素数。
3. ⼀个数如果恰好等于它的因⼦之和,这个数就称为“完数”,⽐如28=1+2+4+7+14。
编写⼀个应⽤程序在屏幕上输出1000之内的完数。
4. 求满⾜1!+2!+3!+ …+n!≤9999的最⼤整数n 。
5. ⼀个三位的整数如果它的各位数字的⽴⽅之和等于这个三位数,就称此数为⽔仙花数,⽐如 333173371++=,编写⼀个应⽤程序在屏幕上输出所有⽔仙花数。
6. 下⾯程序的输出结果是什么?实验⼆ Java⾯向对象特性试验-Java中的类、对象和⽅法⼀、实验⽬的与要求1. 掌握类的定义和使⽤。
2. 掌握对象的声明、创建和使⽤。
3. 掌握构造⽅法的定义和使⽤。
4. 掌握类⽅法(静态⽅法)和⾮类⽅法(⾮静态⽅法)的区别和使⽤。
5. 掌握成员变量和局部变量的区别和使⽤。
⼆、实验内容1. 编写⼀个Java程序,定义⼀个表⽰学⽣的类,类名Student,其成员变量有:学号、班级姓名、性别、年龄;成员⽅法:(1)获得班号(2)获得姓名(3)获得年龄(4)修改年龄;创建⼀个Student的对象,修改该对象的年龄,并输出该对象的年龄。
3 实验三 类的继承及多态
public void printA2(){
System.out.println("HelloChina!");
}
public void printB(){
System.out.println("Hello "+NAME);
}
}
public class InterfaceExtendsDemo{
public static void main(String args[]){
【源代码】
class Person{
public String name="张三";
}
class Student extends Person{
public String name="张童";
public void print(){
System.out.println("父类中属性: "+);
}
class X implements A,B{
public void printA1(){
System.out.println("Hello World!");
}
public void printA2(){
System.out.println("HelloChina!");
}
public void printB(){
要求:在重写的方法的方法体中需要调用被隐藏的方法返回a和b的最大公约数m,然后将(a*b/m)返回;在应用的程序的主类中分别使用父类和子类创建对象,并分别调用方法f()计算两个正整数的最大公约数和最小公倍数。
4编写一个圆锥类,能够计算圆锥的体积,要求圆锥类的构造函数中有一参数是圆类的一个对象。
继承与多态实验报告
继承与多态实验报告继承与多态实验报告在面向对象编程中,继承和多态是两个重要的概念。
通过继承,我们可以创建新的类,并从现有的类中继承属性和方法。
而多态则允许我们使用父类的引用来指向子类的对象,实现同一操作具有不同的行为。
本实验旨在通过实际的编程实践,加深对继承和多态的理解。
实验一:继承在这个实验中,我们创建了一个动物类(Animal),并从它派生出了两个子类:狗类(Dog)和猫类(Cat)。
动物类具有一些共同的属性和方法,如名字(name)和发出声音(makeSound)。
子类继承了父类的属性和方法,并可以添加自己的特定属性和方法。
在编写代码时,我们首先定义了动物类,并在其中实现了共同的属性和方法。
然后,我们创建了狗类和猫类,并分别在这两个类中添加了自己的特定属性和方法。
通过继承,我们可以在子类中直接使用父类的方法,并且可以根据需要进行重写。
实验二:多态在这个实验中,我们使用多态的概念来实现一个动物园的场景。
我们定义了一个动物园类(Zoo),并在其中创建了一个动物数组。
这个数组可以存储不同类型的动物对象,包括狗、猫等。
通过多态,我们可以使用动物类的引用来指向不同类型的动物对象。
例如,我们可以使用动物类的引用来指向狗对象,并调用狗类特有的方法。
这样,我们可以统一处理不同类型的动物对象,而不需要为每种类型编写特定的处理代码。
实验三:继承与多态的结合应用在这个实验中,我们进一步探索了继承和多态的结合应用。
我们定义了一个图形类(Shape),并从它派生出了三个子类:圆形类(Circle)、矩形类(Rectangle)和三角形类(Triangle)。
每个子类都实现了自己的特定属性和方法。
通过继承和多态,我们可以在图形类中定义一些通用的方法,如计算面积和周长。
然后,我们可以使用图形类的引用来指向不同类型的图形对象,并调用相应的方法。
这样,我们可以轻松地对不同类型的图形进行统一的处理。
结论:通过本次实验,我们进一步理解了继承和多态的概念,并学会了如何在编程中应用它们。
C++实验报告 继承与多态
四、实验结果分析及总结(对实验的结果是否达到预得派生类中不曾定义过的成员,提高了编程效率; 2)继承与派生分为共有、私有、保护三种继承方式,其中共有使用最广泛,
它使得派生类与基类中的成员具有相同的属性。 3)多重继承存在有二义性,用虚基类能有效解决这一问题。 4)除了继承还有组合关系,及在一个类中定义另一个类的对象,此时初始化时要用对象名 来调用初始化函数。调用对应的函数时,要用对象名调用它的函数。 5)函数重载就是一名多用,可以使代码更容易被理解; 6)对于插入运算符与流提取运算符的重载格式: istream &operator >>(istream &, 自定义类 &); ostream &operator >>(ostream &,自定义类 &); 6)用一个指针调用派生类的函数时,将指针定义为指向基类的指针,基类的函数要定义为 虚函数,将各个派生类的地址赋值给指针,通过指针调用函数,实现多态性。
void Boss::print() { cout << id << '\t' << name << '\t' << age << '\t' << sex << '\t'<< "Boss" << "\t\t" << '$' << getPay() << " per " << salarySystem<< endl;
Boss(string name, int age, string id, string sex, string salarySystem = "year") : Person(name, age, id, sex, salarySystem) {}
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验三字符串与文本
(上课被教师验收的同学不用提交实验结果,并注意在教师处签名。
未完成的同学请提交实验结果,即将程序直接粘贴至本DOC文件,并在邮件名的标题中注明:学号+姓名+实验三)
1.给出下面程序的输出:
2.直接给出下面程序的运行结果:
“B’s constructor is invoked”
“A’s constructor is invoked”
2. 下面的说法对的注明“True”,错的注明“False”
(1)子类是父类的一个子集。
(f)(2)当从子类调用一个构造函数时,它的父类的无参构造方法总是被调用。
(f)(3)可以覆盖定义在父类中的私有方法。
( f) (4)可以覆盖定义在父类中的静态方法。
( f)
(5) 如果子类中的一个方法和它的父类中的方法具有完全相同的方法头,但返回值
类型不同,也可以构成覆盖。
( f)
(6) 可以给面板添加一个框架。
( f)
(7) 可以给框架添加一个面板。
( t )
3. 指出下面程序中的问题:
有四处错误
给radius和length赋值要用this.
调用父类的构造方法Circle()和getArea()前需要加上关键字super
4.下面的程序是要在框架中显示一个按钮,但是什么也没有显示出来。
这个程序有什么问
题?
Test()中没有创建实例对象
将new javax.swing.JFrame() 改成new Test()
5.填空:
(1)在类上使用default修饰符,才能使同一个包中的类可以访问它,而不同包中的类不能访问它。
(2)在类上使用protected 修饰符,才能使不同包中的类不能访问这个类,而任何包中的子类可以访问它。
6. 在程序清单11-9中,MyStack是用组合实现的,现请扩展ArrayList,利用继承来实现MyStack。
编写一个测试程序,提示用户输入五个字符串,然后以逆序显示这些字符串。
package Test03;
public class MyStack extends java.util.ArrayList {
public Object peek() {
return this.get(size() - 1);
}
public Object pop() {
Object o = this.get(size() - 1);
this.remove(size() - 1);
return o;
}
public void push(Object o) {
this.add(o);
}
public static void main(String[] args) {
java.util.Scanner input = new java.util.Scanner(System.in);
System.out.println("请输入5个字符串: ");
String[] o = new String[5];
MyStack mystack = new MyStack();
for(int i = 0; i < 5; i++) {
o[i] = input.next();
mystack.push(o[i]);
}
System.out.println("逆序输出为: ");
while(mystack.peek() != null)
System.out.print(mystack.pop() + " ");
}
}
7.编写程序,创建一个ArrayList,然后向这个线性表中添加一个Object对象、一个Date
对象、一个字符串、一个JFrame对象,然后使用循环调用对象的toString( )方法,来显示线性表中所有的元素。
package Test03;
import javax.swing.JFrame;
import java.util.ArrayList;
import java.util.Date;
public class Test {
public static void main(String[] args) {
ArrayList mylist = new ArrayList();
Object object = new Object();
Date date = new Date();
String s = "mylist";
JFrame frame = new JFrame();
mylist.add(object);
mylist.add(s);
mylist.add(date);
mylist.add(frame);
for(int i = 0; i < mylist.size(); i++) { System.out.println(mylist.get(i));
}
}
}
8. 编写程序,显示如下计算器的界面。
package Test03;
import java.awt.*;
import javax.swing.*;
public class Calculator extends JFrame { public Calculator() {
JPanel p1 = new JPanel();
p1.setLayout(new GridLayout(5,3));
for(int i = 1; i <= 9; i++) {
p1.add(new JButton("" + i));
}
p1.add(new JButton("" + 0));
p1.add(new JButton(" + "));
p1.add(new JButton(" - "));
p1.add(new JButton(" * "));
p1.add(new JButton(" / "));
p1.add(new JButton(" = "));
JPanel p2 = new JPanel(new BorderLayout());
p2.add(p1, BorderLayout.CENTER);
add(p2, BorderLayout.EAST);
add(new JButton(" 2 + 7 = "), BorderLayout.CENTER);
}
public static void main(String[] args) {
Calculator calculator = new Calculator();
calculator.setTitle("简易计算");
calculator.setSize(300,400);
calculator.setLocationRelativeTo(null);
calculator.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
calculator.setVisible(true);
}
}。