JAVA实验二 类的继承和封装

一、实验目的1. 理解封装的概念及其在面向对象编程中的重要性。

2. 掌握如何使用Java语言实现类的封装。

3. 学会使用访问控制符（public、private、protected）来控制成员的访问权限。

4. 理解静态成员和实例成员的区别。

二、实验环境1. 操作系统：Windows 102. 开发工具：Eclipse IDE3. 编程语言：Java三、实验内容1. 创建一个名为“Person”的类，包含以下成员变量：- private String name; // 姓名- private int age; // 年龄- private String id; // 身份证号2. 创建一个名为“Person”的类，包含以下成员方法：- public String getName(); // 获取姓名- public void setName(String name); // 设置姓名- public int getAge(); // 获取年龄- public void setAge(int age); // 设置年龄- public String getId(); // 获取身份证号- public void setId(String id); // 设置身份证号3. 在主类“Main”中，创建一个“Person”对象，并通过访问控制符进行封装测试。

四、实验步骤1. 打开Eclipse IDE，创建一个名为“Experiment”的Java项目。

2. 在“Experiment”项目中，创建一个名为“Person”的类。

3. 在“Person”类中，定义成员变量name、age和id，并使用private关键字进行封装。

4. 在“Person”类中，定义成员方法getName、setName、getAge、setAge、getId和setId，并使用public关键字暴露给外部。

5. 在主类“Main”中，创建一个“Person”对象，并调用其成员方法进行测试。

java实验报告总结_java总结范文
实验报告总结
通过本次实验，我对Java语言的基本语法和面向对象的编程思想有了更深入的了解。

在实验过程中，我学会了如何定义类和对象，以及如何使用封装、继承和多态等特性来进
行编程。

在实验一中，我通过编写一个简单的Java程序，熟悉了Java的基本语法和标准输入
输出的操作。

我了解了Java的数据类型和运算符，并能够使用if语句和循环结构来实现
程序逻辑。

通过这个实验，我掌握了基本的程序设计能力。

在实验二中，我学习了面向对象的编程思想，并通过编写一个学生管理系统来实践。

我定义了一个Student类，使用封装来隐藏内部细节，并定义了一些方法来实现对学生对
象的操作。

我还使用继承来创建了一个Teacher类，体会到了面向对象编程中的继承和多
态的概念。

通过这个实验，我进一步提高了程序设计的能力。

在实验三中，我学习了异常处理的方法，并通过编写一个简单的图书管理系统来实践。

在程序中，我使用try-catch语句来捕获和处理异常，保证程序的健壮性。

通过这个实验，我对异常处理有了更深入的理解。

在实验四中，我学习了Java中的线程编程，并通过编写一个简单的多线程程序来实践。

在程序中，我使用了Thread类和Runnable接口来创建线程，并学会了如何控制线程的执
行顺序和共享数据。

通过这个实验，我对多线程编程有了初步的了解。

通过这些实验，我对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实验报告继承、多态、接⼝和异常处理实验5 继承、多态、接⼝和异常处理⼀、实验⽬的1、掌握Java的类和对象的声明和使⽤⽅法；2、掌握Java的类的继承和实现⽅法；3、掌握多态性在类的继承中的运⽤；4、掌握接⼝的定义与使⽤；5、掌握基本异常的处理机制；6、熟悉try语句与catch语句的搭配使⽤；7、了解有异常处理与没有异常处理的差别；8、多重catch语句的使⽤；9、使⽤Throws声明异常和Throw抛出异常。

⼆、实验环境1、PC微机；2、DOS操作系统或 Windows 操作系统；3、Java sdk程序开发环境、eclipse集成环境。

三、实验内容1. 设计三个类，分别是学⽣类Student，本科⽣类UnderGraduate，研究⽣类Postjgraduate，其中Student类是⼀个抽象类，它包含学⽣的基本信息如姓名、所学课程、课程成绩等，⽽Undergraduate类和Postgraduate类都是Student类的⼦类，这两个类计算课程成绩等级的⽅法有所不同，如下表所⽰。

假设某班级⾥既有研究⽣⼜有本科⽣，编写程序统计出全班学⽣2. 和Mobilephone具体实现，并设计⼀个应⽤程序类来使⽤这些类。

3．要求设计⼀个GUI图形窗⼝程序，该程序让⽤户输⼊⼀个星期中的任意⼀天的数字1-7，然后输出该数字所对应的是星期⼏。

四、实验步骤实验内容⼀1.建⽴package experiment5_1，其最终⽬录结构如下：2.建⽴Student类：package experiment5_1;public abstract class Student {final static int CourseNo = 3;String name;String type;int[] courses;String courseGrade;public Student(String name) {/doc/1bd4a299a66e58fafab069dc5022aaea998f41e2.html = name; courses = new int[CourseNo];courseGrade = "" ;}public abstract void calculateGrade();public String getName( ) {return name;}public String getType( ) {return type ;}public String getCourseGrade( ) {return courseGrade;}public int getCourseScore(int courseNumber) {return courses[courseNumber];}public void setName(String name) {/doc/1bd4a299a66e58fafab069dc5022aaea998f41e2.html = name;}public void setType(String type) {this.type = type;}public void setCourseScore(int courseNumber, int courseScore) { //按课程索引号设置课程成绩this.courses[courseNumber] = courseScore ;}}3.建⽴外部类（1）研究⽣类Postjgraduatepackage experiment5_1;public class postgraduate extends Student {public postgraduate(String name) {super(name);type = "研究⽣";}public void calculateGrade() {// TODO Auto-generated method stubint total = 0;double average = 0;for (int i = 0; i < CourseNo; i++) {total += courses[i];};average = total / CourseNo;if (average>=90&&average<100) courseGrade = "优秀"; else if (average>=80&&average<90) courseGrade = "良好"; else if (average>=70&&average<80) courseGrade = "⼀般"; else if (average>=60&&average<70) courseGrade = "及格"; else courseGrade = "不及格";}}（2）本科⽣类UnderGraduatepackage experiment5_1;public class undergraduate extends Student {public undergraduate(String name ) {super(name);type = "本科⽣";}public void calculateGrade() {int total = 0;double average = 0;for (int i = 0; i < CourseNo; i++) {total += getCourseScore(i) ;};average = total / CourseNo;if (average>=80&&average<100) courseGrade = "优秀"; else if (average>=70&&average<80) courseGrade = "良好"; else if (average>=60&&average<70) courseGrade = "⼀般"; else if (average>=50&&average<60) courseGrade = "及格"; else courseGrade = "不及格";}}4.编写代码测试函数package experiment5_1;public class polymorphism {public static void main(String[] args) {Student[] students = new Student[5];students[0] = new undergraduate("陈建平");students[1] = new undergraduate("鲁向东");students[2] = new postgraduate("匡晓华");students[3] = new undergraduate("周丽娜");students[4] = new postgraduate("梁欣欣");for (int i=0; i<5 ;i++) {students[i].setCourseScore(0,87);students[i].setCourseScore(1,90);students[i].setCourseScore(2,78);}for (int i=0; i<5 ;i++) {students[i].calculateGrade();}System.out.println("姓名" + " 类型" +" 成绩");System.out.println("-----------------------");for (int i=0; i<5 ;i++) {System.out.println(students[i].getName( )+" "+students[i].getType( )+" "+students[i].getCourseGrade( ));}}}实验内容⼆1.建⽴package experiment5_2，其最终⽬录结构如下：2.写接⼝Soundable代码：package experiment5_2;public interface Soundable {public void increaseV olume( );public void decreaseV olume( );public void stopSound( );public void playSound( );}3.创建三个类Radio、Walkman和Mobilephone具体实现，分别添加代码：// Mobilephone类package experiment5_2;class Mobilephone implements Soundable{public void increaseV olume( ) {System.out.println("增⼤⼿机⾳量");}public void decreaseV olume( ) {System.out.println("减⼩⼿机⾳量");}public void stopSound( ) {System.out.println("关闭⼿机");}public void playSound( ) {System.out.println("⼿机发出来电铃声");}}// Walkman类package experiment5_2;class Walkman implements Soundable { public void increaseV olume( ) { System.out.println("增⼤随声听⾳量"); }public void decreaseV olume( ) { System.out.println("减⼩随声听⾳量"); }public void stopSound( ) {System.out.println("关闭随声听");}public void playSound( ) {System.out.println("随声听发出⾳乐"); }}// Radio类package experiment5_2;class Radio implements Soundable{ public void increaseV olume( ) { System.out.println("增⼤收⾳机⾳量"); }public void decreaseV olume( ) { System.out.println("减⼩收⾳机⾳量"); }public void stopSound( ) {System.out.println("关闭收⾳机");}public void playSound( ) {System.out.println("收⾳机播放⼴播"); }}4.创建people类及编写测试代码：//People类package experiment5_2;class People {public void listen(Soundable s) {s.playSound( );}}//测试代码package experiment5_2;import java.util.Scanner;public class InterfaceTest {public static void main(String[] args) {int i;People sportsman = new People( );Scanner scanner = new Scanner(System.in);Soundable[] soundDevice = new Soundable[3];//往声⾳设备数组中放⼊能发声的设备soundDevice[0] = new Radio( );soundDevice[1] = new Walkman( );soundDevice[2] = new Mobilephone();System.out.println("你想听什么? 请输⼊选择：0-收⾳机1-随声听2-⼿机");i = scanner.nextInt( );//开始听声⾳sportsman.listen(soundDevice[i]);soundDevice[i].increaseV olume( );soundDevice[i].stopSound();scanner.close();}}实验内容三1.建⽴package experiment5_3，其最终⽬录结构如下package experiment5_3;import java.awt.*;import java.awt.event.*;import javax.swing.*;public class DateTransf extends JFrame implements KeyListener{/****/private static final long serialVersionUID = 1L;private static DateTransf frm;private static JTextField txt;private static JTextField data;DateTransf() {setTitle("数字与星期转换");setLocation(700, 300);setSize(400,130);}public static void main(String[] args) {frm = new DateTransf();frm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);frm.setLayout(new GridLayout(2,2));txt = new JTextField(12);data = new JTextField(12);JLabel lable1 = new JLabel("输⼊数字:");JLabel lable2 = new JLabel("星期⼏:");frm.add(lable1);txt.addKeyListener(frm);frm.add(txt);frm.add(lable2);frm.add(data);frm.setVisible(true);}public void keyPressed(KeyEvent e) {if (e.getSource() == txt) {if (e.getKeyCode() == KeyEvent.VK_ENTER) // 判断按下的键是否是回车键{try {int number = Integer.parseInt(txt.getText());switch (number) {case 1:data.setText("Mon");break;case 2:data.setText("Tue");break;case 3:data.setText("Wen");break;case 4:data.setText("Thu");break;case 5:data.setText("Fri");break;case 6:data.setText("Sat");break;case 7:data.setText("Sun");break;default:JOptionPane.showMessageDialog(null, "您输⼊的数字不是1~7","⽆效⽇期",/doc/1bd4a299a66e58fafab069dc5022aaea998f41e2.html RMATION_MESSAGE); break;}}catch (Exception e1) {// TODO: handle exceptionJOptionPane.showMessageDialog(null, "您输⼊的不是整数","⽆效⽇期",/doc/1bd4a299a66e58fafab069dc5022aaea998f41e2.html RMA TION_MESSAGE); }}}}public void keyReleased(KeyEvent e) {}public void keyTyped(KeyEvent e) {}}2.编译运⾏五、实验结果●实验内容⼀结果：●实验内容⼆结果：●实验内容三结果：六、实验⼩结1.这次实验的内容⽐较多，需要掌握Java的类和对象的声明和使⽤⽅法、Java的类的继承和实现⽅法、多态性在类的继承中的运⽤、接⼝的定义与使⽤、基本异常的处理机制、try语句与catch语句的搭配使⽤等等；2. 在实验过程中，重点是要区分好实例和类，灵活掌握类的调⽤。

实验报告实验课程： 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 speed;int bulletAmount;void speedUp(int s){speed=s+speed;}void speedDown(int d){if(speed-d>=0)speed=speed-d;elsespeed=0;}void setBulletAmount(int m){bulletAmount=m;}int getBulletAmount(){return bulletAmount;}double getSpeed(){return speed;}void fire(){if(bulletAmount>=1){bulletAmount=bulletAmount-1;System.out.println("打出一发炮弹");}else{System.out.println("没有炮弹了，无法开火");}}}package p1;public class Fight {public static void main(String args[]){Tank tank1,tank2;tank1=new Tank();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();图3：可看出tank2被清零实验2：计算机与光盘1、程序源代码：package p1;public class CD {int size;int content[];public void setSize(int size){this.size=size;content=new int[size];}public int getSize(){return size;}public int []getContent(){return content;}public void setContent(int [] b){int min=Math.min(content.length,b.length);for(int i=0;i<min;i++)content[i]=b[i];}}package p1;public class Computer {int data[];CD includeCD;public void putCD(CD cd){includeCD=cd;int size=includeCD.getSize();data=new int[size];}void copyToComputer(){int []b=includeCD.getContent();int min=Math.min(data.length,b.length);for(int i=0;i<min;i++)data[i]=b[i];}public void addData(int m){for(int i=0;i<data.length;i++){data[i]=data[i]+m;}}void copyToCD(){includeCD.setContent(data);}void showData(){for(int i=0;i<data.length;i++){System.out.printf("%3d",data[i]);}}}package p1;public class User {public static void main(String args[]){ CD dataCD=new CD();int b[]={1,2,3,4,5,6,7,8};dataCD.setSize(b.length);dataCD.setContent(b);int a[]=dataCD.getContent();System.out.println("dataCD上的内容：");for(int i=0;i<a.length;i++)System.out.printf("%3d",a[i]);Computer computerIMB=new Computer();computerIMB.putCD(dataCD);System.out.println("\n将dataCD的数据复制到计算机：computerIMB");computerIMB.copyToComputer();System.out.println("\ncomputerIMB上的内容：");computerIMB.showData();int m=12;System.out.println("\ncomputerIMB将每个数据增加"+m);computerIMB.addData(m);System.out.println("computerIMB将增值后的数据复制到CD：dataCD");computerIMB.copyToCD();System.out.println("dataCD上的内容：");a=dataCD.getContent();for(int i=0;i<a.length;i++)System.out.printf("%3d",a[i]);}}2、实验结果：图42、实验课后练习：主类中再添加一个CD的对象，然后将计算机中的数据（data数组）复制到CD对象中。

实验二Java类编程实验实验目的1．掌握Java类的基本定义和使用方法2．熟悉Java语言的基本语法和运行原理3．掌握Java的基本数据类型、表达式和程序控制结构4．熟悉Eclipse开发环境的基本使用方法实验内容1. 对象的创建和使用使用集成开发环境编写一个圆环类Ring的Java程序。

圆环类有3个数据成员，分别是内半径innerRadius，外半径outerRadius和颜色color，这些属性通过get和set方法进行封装。

另外，圆环类中的getArea方法可以返回其面积。

把程序中的代码补充完整，并查看结果。

public class Ring {private double innerRadius;private double outerRadius;private String color;public Ring(double iRadius, double oRadius, String c) { //初始化数据成员}//用get和set方法封装数据成员public double getArea() {}public static void main(String[] args) {Ring ring = new Ring(5,8,"red");System.out.println("圆环的内半径: " +ring.getInnerRadius( ));System.out.println("圆环的外半径: " + ring.getOuterRadius( ));System.out.println("圆环的颜色: " + ring.color);System.out.println("圆环的面积: " + ring.getArea() + "\n");ring.setInnerRadius(4);//设置圆环ring的外半径为6ring.setColor("blue");System.out.println("圆环的内半径: " + ring.getInnerRadius( ));System.out.println("圆环的外半径: " + ring.getOuterRadius( ));System.out.println("圆环的颜色: " + ring.color);System.out.println("圆环的面积: " + ring.getArea());}}思考：1)将程序中的语句Ring ring = new Ring(5,8,"red"); 改成Ring ring = newRing();修改后编译运行，此时有错误发生吗？分析错误的原因。

封装、继承和多态的概念
封装、继承和多态是面向对象编程中的三个重要概念，下面分别进行详细解释：
一、封装
封装是指将对象的属性和方法封装在一起，形成一个独立的单元，对外部隐藏对象的实现细节，只暴露必要的接口供外部使用。

封装可以有效地保护对象的数据和行为，避免外部的误操作和非法访问，提高了代码的安全性和可维护性。

在面向对象编程中，封装是实现信息隐藏和数据保护的重要手段。

二、继承
继承是指一个类可以从另一个类中继承属性和方法，从而可以重用已有的代码和功能。

继承是面向对象编程中实现代码复用的重要手段，可以减少代码的重复性，提高代码的可读性和可维护性。

继承可以分为单继承和多继承两种方式，单继承是指一个类只能从一个父类中继承，而多继承是指一个类可以从多个父类中继承属性和方法。

三、多态
多态是指同一个方法在不同的对象上可以有不同的行为，即同一个方法可以有多
种不同的实现方式。

多态是面向对象编程中的重要概念，可以提高代码的灵活性和可扩展性。

多态可以分为编译时多态和运行时多态两种方式，编译时多态是指方法的重载，即同一个类中可以有多个同名但参数不同的方法；而运行时多态是指方法的重写，即子类可以重写父类的方法，从而实现不同的行为。

通过多态，可以实现面向对象编程中的“开闭原则”，即对扩展开放，对修改关闭。

java类的继承实验报告Java类的继承实验报告引言：在面向对象的编程语言中，继承是一种重要的概念。

Java作为一种面向对象的编程语言，也提供了类的继承机制。

本实验旨在通过编写Java程序，深入理解和掌握Java类的继承。

实验目的：1. 理解继承的概念和原理；2. 掌握Java中类的继承的语法和用法；3. 实践继承的实际应用。

实验过程：1. 创建父类和子类在实验中，我们首先创建一个父类和一个子类。

父类可以是一个基本的类，子类则继承了父类的属性和方法。

这样，子类就可以在不改变父类的基础上，扩展自己的功能。

2. 继承的语法和用法Java中，使用关键字"extends"来实现类的继承。

子类通过继承父类，可以获得父类的属性和方法，并且可以在子类中添加新的属性和方法。

在实验中，我们可以通过创建子类对象，并调用继承自父类的方法来验证继承的正确性。

3. 方法的重写在继承中，子类可以重写父类的方法。

这样，当子类调用该方法时，实际上执行的是子类重写后的方法。

通过方法的重写，我们可以实现多态性的效果。

4. 实际应用在实验中，我们可以选择一个具体的应用场景，例如动物类的继承。

我们可以创建一个父类Animal，包含基本的属性和方法，然后创建子类Dog和Cat，分别继承Animal类，并添加自己的特有属性和方法。

通过这个实例，我们可以更好地理解继承的实际应用。

实验结果：通过实验，我们成功地创建了父类和子类，并验证了继承的正确性。

我们还成功地重写了父类的方法，实现了多态性的效果。

最后，我们还通过实际应用的例子，更好地理解了继承的实际应用。

实验总结：通过本次实验，我们深入理解和掌握了Java类的继承。

继承是面向对象编程中的重要概念，通过继承，我们可以实现代码的重用和扩展。

在实际应用中，继承也可以帮助我们更好地组织代码，提高代码的可读性和可维护性。

然而，继承也有一些限制和注意事项。

首先，Java中只支持单继承，即一个子类只能继承一个父类。

java面向对象实验报告《Java面向对象实验报告》摘要：本实验报告旨在探讨Java面向对象编程的基本概念和实践方法。

通过实验，我们将学习如何创建类、对象、封装、继承和多态等面向对象的特性，并通过实际代码演示这些概念的应用。

本报告将详细介绍实验过程和结果，并总结所得到的经验和教训。

一、实验目的1. 了解面向对象编程的基本概念和原则2. 掌握Java语言中类、对象、封装、继承和多态的使用方法3. 通过实验加深对面向对象编程的理解和掌握二、实验环境1. Java开发环境：Eclipse/IntelliJ IDEA等2. Java SDK版本：1.8及以上三、实验内容1. 创建一个简单的Java类2. 创建对象并调用对象方法3. 实现类的封装和访问控制4. 实现类的继承和方法重写5. 实现类的多态四、实验步骤1. 创建一个名为Person的Java类，包含姓名和年龄两个私有属性，并提供公有的get和set方法进行访问和修改。

2. 创建一个名为Student的子类，继承Person类，并重写父类的get方法。

3. 创建一个名为Teacher的子类，继承Person类，并重写父类的get方法。

4. 创建一个名为Main的主类，实例化Person、Student和Teacher对象，并调用其方法进行测试。

五、实验结果1. 成功创建了Person、Student和Teacher三个类，并实现了类的封装、继承和多态。

2. 通过测试，验证了类的封装和访问控制的有效性。

3. 通过测试，验证了类的继承和方法重写的有效性。

4. 通过测试，验证了类的多态的有效性。

六、实验总结通过本次实验，我深刻理解了面向对象编程的重要性和优势，掌握了Java语言中面向对象编程的基本概念和实践方法。

在今后的学习和工作中，我将继续加强对面向对象编程的理解和应用，不断提高自己的编程水平。

七、实验感想通过本次实验，我对Java面向对象编程有了更深入的了解，也更加熟练地掌握了面向对象编程的基本概念和实践方法。

java的封装，继承和多态类和对象类类声明 { 成员变量的声明； 成员方法的声明及实现； }声明类：[修饰符] class 类<泛型> [extends 父类] [implements 接口列表]声明成员变量：[修饰符]数据类型 变量[=表达式]{,变量[=表达式]}成员方法声明：[修饰符]返回值类型 方法（[形式参数列表]）[throws 异常类列表]{语句序列；[return[返回值]]； }重载：一个类中可以有多个同名的成员方法，前提是参数列表不同，称为类的成员方法重载，重载的多个方法为一种功能提供多种实现。

重载方法之间必须以不同的参数列表（数据类型、参数个数、参数次序）来区别。

例如，MyDate 类可声明多个重载的set()方法如下: void set(int y,int m, int d)void set(int m, int d) //重载方法，参数个数不同void set(int d) void set(MyDate date)//重载方法，参数的数据类型不同对象对象声明：类 对象构造实例：对象 = new 类的构造方法（[实际参数列表]）引用对象的成员变量和调用成员方法：对象.成员变量 对象.成员方法([实际参数列表])类的封装性构造与析构类的构造方法用于创建类的一个实例并对实例的成员变量进行初始化一个类可声明多个构造方法对成员变量进行不同需求的初始化，构造方法不需要写返回值类型，因为它返回的就是该类的一个实例。

例：MyDate类声明以下构造方法:public MyDate(int year, int month, int day)// 声明构造方法，方法名同类名，初始化成员变量 {set(year, month day);// 调用 set()方法，为成员变量赋值}使用new运算符调用指定类的构造方法，实际参数列表必须符合构造方法声明。

例如:MyDate d1 = new MyDate(2017,10,1);//创建实例并初始化成员变量当一个类没有声明构造方法时，Java 自动为该类提供一个无参数的默认构造方法对象的引用与运算this引用访问本类的成员变量和成员方法：this.成员变量，this.成员方法([实际参数列表])调用本类重载的构造方法：this([实际参数列表])访问控制类的访问控制权限公有和(public)和缺省类中成员4级访问控制权限及范围声明set()和get()方法存取对象的属性例：public void set(int year, int month, int day) //设置日期值 public void set(MyDate date)//设置日期值，重载 public int getYear()//获得年份 public int getMonth()// 获得月份 public int getDay()//获得当月日期静态成员定义及访问格式使用关键字static声明的成员称为静态成员在类内部，可直接访问静态成员，省略类名。

Java程序设计实验报告一．实验要求1．实验一：Java程序的编辑、编译和运行（1）了解java语言特点，掌握JDK环境中编译、运行程序的操作。

（2）熟悉EditPlus编辑器的使用。

（3）掌握Java Application的程序结构和开发过程。

（4）了解Java程序文件名和类名的说明方法。

2.实验二：Java程序设计基础（1）了解Java 的数据类型；（2）掌握各种变量的声明方式；（3）理解运算符的优先级；（4）掌握Java 基本数据类型、运算符与表达式、数组的使用方法；（5）理解Java 程序语法结构，掌握顺序结构、选择结构和循环结构语法的程序设计方法；（6）熟练掌握数组的使用（7）通过以上内容，掌握Java 语言的编程规则。

3.实验三：类的封装性设计（1）掌握从实体中抽象类与对象的方法（2）掌握定义类、创建对象、使用类与对象（3）掌握类及其成员的修饰符的使用（4）掌握构造函数的使用。

4.实验四：类的继承性与多态设计（1）掌握类的继承机制（2）熟悉类中成员的访问控制（3）掌握方法的多态性5.实验五：Applet小程序图形用户界面设计（1）掌握Java 的GUI 设计技术，（2）掌握AWT 和Swing 的应用技巧。

（3）掌握布局管理器（4）掌握事件处理的方法。

（5）掌握Java小程序的特点和编写方法。

二．实验内容1.实验一：java程序的编辑、编译和运行。

（1）使用EditPlus编写源程序（2）编写两个Java Application程序（A）输出一行文字“Hello,JAVA!”用消息对话框显示文本信息。

（B）找出教材复习题1.16中程序的错误，上机调试验证、修改得出正确输出结果。

A．错误程序public class Wlecome{public void Main(string[] args){System,out.println("Welcome to Java!);}}B.修改后程序public class Wlecome{public static void main(String[] args){System.out.println("Welcome to Java!");}}C.运行结果2实验二：分别使用while、do-while和for语句编程，找出所有的水仙花数并输出。

实验报告课程名称 Java技术专业班级 13-计算机科学与技术-1班学生姓名及学号 98 潘汀指导教师钟华刚实验地点计算中心2015 ～ 2016 学年第一学期实验一类的封装、继承、多态一、实验目的1．复习、理解OOP的特征——封装、继承和多态。

2．学会使用Java编写简单的类。

理解类的属性和方法。

3．掌握关键字private, protected, public的作用。

4．掌握多态的概念。

二、实验内容1．分别编写两个类Point2D，Point3D来表示二维空间和三维空间的点，使之满足下列要求：（1） Point2D有两个整型成员变量x, y (分别为二维空间的X,Y方向坐标)，Point2D的构造方法要实现对其成员变量x, y的初始化。

（2） Point2D有一个void型成员方法offset(int a, int b)，它可以实现Point2D的平移。

（3） Point3D是Point2D的直接子类，它有有三个整型成员变量x,y,z (分别为三维空间的X,Y,Z方向坐标)，Point3D有两个构造方法：Point3D(int x,int y,int z)和Point3D(Point2D p,int z)，两者均可实现对Point3D的成员变量x, y,z的初始化。

（4） Point3D有一个void型成员方法offset(int a, int b,int c)，该方法可以实现Point3D的平移。

（5）在Point3D中的主函数main()中实例化两个Point2D的对象p2d1，p2d2，打印出它们之间的距离，再实例化两个Point3D的对象p3d1，p3d2，打印出他们之间的距离。

提示：方法2．创建一个数组，随机生成Point2D或者Point3D的对象放于其中。

最后依次调用数组中每个对象的“打印方法”，显示数组中存储的对象是什么。

提示：方法或者类三、实验代码四、思考题1．你对面向对象的理解。

Java中封装、继承、多态的理解Java中的继承、封装、多态继承的理解：1、继承是⾯向对象的三⼤特征之⼀，也是实现代码复⽤的重要⼿段。

Java的继承具有单继承的特点，每个⼦类只有⼀个直接⽗类。

2、Java的继承通过extends关键字来实现，实现继承的类被称为⼦类，被继承的类称为⽗类(有的也称其为基类、超类)，⽗类和⼦类的关系，是⼀种⼀般和特殊的关系。

就像是⽔果和苹果的关系，苹果继承了⽔果，苹果是⽔果的⼦类，⽔果是苹果的⽗类，则苹果是⼀种特殊的⽔果。

3、Java使⽤extends作为继承的关键字，extends关键字在英⽂是扩展的意思，⽽不是继承。

为什么国内把extends翻译成继承呢？除了与历史原因有关外，把extends翻译成为继承也是有其道理的：⼦类扩展⽗类，将可以获得⽗类的全部属性和⽅法，这与汉语中得继承（⼦辈从⽗辈那⾥获得⼀笔财富成为继承）具有很好的类似性。

值得指出的是：Java的⼦类不能获得⽗类的构造器。

4、实例：class BaseClass{public double weight;public void info() {System.out.println("我的体重是"+weight+"千克");}}public class ExtendsDemo001 extends BaseClass {public static void main(String[] args) {//创建ExtendsDemo001对象ExtendsDemo001 ed = new ExtendsDemo001();//ExtendsDemo001本⾝没有weight属性，但是ExtendsDemo001的⽗类有weight属性，也可以访问ExtendsDemo001对象的属性ed.weight = 56;//调⽤ExtendsDemo001对象的info()⽅法();}}打印结果为：我的体重是56.0千克5、Java类只能有⼀个⽗类。

java类的继承实验总结
在Java中，类的继承是面向对象编程的重要特性之一。

通过继承，子类可以从父类继承属性和方法，从而实现代码复用和层次化设计。

在实验过程中，我深入学习了Java的继承机制，总结了以下几点经验：
1. 子类可以继承父类的非私有属性和方法，可以重写父类的方法。

在重写方法时，要遵循Liskov替换原则，确保子类可以替换掉父类。

2. Java中只支持单继承。

利用接口可以实现多重继承的效果。

3. super关键字可以访问父类的属性和方法，也可以调用父类的构造方法。

4. 父类的构造方法会被自动调用，如果没有显式地调用super()，则会默认调用父类的无参构造方法。

如果父类没有无参构造方法，则需在子类中显式调用super()并传入相应的参数。

5. 子类构造方法中的第一行可以调用super()，也可以调用this()。

但是二者不能同时出现。

6. 父类和子类的引用可以相互转换，但是只能通过向上转型实现。

在向上转型时，子类的特有属性和方法会被隐藏。

通过这次实验，我更深刻地理解了Java的继承机制，并掌握了其在面向对象设计中的重要作用。

在今后的Java开发中，我将充分利用继承的优势，编写出更加优雅和高效的代码。

Java语言程序设计实验指导书目录实验一 JDK的安装和运行环境变量的设置 (3)实验二 JA V A语言基础实验 (3)实验三 JA V A面向对象特性实验 (5)实验四 Java输入输出实验 (6)实验五基于AWT及SWING的GUI及事件处理实验 (8)实验六Applet (11)附录Ⅰ (14)附录Ⅱ (15)实验一 JDK的安装和运行环境变量的设置实验目的1．通过实验使学生掌握J2SDK安装和运行环境设置。

2．掌握java最简单的程序结构，会使用javac和java命令。

实验内容1．下载j2sdk1.4.2。

在网站的download链接中选择J2SE1.4.2链接，选择j2sdk-1.4.2-04-windows-i586.exe下载。

2．安装该程序。

默认安装路径为c:\jdk1.4.2。

3．设置环境变量。

主要有path和classpath两个环境变量需设置。

在windows98中的设置方式为：使用记事本打开autoexec.bat文件，加入：SET PA TH=%PATH%;c:\jdk1.4.2\binSET CLASSPATH=.; c:\jdk1.4.2\lib在windows2000按如下方法设置：进入“控制面板”->“系统”->“高级”->“环境变量”->“系统变量”后，双击path，在后面添加：c:\jdk1.4.2\bin，双击classpath，在后面添加：c:\jdk1.4.2\lib。

重新启动系统。

4、编写一个输出“这是我的第一个JA V A程序”程序。

5、示例程序：public class HelloWorld{public static void main(String [ ] args){System.out.println(“Hello World”);}}在记事本中编写该程序，并保存为d:\my\HelloWorld.java。

运行过程为：进入dos环境，切换到保存路径，然后在命令行中输入下列命令：javac HelloWorld.java编译通过后，在命令行中输入下面的命令java HelloWorld运行结果应该为：Hello World实验二 JA V A语言基础实验实验目的1．通过实验使学生掌握JA V A变量、标识符以及语法规则。

一、摘要随着Java编程语言的广泛应用，类与类之间的关系成为程序设计中一个重要的概念。

本实验旨在通过实际操作，探究Java中类与类之间的各种关系，包括继承、组合和聚合等。

通过实验，加深对面向对象编程思想的理解，提高编程能力。

二、实验目的1. 掌握Java中类与类之间关系的概念。

2. 了解继承、组合和聚合等类关系的特点。

3. 学会使用类关系实现实际编程问题。

三、实验原理在Java中，类与类之间的关系主要有以下几种：1. 继承：子类继承父类的属性和方法，使得子类具有父类的功能，并在此基础上进行扩展。

2. 组合：一个类包含另一个类的对象，组合关系体现为“整体与部分”的关系。

3. 聚合：与组合类似，但部分类可以独立存在，聚合关系体现为“整体与部分”的松散关系。

四、实验步骤1. 创建父类：定义一个名为“Animal”的父类，包含属性“name”和“age”，以及方法“eat()”和“sleep()”。

```javapublic class Animal {private String name;private int age;public Animal(String name, int age) { = name;this.age = age;}public void eat() {System.out.println(name + " is eating.");}public void sleep() {System.out.println(name + " is sleeping.");}}```2. 创建子类：定义一个名为“Dog”的子类，继承自“Animal”类，并添加一个方法“wang()”。

```javapublic class Dog extends Animal {public Dog(String name, int age) {super(name, age);}public void wang() {System.out.println(name + " is barking.");}}```3. 创建组合关系：定义一个名为“Person”的类，包含一个“Dog”类型的对象。