第5章类的继承、包及接口
在前一章的实验中已经了解了类的基本构成、对象的创建及重载方法的应用等。本章实验的任务主要是了解Java中类的继承、类包、内部类、匿名类及接口的基本构成及应用。
5.1 实验一：类的继承
1. 实验目的
1）正确理解Java中类继承基本概念及思想；
2）基本掌握继承类和被继承类（子类和父类）之间的关系，正确地创建继承类。
2. 实验要求
正确地划分类，根据类之间的关系，确定父类和子类，掌握覆盖方法的应用，完成类程序的编写与调试。
3. 实验内容
在上一章的实验中，建立了公司职员信息类，现在需要处理职员的工资信息，建立职员工资类。
实验示例5.1.1 创建职员工资类Payroll类。
实现该示例的方法步骤如下：
⑴首先分析一下该类的构成
工资信息应包括职工的基本信息，因此可以把Employers类作为Payroll类的父类，Payroll类继承了父类所有的成员变量和方法，因此在Payroll类中需要定义的内容是：
①成员变量
对于工资信息项应该包括basicWage(基本工资)、positionWage(职位工资)、extraWage(附加工资)、other(其他补贴)等等。它们均可声明为int (整数类型)。
②成员方法
常常需要显示或获得全部或某些项工资的信息，因此需要定义如下一些方法：
display() 显示工资的全部信息；
display(int value) 显示一项工资额；
display(int value1, int value2) 显示两项工资额。
③构造方法
如前所述，一个类能够有多个构造对象方法，视需要而定。对Payroll类来说可以给出两个构造方法：
Payroll () 构造无名对象；
Payroll(String ID,String name,String sex,String birthday,String home,String address, String number,int basicWage,int positionWage,int extraWage,int other) 构造一般对象。
⑵根据上边分析和描述，按照类的构成，给出如下类程序代码：
public class Payroll extends Employers
{
int basicWage; //定义基本工资
int positionWage; //定义职位工资
int extraWage; //定义附加工资
int other; //定义其他项
public void display() //显示信息方法
{
super.display(); //引用父类的display()方法
System.out.println("基本工资："+basicWage);
System.out.println("职位工资："+positionWage);
System.out.println("附加工资："+extraWage);
System.out.println("其他项："+other);
System.out.println("工资总额："+(basicWage+positionWage+extraWage+ other));
} //显示所有信息方法结束
public void display(int value1) //显示一项工资额
{
System.out.println("工号:"+this.number+" 该项工资额:"+value1);
} //显示一项工资额方法结束
public void display(int value1,int value2) //显示两项工资额
{
System.out.println("工号:"+this.number+" 两项工资额分别是:"+value1+"、"+value2);
} //显示两项工资额方法结束
public Payroll() //构造方法
{
super();//引用父类的构造方法
basicWage=0;
positionWage=0;
extraWage=0;
other=0;
} //无参构造方法结束
public Payroll(String number,String name,String sex,String birthday,String home,String address,String ID,int basicWage,int positionWage,int extraWage,int other)//构造方法
{
super(number,name,sex,birthday,home,address,ID);//引用父类的构造方法
this.basicWage=basicWage;
this.positionWage=positionWage;
this.extraWage=extraWage;
this.birthday=birthday;
this.other=other;
} //有参构造方法结束
}
⑶在完成了公用类（public）Payroll源程序文件Payroll.java的建立之后,编译它生成类文件（.class字节码文件），以便在应用程序中使用它。
⑷程序分析
该类是Employers类的子类，在程序中，覆盖（重写）了父类中的一些方法（如display()等），并使用super关键词引用父类方法。要注意在使用super引用父类成员方法和构造方法的区别。
在完成上边的实验之后，请认真阅读、理解程序，仿照上边的程序，完成下边的自由练习。
自由练习5.1以上一章自由练习中建立的学生信息类Students为父类，建立一个学生学期的成绩单类Results，可以包含7～10项成绩，并包含可显示若干项成绩的方法。
实验示例5.1.2 测试Payroll类，编写测试程序TestPayroll.java,创建Payroll对象，显示职员对象工资的相关信息。
完成该示例的方法步骤如下：
⑴这是一个测试Payroll类的程序，在测试程序中，我们需要创建Payroll类的对象，然后分别执行对象的各个方法，以测试类的功能。
⑵根据示例题目的要求，可给出如下的程序代码：
public class TestPayroll
{
public static void main(String [] args)
{
/* 首先创建一个无名和有名对象，测试两个构造方法*/
Payroll e1=new Payroll();
Payroll e2=new Payroll("0110","孙仁","男", "1988.10.15","重庆","航海路21号","422401************",600,500,400,200);
/*测试对象的成员方法*/
System.out.println("-------无名对象----------");
e1.display();
System.out.println("-------有名对象----------");
e2.display();
https://www.doczj.com/doc/049695792.html,="力士靓"; //修改无名对象的名字
e1.sex="女"; //修改无名对象的性别
e1.birthday="1989.12.30"; //修改无名对象的生日
e1.number="0111"; //修改无名对象的职员号
e1.basicWage=500; //修改无名对象的基本工资
System.out.println("--------"+https://www.doczj.com/doc/049695792.html,+"的基本工资-------");
e1.display(e1.basicWage);
System.out.println("--------"+https://www.doczj.com/doc/049695792.html,+"的基本工资、职位工资-------");
e2.display(e2.basicWage,e2.positionWage);
}
}
⑶编译并运行程序，程序执行结果如错误！未找到引用源。所示。
图5-1 示例5.1.2程序执行结果 ⑷ 程序及执行结果分析与思考
在程序中以创建无名对象和有名对象队两个构
造方法的功能进行了测试，对无名对象的部分属性
(name 、sex 等）进行了赋值处理，然后对显示一项
工资额和显示两项工资额的方法进行了测试。
需要注意的是，在方法引用中参数是一一对应
的，其相应的类型必须一致，否则在编译时将会出
现编译错误。
在程序中创建了Payroll 对象，好像并没有涉及
Employers 对象，请分析思考一下，为什么？
作为本实验的部分，完成如下的自由练习：
自由练习5.2 仿照上边测试程序，编写程序，
完成对自由练习5.1建立的Result 类的功能的测试。
5.2 实验二：包及包中类的引用
1. 实验目的
1）正确理解Java 中包的基本概念；
2）基本掌握包的创建以及包中类的引用。
2.实验要求
根据包、类之间的关系，设计类（父类、子类或一般类）将它们放入包中，完成类程序的编写与调试，掌握包中类的引用方法。
3.实验内容
实验示例 5.2.1 创建一个简单的汽车（Car ）组件包（其中包括车身车架合成、发动机合成、控制组件合成）。
⑴ 汽车组件简要分析
大家知道汽车是一个抽象的概念，因为汽车的种类繁多，功能各异。但不管何类汽车都包括如下组件：车身车架（含驾驶室）、发动机、控制组件（变速器、驱动桥、转向制动系统等）。因此一辆汽车可以看成是若干部件的组合。如果我们分别把它们划分为汽车部件类，可以简单地描述如下：
车身车架（CarBody ）类：属性可以有：型号、颜色、轮胎个数等；动作有开门(open)，关门(close);
发动机（Engine ）类：属性可以有：类型、功率等；动作有启动(start)，关闭(close); 控制组件（ControlCompModule ）类： 动作有：前进(forward)、倒退(backward)，加速(quicken)、减速(slowDown)、停车(stop)等。
⑵ 根据如上简单分析，可以建立Car.java 源程序代码文件，分别定义各组件类，源程序参考代码如下：
package car;
/* 定义车身车架类*/
class CarBody
{
String type; //声明类型
String color; //声明颜色
int tire; //声明轮胎数
public void open()
{
System.out.println("车门已打开！");
}
public void close()
{
System.out.println("车门已关闭！");
}
public CarBody(String type,String color,int tire)
{
this.type=type;
this.color=color;
this.tire=tire;
}
}
/* 定义发动机类 */
class Engine
{
String model; //声明发动机型号
int power; //声明功率
public void start()
{
System.out.println("发动机已发动！");
}
public void close()
{
System.out.println("发动机已关闭！");
}
public Engine(String model,int power)
{
this.model=model;
this.power=power;
}
}
/* 以下定义控制系统类 */
class ControlModule
{
public void forward(int speed)
{
System.out.println("汽车以"+speed+"速度开始向前行进...");
}
public void backward(int speed)
{
System.out.println("请注意：正在以"+speed+"速度倒车！");
}
public void stop()
{
System.out.println("已经停车！");
}
}
⑶编译Car.java源程序代码，在car包中生成各个类的字节码文件，供其他应用程序使用。我们可以查看一下，在当前的文件夹下，编译系统自动创建了car文件夹，并把编译生成的类文件CarBody.class、Engine.class、ControlModule.class放在了car文件夹下。
在完成上边的操作之后，作为本实验的作业完成下边的自由练习：
自由练习5.3 仿造上边的操作，完成平面几何形状类包shape的创建，其中包括圆(Circle)、三角形（Triangle）、矩形（Rectangle）等。
实验示例5.2.2 编写测试程序TestCar.java，组合一个汽车对象，测试汽车部件类的功能。
完成该示例的方法步骤如下：
⑴这是一个测试类的程序，在测试程序中，我们需要组合一个汽车对象，然后分别执行对象的各个部件的行为方法。测试程序的参考代码如下：
package car;
public class TestCar
{
CarBody carBody; //声明车体构架
Engine engine; //声明发动机
ControlModule CM; //声明控制组件
public TestCar(String type,String color,int tire,String model,int power) {
carBody=new CarBody(type,color,tire) ; //创建车体构架成员对象 engine=new Engine(model,power); //创建发动机成员对象
CM=new ControlModule(); //创建控制组件成员对象
}
public static void main(String [] args)
{
TestCar car=new TestCar("奔马2000","褐色",4,"N-Ⅳ-B5",220); //创建汽车对象
car.carBody.open(); //打开车门
car.carBody.close(); //关闭车门
car.engine.start(); //启动发动机
car.CM.forward(30); //向前行进
car.CM.stop(); //停止前进
car.CM.backward(1); //倒车
car.engine.close(); //关闭发动机
car.carBody.open(); //打开车门
car.carBody.close(); //关闭车门
System.out.println("测试已完成");
}
}
⑵在建立TestCar.java源程序文件之后，编译并执行程序，执行结果如图5-2所示。
图5-2 示例5.2.2执行结果
⑶程序及结果分析与思考
在测试程序中，我们声明了汽车组件类变量，把它们作为汽车测试类的成员来对待，它们既是本类的成员，也是相对独立的对象，因此在本类的构造方法中创建了这些对象，当本类对象引用时，采用了对象.组件对象.方法的引用方式。
这是一个带包语句的测试类程序，思考如下问题：
①如果把语句：package car; 从程序中去掉，将会发生什么情况？为什么？
②将语句：package car;换成：import car.*;可以吗？为什么？
③如果使用语句：import car.*; 应该如何重新说明组件类？
在完成上边的实验示例之后，作为本实验的作业完成下边的自由练习：
自由练习5.4 编写测试程序，测试自由练习5.3创建的平面几何形状类包shape包中的几何形状类的功能。
5.3 实验三：接口构成、异常处理
1. 实验目的
1）正确理解接口的构成及作用；
2）了解异常的基本概念、异常处理在程序中的作用，掌握简单异常处理的应用。
2.实验要求
根据接口的特点，编写接口程序；完成常用异常处理程序的编写和调试，掌握异常处理在程序中的应用方式。
3.实验内容
实验示例5.3.1根据接口的特点将汽车的控制组件类ControlModule改为接口实现。
⑴简要分析
其实，汽车的控制系统是一个较为复杂的系统，这里我们只是对变速器进行了简单的模拟，不论是手工换档还是自动换档，其作用都是一样的。假如我们模拟一个换档器，并为每一档规定速度，0档为停，小于0档为倒车，大于0档为前进，那么只需要定义一个方法，而用参数来确定前进、停止和后退动作就可以了。
⑵根据如上简单分析，可以建立如下的ControlInterface.java源程序代码文件：
package car; //放入car包中
public interface ControlInterface
{
public void shiftGear(int speed); //声明接口方法
}
⑶编译程序，生成ControlInterface.class文件，并将它放入car包中。
⑷程序分析及思考
可以看到接口文件在编译后生成了类文件，因此说接口也是一个特殊的类，接口体中只能包含常量和抽象方法定义，和抽象类相比较，思考如下问题：
①如果使用抽象类来定义换档操作，可以么？
②分别用抽象类和接口定义相同的内容，能获得相同的效果么？为什么？
实验示例 5.3.2 编写测试程序TestInterface.java，组合一个汽车对象，使用ControlInterface接口实现变速控制，测试接口的功能。
完成该示例的方法步骤如下：
⑴这是一个测试类的程序，参照5.2.2测试程序，实现ControlInterface 接口替代ControlModule类，测试程序的参考代码如下：
package car;
public class TestInterface implements ControlInterface
{
CarBody carBody; //声明车体构架
Engine engine; //声明发动机
public TestInterface(String type,String color,int tire,String model,int power)
{
carBody=new CarBody(type,color,tire) ; //创建车体构架成员对象 engine=new Engine(model,power); //创建发动机成员对象
}
public void shiftGear(int speed) //实现接口方法
{
if(speed>0) System.out.println("汽车以"+speed+"档速度行进....");
else if(speed==0) System.out.println("汽车已停止前进!!!");
else System.out.println("正以"+speed+"档速度倒车....");
}
public static void main(String [] args)
{
TestInterface car=new TestInterface("奔马2000","褐色",4,"N-Ⅳ-B5",220); //创建汽车对象
car.carBody.open(); //打开车门
car.carBody.close(); //关闭车门
car.engine.start(); //启动发动机
car.shiftGear(3); //向前行进
car.shiftGear(0); //停止前进
car.shiftGear(1); //倒车
car.engine.close(); //关闭发动机
car.carBody.open(); //打开车门
car.carBody.close(); //关闭车门
System.out.println("测试已完成");
}
}
⑵在建立TestInterface.java源程序文件之后，编译并执行程序，执行结果如示例程序5.2.2执行结果（图5-2所示）。
⑶程序及结果分析与思考
在测试程序中，我们使用接口ControlInterface替换了ControlModule类的功能，请注意使用它们之间的区别。在既可用类也可用接口来处理解决的问题，使用接口可能要更灵活方便一些。
实验示例 5.3.3 商场会以各种方式进行促销活动，在购买一定数量的商品之后，可以现场抽奖。编写一个抽奖程序，可以从键盘上输入0~9中任意一个字符，如果和系统随机产生的字符相吻合，则显示“恭喜中奖了”，否则显示“祝君下次好运!”。
实现该示例的方法步骤如下：
⑴首先简要分析实现该示例需要涉及的问题
要从键盘上输入数据，涉及到标准设备的输入问题，需要处理系统可能出现的I/O异常问题；要使系统随机产生字符，涉及到使用java.util类包中的Random类对象产生随机数的方法来完成。
⑵根据上述分析，编写处理程序Bonus.java，参考程序代码如下：
import java.util.*;
public class Bonus
{
public static void main(String [] args) throws java.io.IOException
{
Random rd=new Random();
System.out.print("开始抽奖，请输入0~9之间任意一数：");
while(true)
{
int c1=System.in.read(); //从键盘上输入一个字符
if(c1<48||c1>57) continue; //如果不是0~9，重新输入，并滤掉回车换行字符
int n=rd.nextInt(10); //产生10以内的随机数
if(n==c1-48) System.out.println("恭喜中奖了!请到1号服务台领取奖品！");
else System.out.println("祝君下次好运!");
System.out.print("开始抽奖，请输入0~9之间任意一数：");
}
}
}
⑶编译Bonus.java程序之后，执行程序，执行结果如图5-3所示。
图5-3 示例5.3.3执行结果
⑷程序及程序结果分析
在程序中的main()方法说明中使用了throws java.io.IOException子句来抛出I/O可能引起的异常，因为这类异常即便进行捕捉，也没有方法对其进行处理。
在使用System.in.read()语句接受从键盘上输入的字符时，是以字符的ASCII码计值的，我们从键盘上输入的字符”0”~”9”对应的ASCII码值为48~57。
此外，在键盘上输入一个数字然后按”Enter”键，这就包含3个字符：所按的数字、回车和换行（对应的ASCII码13和10），因此在程序中加入了判别语句：
if(c1<48||c1>57) continue;
它过滤非数字字符（包括回车和换行符）。
在完成上边的实验示例之后，请认真阅读理解程序完成下边的自由练习：
自由练习5.5 将5.5.3示例程序修改为采用try~catch方式捕捉处理IOException
《面向对象程序设计》实验报告 实验六、类的继承 课程代码：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 山西大学计算机与信息技术学院 实验报告 姓名学号专业班级 课程名称 Java实验实验日期成绩指导教师批改日期 实验5 JAVA常用类实验名称 一．实验目的： （1）掌握常用的String，StringBuffer(StringBuilder)类的构造方法的使用；（2）掌握字符串的比较方法，尤其equals方法和==比较的区别； （3）掌握String类常用方法的使用； （4）掌握字符串与字符数组和byte数组之间的转换方法； （5）Date，Math，PrintWriter，Scanner类的常用方法。 二．实验内容 1.二进制数转换为十六进制数（此程序参考例题249页9. 2.13） 程序源代码 import java.util.*; public class BinToHexConversion{ //二进制转化为十六进制的方法 public static String binToHex(String bin){ int temp; //二进制转化为十六进制的位数 if(bin.length()%4==0) temp = bin.length()/4; else temp = bin.length()/4 + 1; char []hex = new char[temp]; //十六进制数的字符形式 int []hexDec = new int[temp];//十六进制数的十进制数形式 int j = 0; for(int i=0;i 信息与计算科学专业实验报告 课程名称Java课程设计总实验学时： 16 第3 次共6 次 实验项目名称继承与接口本次实验学时数： 3 实验类 型 验证 日期20 12 年 3 月6 日星期二年级 学生姓名学号课任教师 1.实验目的 巩固如下概念：子类的继承性、子类对象的创建过程、成员变量的继承与隐藏、方法的继承与重写；掌握上转型对象的使用；掌握接口回调技术。 2.实验要求 实验前，应事先熟悉相关知识点，拟出相应的实验操作步骤，明确实验目的和要求；实验过程中，服从实验指导教师安排，遵守实验室的各项规章制度，爱护实验仪器设备；实验操作完成后，认真书写实验报告，总结实验经验，分析实验过程中出现的问题。 3.实验内容 1、继承 编写一个Java应用程序，除主类外，该程序中还有4个类：People、ChinaPeople、AmericanPeople和BeijingPeople类。要求如下：People类有访问权限是protected的double 型成员变量：height和weight，以及public void speakHello()、public void averageHeight()、public void averageWeight()方法；ChinaPeople类是People的子类，新增了public void chinaGongfu()方法。要求ChinaPeople重写父类的public void speakHello()、public void averageHeight()、public void averageWeight()方法；AmericanPeople类是People的子类，新增public void americanBoxing()方法。要求AmericanPeople重写父类的public void speakHello()、public void averageHeight()、public void averageWeight()方法；BeijingPeople类是ChinaPeople的子类，新增public void beijingOpera()方法。要求BeijingPeople重写父类的public void speakHello()、public void averageHeight()、public void averageWeight()方法；请按模板要求，将【代码】替换为Java程序代码。 2、上转型对象 编写一个Java应用程序，要求有一个abstract类，类名为Employee。Employee的子类有YearWorker、MonthWorker和WeekWorker。YearWorker对象按年领取薪水，MonthWorker按月领取薪水，WeekWorker按周领取薪水。Employee类有一个abstract方法：public abstract double earnings(); 子类必须重写父类的earnings()方法，给出各自领取报酬的具体方式。有一个 第5章类的继承、包及接口 在前一章的实验中已经了解了类的基本构成、对象的创建及重载方法的应用等。本章实验的任务主要是了解Java中类的继承、类包、内部类、匿名类及接口的基本构成及应用。 5.1 实验一：类的继承 1. 实验目的 1）正确理解Java中类继承基本概念及思想； 2）基本掌握继承类和被继承类（子类和父类）之间的关系，正确地创建继承类。 2. 实验要求 正确地划分类，根据类之间的关系，确定父类和子类，掌握覆盖方法的应用，完成类程序的编写与调试。 3. 实验内容 在上一章的实验中，建立了公司职员信息类，现在需要处理职员的工资信息，建立职员工资类。 实验示例5.1.1 创建职员工资类Payroll类。 实现该示例的方法步骤如下： ⑴首先分析一下该类的构成 工资信息应包括职工的基本信息，因此可以把Employers类作为Payroll类的父类，Payroll类继承了父类所有的成员变量和方法，因此在Payroll类中需要定义的内容是： ①成员变量 对于工资信息项应该包括basicWage(基本工资)、positionWage(职位工资)、extraWage(附加工资)、other(其他补贴)等等。它们均可声明为int (整数类型)。 ②成员方法 常常需要显示或获得全部或某些项工资的信息，因此需要定义如下一些方法： display() 显示工资的全部信息； display(int value) 显示一项工资额； display(int value1, int value2) 显示两项工资额。 ③构造方法 如前所述，一个类能够有多个构造对象方法，视需要而定。对Payroll类来说可以给出两个构造方法： Payroll () 构造无名对象； Payroll(String ID,String name,String sex,String birthday,String home,String address, String number,int basicWage,int positionWage,int extraWage,int other) 构造一般对象。 ⑵根据上边分析和描述，按照类的构成，给出如下类程序代码： public class Payroll extends Employers { int basicWage; //定义基本工资 int positionWage; //定义职位工资 int extraWage; //定义附加工资 1,定义一个接口Assaultable(可攻击的)，该接口有一个抽象方法attack()。 2,定义一个接口Mobile（可移动的）,该接口有一个抽象方法move()。 3,定义一个抽象类Weapon,实现Assaultable接口和Mobile接口，但并没有给出具体的 实现方法。 4,定义3个类：Tank,Flighter,WarShip都继承自Weapon,分别用不同的方式实现Weapon 类中的抽象方法。 5,写一个类Army,代表一支军队，这个类有一个属性是Weapon数组w（用来存储该军队所拥有的所有武器）；该类还提供一个构造方法，在构造方法里通过传一个int类型的参数来限定该类所能拥有的最大武器数量,并用这一大小来初始化数组w。该类还提供一个方法addWeapon(Weapon wa),表示把参数wa所代表的武器加入到数组w中。在这个类中还定义两个方法attackAll()和moveAll()，让w数组中的所有武器攻击和移动。 6，写一个主方法去测试以上程序。 interface Assaultable{//可攻击的 void attack(); } interface Mobile{//可移动的 void move(); } abstractclass Weapon implements Assaultable,Mobile { publicvoid attack(){} publicvoid move(){} } class Tank extends Weapon{ publicvoid attack(){ System.out.println("坦克攻击！！！"); } publicvoid move(){ System.out.println("坦克移动！！！"); } } class Flighter extends Weapon{ publicvoid attack(){ System.out.println("战斗机攻击！！！"); } publicvoid move(){ System.out.println("战斗机移动！！！"); JAVA屮常用类的常用方法 一．java?丨ang.Object 类 1、clone()方法 创建丼返M此对象的一个副木。要进行“克隆”的对象所属的类必须实现https://www.doczj.com/doc/049695792.html,ng. Cloneable 接口。 2、equals(Objectobj)方法 0 功能：比较引用类型数据的等价性。 0 等价标准.?引用类型比较引用，基木类型比较值。 0 存在特例.?对File、String、Date及封装类等类型来说，是比较类型及对象的内稃而+ 考虑引用的是否为同一实例。 3、finalize〇方法 当垃圾丨"丨收器确定>(、存在对该对象的更多引用时，由对象的垃圾丨"丨收器调用此方法。 4、hashCode〇方法返 回该对象的哈希码值。 5、notify〇方法 唤醒在此对象监视器上等待的中?个线祝。 6、notifyAII〇方法 唤醒在此对象监视器上等待的所有线程= 7、toString()方法 返W该对象的字符串表示。在进行String与其它类型数据的连接操作时，&动调用tostringo 方法。可以根据耑要重写toStringO方法。 8、wait()方法 在其他线程调用此对象的n〇tify()方法或notifyAIIO方法前，异致当前线程等待。 二、字符串相关类 I String 类 charAt(int index)返回指定索引处的char值。compareTo{String anotherString)按字 典顺序比较两个字符串。compareTolgnoreCase(Stringstr)按字典顺序比较两个字 符串，不考虑人小写。concat(String str)将指定字符串连接到此字符串的结尾。 endsWith(String suffix)测试此字符串是否以指定的〗?缀结束。equals{Object anObject)将此字符串与指定的对象比较。 equalslgnoreCase(String anotherString)将此String 与另一个String 比较，考虑人小'与’。indexOf(int ch)返H指定字符在此字符串屮第一次出现处的索引。 indexOf(String str)返回第一次出现的指定子字符串在此字符串屮的索引， lastlndexOf(intch)返回指定字符在此字符串中最后??次出现处的索引。 length()返|n丨此字符串的长度。 replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用newChar替换此字符串中出现的所有oldChar得到的。 split(String regex)根据给定正则表达式的匹配拆分此字符串。startsWith{String prefix)测试此字符 串是否以指定的前缀开始。substring(int beginlndex) 返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。 substring(int beginlndex, int endlndex) 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的beginlndex 处开始，一直到索引endlndex-1处的字符。 t〇CharArray()将此字符串转换为一个新的字符数组。 实验15：面向对象基础编程（六）继承 实验目的： 1.理解继承的概念 2.掌握继承的实现 3.理解继承中的覆盖现象 4.理解抽象类的概念，掌握定义抽象类的方法和应用 实验数据记录及分析（或程序及运行结果） 1.首先预测下列程序的运行结果，然后编译、执行以验证你的预测： class Pet{ protected String name; public Pet(String n){ name = n; } public String getName(){ return name; } public String move(){ return "run"; } public String speak(){ return ""; } public String toString(){ return "My pet " + name; } } class Dog extends Pet{ protected int weight; public Dog(String s){ super(s); } } class PetTest{ public static void main(String[] args){ Pet myPet = new Pet("George"); Dog myDog = new Dog("Spot"); System.out.println(myPet.toString() + "\n" + "Speak: " + myPet.speak() +"\n" + myPet.move() + " " + myPet.getName() + "\n"); System.out.println(myDog.toString() + "\n" + "Speak: " + myDog.speak() +"\n" + myDog.move() + " " +myDog.getName() + "\n"); } 史上最全Java基础知识点归纳 写这篇文章的目的是想总结一下自己这么多年来使用Java的一些心得体会，主要是和一些Java基础知识点相关的，所以也希望能分享给刚刚入门的Java 程序员和打算入Java开发这个行当的准新手们，希望可以给大家一些经验，能让大家更好学习和使用Java。 这次介绍的主要内容是和J2SE相关的部分，另外，会在以后再介绍些J2EE 相关的、和Java中各个框架相关的内容。 经过这么多年的Java开发，以及结合平时面试Java开发者的一些经验，我觉得对于J2SE方面主要就是要掌握以下的一些内容。 1.JVM相关(包括了各个版本的特性) 对于刚刚接触Java的人来说，JVM相关的知识不一定需要理解很深，对此里面的概念有一些简单的了解即可。不过对于一个有着3年以上Java经验的资 深开发者来说，不会JVM几乎是不可接受的。 JVM作为Java运行的基础，很难相信对于JVM一点都不了解的人可以把Java语言吃得很透。我在面试有超过3年Java经验的开发者的时候，JVM几乎就是一个必问的问题了。当然JVM不是唯一决定技术能力好坏的面试问题，但是可以佐证Java开发能力的高低。 在JVM这个大类中，我认为需要掌握的知识有： JVM内存模型和结构 GC原理，性能调优 调优：Thread Dump，分析内存结构 class二进制字节码结构，class loader体系，class加载过程，实例创建过程 方法执行过程 Java各个大版本更新提供的新特性(需要简单了解) 2.Java的运行（基础必备） 这条可能出看很简单，Java程序的运行谁不会呢？不过很多时候，我们只是单纯通过IDE去执行Java程序，底层IDE又是如何执行Java程序呢？很多人并不了解。 西安邮电大学 （计算机学院） 课内实验报告 实验名称：继承与多态 专业名称：计算机科学与技术 班级：计科1405班 学生姓名：高宏伟 学号：04141152 指导教师：刘霞林 实验日期：2016.10.13 一、实验目的 通过编程和上机实验理解Java 语言的继承和多态特性，掌握变量的隐藏、方法的覆盖、重载，掌握抽象类和接口的使用。 二、实验要求 1.编写体现类的继承性（成员变量、成员方法、成员变量隐藏）的程序。 2.编写体现类的多态性（成员方法重载）的程序。 3.编写体现类的多态性（构造方法重载）的程序。 4.编写使用接口的程序。 三、实验内容 （一）类的继承 1.创建公共类Student. （1）编写程序文件Student.java，源代码如下: public class Student { protected String name; //具有保护修饰符的成员变量 protected int number; void setData(String m,int h) //设置数据的方法 { name =m; number= h; } public void print() //输出数据的方法 { System.out.println(name+", "+number); } } （2）编译Student.java，产生类文件Student.class。 2．创建继承的类Undergraduate （1）程序功能：通过Student 类产生子类undergraduate，其不仅具有父类的成员变量name（）、number（学号），还定义了新成员变量academy（学院）、department （系）。在程序中调用父类的print 方法。 （2）编写Undergraduate 程序: class Undergraduate extends Student { 【代码1】//定义成员变量academy 【代码2】//定义成员变量department public static void main(String args[]) { 【代码3】//创建一个学生对象s 【代码4】//用父类的setData方法初始化对象s 【代码5】//对象s调用print方法 【代码6】//创建一个大学生对象u 【代码7】//调用父类的成员方法setData初始化对象u 【代码8】//设置对象u的成员变量academy 【代码9】//设置对象u的成员变量department System.out.print(https://www.doczj.com/doc/049695792.html,+", "+u.number+", "+u.academy+", "+u.department); } } （3）编译并运行程序 注意：公共类Student 与undergraduate 类要在同一文件夹（路径）。 (二)方法的重载 （1）程序功能：对不同的数进行排序输出。在IntSort 类中定义3 个同名的方法sort。 （2）编写Sort.java 文件，源代码如下。 import java.awt.Graphics; import java.applet.Applet; class IntSort { public String sort(int a, int b) { if (a>b) return a+""+b; else return b+""+a; } public String sort(int a, int b, int c) { int swap; if (a 第1章 Java语言概述与面向对象思想 1 1.1 Java语言的发展 1 1.1.1 Java语言的产生 1 1.1.2 Java语言的发展 1 1.2 Java语言的特点 2 1.3 面向对象与面向过程的差异 3 1.3.1 面向过程思想回顾 4 1.3.2 面向对象思想介绍 4 1.4 面向对象程序设计中的主要概念和特征 4 1.4.1 主要概念 5 1.4.2 主要特征 5 *1.5 Java与C++的差异 5 1.6本章小结5 习题 5 第2章 Java语言开发环境 6 2.1 JDK 6 2.1.1 JDK的简介6 2.1.2 JDK的构成6 2.1.3 JDK的使用6 2.2 IDE 8 2.2.1 IDE简介8 2.2.2 JBuilder 9 2.2.3 Eclipse 9 2.2.4 相关资源9 2.3 Project管理9 2.3.1 Project的含义9 2.3.2 可行的Project组织模式9 2.3.3 主要开发工具的Project目录10 2.4 本章小结10 习题10 第1章 Java语言概述与面向对象思想 1.1 Java语言的发展 1.1.1 Java语言的产生以介绍面向对象编程的基本概念、基本理论为重点，结合Java语言的语法规则、编程特点和设计思想、强调容易发生错误和编程应注意的地方，使学生能对Java 技术有一个总体了解，通过本课程学习，使学生掌握Java语言的基础知识，理解和掌握面向对象程序设计的基本思想，熟练地使用Java语言进行程序的编写、编译以及调试工作 上世纪90年代初期，Sun公司在研究一种适用于未来的智能设备的编程语言，该语言要具有一些新的特性，以避免C++的一些不足。 该语言起初命名为Oak，来源于语言作者Gosling办公室窗外的一棵橡树（Oak）。后来在注册时候遇到了冲突，于是就从手中的热咖啡联想到了印度尼西亚一个盛产咖啡的岛屿，中文名叫爪哇，Java语言得名于此。 随着Internet的迅速发展，Web应用日益广泛，Java语言也得到了迅速发展。1994年，Gosling 实验三类的继承 实验目的：掌握类的继承、抽象类的定义和使用、对象的向上转型。实验内容：已知若干图形，求以该图形为底的锥体的体积。 实验要求：用面向抽象的思想实现 实验步骤： 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测试包最终代码： 教学内容 第七讲Java常用类库介绍 7.1 Java类库的结构 类库就是Java API(Application Programming Interface，应用程序接口)，是系统提供的已实现的标准类的集合。在程序设计中，合理和充分利用类库提供的类和接口，不仅可以完成字符串处理、绘图、网络应用、数学计算等多方面的工作，而且可以大大提高编程效率，使程序简练、易懂。 Java类库中的类和接口大多封装在特定的包里，每个包具有自己的功能。表7．1列出了Java中一些常用的包及其简要的功能。其中，包名后面带“. *”的表示其中包括一些相关的包。有关类的介绍和使用方法，Java中提供了极其完善的技术文档。我们只需了解技术文档的格式就能方便地查阅文档。 表7．1Java提供的部分常用包 注：在使用Java时，除了https://www.doczj.com/doc/049695792.html,ng外，其他的包都需要import语句引入之后才能使用。 7.2 https://www.doczj.com/doc/049695792.html,ng包中的常用类 https://www.doczj.com/doc/049695792.html,ng是Java语言最广泛使用的包。它所包括的类是其他包的基础，由系统自动引入，程序中不必用import语句就可以使用其中的任何一个类。https://www.doczj.com/doc/049695792.html,ng中所包含的类和接口对所有实际的Java程序都是必要的。下面我们将分别介绍几个常用的类。 7.2.1 String类和StringBuffer类 许多语言中，字符串是语言固有的基本数据类型。但在Java语言中字符串通过String类和StringBuffer类来处理。 1．String类 Java语言中的字符串属于String类。虽然有其它方法表示字符串（如字符数组），但Java使用String 类作为字符串的标准格式。Java编译器把字符串转换成String对象。String对象一旦被创建了，就不能被改变。如果需要进行大量的字符串操作，应该使用StringBuffer类或者字符数组，最终结果可以被转换成String格式。 （1）创建字符串 创建字符串的方法有多种方式，通常我们用String类的构造器来建立字符串。表6．2列出了String 类的构造器及其简要说明。 表7．2 String类构造器概要 【例7．1】使用多种方法创建一个字符串并输出字符串内容。 public class StrOutput { public static void main(Sring[] args) { //将字符串常量作为String对象对待，实际上是将一个String对象赋值给另一个 String s1 = "Hello,java!"; //声明一个字符串，然后为其赋值 String s2; s2 = "Hello,java!"; 一、单选题 1.对类：(B) public class Test( //...do something } 下面那个正确地定义了类Test的构造函数。 A)public void Test() () B)publicTest()(} C ) public static Test() (} D) publicTest(); 2.下面哪个函数是public void example()(...)的重载函数。(A) A)public void example( float f)(...) B)public int example() (...) C)public void example2()(...} D)public int example_overLoad ()(...) 3.下面的代码段中，执行之后i和j的值是_C_。 int i = 1; intj； j = i++； A)1, 1 B) 1,2 C) 2, 1 D) 2,2 4.以下for循环的执行次数是_B o for(int x=0,y=0;(y !=0)&&(x<4) ;x++); A)无限次B) 一次也不执行 C)执行4次D)执行3次 5.下面程序的输出结果是—C o public class People( String name; int id; public People( String str, int n )( name = str; id = n; } public String toString(){ return id + " ：” + name; } public String print()( JAVA中继承的总结 一、继承概念： 把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系， 这多个类就具备了这些内容。这个关系叫继承。 二、何时实现继承 A:继承体现的是：is a的关系。 B:采用假设法 三、怎么实现继承 A:用关键字extends表示 B:格式： class 子类名 extends 父类名 {} C:子类 public class 子类 extends 父类 { //增加自己属性 //重写父类的属性 //增加自己的方法 //重写父类的方法 } 四、继承的好处： A:提高了代码的复用性 B:提高了代码的维护性 C:让类与类产生了一个关系，是多态的前提 继承的弊端： A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。 原则：低耦合，高内聚。 耦合：类与类的关系 内聚：自己完成某件事情的能力 B:打破了封装性 五、Java中继承的特点 A:Java中类只支持单继承，只能一个直接父类，Object 根类 B:Java中可以多层(重)继承(继承体系) 六、继承的注意事项： A:子类能继承父类的私有成员,但不是都能访问 B:子类不能继承父类的构造方法，但是可以通过super去访问 C:不要为了部分功能而去继承 七、继承中static用法 A:static:子类可以继承父类的静态方法,但不能重写 B:static 的属性和方法都是不能覆盖的，因为static修饰的部分都是与对象无关的，只与类有关 八、Java继承中的成员关系 A:成员变量 a:子类的成员变量名称和父类中的成员变量名称不一样，这个太简单 b:子类的成员变量名称和父类中的成员变量名称一样，这个怎么访问呢? JAVA中常用类的常用方法 一、类 1、clone()方法 创建并返回此对象的一个副本。要进行“克隆”的对象所属的类必须实现. Cloneable接口。 2、equals(Object obj)方法 功能：比较引用类型数据的等价性。 等价标准：引用类型比较引用，基本类型比较值。 存在特例：对File、String、Date及封装类等类型来说，是比较类型及对象的内容而不考虑引用的是否为同一实例。 3、finalize()方法 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 4、hashCode()方法返回该对象的哈希码值。 5、notify()方法唤醒在此对象监视器上等待的单个线程。 6、notifyAll()方法唤醒在此对象监视器上等待的所有线程。 7、toString()方法 返回该对象的字符串表示。在进行String与其它类型数据的连接操作时，自动调用toString()方法。可以根据需要重写toString()方法。 8、wait()方法 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。 二、字符串相关类 l String类 charAt(int index) 返回指定索引处的 char 值。 compareTo(String anotherString) 按字典顺序比较两个字符串。compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。concat(String str) 将指定字符串连接到此字符串的结尾。 endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 equals(Object anObject) 将此字符串与指定的对象比较。 equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写。 indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。length() 返回此字符串的长度。 replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 split(String regex) 根据给定正则表达式的匹配拆分此字符串。 startsWith(String prefix) 测试此字符串是否以指定的前缀开始。 substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。 应用数学学院信息与计算科学专业 2 班学号3111008162 姓名许庆平教师评定_________________ 实验题目继承与接口 一、实验目的与要求 实验目的： 1、掌握类的继承关系。 2、掌握接口的定义与使用。 实验要求： 按下列要求编写Java程序： 1、定义接口Printx，其中包括一个方法printMyWay()，这个方法没有形参，返回值为空。 2、编写矩形类，矩形类要求实现Printx接口，有求面积、求周长的方法，printMyWay()方法要能显示矩形的边长、面积和周长。 3、编写正方形类作为矩形类的子类，正方形类继承了矩形类求面积和周长的方法，新增加求对角线长的方法，重写printMyWay()方法，要求该方法能显示正方形的边长、面积、周长和对角线长。 二、实验方案 先按要求定义接口Printx，再创建一个矩形类Rectangle，有成员变量length 和width，area（）求面积，circle（）求周长，用PrintMyWay()显示。 然后定义正方形类，继承Rectangle类，定义求对角线长的函数duijiaoxian()。面积和周长用父类中的area（）和circle（）实现。用PrintMyWay()显示。最后在主类中实现这两个类。 三、代码如下 interface Printx { void PrintMyWay();} class Rectangle implements Printx { int length,width; Rectangle(int x,int y){ length=x; width=y; } int area(){ return length*width; } int circle(){ return 2*(length+width); } public void PrintMyWay(){ System.out.println("矩形的长为:"+length); System.out.println("矩形的宽为:"+width); System.out.println("矩形的面积为:"+area()); System.out.println("矩形的周长为:"+circle()); } JAVA中常用类的常用方法 一、https://www.doczj.com/doc/049695792.html,ng.Object类 1、clone()方法 创建并返回此对象的一个副本。要进行“克隆”的对象所属的类必须实现https://www.doczj.com/doc/049695792.html,ng. Cloneable接口。 2、equals(Object obj)方法 ?功能：比较引用类型数据的等价性。 ?等价标准：引用类型比较引用，基本类型比较值。 ?存在特例：对、Date及封装类等类型来说，是比较类型及对象的内容而不考虑引用的是否为同一实例。 3、finalize()方法 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 4、hashCode()方法返回该对象的哈希码值。 5、notify()方法唤醒在此对象监视器上等待的单个线程。 6、notifyAll()方法唤醒在此对象监视器上等待的所有线程。 7、toString()方法 返回该对象的字符串表示。在进行String与其它类型数据的连接操作时，自动调用toString()方法。可以根据需要重写toString()方法。 8、wait()方法 在其他线程调用此对象的notify() 方法或notifyAll() 方法前，导致当前线程等待。 二、字符串相关类 l String类 charAt(int index) 返回指定索引处的char 值。 compareTo(String anotherString) 按字典顺序比较两个字符串。 compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。 concat(String str) 将指定字符串连接到此字符串的结尾。 endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 equals(Object anObject) 将此字符串与指定的对象比较。 equalsIgnoreCase(String anotherString) 将此String 与另一个String 比较，不考虑大小写。indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。 lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 length() 返回此字符串的长度。 replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用newChar 替换此字符串中出现的所有oldChar 得到的。split(String regex) 根据给定正则表达式的匹配拆分此字符串。 startsWith(String prefix) 测试此字符串是否以指定的前缀开始。 substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。 substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的beginIndex 处开 在UML中表示Java继承和接口 作者：仙人掌工作室本文选自：赛迪网 在上一篇文章中，我们引入了UML类图的概念，比较了在Java编程语言和UML类图中表示类、属性、操作和关联关系的不同之处。下面我们来看看如何在UML中表示两个重要的Java概念——继承，接口。 继承 在Java中，我们可以声明一个类扩展（extends）另一个类，还可以声明一个类实现（implements）一个或者多个接口。下面我们来看看如何在UML中表达这些概念。 下面是三个Java类的基本骨架。第一个类是代表某种支付方式的Payment抽象类，另外两个类分别扩展Payment 类，描述两种不同的支付方式： 图一用UML显示了同样的三个类。在操作和属性声明中，类型和参数之类的细节都没有显示出来，这是为了更 清楚地显示出类的整体结构以及各个类之间的关系。 图一：UML一般化关系 Java中的extends关键词声明了继承关系，相当于UML中的“一般化”（Generalization，也译为“泛化”）关系，在UML图形中用子类向超类的实线空心封闭箭头表示。图一额外增加了一个Sale类，这是为了更清楚地说明UML一般化关系与UML定向关联关系所用箭头的不同。关联关系与一般化关系的另一个不同之处在于，一般化关系的两端不需要说明多重性或角色名称。 显然，UML类图比三个Java源代码文件更清楚直观地显示出了三个类之间的继承关系。如果你要与别人探讨设计思路，绘制UML草图也要比直接使用代码简单快捷得多。 也许有人会说，系统的类结构图就在他们的头脑中，他们只需要直接使用Java代码。实际上，对于规模较大的系统，这种说法显然是不成立的；即使对于规模较小的系统，如果一定的时间之后要由其他程序员修改，没有UML图也会寸步难行——很难保证每一个人都了解你头脑中的类结构图。 在UML中，抽象类的标志是类的名字以斜体显示。在白板或纸张上手工画UML草图时，很难区分字体是否是斜体。为此，一些人建议这些场合可以在类名称的右下角加上{abstract}标记以示区别。 另一些人认为，在白板上写{abstrac t}显得太罗嗦，他们倾向于打破UML常规，在类名称的右下角加上一个0表示零个实例，如果在该位置写上1，则表示该类是一个singleton类（永远只有一个实例的类）；如果在该位置写上N，则表示它是一个枚举类（拥有固定实例数量的类，如一星期中的天数，彩虹的颜色，等等）。不过，这一切都不是标准的UML，只能用于手工绘制UML图的场合，看来也不可能得到UML建模工具的支持。 历史知识：UML首先由Rational公司的一个工作组发明，Ration公司是UML建模工具Rose的生产者。UML于1995年的OOPSLA会议上被公诸于世，随后，OMG（对象管理组织）于1997年采用了UML规范。不难理解，继实验5 JAVA常用类
java继承与接口实验三
第五章 Java类的继承、包及接口
Java 接口与类之间继承例题
JAVA中常用类的常用方法
实验15、16：JAVA面向对象编程(继承、接口)
史上最全Java基础知识点归纳
Java继承与多态实验报告
Java基础入门教程(适合所有初学者)
java 类的继承 实验报告(含代码)
Java常用类库介绍
JAVA技术--Java基础知识常见考试题JAVA技术.doc
java中继承的相关知识总结
JAVA中常用类的常用方法
java继承与接口 实验报告
JAVA中常用类的常用方法
在UML中表示Java继承和接口
相关主题
文本预览