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程序，熟悉了Java的基本语法和标准输入
输出的操作。
我了解了Java的数据类型和运算符，并能够使用if语句和循环结构来实现
程序逻辑。
通过这个实验，我掌握了基本的程序设计能力。
在实验二中，我学习了面向对象的编程思想，并通过编写一个学生管理系统来实践。
我定义了一个Student类，使用封装来隐藏内部细节，并定义了一些方法来实现对学生对
象的操作。
我还使用继承来创建了一个Teacher类，体会到了面向对象编程中的继承和多
态的概念。
通过这个实验，我进一步提高了程序设计的能力。
在实验三中，我学习了异常处理的方法，并通过编写一个简单的图书管理系统来实践。
在程序中，我使用try-catch语句来捕获和处理异常，保证程序的健壮性。
通过这个实验，我对异常处理有了更深入的理解。
在实验四中，我学习了Java中的线程编程，并通过编写一个简单的多线程程序来实践。
在程序中，我使用了Thread类和Runnable接口来创建线程，并学会了如何控制线程的执
行顺序和共享数据。
通过这个实验，我对多线程编程有了初步的了解。
通过这些实验，我对Java语言有了更深入的了解，并提高了自己的编程能力。
在今后的学习和工作中，我将继续学习和实践，提高自己的编程水平。
java实验报告——继承与接口
System.out.print('\t'+"平均分");
System.out.println('\t'+"成绩等级");
for(int i=0; i<pg.length;i++) {
System.out.print(pg[i].Name); System.out.print('\t'+pg[i].Stu_type); System.out.print('\t'+String.valueOf(pg[i].C_score)); System.out.print('\t'+String.valueOf(pg[i].English_score)); System.out.print('\t'+String.valueOf(pg[i].Java_score)); System.out.print('\t'+String.valueOf(pg[i].score)); System.out.println('\t'+pg[i].sco_Level); } System.out.println(); } }
String Name=""; String Stu_type=""; int C_score; int English_score; int Java_score; int score; // String sco_Level=""; Sco_Level sco_Level;
public Student(String name,String stu_type,int sco1,int sco2,int sco3) {
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实验报告继承、多态、接⼝和异常处理实验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实验类与继承
实验报告实验课程： 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类编程实验
实验二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();修改后编译运行，此时有错误发生吗？分析错误的原因。
封装、继承和多态的概念
封装、继承和多态的概念
封装、继承和多态是面向对象编程中的三个重要概念，下面分别进行详细解释：
一、封装
封装是指将对象的属性和方法封装在一起，形成一个独立的单元，对外部隐藏对象的实现细节，只暴露必要的接口供外部使用。
封装可以有效地保护对象的数据和行为，避免外部的误操作和非法访问，提高了代码的安全性和可维护性。
在面向对象编程中，封装是实现信息隐藏和数据保护的重要手段。
二、继承
继承是指一个类可以从另一个类中继承属性和方法，从而可以重用已有的代码和功能。
继承是面向对象编程中实现代码复用的重要手段，可以减少代码的重复性，提高代码的可读性和可维护性。
继承可以分为单继承和多继承两种方式，单继承是指一个类只能从一个父类中继承，而多继承是指一个类可以从多个父类中继承属性和方法。
三、多态
多态是指同一个方法在不同的对象上可以有不同的行为，即同一个方法可以有多
种不同的实现方式。
多态是面向对象编程中的重要概念，可以提高代码的灵活性和可扩展性。
多态可以分为编译时多态和运行时多态两种方式，编译时多态是指方法的重载，即同一个类中可以有多个同名但参数不同的方法；而运行时多态是指方法的重写，即子类可以重写父类的方法，从而实现不同的行为。
通过多态，可以实现面向对象编程中的“开闭原则”，即对扩展开放，对修改关闭。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
课程名称：JAVA 程序设计
姓名
学号
设备名称及软件环境
实验名称 一．实验内容
类的继承和封装
班级
Eclipse 实验日期
成绩 2013-4-11
掌握类的定义，类的继承，及相关语法规则，掌握对类成员的使用，理解类的封装。
二．重点及难点
类的继承及相关语法规则，理解类的封装。
三．理论分析或算法分析
1
四．实现方法（含实现思路、程序流程图和源程序列表等） 1. final修饰符 //public class c4_6 extends P1 //错，用final修饰的类P1不能有继承类 public class ຫໍສະໝຸດ 4_6 extends Applet{
/** * final修饰符 */ public void paint(Graphics g){
P1 n=new P1(); n.f(g); n.i=40; n.j++; g.drawString("i+"+n.i, 20,70); g.drawString("j="+n.j, 20, 90); } } final class P1{//用final修饰的类P1 int i=7; int j=1; void f(Graphics g){ g.drawString("OK", 20, 50); } } 2. 形式参数与实际参数 public class c4_12 { /** * 形式参数与实际参数 */ public static void main(String[] args){ int a=2,b=7; double f1=2,f2=4,f3; add(a,b); System.out.println("a="+a+"\tb="+b); //f3=add1(f1,f2,3.5); //错，实参与形参的参数个数不一致 f3=2+add1(f1,f2); System.out.println("f1="+f1+"\tf2="+f2+"\tf3="+f3); } public static void add(double x,double y){ double z; z=x+y; System.out.println("z="+z); x=x+3.2; y=y+1.2; System.out.println("x="+x+"\ty="+y); }
1. final修饰符 用 final 修饰符修饰的类被称为最终类。最终类不能被任何其他类所继承。定义最终类
的目的有三： （1）用来完成某种标准功能； （2）提高程序的可读性； （3）提高安全性。
2. 形式参数与实际参数 一般来说，可通过如下的格式来引用成员方法： 成员方法名（实参列表） 引用时应注意以下几个重要问题： （1）引用无参的成员方法时方法名后的括弧不能省略； （2）实参的个数、顺序和数据类型必须与形式参数保持一致； （3）实参也可以是表达式，此时要注意数据类型的一致性； （4）只能由实参传递给形参，而不能有形参传递给实参。
3
五．实验结果分析（含执行结果验证、输出显示信息、图形、调试过程中所遇的问题及处理方法等）
六．结论
用 final 修饰符修饰某些重要的类可以提高程序的安全性，调用方法时要注意参数的类 型和个数，重写父类方法可以将子类和父类的共同属性和方法体现出来，提高程序代码的 可读性。
报告提交日期
2013-4-16
4
a1 p2=new a1(); c5_9 p1=new c5_9(); p1.Printme(); p2.Printme(); } public void Printme(){ System.out.println("z="+z); } } class a1{ int x=10; int y=31; public void Printme(){ System.out.println("x="+x+" y"+y); } }
3. 成员方法的覆盖（overload） 子类可重新定义与父类同名的成员方法，实现对父类方法的覆盖。方法的覆盖与数据
成员的隐藏的不同之处在于：子类隐藏父类的数据成员只是使之不可见，父类同名的数据 成员在子类对象中仍然占有自己独立的内存空间；子类方法对父类同名方法的覆盖将清除 父类方法占用的内存，从而使父类方法在子类对象中不复存在。
2
public static double add1(double y1,double y2){ double z; z=y1+y2+2.9; return z;
} } 3. 成员方法的覆盖（overload） public class c5_9 extends a1{
int z=35; /** * 成员方法的覆盖（overload） */ public static void main(String[] args) {