Java实验 类和对象
Java类对象实验
实验1. Java 的类和对象实验
实验目的：熟悉Java 的类和对象的概念。
实验内容：设计一个大学生类，包括学生的学号、姓名、性别、出生日期、生源地、所在学校、学院、专业、及所学课程的名称、成绩，等信息；能够实现：(1)显示学生的所有信息；
(2)统计学生课程成绩的平均分、最高分、最低分；(3)自动对挂科多的学生提出警告等功能；
(4)可以根据学号来查询学生的课程成绩。
实验要求：掌握Java 类和对象的使用。
提醒：采用方式1从键盘接收字符；验收时，实验1至少输入3名学生的信息，每个学生至少包括3门课程。
实验2. Java 的继承和多态实验
实验目的：熟悉Java 的继承和多态的特性。
实验内容：在实验1设计的学生类的基础上，再设计一个研究生类，并给该类添加研究方向与导师两个属性，采用多态的知识，(1)统计研究生的各科课程成绩的平均分、最高分、最低分，并提示“XXX为研究生”)；(2)可以根据学号来查询学生的课程成绩，并提示“XXX 为大学生”或“XXX为研究生”。
实验要求：要求采用继承的方式完成类的设计；掌握Java 继承和多态的使用。
提醒：采用方式1从键盘接收字符；验收时，实验2，至少输入3名大学生与3名研究生的信息，每个学生至少包括3门课程。
Java实验报告-2-类和对象
class Fushu
{
private double a; //实部
private double b;//虚部
public Fushu(double x,double y)
{
a=x;
b=y;
}
public void addfushu(double x,double y)
"b="+10.4+"+"+11.2+"*i"+"\n"+
"a+b="+a.geta()+"+"+a.getb()+"*i"+"\n"+
"a-b="+b.geta()+b.getb()+"*i");
}
}
实验结果
小结
通过本次实验，我对java里面类和对象的定义和使用有了一定的认识和熟悉。
说明：如果完成了一次实验的多个实验题目，可以在实验报告中复制该表，填写其他实验题目的报告。
{
return this.b;
}
}
Fushu a = new Fushu(12.9,9.7);
a.addfushu(10.4, 11.2);
Fushu b = new Fushu(12.9,9.7);
b.plusfushu(10.4, 11.2);
JOptionPane.showMessageDialog(null,"a="+12.9+"+"+9.7+"*i"+"\n"+
类与对象实验报告
类与对象实验报告类与对象实验报告引言：类与对象是面向对象编程的基本概念，通过定义类和创建对象，可以实现对数据和行为的封装，使程序更加模块化和可扩展。
本实验旨在通过实际操作，加深对类与对象的理解，并掌握其基本用法。
实验过程：1. 定义类：在实验开始前，我们首先需要定义一个类。
类是对象的抽象描述，包含了对象的属性和方法。
以汽车为例，我们可以定义一个Car类，其中包含品牌、颜色和速度等属性，以及启动、加速和刹车等方法。
2. 创建对象：在定义了Car类之后，我们可以通过创建对象来实例化该类。
通过使用new关键字，我们可以创建多个汽车对象，每个对象都拥有独立的属性和方法。
例如，我们可以创建一个名为myCar的对象，它是Car类的一个实例。
3. 访问对象的属性和方法：创建了对象之后，我们可以通过点运算符来访问对象的属性和方法。
例如，通过myCar.brand可以获取myCar对象的品牌属性，通过myCar.start()可以调用myCar对象的启动方法。
这样，我们可以通过对象来操作和管理数据，使代码更加清晰和可读。
4. 对象之间的交互：在实际编程中，对象之间经常需要进行交互。
通过在类中定义方法，我们可以实现对象之间的数据传递和信息交流。
例如，我们可以定义一个方法来获取其他汽车对象的速度，并根据这些速度进行比较和判断。
实验结果：通过实验，我们深入了解了类与对象的概念和用法。
通过定义类和创建对象，我们可以更好地组织和管理代码，提高程序的可维护性和可扩展性。
通过访问对象的属性和方法，我们可以实现对数据和行为的封装，使代码更加模块化和易于理解。
通过对象之间的交互，我们可以实现数据的共享和协作，提高程序的效率和灵活性。
实验总结：类与对象是面向对象编程的核心概念，掌握了类与对象的基本用法对于开发高质量的程序至关重要。
通过本次实验，我们加深了对类与对象的理解，并通过实际操作掌握了其基本用法。
在以后的编程过程中，我们可以更加灵活地运用类与对象，提高代码的可读性和可维护性。
java类与对象实验报告心得
java类与对象实验报告心得哇，做完这个Java类与对象的实验，真的是感触颇多呢。
在做这个实验之前呀，对于Java里的类和对象，我就只停留在理论知识上，觉得它们好抽象哦。
什么是类呢？就像是一个蓝图一样，描述了对象应该具有的属性和行为。
可那时候，我对这个概念也只是一知半解啦。
当开始做实验的时候，我才真正体会到其中的乐趣与挑战。
创建类的时候，我要去仔细思考这个类到底需要哪些属性。
就好比我要创建一个表示学生的类，那姓名、年龄、学号这些属性肯定是必不可少的呀。
这就像是在设计一个学生的模板一样，好有趣呢。
定义类中的方法也很有意思。
这些方法就像是这个类的功能一样。
比如说学生类中的学习方法，我可以在这个方法里编写一些代码来表示学生学习的过程。
刚开始写的时候，还老是出错呢，哎呀。
不是语法错误，就是逻辑上有点混乱。
不过这也是学习的过程嘛。
创建对象就像是根据这个蓝图来制造一个具体的东西。
我根据学生类创建了具体的学生对象，每个学生对象都有自己独特的属性值。
这就像是在现实生活中，每个学生都是独一无二的一样。
当我成功创建出这些对象并且让它们执行相应的方法时，那种成就感真的难以言表，哈哈。
在实验过程中，我还深刻体会到了封装的重要性。
把类的属性和方法封装起来，就像是给它们穿上了一层保护罩一样。
这样可以防止外部的代码随意修改类内部的数据，使得代码更加安全和可靠。
这让我觉得Java真的是一门很严谨的编程语言呢。
另外呀，类与类之间的关系也很复杂但又很有趣。
有继承关系，就像儿子类继承父亲类的属性和方法一样。
还有组合关系，一个类可以包含其他类的对象作为自己的属性。
理解这些关系的时候，我费了好大的劲呢，不过一旦理解了，就感觉像是打开了新世界的大门。
这次实验让我对Java类与对象的理解不再停留在书本上的文字，而是真正地可以运用它们来编写程序了。
我觉得自己在编程的道路上又前进了一大步呢。
希望以后还能做更多这样有趣又有挑战性的实验，让我可以更加熟练地掌握Java编程呀。
java类与对象实验报告
java类与对象实验报告Java类与对象实验报告一、引言Java是一种面向对象的编程语言，类和对象是Java编程的基本概念。
在本次实验中，我们将学习和掌握Java类和对象的概念、定义和使用方法，并通过实际的编程实验来加深对这些概念的理解。
二、实验目的1. 理解Java类和对象的概念；2. 学会定义和使用Java类；3. 掌握创建和操作Java对象的方法；4. 熟悉Java类和对象的相关语法和规范。
三、实验过程1. 类的定义在Java中，类是对象的模板，用于描述对象的属性和行为。
我们首先需要定义一个类，以便创建对象。
类的定义包括类名、属性和方法。
属性即对象的特征，方法即对象的行为。
2. 对象的创建通过使用关键字"new"，我们可以创建一个类的对象。
对象是类的实例化，每个对象都有自己的属性和方法。
3. 对象的属性和方法对象的属性和方法可以通过对象名加点操作符来访问。
属性可以是基本类型或其他类的对象，方法可以是对象的行为或功能。
4. 构造方法构造方法是一种特殊的方法，用于创建对象时进行初始化操作。
构造方法的名称必须与类名相同，没有返回类型，可以有参数。
5. 封装性封装性是面向对象编程的重要特性之一，它将数据和方法封装在类中，对外部隐藏内部实现细节。
通过使用访问修饰符(private, public, protected)来控制属性和方法的访问权限。
6. 继承继承是面向对象编程的另一个重要特性，它允许我们创建一个新类，并从现有类中继承属性和方法。
通过使用关键字"extends"来实现继承。
7. 多态性多态性是面向对象编程的核心概念之一，它允许我们使用一个父类类型的引用来引用子类的对象。
通过方法的重写和重载来实现多态性。
四、实验结果通过本次实验，我们成功定义了一个Java类，并创建了多个对象。
我们可以通过对象名来访问对象的属性和方法，并对其进行操作。
我们还学习了构造方法的使用，以及封装性、继承和多态性的相关概念。
Java类与对象实验报告
实验报告一、实验项目:类与对象二、实验目的：1。
学会使用类来封装对象的属性和功能2. 掌握类变量与实例变量，以及类方法与实例方法的区别3。
掌握使用package和import语三、实验器材：计算机、Java编程软件JCreator四、实验原理(或仪器装置图）：1. 类与对象类是组成Java程序的基本要素。
类封装了一类对象的状态和方法。
类是用来定义对象的模板。
类声明class 类名{类体｝对象的声明一般格式为：类的名字对象名字;定义对象引用后，用new运算符完成对象的创建工作,分配存储空间，并对其初始化。
变量名=new 类名（［构造方法实参表］);对象的使用访问成员的基本语法形式如下：对象名。
变量成员名对象名.方法成员名（［实际参数表])2.成员变量和局部变量成员变量格式：［修饰符] 变量类型变量名［=初值];成员方法：格式:[修饰符］返回值的数据类型方法名（参数1，参数2,…）｛语句序列；return［表达式];}类中定义的变量是成员变量,而方法中定义的变量是局部变量。
3. 构造方法构造方法是一种特殊的方法，创建对象时被自动调用.与一般的方法不同，它没有返回值类型的说明，方法体中也不可以用return语句带回返回值。
构造方法的方法名与类名相同在构造方法中可以通过this关键字调用该类中其他的构造方法。
4。
包包是Java语言中有效地管理类的一个机制。
①通过关键字package声明包语句。
package 语句作为Java源文件的第一条语句，指明该源文件定义的类所在的包.package语句的一般格式为：package 包名;②import 语句：使用import 语句可以引入包中的类。
五、实验步骤及数据记录：1．定义一个圆柱体类Cylinder,并创建相应的对象，然后计算圆柱体的底面积与体积。
class Cylinder{double radius;int height；double pi=3.14；void area（）｛System。
Java实验 类和对象
一、实验目的掌握类和对象的定义，以及它们之间的关系学习类中属性和方法的设计会用UML图来对类进行描述熟悉修饰符的作用，会用set/get方法对数据进行封装二、实验要求设计一个名为Rectangle的类表示矩形。
这个类包括：∙两个名为width和height的私有double型数据域。
用来表示宽、高。
默认值为1.0。
∙创建默认矩形的无参构造方法。
∙一个创建width和height为指定值的矩形的构造方法。
∙一个名为GetArea()的公有方法返回矩形面积double∙一个静态的Compare方法，比较两个矩形的面积大小是否相等并返回一个布尔型结果，相等返回true，不等返回false；画出UML 类图，实现Rectangle类，编写测试程序创建两个Rectangle类的对象。
第一个对象的width为1，height为1；第一个对象的width为5，height为6。
调用compare方法判断两个矩形是否相等并显示结果。
三、实验内容1.使用Jude工具绘制UML图2.编写代码实现类Rectanglepackage edu.neu.li.test;publicclass Rectangle {privatedouble width;privatedouble height;public Rectangle() {this.width = 1.0;this.height = 1.0;public Rectangle(double width, double height) {this.width = width;this.height = width;}publicdouble GetArea() {returnthis.width * this.height ;}publicstaticboolean Compare(Rectangle rec1, Rectangle rec2) { if(rec1.GetArea()==rec2.GetArea()){returntrue;}returnfalse;}}3.编写测试程序完成功能。
JAVA实验报告-实验3-类与对象-
Java Object-Oriented Programming Experimental ReportSystem.out.println ("Your lucky numbers are " + lucky1 + ", " + lucky2+ ", and " + lucky3);}}3.2 Working with Strings(Choose to do)3.3 Rolling Dice3.4 Computing Distance3.5 formatting Output3.6 Playing with Cards(Choose to do)3.7 Experimenting with the Integer Class(Choose to do) 3.8 Nested Panels(1)宽度两倍（4）添加主界面宽度高度设定(5)添加MyPanels4.Experimental results and data processing5.Analysis and discussionScore: 6.Teacher ReviewsSignature：Date：Experimental Report List1Exercises1) Source code list3.3package test_java_03;import java.util.Random;public class point3_3 {public static void main(String[] args) {Random ger = newint lucky1, lucky2, lucky3;lucky1 = ger.nextInt(6)+1;lucky2 = (int)(ger.nextFloat()*6)+1;lucky3 = (int)(ger.nextFloat()*10)+20;System.out.print(lucky1+lucky2);}}3.4package test_java_03;import java.util.Scanner;public class point_3_4 {public static void main (String[] args){double x1, y1, x2, y2;double distance;Scanner scan = new Scanner(System.in);System.out.print ("Enter the coordinates of the first point " + "(put a space between them): ");x1 = scan.nextDouble();y1 = scan.nextDouble();System.out.print ("Enter the coordinates of the second point: ");x2 = scan.nextDouble();y2 = scan.nextDouble();doubley=Math.abs(y2-y1)*Math.abs(y2-y1),x=Math.abs(x2-x1)*Math.abs(x2-x1);double z=Math.sqrt(y+x);System.out.print("The distance between the two points is "+z);}}3.5package test_java_03;import java.util.*;import java.text.NumberFormat;import java.text.DecimalFormat;public class point_3_5 {public static void main (String[] args){final double OUNCES_PER_POUND = 16.0;double pricePerPound;double weightOunces;double weight;double totalPrice;Scanner scan = new Scanner(System.in);NumberFormat money=NumberFormat.getCurrencyInstance();DecimalFormat fmt=new DecimalFormat("0.#####");System.out.println ("Welcome to the CS Deli!!\n ");System.out.print ("Enter the price per pound of your item: ");pricePerPound = scan.nextDouble();System.out.print ("Enter the weight (ounces): ");weightOunces = scan.nextDouble();weight = weightOunces / OUNCES_PER_POUND;totalPrice = pricePerPound * weight;System.out.println("total price is:"+fmt.format(totalPrice));}}3.8(1)package test_java_03;import java.awt.*;import javax.swing.*;public class point_3_8 {public static void main (String[] args){JFrame frame = new JFrame ("Nested Panels");// Set up first subpanelJPanel subPanel1 = new JPanel();subPanel1.setPreferredSize (new Dimension(150, 100));subPanel1.setBackground (Color.green);JLabel label1 = new JLabel ("One");subPanel1.add (label1);// Set up second subpanelJPanel subPanel2 = new JPanel();subPanel2.setPreferredSize (new Dimension(150, 100));subPanel2.setBackground (Color.red);JLabel label2 = new JLabel ("Two");subPanel2.add (label2);JPanel subPanel3 = new JPanel();subPanel3.setPreferredSize (new Dimension(300, 100));subPanel3.setBackground (Color.black);JLabel label3 = new JLabel ("Three");subPanel3.add (label3);// Set up primary panelJPanel primary = new JPanel();primary.setBackground (Color.blue);primary.add (subPanel1);primary.add (subPanel2);primary.add (subPanel3);frame.getContentPane().add(primary);frame.pack();frame.setVisible(true);}}(4)package test_java_03;import java.awt.*;import javax.swing.*;public class point_3_8 {public static void main (String[] args){JFrame frame = new JFrame ("Nested Panels");// Set up first subpanelJPanel subPanel1 = new JPanel();subPanel1.setPreferredSize (new Dimension(150, 100));subPanel1.setBackground (Color.green);JLabel label1 = new JLabel ("One");subPanel1.add (label1);// Set up second subpanelJPanel subPanel2 = new JPanel();subPanel2.setPreferredSize (new Dimension(150, 100));subPanel2.setBackground (Color.red);JLabel label2 = new JLabel ("Two");subPanel2.add (label2);JPanel subPanel3 = new JPanel();subPanel3.setPreferredSize (new Dimension(300, 100));subPanel3.setBackground (Color.black);JLabel label3 = new JLabel ("Three");subPanel3.add (label3);// JPanel subPanel4 = new JPanel();// subPanel4.setPreferredSize(new Dimension(320,20));// subPanel4.setBackground(Color.orange);// JLabel label4 = new JLabel("My Panels");// subPanel4.add(label4);// Set up primary panelJPanel primary = new JPanel();primary.setBackground (Color.white);primary.setPreferredSize(new Dimension(320,260));//primary.add (subPanel4);primary.add (subPanel1);primary.add (subPanel2);primary.add (subPanel3);frame.getContentPane().add(primary);frame.pack();frame.setVisible(true);}}(5)package test_java_03;import java.awt.*;import javax.swing.*;public class point_3_8 {public static void main (String[] args){JFrame frame = new JFrame ("Nested Panels");// Set up first subpanelJPanel subPanel1 = new JPanel();subPanel1.setPreferredSize (new Dimension(150, 100));subPanel1.setBackground (Color.green);JLabel label1 = new JLabel ("One");subPanel1.add (label1);// Set up second subpanelJPanel subPanel2 = new JPanel();subPanel2.setPreferredSize (new Dimension(150, 100));subPanel2.setBackground (Color.red);JLabel label2 = new JLabel ("Two");subPanel2.add (label2);JPanel subPanel3 = new JPanel();subPanel3.setPreferredSize (new Dimension(300, 100));subPanel3.setBackground (Color.black);JLabel label3 = new JLabel ("Three");subPanel3.add (label3);JPanel subPanel4 = new JPanel();subPanel4.setPreferredSize(new Dimension(320,20));subPanel4.setBackground(Color.orange);JLabel label4 = new JLabel("My Panels");subPanel4.add(label4);// Set up primary panelJPanel primary = new JPanel();primary.setBackground (Color.white);primary.setPreferredSize(new Dimension(400,400));primary.add (subPanel4);primary.add (subPanel1);primary.add (subPanel2);primary.add (subPanel3);frame.getContentPane().add(primary);frame.pack();frame.setVisible(true);}}。
java类和对象的应用实验总结
Java类和对象的应用实验总结在Java编程语言中，类（Class）和对象（Object）是两个核心的概念。
类是对象的模板或蓝图，而对象则是类的实例。
通过使用类和对象，我们可以创建具有共享属性和方法的实体，也可以创建具有独特属性和行为的实体。
以下是我对Java类和对象应用实验的一些总结：类的定义和使用：在Java中，我们使用class关键字来定义一个类。
例如，我们可以创建一个名为Person的类，该类具有name、age 和height等属性，以及eat()和sleep()等方法。
我们可以通过创建类的实例（即对象）来使用类。
对象的创建和使用：我们使用new关键字来创建一个类的实例，这个实例就是一个对象。
例如，我们可以创建一个Person类的对象，并通过调用对象的方法来执行特定的行为。
我们也可以通过访问对象的属性来获取或修改对象的状态。
继承：Java中的类可以继承其他类的属性和方法。
通过继承，我们可以创建一个新的类，该类继承了父类的所有属性和方法，并可以添加自己的属性和方法。
这个过程被称为类的扩展或继承。
多态：在Java中，一个对象可以被引用为多种类型。
例如，我们可以有一个父类类型的引用指向一个子类对象。
当调用这个对象的方法时，会根据对象的实际类型来调用相应的方法。
这就是多态性的体现。
封装：封装是Java中一个重要的面向对象编程概念。
通过封装，我们可以将数据（属性）和处理数据的方法（方法）绑定在一起，形成一个独立的实体。
封装的目的是增加安全性和简化性，用户只知道对象提供哪些方法，至于内部的具体实现细节则一概不知。
通过这些实验，我深入理解了Java的类和对象的概念，以及它们在面向对象编程中的重要性。
这些实验也帮助我理解了如何使用类和对象来设计和实现复杂的系统。
Java的类和对象实验
1、实验内容1)设计一个Point类，该类包含两个int类型的成员变量：x、y，一个Color类型的成员变量mycolor。
请给出此类的构造方法，分别是一个不带参数的，一个带两个参数的，一个带三个参数的构造方法。
还要给出对应的get方法和set方法，最后重写equals和toString方法。
2)Vector类的使用。
要求：编写一个程序，创建Vector类的实例vectorInstance；随机产生[0,100]之间的3个整数，依次插入到vectorInstance中；将字符串“hello world”，插入到vectorInstance 的末尾。
将字符‘A’，插入到vectorInstance的第一个位置；在显示器上输出vectorInstance中的所有数据。
3)一个公司，拥有普通员工、行政人员和经理三类员工，全体员工的工资都包括：基本工资、奖金，同时享受医疗保险和劳动保险。
行政人员和经理还享受车补；经理还有内部分红。
请你为该公司设计一个简单的工资管理程序。
九、程序清单1>package imut.cstd.j09_2;import java.awt.Color;public class Point {private int x;private int y;private Color mycolor;public Point(){x=0;y=0;mycolor=null;}public Point(int x,int y){this.x=x;this.y=y;}public Point(int x,int y,Color mycolor){this.x=x;this.y=y;this.mycolor=mycolor;}public int getX(){return x;}public int getY(){return y;}public Color getMycolor(){return mycolor;}public void setX(int x){this.x=x;}public void setY(int y){this.y=y;}public void setMycolor(Color mycolor){this.mycolor=mycolor;}public String toString(){return"X="+x+"\n"+"Y="+y+"\n"+"Mycolor="+mycolor;}public boolean equals(Object p){if(p==null)return false;if(!(p instanceof Point))return false;Point temp=(Point)p;if((mycolor==null)&&(temp.mycolor==null)&&(x==temp.x)&&(y==temp.y))return true;if(!(temp.mycolor==null)&&(mycolor.equals(temp.mycolor))&&(x==temp.x)&&(y==t emp.y))return true;else return false;}public static void main(String[] args){Point p=new Point();System.out.println(p);Point p1=new Point(2,2,new Color(45));Point p2=new Point(2,2,new Color(45));System.out.print(p1+"和"+p2+"相等?"+p1.equals(p2) +"\n");Point p3=new Point(5,4);Point p4=new Point(5,4);System.out.print(p3+"和"+p4+"相等?"+p3.equals(p4)+"\n");Point p5=new Point(2,4);Point p6=new Point(5,4);System.out.print(p5+"和"+p6+"相等?"+p5.equals(p6));}}2>package imut.cstd.j09_2;import java.util.Vector;public class Connect {@SuppressWarnings({ "unchecked", "rawtypes" })public static void main(String[] args){Vector vectorInstance = new Vector();vectorInstance.add("A");for(int i=0;i<3;i++){int rand=(int)(Math.random()*101);vectorInstance.add(rand);}vectorInstance.add("hello world");for(int i=0;i<vectorInstance.size();i++)System.out.println(vectorInstance.get(i));}}3>package imut.cstd.j09_2;public class Employee {private float wages;private float reward;private float meinsure;private float lainsure;public Employee(){this(0.0f,0.0f,0.0f,0.0f);}public Employee(float wages,float reward,float meinsure,float lainsure){ this.wages=wages;this.reward=reward;this.meinsure=meinsure;insure=lainsure;}public float getWages(){return wages;}public float getReward(){return reward;}public float getMeinsure(){return meinsure;}public float getLainsure(){return lainsure;}public void setWages(float wages){this.wages=wages;}public void setReward(float reward){this.reward=reward;}public void setMeinsure(float meinsure){this.meinsure=meinsure;}public void setLainsure(float lainsure){insure=lainsure;}public String toString(){return"工资"+getWages()+"\t奖金"+getReward()+"\t医保"+getMeinsure()+"\t劳保"+getLainsure();}public float salarysum(){return getWages()+getReward()+getMeinsure()+getLainsure();}}package imut.cstd.j09_2;public class Officeholder extends Employee{private float chebu;public Officeholder(){this(0.0f,0.0f,0.0f,0.0f,0.0f);}public Officeholder(float wages,float reward,float meinsure,float lainsure, float chebu) {this.setWages(wages);this.setReward(reward);this.setMeinsure(meinsure);this.setLainsure(lainsure);this.chebu=chebu;}public float getChebu(){return chebu;}public void setChebu(float chebu){this.chebu=chebu;}public String toString(){return"工资"+getWages()+"\t奖金"+getReward()+"\t医保"+getMeinsure()+"\t劳保"+getLainsure()+"\t车补"+getChebu();}public float salarysum(){return getWages()+getReward()+getMeinsure()+getLainsure()+getChebu();}}package imut.cstd.j09_2;public class Manager extends Officeholder{private float fenhong;public Manager(){this(0.0f,0.0f,0.0f,0.0f,0.0f,0.0f);}public Manager(float wages,float reward,float meinsure,float lainsure, float chebu,float fenhong) {this.setWages(wages);this.setReward(reward);this.setMeinsure(meinsure);this.setLainsure(lainsure);this.setChebu(chebu);this.fenhong=fenhong;}public float getFenhong(){return fenhong;}public void setFenhong(float fenhong){this.fenhong=fenhong;}public String toString(){return"工资"+getWages()+"\t奖金"+getReward()+"\t医保"+getMeinsure()+"\t劳保"+getLainsure()+"\t车补"+getChebu()+"\t分红"+getFenhong();}public float salarysum(){returngetWages()+getReward()+getMeinsure()+getLainsure()+getChebu()+getFenhong();}}package imut.cstd.j09_2;public class Test3 {public static void main(String[] args) {Employee e=new Employee();System.out.println(e);System.out.println("员工总工资="+e.salarysum());Officeholder o=new Officeholder();System.out.println(o);System.out.println("行政人员工资="+o.salarysum());Manager m=new Manager();System.out.println(m);System.out.println("经理工资="+m.salarysum());Employee e1=new Employee(1500.0f,500f,100.5f,201.6f);System.out.println(e1);System.out.println("员工总工资="+e1.salarysum());Officeholder o1=new Officeholder(1500.0f,500f,100.5f,201.6f,108.5f);System.out.println(o1);System.out.println("行政人员工资="+o1.salarysum());Manager m1=new Manager(1500.0f,500f,100.5f,201.6f,108.5f,1400.9f);System.out.println(m1);System.out.println("经理工资="+m1.salarysum());}}。
java实验四对象和类(抽象类、接口与包)
java实验四对象和类(抽象类、接口与包) 实验四对象和类(抽象类、接口与包) 一、实验目的1、熟练掌握抽象类abstract的概念。
2、熟练掌握接口interface的概念。
3、熟练包package的概念以及编译运行的方法。
4、熟练掌握内部类inner class的概念。
5、熟练掌握递归的概念。
6、理解面向对象的程序设计方法。
二、实验内容与要求1(编写求解几何图形(如三角形，矩型，圆，多边型)的周长、面积的应用程序，要求用到继承、多态、抽象类、接口、内部类等面向对象程序设计技术的特点。
程序如下:abstract class Geometric{ //定义抽象类abstract double getPerimter();abstract double getArea(); }interface MY{ //定义接口float getarea();float getperimter();}class sanjiaoxing extends Geometric{ //三角形类继承抽象类private float a;private float b;private float c;sanjiaoxing(float x1,float x2,float x3){a=x1;b=x2;c=x3;}double getPerimter(){return a+b+c;}double getArea(){float p=(a+b+c)/2;return Math.sqrt(p*(p-a)*(p-b)*(p-c));}}class yuanxing extends Geometric{ //圆类继承抽象类private float radius;yuanxing(float a){radius=a;}double getPerimter(){double p;p=2*3.14f*radius;return p;}double getArea(){return 3.14f*radius*radius;}}class juxing implements MY{ //矩形类实现接口private float height;private float width;juxing(float a,float b){height=a;width=b;}public float getperimter(){return 2*(width+height);}public float getarea(){return width*height;}}class abc{public static void main(String args[]){ sanjiaoxing obj1=new sanjiaoxing(3,4,5); System.out.println("当三角形三边是3,4,5时:"); System.out.println("边长是:"+obj1.getPerimter()); System.out.println("面积是:"+obj1.getArea()); yuanxing obj2=new yuanxing(4);System.out.println("当圆的半径是4时:");System.out.println("周长是:"+obj2.getPerimter());System.out.println("面积是:"+obj2.getArea());juxing obj3=new juxing(3,4);System.out.println("当矩形长和宽是3,4时:");System.out.println("周长是:"+obj3.getperimter());System.out.println("面积是:"+obj3.getarea());}}结果如下:, 出现的问题1:需要定义抽象类和接口，并用三角形、矩形和圆形来实现里边定义的方法。
JAVA实验报告_Java类与对象
JAVA实验报告_Java类与对象实验目的：通过 Java 类与对象的实验，学习 Java 面向对象编程的基本概念和语法，并了解Java 的封装、继承和多态特性。
实验环境：操作系统：Windows 10开发工具：Eclipse IDE for Java DevelopersJava 版本：jdk1.8.0_231实验步骤：1. 创建一个名为 Person 的 Java 类，用于表示人物的基本信息，包括姓名、性别和年龄等。
2. 在 Person 类中使用 private 关键字对字段进行封装，以实现对字段的访问控制，使其只能通过方法进行访问和修改。
3. 在 Person 类中编写构造方法，用于初始化对象的属性值。
6. 调用 Person 对象的方法，显示对象的基本信息。
7. 创建一个名为 Student 的子类，继承 Person 类，并添加一个字段表示学号，以及相应的 get 和 set 方法。
实验结果：Person 类的实现：```javapublic class Person {private String name;private String gender;private int age;public Person(String name, String gender, int age) { = name;this.gender = gender;this.age = age;}public String getName() {return name;}public String getGender() {return gender;}public int getAge() {return age;}public void setName(String name) { = name;}public void setGender(String gender) {this.gender = gender;}public void setAge(int age) {this.age = age;}public void display() {System.out.println("Name: " + getName());System.out.println("Gender: " + getGender());System.out.println("Age: " + getAge());}}```实验分析：通过本次实验，我们学习了 Java 类与对象的基本概念和语法，并了解了 Java 的封装、继承和多态特性。
Java类及对象实验报告
西安邮电大学（计算机学院）课实验报告实验名称：类与对象专业名称：计算机科学与技术班级：计科1405班学生：高宏伟学号：04141152指导教师：霞林实验日期：2016.9.29一、实验目的通过编程和上机实验理解Java 语言是如何体现面向对象编程基本思想，了解类的封装方法，以及如何创建类和对象，了解成员变量和成员方法的特性，掌握OOP 方式进行程序设计的方法。
二、实验要求1．编写一个创建对象和使用对象的方法的程序。
2．编写一个包含类成员和示例成员的程序。
3．编写一个使用Java包的程序。
三、实验容（一）三角形、梯形和圆形的类封装✧实验要求：编写一个Java应用程序，该程序中有3个类：Trangle、Leder和Circle，分别用来刻画“三角形”、“梯形”和“圆形”。
具体要求如下：a) Trangle类具有类型为double的三个边，以及周长、面积属性，Trangle类具有返回周长、面积以及修改三个边的功能。
另外，Trangle类还具有一个boolean型的属性，该属性用来判断三个属能否构成一个三角形。
b) Lader类具有类型double的上底、下底、高、面积属性，具有返回面积的功能。
c) Circle类具有类型为double的半径、周长和面积属性，具有返回周长、面积的功能。
✧程序模板：AreaAndLength.javaclass Trangle{double sideA,sideB,sideC,area,length;boolean boo;public Trangle(double a,double b,double c){this.sideA=a; //【代码1】参数a,b,c分别赋值给sideA,sideB,sideCthis.sideB=b;this.sideC=c;if((sideA+sideB)>sideC&&(sideC+sideB)>sideA&&(sideC+sideA)>sideB)//【代码2】a,b,c构成三角形的条件表达式{boo=true;//【代码3】给boo赋值。
java实验报告——类与对象
return id; } public String getName(){
return name; } public int getAge(){
return age;
2
实验报告
} public boolean getSex(){
return sex; } public String getPhone(){
input():void display():void insert():void delete():void ……
3）写出 toString()方法的实现 public String toString(){
return "\n 编号："+id+"姓名："+name+"年龄："+"性别："+sex+"联系电 话："+phone;
}
9）写出 Cmanage 类中的查询方法
public void search(){
int f=0;
Scanner in=new Scanner(System.in);
System.out.println("请输入查询的 id 号：");
long n=in.nextLong();
for(int i=0;i<cu.length;i++){
}
5
实验报告
实验报告
四、实验小结（包括问题和解决方法、心得体会、意见与建议等）
1．你设计该软件使用的哪个集成开发环境？ 答：NetBeans IDE 6.9
实验三：类与对象(bo)
实验三Java类与对象【实验目的】1）理解面向过程与面向对象区别2）理解面向对象的三大特征3）掌握类声明的方法4）掌握构造方法5）掌握对象的创建方法与创建机制6）掌握成员变量、类变量和局部变量区别7）掌握成员方法与类方法区别8）掌握函数的重载9）掌握4种访问修饰符的区别【实验环境】JDK1.6+Eclpise3.2【实验准备】1）复习课件中理论知识2）练习课堂所讲的例子【实验内容】1、创建猴子类。
具体要求如下：1）编写一个类Monkey，用来表示猴子类；2）给Monkey类确定添加4个属性：3个实例成员变量（名字、体重、年龄）、1个静态成员变量（爱好：默认值为：吃香蕉）；3）添加默认构造方法和有参构造方法（3个参数，分别给名字、体重和年龄赋初始值）4）编写展示猴子能够爬树（climbTree）的方法――提供两个参数传入：分别代码猴子的名字(name)和爬树的高度(height)（方法内只需打印猴子的”名字+会爬树，能爬+高度”）5）测试：在main方法中创建两个猴子对象monkey1（皮蛋、50、3）和monkey2（兰兰、45、2），monkey1使用默认构造方法创建，monkey2使用有参构造方法创建。
分别打印出monkey1和monkey2的名字、体重、年龄和爱好。
并调用monkey1和monkey2的爬树方法。
2、创建矩形Rectangle类。
具体要求如下：1）创建一个Rectangle类；2）创建属性：两个double成员变量：width和height。
3）创建方法：计算矩形的周长getLength()和面积getArea()。
4）测试：创建Rectangle对象，并给两个成员变量赋值，调用周长和面积的方法，输出周长和面积。
【实验过程及结果】实验代码及结果：1. package arp;public class Monkey {//创建类// 4个属性（成员变量）private String name;private int weight;private int age;private static String love="吃香蕉";public Monkey(){}//有参构造方法public Monkey(String name,int weight,int age) {=name;this.weight=weight;this.age=age;}//爬树public void climbTree(String name,int height){System.out.println(name+"会爬树，能爬"+height+"米");}//测试public static void main(String [] args){Monkey monkey2=new Monkey();="猪猪";monkey2.weight=50;monkey2.age=3;Monkey monkey3=new Monkey("猫猫",45,2);System.out.println(+"体重为"+monkey2.weight +"年龄为："+monkey2.age+"爱好为："+monkey2.love);System.out.println(+"体重为："+monkey3.weight+"年龄为："+monkey3.age+"爱好为："+monkey3.love);monkey2.climbTree(,100);monkey3.climbTree(,88);}}2. package arp;//创建类public class Rectangle {//两个成员变量private double width;private double height;//计算周长public double getLength(){return (this.width+this.height)*2;}//计算面积public double getArea(){return this.width*this.height;}public static void main(String[] args) {Rectangle rectangle =new Rectangle();rectangle.width=100;rectangle.height=50;System.out.println("周长为："+rectangle.getLength());System.out.println("面积为："+rectangle.getArea());}}【实验感想】本次实验态度鲜明的提出了面向对象和面向过程的区别以及面向对象的三大特征，并由此引入了类的声明，对象的创建方法等实质性问题，在上机练习中通过创建相应的类，给我留下了对于类和对象的深刻认识，对于这些新接触的知识还要在进一步的学习中去感悟和理解它所包含的实在的东西。
Java实验报告2 类和对象
实验报告【实验名称】第二章类和对象【实验目的】1.学习Java的基本语法2.学习Java的运算符和控制语句3.学习类和对象的概念【实验原理】1.Java程序设计基本原理2.面向对象程序设计基本原理【实验内容】一、填空题1. System.out.println(“12”+ 5)；语句的输出结果是 125 。
2. Java语言中“2.5%1.2”的运算结果是 0.1 。
二、简答1. 为什么类成员方法只能操作类成员变量，而不能操作实例变量？[解答]因为类方法是静态方法，静态方法在加载class的时候就会初始化，而非静态成员（实例成员）还未进行初始化，所以类成员方法只能操作类成员变量，而不能操作实例变量。
2. 简述指针和引用有什么区别？[解答]指针表示的是地址，引用表示的也是地址，但是指针可以进行修改，引用则不能进行改动。
并且使用指针具有三大缺点，指针指向的内存并不是我们所需要的内存、指针所访存的内存空间是不允许被访存的、指针访存的空间并不存在。
三、实验题1. 指出程序中的错误，并修正public class Example{public static void main(String args[]){int a=1.0;float fa=216;float fb=21.656f;double da=125e45d;double db=123.45;float fc=0.1;}}[解答]：int a=1.0 修改为 double a=1.0 (float型比int型级别高)float fc=0.1 修改为 double fc=0.1 （double的类型比float级别高）2.写出如下程序输出结果，并说明原因public class E_c{public static void main(String args[]){String sx1="my";String sx2="god";char cx='a';System.out.println(sx1+sx2);System.out.println(sx2+cx);System.out.println(sx1+5);System.out.println(cx+5);}}结果：mygodgodamy5102原因：因为在输出内容包含字符串的时候，输出结果就全部为字符串，因此前三个结果为字符，第四个并不是，c的ascii为97，所以结果为1023、把如下程序改成从键盘输入两个整数，并判断大小。
java实验类和对象
实验二类和对象实验名称类和对象的有关实验实验环境Myeclipse 9.0.jdk 1.6,windows7 professional 64 bit实验内容通过实验了解和初步掌握类的创建和对象的创建和使用实验题目1.对象的创建和使用。
编写一个圆环类Ring的Java程序。
圆环类有3个数据成员，分别是内半径innerRadius，外半径outerRadius和颜色color，这些属性可以查看get也可以重新设置set，另外，圆环还可以返回其面积area。
2.方法重载。
编写一个Java程序，反映出方法重载的使用特点，该程序包含多个重载的加法运算，例如：整型加法、实型加法、以及混合加法运算等。
实验代码问题一：publicclass Ring{finaldouble PI=3.1415926;double innerRadius;double outerRadius;String color;public Ring(double iRadius,double oRadius,String c){innerRadius=iRadius;outerRadius=oRadius;color=c;}publicdouble getInnerRadius(){return innerRadius;}publicdouble getOuterRadius(){return outerRadius;}publicvoid resetI(double a){innerRadius=a;}publicvoid resetO(double a){outerRadius=a;}publicvoid resetC(String a){color=a;}publicdouble area(){return (outerRadius*outerRadius-innerRadius*innerRadius)*PI; }publicstaticvoid main(String args[]){Ring a=new Ring(5,8,"blue");System.out.println("内径为"+a.getInnerRadius()+"\n");System.out.println("外径为"+a.getOuterRadius()+"\n");System.out.println("面积为"+a.area()+"\n");System.out.println("颜色为"+a.color+"\n");a.resetI(60);a.resetO(80);a.resetC("yellow");System.out.println("内径为"+a.getInnerRadius()+"\n");System.out.println("外径为"+a.getOuterRadius()+"\n");System.out.println("面积为"+a.area()+"\n");System.out.println("颜色为"+a.color+"\n");}}问题二：publicclass OverLoad{int m,n;OverLoad(){m=0;n=0;}OverLoad(int a,int b){m=a;n=b;}int add(){System.out.println("无参数加法"+m+"+"+n+"="+(m+n));return m+n;}int add(int a,int b){System.out.println("整形加法"+m+"+"+n+"="+(m+n));return m+n;}double add(double a,double b){System.out.println("实型加法"+a+"+"+b+"="+(a+b));return a+b;}double add(int a,int b,double c){System.out.println("混合加法"+a+"+"+b+"+"+c+"="+(a+b+c)); return a+b+c;}publicstaticvoid main(String args[]){int ix,iy;double dx,dy;OverLoadov=new OverLoad();ix=ov.add();iy=ov.add(3,6);dx=ov.add(3,6,2);dy=ov.add(3,6,2.2);}}实验运行结果问题一：实验二：实验结论通过以上的运行和实验，我初步掌握了java中类的相关操作方法。
java类和对象实验
}
public void setY(int newY) {
y = newY;
}
public static void main(String[] args) {
System.out.println("静态变量x="+StaticDemo.getX());
//System.out.println("实例变量y="+StaticDemo.getY()); //非法，编译时将出错
c2.setRadius(5);
System.out.println("圆的面积是："+c2.area());
System.out.println("圆的周长是："+c2.circumference());
运行结果：
圆的面积是：3.14
圆的周长是：6.28
圆的面积是：78.5
圆的周长是：31.400000000000002
System.out.println("c1引用的牌是："+c1+"\tc2引用的牌是："+c2);
System.out.println("第11张牌是："+cards[10]+"\t第13张牌是："+cards[12]);
运行结果：
2．在主方法中用创建一个不指定半径的Circle类的实例myCircle2，输出它的周长和面积，然后利用修改半径的方法设置它的半径为5，再次输出它的周长和面积。
程序：
Circle c2=newCircle();
System.out.println("圆的面积是："+c2.area());
java实验报告——对象和类
成绩：面向对象原理与Java实践课程实验报告实验1：对象和类姓名 ____班级 ____学号 ____实验地点 ____实验时间 ____指导教师 ____面向对象原理与Java实践课程实验报告实验1：对象和类一、实验目的：●掌握类的定义及应用方法●掌握对象的创建方法，了解实例变量、实例方法和静态字段的特性●体会Java在类和对象的设计中体现的面向对象的思想二、实验要求：●具备Java基础知识（教材第1、2章内容）●掌握Java中对象和类的基本概念和应用方法（教材第3章内容）●设计类时注意保证类的封装性●编写程序完成以下实验内容并上交实验报告（包括电子文档与纸质文档）三、实验内容：设计并实现一个“广石化院电信学院学生通信录”系统。
系统采用字符界面，在出现的主界面中按提示输入相应字符以选择“增加”、“删除”、“修改”、“查找”等功能进行操作（其中“查找”功能除能够查找某个学生的信息之外，还能够显示所有学生的信息）。
记录的存储可采用数组或链表的方式。
四、设计思路：为了实现该系统，首先要需要两个类；一个类为主界面服务，用于接收用户输入信息以及做出相关反应；一个类为学生信息服务，定义学生通讯录信息的各个字段，以及操作字段的各个方法，考虑到部分字段的属性问题，所以将操作方法都写在学生类中，不再另外放置在其他类中。
学生信息将会采用学生类的对象数组来储存。
五、程序源代码：下面是ZhuJieMian 主界面类package pkg_TXL;import java.util.Scanner;public class ZhuJieMian{/**** 该类为通讯录系统的主界面提供主要功能显示，以及负责主菜单与子菜单的正常跳转*/public static void main(String[] args){// TODO Auto-generated method stub//XueShengXinXi[] Stu=ChuShiHua(); //初始化系统数据XueShengXinXi[] Stu=new XueShengXinXi[100];Stu[0]=new XueShengXinXi("专业", "班级", "姓名", "性别", "电话", "家庭住址");Stu[1]=new XueShengXinXi("自动化", "自动化10-1", "张三", "男", "63256", "fnhjfdhsdbh");Stu[2]=new XueShengXinXi("自动化", "自动化10-2", "李四", "女", "653256", "nfhggdfddhsdbh");Stu[3]=new XueShengXinXi("电子", "电子10-1", "王五", "男", "6156", "fnhvjbh");Stu[4]=new XueShengXinXi("电子", "电子10-2", "小红", "女", "63956", "asdfnhjbh");Stu[5]=new XueShengXinXi("网络", "网络10-1", "小明", "男", "656", "nfgdgfnhjbh");Stu[6]=new XueShengXinXi("网络", "网络10-2", "小芳", "女", "62215", "nfgdmmmdfhbdsh");Stu[7]=new XueShengXinXi("计算机", "计算机10-1", "黄龙", "男", "65584", "bbbdddfnhjbh");Stu[8]=new XueShengXinXi("计算机", "计算机10-2", "陈玲", "女", "666114", "mjgfddddfnhjbh");Stu[9]=new XueShengXinXi("测控", "测控10-1", "赵小斌", "男", "644814", "fthnrehbkjhjbh");Stu[10]=new XueShengXinXi("测控", "测控10-2", "钱颖", "女", "63641", "dbfsvnnhjbh");Stu[11]=new XueShengXinXi("电信", "电信10-1", "孙武", "男", "6321514", "mmhmgvvdfnhjbh");Stu[12]=new XueShengXinXi("电信", "电信10-2", "李雨", "女", "6314", "43ghffvvdfnhjbh");for(int x=13;x<Stu.length;x++){Stu[x]=new XueShengXinXi();}System.out.println("欢迎使用广石化电信学院通讯录系统！");ZhuJieMian: for(int exit=0;exit==0;)//exit为退出主菜单的指示变量，0为不退出，非0为退出{System.out.println();System.out.println("************************************");System.out.println("****************主菜单****************");System.out.print(" 1。
Java实验6(07) 类与对象
班级：姓名：学号：面向对象编程基础(一)简单的类和对象public static void swap1(int i,int j){Card c=cards[i];cards[i]=cards[j];cards[j]=c;}public static void swap2(Card c1,Card c2){char s=c1.suit;c1.suit=c2.suit;c2.suit=s;String r=c1.rank;c1.rank=c2.rank;c2.rank=r;}public static void main(final String[] args) {init(); //创建52张扑克牌对象//任取两张牌Card c1=cards[10]; //c1和cards[10]都是指向HJ这张扑克牌Card c2=cards[12]; // c1和cards[11]都是指向HK这张扑克牌System.out.println("第11张牌是："+c1+"\t第13张牌是："+c2);//添加代码之处：}}1) 在main方法中，添加下面几行语句，写出并分析结果swap1(c1,c2);System.out.println("执行swap1(c1,c2)后");System.out.println("c1引用的牌是："+c1+"\tc2引用的牌是："+c2);System.out.println("第11张牌是："+cards[10]+"\t第13张牌是："+cards[12]);2) 在main方法中，去掉刚才添加的语句，添加下面几行语句，写出并分析结果swap1(10,12);System.out.println("执行swap1(10,12)后");System.out.println("c1引用的牌是："+c1+"\tc2引用的牌是："+c2);System.out.println("第11张牌是："+cards[10]+"\t第13张牌是："+cards[12]);3) 在main方法中，去掉刚才添加的语句，添加下面几行语句，写出并分析结果swap2(c1,c2);System.out.println("执行swap2(c1,c2)后");System.out.println("c1引用的牌是："+c1+"\tc2引用的牌是："+c2);System.out.println("第11张牌是："+cards[10]+"\t第13张牌是："+cards[12]);11.写出程序运行结果，如有错误，指出原因class StaticDemo {static int x; //0int y;static{x=10;}public static int getX() {return x;}public static void setX(int newX) {x = newX;}public int getY() {return y;}public void setY(int newY) {y = newY;}public static void main(String[] args) {System.out.println("静态变量x="+StaticDemo.getX()); //10System.out.println("实例变量y="+StaticDemo.getY());//错误。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一、实验目的
掌握类和对象的定义，以及它们之间的关系
学习类中属性和方法的设计
会用UML图来对类进行描述
熟悉修饰符的作用，会用set/get方法对数据进行封装
二、实验要求
设计一个名为Rectangle的类表示矩形。
这个类包括：
∙两个名为width和height的私有double型数据域。
用来表示宽、高。
默认值为1.0。
∙创建默认矩形的无参构造方法。
∙一个创建width和height为指定值的矩形的构造方法。
∙一个名为GetArea()的公有方法返回矩形面积double
∙一个静态的Compare方法，比较两个矩形的面积大小是否相等并返回一个布尔型结果，相等返回true，不等返回false；
画出UML 类图，实现Rectangle类，编写测试程序创建两个Rectangle类的对象。
第一个对象的width为1，height为1；第一个对象的width为5，height为6。
调用compare方法判断两个矩形是否相等并显示结果。
三、实验内容
1.使用Jude工具绘制UML图
2.编写代码实现类Rectangle
package edu.neu.li.test;
publicclass Rectangle {
privatedouble width;
privatedouble height;
public Rectangle() {
this.width = 1.0;
this.height = 1.0;
public Rectangle(double width, double height) {
this.width = width;
this.height = width;
}
publicdouble GetArea() {
returnthis.width * this.height ;
}
publicstaticboolean Compare(Rectangle rec1, Rectangle rec2) { if(rec1.GetArea()==rec2.GetArea())
{
returntrue;
}
returnfalse;
}
}
3.编写测试程序完成功能。
package edu.neu.li.test.run;
import edu.neu.li.test.Rectangle;
publicclass test4run {
publicstaticvoid main(String[] args)
{
boolean bEqual=false;
Rectangle rec1=new Rectangle();
Rectangle rec2=new Rectangle(5.0,6.0);
bEqual=pare(rec1, rec2);
System.out.println("The Compare Resule is:"+bEqual);
}
}
四、实验结果。