java 类与对象实验报告

JAVA实验报告_Java类与对象贵州大学实验报告学院：计信学院专业：网络工程班级：101 姓名学号实验组实验时间05.11 指导教师肖源源成绩实验项目名称Java类与对象实验目的1）理解面向过程与面向对象区别2）理解面向对象的三大特征3）掌握类声明的方法4）掌握构造方法5）掌握对象的创建方法与创建机制6）掌握成员变量、类变量和局部变量区别7）掌握成员方法与类方法区别8）掌握函数的重载9）掌握4种访问修饰符的区别实验要求1．安装并设置Java SDK 软件包。

2．按要求编写程序完成实验指导所需实验要求。

3．调试并成功运行。

实验内容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.深入理解类和对象二、实验内容和原理1. 建立包myPackageA，在包中创建一个矩形类，其中包括计算矩形周长和面积两个方法。

在包myPackageB中建立一个Main类，在Main类中使用该矩形类，计算给定长和宽的矩形的周长和面积。

要求：当给定的长或者宽为负数或者0时，应该无法计算。

2. 编写一个Rational(有理数)类，具体要求如下：①Rational类有两个int型的成员变量，名字分别为fengZi(分子)和fengMu(分母)。

②提供Rational add(Ration al r)方法，即有理数调用该方法与参数指定的有理数做加法运算，并返回一个Rational对象③提供Rational multi(Rational r)方法，即有理数调用该方法与参数指定的有理数做乘法运算，并返回一个Rational对象。

④为了弱化难度，设参与运算的有理数均为正数。

三、实验环境1.硬件环境：2.软件环境：JDK1.5四、算法描述及实验步骤1.算法描述（可以用流程图、伪代码或源程序描述）2.实验步骤一、package myPackageA;public class 矩形类{public double Long,Wide;public double Girth(){if(Long>0&&Wide>0){double result=(Long+Wide)*2;System.out.println("长为:"+Long+","+"宽为:"+Wide+"的矩形");System.out.print("其周长是"+result+"；");return result;}elseSystem.out.println("您输入的数据有误");return 1;}public double Area(){if(Long>0&&Wide>0){double result=Long*Wide;System.out.println("其面积是"+result);return result;}elsereturn 1;}}package myPackageB;import myPackageA.*;public class Main {public static void main(String args[]){矩形类a=new 矩形类();a.Long=2;a.Wide=0; // a.Wide=6;a.Girth();a.Area();}}二、package myPackageC;public class Rational {int fengzi,fengmu;Rational add(Rational r) {int a=r.fengzi;int b=r.fengmu;int newFengzi=fengzi*b+fengmu*a;int newFengmu=fengmu*b;Rational result1=new Rational();result1.fengzi=newFengzi;result1.fengmu=newFengmu;int x=newFengzi;int y=newFengmu;if(x<y) {int z=x;x=y;y=z;}int c=x%y;while(c!=0) {x=y;y=c;c=x%y;}System.out.println(fengzi+"/"+fengmu+"+"+r.fengzi+"/"+r.fengmu +"="+newFengzi/y+"/"+newFengmu/y);return result1;}Rational multi(Rational r){int a=r.fengzi;int b=r.fengmu;int newFengzi=fengzi*a;int newFengmu=fengmu*b;Rational result2=new Rational();result2.fengzi=newFengzi;result2.fengmu=newFengmu;int x=newFengzi;int y=newFengmu;if(x<y) {int z=x;x=y;y=z;}int c=x%y;while(c!=0) {x=y;y=c;c=x%y;}System.out.println(fengzi+"/"+fengmu+"*"+r.fengzi+"/"+r.fengmu+ "="+newFengzi/y+"/"+newFengmu/y);return result2;}public static void main(String args[]){Rational r1=new Rational();r1.fengzi=7;r1.fengmu=10;Rational r2=new Rational();r2.fengzi=2;r2.fengmu=5;r1.add(r2);r1.multi(r2);}}五、调试过程1.编译过程2.调试过程六、实验结果用与测试用例不同的输入数据运行算法，写出得到的结果，并分析结果是否正确。

三、实验内容与步骤：
一.三角形、梯形和圆形的类封装：分别定义三角形、梯形和圆形类，要求每个类中包含构造方法、求周长及面积的方法。最后在主方法中为三角形、梯形和圆形类创建对象并打印输出各种图形的周长及面积。编写该程序的代码并将其放在几个class类中即：
在Jdk环境下运行该程序，在记事本中编写代码如下：
运行的：
二．、学习实例成员与类成员的区别的简单例题：
在Myeclipse环境下运行得：
在JDK环境下编写代码并运行的：
运行的：
三．使用package语句与import语句的简
运行结果:
四．定义父类People，分别定义People类的子类ChinaPeople，AmericanPeople和BeijingPeople并分别重写父类中的各个方法。最后在主方法中分别创建各子类的对象并调用各自的方法打印输出信息。代 码如下:
六、指导教师评语及成绩：
教室签名
成绩
批阅日期
2011年4月15日
在接口与继承，
五、实验总结：通过实验了解并掌握了Java面向对象程序设计的基本思想,类的创建与作用,对象的定义。可以将一个程序分几个class处理，即存在几个class中，运行时只需将其全选即可。同时通过上机调试学会了package的创建用法与import导入某个文件的用法。掌握了抽象类的定义及其实现方法，上转型对象的运用方法。掌握了方法重写式接口的定义及其实现方法，实现了接口回调的运用方法.
运行结果:
五．抽象类的定义及其实现方法的程序：
六.。掌握接口的定义及其实现方法，学习接口回调的运用方法。
四、实验过程与分析：
在实验时,先将eclipse安装好，再打开new出java project,在java project下面new class加类名，将其创建成功。运行时，将创建的所有class均运行。方法重写时注意方法的形式及其开头的代码不变,只把函数体的内容改变。

id=i; } public void setName(String n){
name=n; } public void setAge(int a){
age=a; } public void setSex(boolean s){
sex=s; } public void setPhone(String p){
phone=p; } public long getId(){
return id; } public String getName(){
return name; } public int getAge(){
return age;
2
实验报告
} public boolean getSex(){
return sex; } public String getPhone(){
6)写出 Cmanage 类中的属性
由 Customer 中的属性决定，即：编号 id，姓名 name，年龄 age，性别 sex， 电话号码 phone。
7）写出 Cmanage 类中的构造方法 Cmanage();//无参构造函数
4
实验报告
8）写出 Cmanage 类中插入方法 public void insert(){ Scanner in=new Scanner(System.in); System.out.println("请输入要插入的人数："); int n=in.nextInt(); cu=new Customer[n]; for(int i=0;i<n;i++){ cu[i]=new Customer(); System.out.println("请输入第"+(i+1)+"个要插入的顾客的信息："); cu[i].id=in.nextLong(); cu[i].name=in.next(); cu[i].age=in.nextInt(); cu[i].sex=in.nextBoolean(); cu[i].phone=in.next(); }

西安邮电⼤学java类与对象实验报告西安邮电⼤学（计算机学院）Java程序设计课内实验报告实验名称：类与对象专业名称：软件⼯程班级：学⽣姓名：学号（8位）：指导教师：实验⽇期：2014年4⽉2⽇⼀. 实验⽬的及实验环境理解类与对象的概念，掌握Java 类的定义（域、⽅法）、创建对象和使⽤对象。

理解包的概念，会创建包，引⼊包。

掌握访问权限规则。

环境：eclipse⼆. 实验内容1. 设计Point 类⽤来定义平⾯上的⼀个点，⽤构造⽅法传递坐标位置。

默认构造⽅法创建坐标原点，带参数构造⽅法根据指定坐标创建⼀个点对象。

提供get、set ⽅法返回和设置坐标。

distance 返回两个点之间距离或当前点到指定坐标之间的距离。

同时设计应⽤类进⾏测试。

2. 设计⼀个三⾓形类，能判断给定三边是否构成三⾓形，能判断三⾓形的类型（普通、等腰、等边、直⾓，⽤枚举类型（参见第六章））能计算周长与⾯积。

并在应⽤类中演⽰。

3.定义⼀个Line 类，该类包含两个Point 类型的实例变量，⽤以表⽰线段的两个端点。

提供以下⽅法：计算线段长度；判断线段是否⽔平、判断是否为垂直、计算线段斜率、计算线段中点、判断两条线段是否相等。

并在应⽤类中演⽰。

4.定义两个包p1、p2，三个类C1、C2、C3.其中C1、C2 位于p1 中，C3 位于p2 中。

在C1 中定义四个不同访问控制修饰类型的变量，在C2、C3 中进⾏访问测试。

并练习在JDK 命令⾏下⽣成包。

三．⽅案设计对于第⼀题，⽤了staticstatic double distance(Point p1,Point p2){return Math.sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));}对于第⼆题，采⽤if –else,严谨的判断三⾓形的形状public void judge(){if(a==b || b==c || c==a){if(a==b && b==c)System.out.println("该三⾓形为等边三⾓形。

// TODO 自动生成的方法存根
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"+

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类，并创建了多个对象。

我们可以通过对象名来访问对象的属性和方法，并对其进行操作。

我们还学习了构造方法的使用，以及封装性、继承和多态性的相关概念。

实验报告一、实验项目:类与对象二、实验目的：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类和对象的应用实验总结在Java编程语言中，类（Class）和对象（Object）是两个核心的概念。

类是对象的模板或蓝图，而对象则是类的实例。

通过使用类和对象，我们可以创建具有共享属性和方法的实体，也可以创建具有独特属性和行为的实体。

以下是我对Java类和对象应用实验的一些总结：类的定义和使用：在Java中，我们使用class关键字来定义一个类。

例如，我们可以创建一个名为Person的类，该类具有name、age 和height等属性，以及eat()和sleep()等方法。

我们可以通过创建类的实例（即对象）来使用类。

对象的创建和使用：我们使用new关键字来创建一个类的实例，这个实例就是一个对象。

例如，我们可以创建一个Person类的对象，并通过调用对象的方法来执行特定的行为。

我们也可以通过访问对象的属性来获取或修改对象的状态。

继承：Java中的类可以继承其他类的属性和方法。

通过继承，我们可以创建一个新的类，该类继承了父类的所有属性和方法，并可以添加自己的属性和方法。

这个过程被称为类的扩展或继承。

多态：在Java中，一个对象可以被引用为多种类型。

例如，我们可以有一个父类类型的引用指向一个子类对象。

当调用这个对象的方法时，会根据对象的实际类型来调用相应的方法。

这就是多态性的体现。

封装：封装是Java中一个重要的面向对象编程概念。

通过封装，我们可以将数据（属性）和处理数据的方法（方法）绑定在一起，形成一个独立的实体。

封装的目的是增加安全性和简化性，用户只知道对象提供哪些方法，至于内部的具体实现细节则一概不知。

通过这些实验，我深入理解了Java的类和对象的概念，以及它们在面向对象编程中的重要性。

这些实验也帮助我理解了如何使用类和对象来设计和实现复杂的系统。

温州大学瓯江学院 JAVA语言程序设计实验报告t1.setTelenmb("123","88362146");t1.print();}}2.class gg //Student是类名{//声明成员变量int sNumber; //学号String sName; //姓名String sClass; //班号String tNumber;String password;gg(String b){password=b;}int check(String a){if(a==password)return 1;else return 0;}void settNumber(String a,String b){if(check(a)==1)tNumber=b;}String gettNumber(String a){if(check(a)==1)return tNumber;elsereturn"no permittion";}}public class zz //主类Check0{public static void main(String args[ ]) //主方法main { gg x= new gg("123"); //创建Student类的对象x//访问成员变量x.sName="myname";x.sNumber=900001;x.settNumber("123","1547942");System.out.println(x.gettNumber("123"));System.out.println(x.sName);System.out.println(x.sNumber);}}3.class Account{private int id;private String name;private float leftmoney;private String pass;public int getID() { return id;}public void setID(int iD) {id = iD;}public float getLeft() {return leftmoney;}public void setLeft(float left) {this.leftmoney = left;}public String getPass() {return pass;}public void setPass(String pass) {this.pass = pass;}public void withdrawMoney(String a,float amount){i f(a==pass){if(leftmoney>=amount){leftmoney=leftmoney-amount;System.out.println("取钱成功"+"取了"+amount+"元");}elseSystem.out.println("余额不足");}e lseSystem.out.println("密码错误");}public void saveMoney(String a,float amount ){if(a==pass){leftmoney=leftmoney+amount;System.out.println("存钱成功"+"存了"+amount+"元");}elseSystem.out.println("密码错误");}float inqury(String a){if(pass==a)return leftmoney;else return -1;}}class zz{public static void main(String args[]){Account gg=new Account();gg.setID(0245);gg.setLeft(1000);gg.setPass("123");gg.saveMoney("123",600);gg.withdrawMoney("123",700);gg.withdrawMoney("124",5000);System.out.println(gg.inqury("123"));}}4.class acfun{String name;String id;private int intgretResult;private int sports;public void setname(String a){name=a;}public void setid(String a){id=a;}public void setintgretResult(int a){intgretResult=a;} public int getintgretResult(){return intgretResult;} public int getsport(){return sports;}public void setsports(int a){sports=a;}public void print(){System.out.println("name="+name+'\n'+"id="+id +"intgretResult="+intgretResult+"sports="+sports+'\n'+"被录取");}}public class zz {static int check(int a,int b){if(a>300&&b>96)return 1;elsereturn 0;}public static void main(String args[]){acfun hh= new acfun();hh.setname("yyf");hh.setid("0245");hh.setintgretResult(400);hh.setsports(98);if(check(hh.getintgretResult(),hh.getsport())==1)hh.print();acfun x= new acfun();x.setname("sag");x.setid("3443");x.setintgretResult(70);x.setsports(70);if(check(x.getintgretResult(),x.getsport())==1)x.print(); }}五、实验结果与分析（）：六、教师评语：实验成绩：教师：**。

实验报告课程名称： Java语言程序设计姓名:学号:班级:数学与计算机科学学院数学与计算机科学学院实验报告实验名称：类和对象指导教师：日期：实验结果第1题代码：class Dog{private String name,color;private int age;public Dog(String name,String color,int age){=name;this.color=color;this.age=age;}public void show() {System.out.println("名字：" + + "\n毛色：" + color + "\n年龄：" + age); }}public class Tm1{public static void main(String args[]){Dog d=new Dog("松狮","黄色",6);d.show();}}第2题代码：class Student{String name,id;double total,sports;public Student(String i,String j,double k,double m){name=i;id=j;total=k;sports=m;}public double get_total(){ return total;}public double get_sports(){ return sports;}}class School {double ScoreLine;public School(double i){ ScoreLine=i;}public double get_scoreLine()}public class Tm2 {void true_out(Student stu){ System.out.println(+" "+stu.id+" "+"被录取");} void false_out(Student stu){System.out.println(+" "+stu.id+" "+"未被录取");} void judge(Student stu,School line){if((stu.get_total()>line.get_scoreLine())||((stu.get_sports()>96)&&(s tu.get_total()>300)))true_out(stu);elsefalse_out(stu);}public static void main(String[] args) {double scoreline=325.0;School sce = new School(scoreline);Student stu1=new Student("张三","001",331.9,92.4);Student stu2=new Student("李四","002",344.5,89.7);Student stu3=new Student("王五","003",245.0,96.0);Tm2 temp=new Tm2();temp.judge(stu1,sce);temp.judge(stu2,sce);temp.judge(stu3,sce);}}第3题代码：public class Tm3 {private String name;private String password;private static int count;public Tm3(){count++;}public Tm3(String name){=name;count++;}public Tm3(String name,String password){=name;this.password=password;count++;}public String getName(){return name;}public void setName(String name){=name;}public String getPassword()public void setPassword(String password){this.password=password;}public void print(){System.out.println("用户名："+name+"\n"+"口令："+password+"\n");} public void count(){System.out.println("用户个数："+(count-1));}public static void main(String args[]){Tm3 user1=new Tm3("张三","12345");Tm3 user2=new Tm3("李四","67891");Tm3 user3=new Tm3("王五","23456");user1.print();user2.print();user3.print();new Tm3().count();}}第4题代码：import java.text.DecimalFormat;class Point{protected int x,y;Point(int m,int n){x=m;y=n;}public void set_point(int m,int n){x=m; y=n;}public int get_x(){return x;}public int get_y(){return y;}}class Circle extends Point{protected double r;Circle(int m,int n,double l){super(m,n);r=l;}public void set_r(double m){r=m;}public double get_r(){return r;}public double get_area(){return 3.14*r*r;}}public class Tm4 extends Circle{protected double h;Tm4(int m,int n,double r,double l){super(m,n,r);h=l;}public void set_h(double m){h=m;}public double get_h(){return h;}public double get_volume(){return get_area()*h;}public static void main(String[] args) {Tm4 clas1=new Tm4(1,2,4,6);Tm4 clas2=new Tm4(2,5,6,7);Tm4 clas3=new Tm4(8,4,2,5);DecimalFormat df=new DecimalFormat("#.00");System.out.println("轴心位置坐标:("+clas1.get_x()+","+clas1.get_y()+")\n半径:"+clas1.get_r()+"\n面积："+df.format(clas1.get_area())+"\n高："+clas1.get_h()+"\n体积："+df.format(clas1.get_volume())+"\n");System.out.println("轴心位置坐标:("+clas2.get_x()+","+clas2.get_y()+")\n半径:"+clas2.get_r()+"\n面积："+df.format(clas2.get_area())+"\n高："+clas2.get_h()+"\n体积："+df.format(clas2.get_volume())+"\n");System.out.println("轴心位置坐标:("+clas3.get_x()+","+clas3.get_y()+")\n半径:"+clas3.get_r()+"\n面积："+df.format(clas3.get_area())+"\n高："+clas3.get_h()+"\n体积："+df.format(clas3.get_volume())+"\n");}}实验结果第1题：第2题：第3题：第4题：。

实验报告
课程名称
面向对象程序设计
实验名称
实验三、类和对象
日期
2018/4/9
学生学号
姓名
班级
实验目的：
1．掌握面向对象编程语言中的类和对象的使用方法。
2．理解类的封装性。
实验条件：
电脑一台、能上网查阅资料。
实验内容与步骤：
要求：
设计和实现一个学生类，满足以下要求：
1、学生具有学号、姓名、性别、年龄和专业等属性；
super();
this.sname=sname;
this.snum=snum;
this.sex=sex;
}
publicenumSEXENM{
Male,Female
}
}
packagezhy.shiyan3;
importzhy.shiyan3.Student.SEXENM;
publicclassDemo {
}
publicString getSname() {
returnsname;
}
publicString getSnum() {
returnsnum;
}
publicSEXENM getSex() {
returnsex;
}
publicStudent(Stringsname,Stringsnum,SEXENMsex) {
publicstaticvoidmain(String[]args) {
Studentstudent=null;
student=newStudent("翟海洋","1525",SEXENM.Male);
student.setAge(22);

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 的封装、继承和多态特性。

实验二类与对象初识【实验目的】1. 理解类的构造、属性、方法及实例化的使用；2. 学会对类的创建，构造函数的使用，类属性及方法的创建，以及类的实例化及使用；3. 会对类的创建，类的属性及方法的创建进行独立编程；4. 学会对较复杂的类进行分析；5. 掌握使用package和import语句；6. 理解uml类图，尝试使用简单uml工具。

【实验任务】注意：1，本章所有自己创建的类都必须创建到自己的包中，创建规则见课件或自行参考资料；2，本章所有自己创建的类都需附上UML类图截图。

例1：根据java代码生成单个文件（或单个类）的类图本实验以HelloWorld.java这个文件为例，其代码及生成的类图的结果截图如下：以下为UML截图：例2：根据java代码生成多个类之间（可以在同一文件也可以是不同文件）的关系图本实验创建一个HW1类，继承HelloWorld类，即父类与子类的关系，HW1代码见下：然后我把HelloWorld跟HW1两个类分别拖到newfile.cld的编辑窗口，其结果截图如下：实验2-1、给出下面的程序运行结果输出？并解释问题出在哪里？public class My {String s;public void My(){s = "Constructor";}public void go() {System.out.println(s);}public static void main(String args[]) {My m = new My();m.go();}}首先，新建一个类，并将上述代码输入，其运行结果截图如下：然后根据运行提示，将其更改为构造函数，即删除掉void，因为构造方法没有返回类型（修饰符void也不能有），改完程序就能运行并得出正确结果，其截图如下：该程序的UML类图截图如下：实验2-2、课本64页例24，完成BankAccount类以及AccountTester2类，这个例子集中体现了本章2.2-2.5的知识点，注意测试时请使用跟书本不一样测试数据。

java类与对象实验报告《Java类与对象实验报告》实验目的：本实验旨在帮助学生理解和掌握Java中类与对象的概念，以及如何创建和使用它们。

通过实际操作，学生将能够加深对类与对象的理解，并掌握如何在程序中正确地使用它们。

实验内容：1. 创建一个简单的Java类，包括成员变量和成员方法。

2. 创建该类的对象，并调用其成员方法。

3. 理解类与对象之间的关系，以及如何通过对象访问类的成员变量和成员方法。

4. 掌握类的继承与多态的概念，以及如何在程序中应用它们。

实验步骤：1. 首先，我们创建一个名为“Person”的Java类，该类包括姓名和年龄两个成员变量，以及一个打印个人信息的成员方法。

2. 接下来，我们创建一个名为“Main”的主类，在该类中创建“Person”类的对象，并调用其成员方法打印个人信息。

3. 然后，我们创建一个名为“Student”的子类，继承“Person”类，并重写其打印个人信息的方法。

4. 最后，我们创建“Main”类的另一个对象，分别用“Person”类和“Student”类的对象调用成员方法，观察多态的效果。

实验结果：通过本次实验，我们成功创建了一个简单的Java类，并在程序中正确地使用了它。

我们也理解了类与对象之间的关系，以及如何通过对象访问类的成员变量和成员方法。

此外，我们还掌握了类的继承与多态的概念，并成功在程序中应用它们。

结论：本次实验使我们更加深入地理解了Java中类与对象的概念，以及如何正确地创建和使用它们。

通过实际操作，我们掌握了类的继承与多态的概念，并成功在程序中应用它们。

这将为我们今后的学习和工作打下坚实的基础。

实验报告【实验名称】第二章类和对象【实验目的】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、把如下程序改成从键盘输入两个整数，并判断大小。