java 类的继承 实验报告(含代码)
005-实验五 继承和接口(实验报告内容)
实验五继承和接口（实验报告）一、目的1．掌握Java语言继承机制。
二、实验内容定义一个超类，定义一个子类，实例化子类对象，调用超类的属性和方法，体会继承机制。
三、实验环境JDK1.6+dos环境四、实验原理1．继承机制五、实验步骤1、定义一个Person类，有属性姓名，年龄，性别。
Person具有吃饭，睡觉的行为。
定义一个Student类继承Person类，Student具有学习，看书的行为。
定义一个接口，能够输出自己的基本信息。
完成所设计的类的测试。
class Person{private String name;private int age;private String sex;public void setName( String name){ =name;}public String getName( ){return name;}public void setAge( int age){this.age=age;}public int getAge( ){return age ;}public void setSex( String sex){this.sex=sex;}public String getSex( ){return sex;}public void tell01(){System.out.println("会吃饭，能睡觉"); }public void tell02(){System.out.println("姓名:"+this.getName()+"性别:"+this.getSex()+"年龄:"+this.getAge());}}interface A{public void print01();public void print02();}class Student extends Person implements A{private int number;public void setNumber(int number){this.number=number;}public int getNumber( ){return number;}public void tell03(){System.out.println("姓名:"+this.getName()+"\n性别:"+this.getSex()+"\n年龄:"+this.getAge()+"\n学号:"+this.getNumber());}public void tell04(){System.out.println("爱学习，喜欢看书");}public void print01(){System.out.println("巴黎下着小雨!!!");}public void print02(){System.out.println("吉大正在飚雨!!!");}}public class mytest01{public static void main(String args[]){Student stu = new Student();stu.setName("张三");stu.setAge(20);stu.setSex("男");stu.setNumber(2011);stu.tell01();stu.tell03();stu.tell04();stu.print01();stu.print02();}}六、实验小结。
JAVA类的继承实验报告
《面向对象程序设计》实验报告实验六、类的继承课程代码：1H10500学分：6实验类型：实践型实验学时：4个学时实验时间：2017.11.23 实验地点：5407班级：计算机164 专业：计算机科学与技术专业学号：2016011147 姓名：林文辉一、实验目的（1）学习JAVA继承的思想（2）了解JAVA语言继承的实现二、实验内容及步骤内容：在圆柱体类Cylinder里，用一个构造方法调用另一个构造方法步骤：方案的设计与分析（类结构图。
）（1）找出对象的共同属性和行为（2）设计代表共同状态与行为的类（3）决定子类是否需要让某项行为有特定的不同的运行方式（4）寻找更多抽象化的机会（5）完成类的继承层次三、实验过程及结果实验1代码：abstract class Graphics {abstract void parameter();abstract void area();}class Rectangle extends Graphics{double h,w;Rectangle(double u,double v){h=u;w=v;}void parameter() {S ystem.out.println("矩形高度为:"+h+",矩形宽度为:"+w);}void area() {S ystem.out.println("矩形面积为："+(h*w));}}class Circle extends Graphics{double r;String c;Circle(double u,String v){r=u;c=v;}void parameter() {System.out.println("圆半径为:"+r+",圆颜色为:"+c);}void area() {System.out.println("圆面积为:"+(Math.PI*r*r));}}class ExamAbs{public static void main(String args[]) {Rectangle rec=new Rectangle(2.0, 3.0);Circle cir=new Circle(4.0, "Red");Graphics[]g= {rec,cir};for(int i=0;i<g.length;i++) {g[i].parameter();g[i].area();}}}结果：（该部分主要记录实验过程，包括实验代码及运行结果）四、实验小结Java中提供了this关键字，this关键字总是指向调用该方法的对象。
java 类的继承 实验报告(含代码)
实验三类的继承实验目的：掌握类的继承、抽象类的定义和使用、对象的向上转型。
实验内容：已知若干图形，求以该图形为底的锥体的体积。
实验要求：用面向抽象的思想实现实验步骤：1、程序总体框架2、在shape包中创建抽象类Shape，代码如下：3、在centrun包中创建一个类Centrun,代码如下：Centrun这个类为核心类，在之后的代码编写中可以不做更改，getVolume函数用来求椎体的体积，即利用抽象类getArea进行适应性计算。
4、创建一个包myshape，在其中先创建一个Circle类，代码如下：Circle是对抽象类shape的继承（记得导入shape包），在Circle类中，利用对getArea 函数代码的重写操作，具体实现了求圆的面积这一操作。
【此处的具体实现应该放入该图形的具体面积求法。
】5、创建一个包Test，对以上三个包中的代码进行具体实现，代码如下：导入myshape包，在main函数中通过向上转型，实例化shape包中的抽象类Shape，然后调用函数输出圆锥的体积。
6、在求出实验结果1，即调试好shape、myshape、centrun这三个包后，不再更改shape、centrun包，而是在myshape包下新建所需的类，如本次实验所需的三角形、矩形；7、在myshape包下创建一个类Rectangular，代码如下：8、在myshape包下创建一个类Triangle，需注意的是，求三角形的面积需要判断三角形的三边能否构成三角形（不能构成时返回0），代码如下：实验结果：1、Test测试包最终代码：2、圆锥体积测试数据：半径=4.0，高=10测试结果：求得圆锥的体积约为168；3、四棱锥的体积（底面为矩形）测试数据：宽=6，长=8，高=10；测试结果：求得棱锥的体积为160.4、三棱锥的体积（1）测试数据：三边分别为：3 4 5，高为10。
测试结果：求得三棱锥的体积为20.（2）测试数据：三边分别为：15 4 5，高为10。
Java语言程序设计实验六 类的继承(接口与包)实验报告 (2)
**大学**学院Java语言程序设计实验报告System.out.println("sum="+m1.num1+"+"+m1.num2+"+"+m1.num3+"="+m1.sum);}}问题：a、子类的sum,num1,num2分别是多少，父类的sum,num1,num2 分别是多少，如何在main中输出父类的sum,num1,num2子类：sum=600，num1=100，num2=200父类：sum=0，num1=0，num2=0；b、就这个例子，谈谈你对覆盖的理解？当子类的变量与父类的变量相同时，父类的变量被隐藏，main函数自动调用子类的变量2．运行下面的程序，理解方法的继承。
class Sort3{double max1,max2,max3;Sort3(){max1=-1;max2=-1;max3=-1;}double s;if (max1<max2){ s=max1;max1=max2;max2=s; }if (max1<max3){ s=max1;max1=max3;max3=s; }if (max2<max3){ s=max2;max2=max3;max3=s; }}}class sub_Sort3 extends Sort3{void subsort(double i,double j,double k){max1=i;max2=j;max3=k;sort(); //调用父类中的方法sort() …….① } }public class Class1{public static void main (String args[]){sub_Sort3 m1 = new sub_Sort3();m1.subsort(100,200,300);System.out.println("三个数从大到小为："+m1.max1+","+m1.max2+","+m1.max3);}}问题：a、为什么标有.①处可以直接使用，而不需要生成Sort3的对象，然后使用该对象. sort()调用因为sub_sort3继承了sort，所以sort的方法就像是在子类中直接定义一样，可以被子类直接调用 B、程序实现什么功能？三个数之间互相比较大小3．运行下面的程序，理解方法的重载。
java实验报告 类的继承
java实验报告类的继承一、实验目的1、深入理解 Java 中类的继承概念和机制。
2、掌握通过继承实现代码复用和功能扩展。
3、学会使用 super 关键字和方法重写。
二、实验环境1、操作系统：Windows 102、开发工具：Eclipse 或 IntelliJ IDEA三、实验内容1、创建一个父类｀Animal`包含属性：｀name`（字符串类型），｀age`（整数类型）包含方法：｀eat(）｀（打印出动物正在吃东西），｀sleep(）｀（打印出动物正在睡觉）2、创建子类｀Dog` 继承自｀Animal`新增属性：｀breed`（字符串类型，表示狗的品种）重写父类的｀eat(）｀方法，打印出狗吃东西的特有方式新增方法：｀bark(）｀（打印出狗在叫）3、创建子类｀Cat` 继承自｀Animal`新增属性：｀color`（字符串类型，表示猫的颜色）重写父类的｀sleep(）｀方法，打印出猫睡觉的特有姿势新增方法：｀meow(）｀（打印出猫在叫）四、实验步骤1、在 Java 项目中创建一个名为｀Animal` 的类：｀｀｀javapublic class Animal ｛private String name;private int age;public Animal(String name, int age) ｛thisname ＝ name;thisage ＝ age;｝public void eat(）｛Systemoutprintln(name ＋＂ is eating＂）；｝public void sleep(）｛Systemoutprintln(name ＋＂ is sleeping＂）；｝｝｀｀｀2、创建一个名为｀Dog` 的类继承自｀Animal`：｀｀｀javapublic class Dog extends Animal ｛private String breed;public Dog(String name, int age, String breed) ｛super(name, age)；thisbreed ＝ breed;｝＠Overridepublic void eat(）｛Systemoutprintln(supergetName(）＋＂ the ＂＋ breed ＋＂ dog is eating greedily＂）；｝public void bark(）｛｝｝｀｀｀3、创建一个名为｀Cat` 的类继承自｀Animal`：｀｀｀javapublic class Cat extends Animal ｛private String color;public Cat(String name, int age, String color) ｛super(name, age)；thiscolor ＝ color;｝＠Overridepublic void sleep(）｛Systemoutprintln(supergetName(）＋＂ the ＂＋ color ＋＂ cat is sleeping curled up＂）；｝public void meow(）｛｝｝｀｀｀4、在｀Main` 类中进行测试：｀｀｀javapublic class Main ｛public static void main(String args) ｛Dog dog ＝ new Dog(＂Buddy"， 3, ＂Labrador"）；dogeat(）；dogbark(）；dogsleep(）；Cat cat ＝ new Cat(＂Mimi"， 2, ＂White"）；cateat(）；catsleep(）；catmeow(）；｝｝｀｀｀五、实验结果1、运行｀Main` 类后，输出结果如下：｀Buddy the Labrador dog is eating greedily｀｀Buddy is barking｀｀Buddy is sleeping｀｀Mimi is eating｀｀Mimi the White cat is sleeping curled up｀｀Mimi is meowing｀2、可以看到，子类｀Dog` 重写了父类｀Animal` 的｀eat(）｀方法，展示了狗特有的吃东西方式；子类｀Cat` 重写了父类的｀sleep(）｀方法，展示了猫特有的睡觉姿势。
java类的继承实验报告
java类的继承实验报告Java类的继承实验报告引言：在面向对象的编程语言中，继承是一种重要的概念。
Java作为一门面向对象的编程语言，也支持类的继承。
本篇实验报告将介绍Java类的继承的基本概念、语法以及实际应用。
一、继承的基本概念继承是指一个类可以派生出另一个类，被派生出的类称为子类，派生出子类的类称为父类。
子类可以继承父类的属性和方法，并且可以在此基础上进行扩展或修改。
继承的关系可以形成类的层次结构，使得代码的复用性和可维护性得到提高。
二、继承的语法在Java中，使用关键字"extends"来实现类的继承关系。
子类通过继承父类来获得父类的属性和方法。
语法格式如下：```javaclass 子类名 extends 父类名 {// 子类的成员变量和方法}```在子类中可以重写父类的方法，以实现自己的逻辑。
使用关键字"super"可以调用父类的构造方法和成员变量。
三、继承的实际应用1. 代码复用继承的一个主要优势是可以实现代码的复用。
子类可以继承父类的属性和方法，避免了重复编写相同的代码。
例如，假设有一个父类"Animal"，子类"Dog"和"Cat"可以继承父类的一些通用属性和方法，如"eat()"和"sleep()"。
2. 多态性继承也为多态性的实现提供了基础。
多态性是指一个对象可以根据不同的类型表现出不同的行为。
通过继承，可以将不同的子类对象赋给父类引用，实现对不同子类对象的统一操作。
例如，有一个父类"Shape"，子类"Circle"和"Rectangle"可以继承父类的方法"draw()"，并在自己的类中实现具体的绘制逻辑。
通过将子类对象赋给父类引用，可以统一调用"draw()"方法，实现对不同形状的绘制。
继承的含义实验报告
一、实验目的1. 理解继承的概念及其在面向对象编程中的重要性；2. 掌握Java中继承的实现方式；3. 熟悉继承中成员的访问权限；4. 掌握子类与父类之间的关系。
二、实验环境1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：Eclipse三、实验内容1. 定义一个父类Person，包含以下属性和方法：- 属性：name（姓名）、age（年龄）- 方法：setName(String name)、getName(String name)、setAge(int age)、getAge(int age)、toString()2. 定义一个子类Student，继承自Person类，包含以下属性和方法：- 属性：id（学号）- 方法：setId(int id)、getId(int id)3. 编写main方法，创建Person和Student对象，并输出对象信息。
4. 定义一个父类Animal，包含以下属性和方法：- 属性：name（名字）、age（年龄）- 方法：setName(String name)、getName(String name)、setAge(int age)、getAge(int age)、toString()5. 定义一个子类Dog，继承自Animal类，包含以下属性和方法：- 属性：breed（品种）- 方法：setBreed(String breed)、getBreed(String breed)6. 编写main方法，创建Animal和Dog对象，并输出对象信息。
7. 定义一个父类Vehicle，包含以下属性和方法：- 属性：brand（品牌）、model（型号）- 方法：setBrand(String brand)、getBrand(String brand)、setModel(String model)、getModel(String model)、toString()8. 定义一个子类Car，继承自Vehicle类，包含以下属性和方法：- 属性：color（颜色）- 方法：setColor(String color)、getColor(String color)9. 编写main方法，创建Vehicle和Car对象，并输出对象信息。
java类的继承实验报告
java类的继承实验报告Java类的继承实验报告引言：在面向对象的编程语言中，继承是一种重要的概念。
Java作为一种面向对象的编程语言，也提供了类的继承机制。
本实验旨在通过编写Java程序，深入理解和掌握Java类的继承。
实验目的：1. 理解继承的概念和原理；2. 掌握Java中类的继承的语法和用法；3. 实践继承的实际应用。
实验过程：1. 创建父类和子类在实验中，我们首先创建一个父类和一个子类。
父类可以是一个基本的类，子类则继承了父类的属性和方法。
这样，子类就可以在不改变父类的基础上，扩展自己的功能。
2. 继承的语法和用法Java中，使用关键字"extends"来实现类的继承。
子类通过继承父类，可以获得父类的属性和方法，并且可以在子类中添加新的属性和方法。
在实验中，我们可以通过创建子类对象，并调用继承自父类的方法来验证继承的正确性。
3. 方法的重写在继承中，子类可以重写父类的方法。
这样，当子类调用该方法时，实际上执行的是子类重写后的方法。
通过方法的重写，我们可以实现多态性的效果。
4. 实际应用在实验中，我们可以选择一个具体的应用场景，例如动物类的继承。
我们可以创建一个父类Animal，包含基本的属性和方法，然后创建子类Dog和Cat，分别继承Animal类，并添加自己的特有属性和方法。
通过这个实例，我们可以更好地理解继承的实际应用。
实验结果：通过实验，我们成功地创建了父类和子类，并验证了继承的正确性。
我们还成功地重写了父类的方法，实现了多态性的效果。
最后，我们还通过实际应用的例子，更好地理解了继承的实际应用。
实验总结：通过本次实验，我们深入理解和掌握了Java类的继承。
继承是面向对象编程中的重要概念，通过继承，我们可以实现代码的重用和扩展。
在实际应用中，继承也可以帮助我们更好地组织代码，提高代码的可读性和可维护性。
然而，继承也有一些限制和注意事项。
首先，Java中只支持单继承，即一个子类只能继承一个父类。
JAVA实验报告(圆类,动物继承,人类继承)DOC
《Java程序设计》实验报告
心得体会：主要是构建3个对象，操作过程中，老是出现3个圆对象结果相同的情况，反复上机测试才发现是成员变量中的radius，应该用this.radius才能获取到。
2. 实现类的继承.
心得体会：主要运用构造方法的实例化和继承知识。
3. 描述动物世界的特征和关系.
心得体会：主要对name和food进行初始化，以及继承的使用。
4. 汽车的基本属性和行为.
5.求正方形的周长和面积.
总的心得体会：经过这5个小程序的编写，我已经能够熟练地操作程序，对构造方法和继承方面的知识有了更深的理解，并能够编写简单的有关继承和构造方法的小程序。
Java语言程序设计实验六 类的继承(接口与包)实验报告 (2)
三个数之间互相比较大小
3．运行下面的程序，理解方法的重载。 class Sort2or3{
double max1,max2,max3; Sort2or3(){
max1=-1; max2=-1;
max3=-1;
} void sort(double i,double j){
double s; max1=i; max2=j; if(max1<max2){ s=max1;max1=max2;max2=s; } } void sort(double i,double j,double k){ double s; max1=i; max2=j; max3=k; if (max1<max2){ s=max1;max1=max2;max2=s; } if (max1<max3){ s=max1;max1=max3;max3=s; } if (max2<max3){ s=max2;max2=max3;max3=s; } } } public class Class1{ public static void main (String args[]){ Sort2or3 m1 = new Sort2or3(); m1.sort(100,200); System.out.println("两个数从大到小为："+m1.max1+","+m1.max2); m1.sort(50,150,100); System.out.println("三个数从大到小为： "+m1.max1+","+m1.max2+","+m1.max3); } }
Java语言程序设计实验六 类的继承(接口与包)实验报告
**大学**学院Java语言程序设计实验报告7．体会教材的面向接口编程四、实验步骤：1.a.子类:sum=600,num1=100,num2=200父类:sum=0,num1=0,num2=0b.覆盖是指子类在继承父类之后，给变量名相同的参数一个新的值并在类中使用，覆盖了父类中继承下来的值。
子类重写父类的方法，要想在子类中调用超类中被覆盖掉的方法就需要用super关键字2.a.因为子类sub_Sort3继承了父类Sort3，可以直接使用父类的方法b.实现从大到小排序3.4.重载：重载指一个类里可以有多个方法具有相同的名字，但这些方法的参数必须不同。
重写：子类的方法的名字、参数个数、参数的类型和父类的方法完全相同。
子类通过方法的重写可以隐藏继承的方法。
例如class A{float a(int a,int b){return a+b;}float a(int a,int b,int c){return a+b+c;}}是重载class B{float b(int a,int b){return a+b;}}class B extends A{float b(int a,int b){return a-b;}}是重写5.class A{int x=8;void myPrint() {//父类System.out.println(x);}}class B extends A {int y=16;String s="java program!";void myPrint() {//子类System.out.println(y+" "+s);}void printAll() {myPrint();super.myPrint();}}public class Application {public static void main(String args[]) {B b=new B();b.printAll();}}6.class A{int i;float x;A(int i,float x) {this.i=i;this.x=x;}}public class test {public static A b(A a) {a.i=a.i+1;a.x=a.x+2;return a;}public static void main(String args[]) {A a=new A(2,8.0f);System.out.println("i="+a.i+" x="+a.x);a=b(a);System.out.println("i="+a.i+" x="+a.x);}}五、实验结果与分析（含程序、数据记录及分析和实验总结等）：六：思考题：实验成绩：。
java实验报告类的继承
java实验报告类的继承Java实验类与继承实验报告实验课程：Java面向程序设计实验实验内容：类与对象院（系）：计算机学院专业：计算机科学与技术（软件工程方向）班级：学生姓名：学号：指导教师：2014年 3 月26 日一、实验目的:1、掌握用类来封装对象的属性和行为的方法；2、掌握对象的组合和参数传递；3、掌握类变量与实例变量、类方法与实例方法的区别。
二、实验内容（－）实验题目一：编写一个java应用程序，该程序中有两个类：Tank和Fight具体要求如下：1、Tank类有一个double类型变量speed，用于刻画坦克的速度；一个int型变量bulletAmount，用于刻画坦克的炮弹数量。
定义了speedUp()和speedDown（）方法，体现坦克有加速、减速行为；定义了setBulletAmount（int p）方法，用于设置坦克炮弹的数量；定义了fire（）方法，体现坦克有开炮行为。
1．程序源代码：package p1;public class Tank {}double getSpeed(){}void fire(){}}package p1;public class Fight {public static void main(String args[]){Tank tank1,tank2; tank1=new Tank(); if(bulletAmount=1){ bulletAmount=bulletAmount-1; System.out.println(打出一发炮弹); } else{ System.out.println(没有炮弹了，无法开火); } return speed; double speed; int bulletAmount; void speedUp(int s){ speed=s+speed; } void speedDown(int d){ } void setBulletAmount(int m){ } return bulletAmount; bulletAmount=m; if(speed-d=0)speed=speed-d; speed=0; else int getBulletAmount(){} tank2=new Tank(); tank1.setBulletAmount(10); tank2.setBulletAmount(10); System.out.println(tank1的炮弹数量：+tank1.getBulletAmount()); System.out.println(tank2的炮弹数量：+tank2.getBulletAmount()); tank1.speedUp(80); tank2.speedUp(90);System.out.println(tank1目前的速度：+tank1.getSpeed()); System.out.println(tank2目前的速度：+tank2.getSpeed()); tank1.speedDown(15); tank2.speedDown(30); System.out.println(tank1目前的速度：+tank1.getSpeed()); System.out.println(tank2目前的速度：+tank2.getSpeed()); System.out.println(tank1开火：); tank1.fire(); System.out.println(tank2开火：); tank2.fire(); tank2.fire(); System.out.println(tank1的炮弹数量：+tank1.getBulletAmount()); System.out.println(tank2的炮弹数量：+tank2.getBulletAmount()); } 2．实验结果：图13、实验课后练习：(1)改进speedUp方法，使得Tank类的对象调用它能将Speed值超过220；答：只需加入如下代码，其实验结果如图2：void speedUp(int s){if(s+speed=200)//加入判断语句即可speed=s+speed;}图2：tank2加速200，超过220，所以tank2数值保持不变（2）增加一个刹车方法：void brake（），Tank类的对象调用它将speed的值变为0.答：只需增加如下代码：其结果如图3所示：void brake(){} speed=0;System.out.println(tank2加速200：);tank2.speedUp(200);System.out.println(tank2调用brake后：); tank2.brake();篇二：JAVA继承实验报告JAVA语言程序设计实验报告实验一实验题目：面向对象编程指导老师：卢照专业班级：计算机科学与技术系1106班姓名：****（20111006**）2014年3月20日一、实验名称：面向对象编程二、实验目的：1.熟悉Java开发运行环境。
JAVA 继承和多态实验报告
实验项目名称：继承和多态（所属课程：Java语言程序设计）院系：专业班级：姓名：学号：实验地点：指导老师：本实验项目成绩：教师签字：日期：1．实验目的（1）掌握类的继承机制。
（2）熟悉类中成员变量和方法的访问控制。
（3）熟悉方法或构造方法多态性。
2.实验内容（1）模拟编写程序，理解类的继承、多态、继承和多态规则。
（2）独立编程，实现类的继承和多态。
3.实验作业设计一个类Shape（图形）包含求面积和周长的area()方法和perimeter()方法以及设置颜色的方法SetColor()，并利用Java多态技术设计其子类Circle（圆形）类、Rectangle （矩形）类和Triangle（三角形）类，并分别实现相应的求面积和求周长的方法。
每个类都要覆盖toString方法。
海伦公式：三角形的面积等于s(s-a)(s-b)(s-c)的开方，其中s=(a+b+c)/2程序代码为：Class包package Class;public class Shape {private String color = "while";public Shape(String color){this.color = color;}public void setColor(String color){this.color = color;}public String getColor(){return color;精选文库}public double getArea(){return 0;}public double getPerimeter(){return 0;}public String toString(){return"color:" + color;}}package Class;public class Circle extends Shape {private double radius;public Circle(String color,double radius) {super(color);this.radius = radius;}public void setRadius(double radius){this.radius = radius;}public double getRadius(){return radius;}public double getCircleArea(){return 3.14*radius*radius;}public double getCirclePerimeter(){return 3.14*2*radius;}public String toString(){return"The Area is:" + getCircleArea()+ "\nThe Perimeter is:" + getCirclePerimeter();}}package Class;public class Rectangle extends Shape{private double width;private double height;public Rectangle(String color,double width,double height) { super(color);this.width = width;this.height = height;}public void setWidth(double width){this.width = width;}public double getWidth(){return width;}public void setHeight(double height){this.height = height;}public double getHeight(){return height;}public double getRectangleArea(){return width*height;}public double getRectanglePerimeter(){return 2*(width + height);}public String toString(){return"The Area is:" + getRectangleArea()+ "\nThe Perimeter is:" + getRectanglePerimeter();}}package Class;public class Triangle extends Shape{private double a;private double b;private double c;private double s;public Triangle(String color,double a,double b,double c, double s){ super(color);this.a = a;this.b = b;this.c = c;this.s = s;}public void setA(double a){this.a = a;}public double getA(){return a;}public void setB(double b){this.b = b;}public double getB(){return b;}public void setC(double c){this.c = c;}public double getC(){return c;}public double getTriangleArea(){return Math.sqrt(s*(s-a)*(s-b)*(s-c));}public double getTrianglePerimeter(){return a + b + c;}public String toString(){return"The Area is:" + getTriangleArea()+ "\nThe Perimeter is:" + getTrianglePerimeter();}}Main包package Main;import Class.Shape;import Class.Circle;import Class.Rectangle;import Class.Triangle;import java.util.Scanner;public class test {public static void main(String[] args) {Scanner input = new Scanner(System.in);System.out.print("请输入圆的半径： ");double radius = input.nextDouble();Circle circle = new Circle(null, radius);System.out.println(circle.toString());System.out.print("\n请输入矩形的宽： ");double width = input.nextDouble();System.out.print("请输入矩形的高： ");double height = input.nextDouble();Rectangle rectangle = new Rectangle(null, width, height);System.out.println(rectangle.toString());System.out.print("\n请输入三角形的第一条边 a： ");精选文库double a = input.nextDouble();System.out.print("请输入三角形的第二条边 b： ");double b = input.nextDouble();System.out.print("请输入三角形的第三条边 c： ");double c = input.nextDouble();double s = (a + b + c)/2;Triangle triangle = new Triangle(null, a, b, c, s);System.out.println(triangle.toString());}}运行结果为：4．实验总结（1）通过实验掌握了类的继承机制。
Java语言程序设计实验六 类的继承(接口与包)实验报告
**大学Java语言程序设计实验报告m1.sum(100,200,300);System.out.println("sum="+m1.num1+"+"+m1.num2+"+"+m1.num3+"="+m1.sum);}}问题：a、子类的sum,num1,num2分别是多少，父类的sum,num1,num2 分别是多少，如何在main中输出父类的sum,num1,num2。
子类的sum,num1,num2分别是100,200,300父类的sum,num1,num2 分别是多少0,0,0使用super调用父类的构造方法，super（sum,num1,num2）b、就这个例子，谈谈你对覆盖的理解？2．运行下面的程序，理解方法的继承。
问题：a、为什么标有.①处可以直接使用，而不需要生成Sort3的对象，然后使用该对象. sort()调用sub_sort3是sort3的子类，继承了父类的方法B、程序实现什么功能？实现对三个数从大到小排序3．运行下面的程序，理解方法的重载。
class Sort2or3{double max1,max2,max3;Sort2or3(){max1=-1;max2=-1;4．运行下面的程序，理解方法的覆盖。
class sort_Demo{int i,j,k,swap;sort_Demo(){i=j=k=swap=0;}void sort(int t1,int t2[]){ //父类中的方法用来实现升序//用选择法按升序排列for(i=0;i<t1-1;i++){k=i;for(j=i+1;j<t1;j++)if(t2[j]<t2[k]) k=j;if (k!=i){swap=t2[i];t2[i]=t2[k];t2[k]=swap;}}}} }问题：比较3和4，谈谈你对重载和重写的认识，最好可以自己举例说明子类重写方法覆盖了父类的方法，那么子类对象调用发放一定调用的是重写方法，重写方法（覆盖方法）既可以操作继承的成员变量、调用继承的方法也可以操作子类新声明的成员变量、调用新定义的其他方法，但无法操作被子类隐藏的成员变量和方法。
java实验报告类构造函数与继承
实验报告课程名称： Java程序设计成绩评定：实验项目名称：实验5：类构造函数与继承指导教师：学生姓名：学号：专业班级：实验项目类型：基础实验地点：验时间：一、实验目的与要求：1、理解类和对象的区别，掌握构造函数的使用，熟悉通过对象名引用实例的方法和属性，进一步掌握方法调用时参数的传递；2、掌握package、jar打包功能与应用；4、掌握类的继承，理解继承中的覆盖现象.二、实验内容：1、按照要求完成程序public class Test{public static void main(String args[]){System.out.println("创建父类对象：");SuperClass sc0 = new SuperClass();System.out.println("\n创建第一个子类对象：");SubClass sc1 = new SubClass();System.out.println("\n创建第二个子类对象：");SubClass sc2 = new SubClass(1);}}class SuperClass{SuperClass( ){System.out.println("父类的构造函数");}}class SubClass extends SuperClass{SubClass( ){System.out.println("子类的第一个构造函数");}SubClass(int i){System.out.println("子类的第二个构造函数");}}要求：1）运行程序写出结果；创建父类对象：父类的构造函数创建第一个子类对象：父类的构造函数子类的第一个构造函数创建第二个子类对象：父类的构造函数子类的第二个构造函数2）去掉SubClass的所有构造函数，然后将Test类中main方法的最后两行语句删除。
java继承代码实例
java继承代码实例在 Java 中，继承是一种面向对象编程的特性，它允许一个类（子类）继承另一个类（父类）的属性和方法。
通过继承，子类可以继承父类的成员变量和方法，并可以进行扩展和修改。
以下是一个 Java 继承的代码实例：```java// 定义一个父类class ParentClass {// 父类的成员变量int parentVariable;// 父类的方法void parentMethod() {System.out.println("This is the parent method.");}}// 定义一个子类，继承自父类class ChildClass extends ParentClass {// 子类的成员变量int childVariable;// 子类的方法，覆盖了父类的方法@Overridevoid parentMethod() {System.out.println("This is the child method, overriding the parent method.");}// 子类新添加的方法void childOwnMethod() {System.out.println("This is a method unique to the child class.");}}public class Main {public static void main(String[] args) {// 创建子类对象ChildClass child = new ChildClass();// 调用子类的方法child.parentMethod();child.childOwnMethod();// 调用子类继承的父类方法child.childVariable = 10;System.out.println(child.childVariable);}}```在上述代码中，我们定义了一个父类`ParentClass`和一个子类`ChildClass`，子类`ChildClass`继承了父类`ParentClass`。
java继承实验报告
一、实验目的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) { = 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) { = 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","无效日期",RMATION_MESSAGE);break;}}catch (Exception e1) {// TODO: handle exceptionJOptionPane.showMessageDialog(null, "您输入的不是整数","无效日期",RMA TION_MESSAGE);}}}}public void keyReleased(KeyEvent e) {}public void keyTyped(KeyEvent e) {}}2.编译运行五、实验结果●实验内容一结果：●实验内容二结果：●实验内容三结果：六、实验小结1.这次实验的内容比较多，需要掌握Java的类和对象的声明和使用方法、Java的类的继承和实现方法、多态性在类的继承中的运用、接口的定义与使用、基本异常的处理机制、try语句与catch语句的搭配使用等等；2. 在实验过程中，重点是要区分好实例和类，灵活掌握类的调用。
java程序设计继承的使用实验报告总结
java程序设计——继承的使用实验报告总结实验是设计一个简单的动物园程序，其中包括不同类型的动物。
你可以设计一个动物（Animal）的父类，然后创建各种动物的子类，如狮子（Lion）、大象（Elephant）等。
1. 实验背景动物园程序需要管理多种动物，每种动物有各自的属性和行为。
使用继承可以有效地组织这些动物，减少代码的冗余。
2. 实验设计类的层次结构设计：javaCopy codepublic class Animal {private String name;private int age;// 构造方法和其他通用属性、方法public void eat() {System.out.println(name + " is eating.");}// 其他通用行为}public class Lion extends Animal {// 狮子特有的属性和方法}public class Elephant extends Animal {// 大象特有的属性和方法}继承的目的：通过将共同的属性和行为提取到父类 Animal 中，实现代码重用，同时在子类中可以添加特有的属性和行为。
方法的重写：javaCopy codepublic class Lion extends Animal {// 狮子特有的属性和方法@Overridepublic void eat() {System.out.println("The lion is enjoying a meal.");}}3. 代码实现javaCopy codepublic class ZooApp {public static void main(String[] args) {Lion lion = new Lion();lion.setName("Leo");lion.setAge(5);lion.eat(); // 调用被重写的eat方法Elephant elephant = new Elephant();elephant.setName("Ellie");elephant.setAge(10);elephant.eat(); // 调用父类的eat方法}}4. 实验结果程序运行结果截图：Leo is enjoying a meal.Ellie is eating.5. 实验经验和问题在实验中，通过继承，我们成功地将动物的共同属性和行为提取到父类中，实现了代码的重用。
java报告实验类的继承与封装
《JAVA程序设计》课程实验报告专业：网络工程班级： 551学号： 10姓名：高慧鹏日期： 2016年 4月 26日一、实验题目类的继承与封装二、实验目的1.熟练掌握类、类的数据成员和成员方法的定义与实现；2.熟练掌握抽象类与类的继承的相关内容；3.熟练掌握接口与接口的实现的相关内容；4.熟练掌握public、private、static、final、abstract等修饰符的作用。
三、实验内容类的继承与封装：定义抽象类Shape（形状）其中有抽象方法用来求某形状的周长和面积；定义Shape类的子类Circle（圆形）、Triangle（三角形）、Rect（矩形）其中包括该形状的位置、大小信息并实现求其周长和面积的方法。
假设当前有圆心为（100,100）半径为60的圆，左上角坐标为（0,200），水平宽度为120，垂直高度为80的矩形，以及三个顶点坐标分别为（200,200）、（300，400）、（150,350）的三角形，请在控制台输出每个形状的相关信息，及所有形状的周长和面积的和。
接口的定义与实现：通过接口和实现接口的类来完成上一题目。
四、实验步骤1、题目一(1)问题分析子类继承父类，构造类的对象来实现(2)算法描述(3)主要代码及运行结果import java.applet.Applet;import java.awt.Graphics;abstract class Shapes {public int x, y;public int width, height;public Shapes(int x, int y, int width, int height) {this.x = x;this.y = y;this.width = width;this.height = height;}abstract double getArea();abstract double getPerimeter();}class Circle extends Shapes { //圆public double r;public double getArea() {return (r * r * Math.PI);}public double getPerimeter() {return (2 * Math.PI * r);}public Circle(int x, int y, int width, int heigh) { super(x, y, width, heigh);r = (double) width / 2.0;}}class Square extends Shapes { //矩形public double getArea() {return (width * height);}public double getPerimeter() {return (2 * width + 2 * height);}public Square(int x, int y, int width, int height) { super(x, y, width, height);}}class Triangle extends Shapes { //三角形public double c;public double getArea() {return (0.5 * width * height);}public double getArea1() {return (0.5 * width * height);}public double getPerimeter() {return (width + height + c);}public Triangle(int x, int y, int base, int height) {super(x, y, base, height);c = Math.sqrt(width * width + height * height);}}public class test extends Applet {Square Box = new Square(0, 200, 120, 80);Triangle tri_1 = new Triangle(200, 200, 5, 10);Triangle tri_2 = new Triangle(300, 400, 0, 0);Triangle tri_3 = new Triangle(150, 350, 0, 0);Circle Oval = new Circle(100, 100, 60, 60); //public void paint(Graphics g) {int arg0[]={tri_1.x,tri_2.x,tri_3.x} ,arg1[]={tri_1.y,tri_2.y,tri_3.y} ;g.drawRect(Box.x, Box.y, Box.width, Box.height); //画矩形g.drawString("Box Area:" + Box.getArea(), 200, 35+200);g.drawString("Box Perimeter:" + Box.getPerimeter(), 200, 55+200);g.drawPolygon(arg0, arg1, 3);g.drawString("tri Area:" + tri_1.getArea(), 200, 75+200);g.drawString("tri Perimeter:" + tri_1.getPerimeter(), 200, 95+200);g.drawOval(Oval.x, Oval.y, Oval.width, Oval.height); //画圆g.drawString("oval Area:" + Oval.getArea(), 200,150);g.drawString("oval Perimeter:" + Oval.getPerimeter(), 200,150+20);}}五、 体会与总结(1).编写调试程序要注意程序编写的规则，.java 文件名要与主类名相同，JA V A 对字母的大小写特别敏感，输入时要特别注意大小写字母的定义，千万别犯主类名与.java 文件名不同的错误。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验三类的继承
实验目的：掌握类的继承、抽象类的定义和使用、对象的向上转型。
实验内容：已知若干图形，求以该图形为底的锥体的体积。
实验要求：用面向抽象的思想实现
实验步骤：
1、程序总体框架
2、在shape包中创建抽象类Shape，代码如下：
3、在centrun包中创建一个类Centrun,代码如下：
Centrun这个类为核心类，在之后的代码编写中可以不做更改，getVolume函数用来求椎体的体积，即利用抽象类getArea进行适应性计算。
4、创建一个包myshape，在其中先创建一个Circle类，代码如下：
Circle是对抽象类shape的继承（记得导入shape包），在Circle类中，利用对getArea 函数代码的重写操作，具体实现了求圆的面积这一操作。
【此处的具体实现应该放入该图形的具体面积求法。
】
5、创建一个包Test，对以上三个包中的代码进行具体实现，代码如下：
导入myshape包，在main函数中通过向上转型，实例化shape包中的抽象类Shape，然后调用函数输出圆锥的体积。
6、在求出实验结果1，即调试好shape、myshape、centrun这三个包后，不再更改shape、centrun包，而是在myshape包下新建所需的类，如本次实验所需的三角形、矩形；
7、在myshape包下创建一个类Rectangular，代码如下：
8、在myshape包下创建一个类Triangle，需注意的是，求三角形的面积需要判断三角形的三边能否构成三角形（不能构成时返回0），代码如下：
实验结果：
1、Test测试包最终代码：
2、圆锥体积
测试数据：半径=4.0，高=10
测试结果：求得圆锥的体积约为168；
3、四棱锥的体积（底面为矩形）
测试数据：宽=6，长=8，高=10；
测试结果：求得棱锥的体积为160.
4、三棱锥的体积
（1）测试数据：三边分别为：3 4 5，高为10。
测试结果：求得三棱锥的体积为20.
（2）测试数据：三边分别为：15 4 5，高为10。
测试结果：求得三棱锥的体积为0.。