包、接口和常用工具类

实验三包、接口和常用工具类

（一）包的使用与访问控制

【实验目的】

（1）了解Java包的组织概念；

（2）学会编写带有包结构的程序；

（3）掌握包结构下的成员访问控制。

【实验任务】

编写3个类，类名分别为Clock、A、B，其中类Clock和类A放在同一个包packone 中，类B放在另一个包packtwo中，包packone和包packtwo放在同一个目录下。类Clock 中有三个整型数据hour、minutes、second，他们分别是public、private、protected，类Clock 还包含一些方法使用这些数据。类A和类B功能相似，都是使用类Clock并调用类Clock 中的方法。

【实验步骤】

（1）首先在C:\programming目录下创建一个文件夹packone，然后在该文件夹下创建一个名字叫Clock.java的程序，程序清单如下：

package packone;

public class Clock {

public int hour;

private int minute;

protected int second;

public Clock(int i, int j, int k) {

setAll(i, j, k);

}

void setAll(int i, int j, int k) {

hour = i;

minute = j;

second = k;

}

public int getHour() {

return hour;

}

public int getMinute() {

return minute;

}

public int getSecond() {

return second;

}

}

（2）接着在packone文件夹下创建第二个程序名叫A.java，程序清单如下：

package packone;

class A {

public static void main(String[] args) {

Clock c = new Clock(5,20,10);

System.out.println("从类A中访问Clock hour="+c.getHour());

System.out.println("从类A中访问Clock minute="+c.getMinute());

System.out.println("从类A中访问Clock second="+c.getSecond());

} }

（3）在C:\programming目录下创建第二个文件夹packtwo，在该文件夹下创建一个名叫B.java的程序，程序清单如下：

package packtwo;

import packone.*;

class B {

public static void main(String[] args) {

Clock c = new Clock(8,30,5);

System.out.println("从类B中访问Clock hour="+c.getHour());

System.out.println("从类B中访问Clock minute="+c.getMinute());

System.out.println("从类B中访问Clock second="+c.getSecond());

}

}

至此已经编辑好三个源程序，可在MyEclipse环境下直接运行程序查看结果。接下来在DOS命令行窗口进行编译运行程序，查看结果。

编译命令：javac packone\Clock.java

javac packone\A.java

javac packtwo\B.java

运行指令：java packone.A

java packtwo.B

思考：在A.java和B.java程序中分别通过getHour()，getMinute()和getSecond()访问Clock类的数据成员，请问能否不通过这几个方法而直接访问Clock类的数据成员呢？现在把A.java程序的相关部分作如下修改来进行测试，编译运行观察结果。

System.out.println("从类A中访问Clock hour="+c.hour);

System.out.println("从类A中访问Clock minute="+c.minute);

System.out.println("从类A中访问Clock second="+c.second);

接着把B.java程序的相关部分也作类似修改进行测试，编译运行观察结果。

System.out.println("从类B中访问Clock hour="+c.hour);

System.out.println("从类B中访问Clock minute="+c.minute);

System.out.println("从类B中访问Clock second="+c.second);

若不能运行，该如何修改？

（二）接口的实现与运用

【实验目的】

（1）学习如何定义接口；

（2）掌握接口的实现方式；

（3）使用实现了接口的类；

（4）理解接口与抽象类的区别。

【实验任务】

本实验的任务是设计和实现一个Soundable接口，该接口具有发声功能，同时还能调节声音的大小。Soundable接口的这些功能将会由三种声音设备来具体实现，他们分别是收音机Radio、随身听Walkman和手机Mobilephone。最后还要设计一个应用程序类来使用这些实现了Soundable接口的声音设备类。程序运行时，先询问用户想听哪种设备，然后程序就会按照该设备的工作方式来发出声音。

【实验内容】

阅读并分析以下程序，将程序中的代码补充完整，编译并运行程序，查看结果。

//InterfaceTest.java

import java.util.Scanner;

interface Soundable {

public void increaseVolume( );

public void decreaseVolume( );

public void stopSound( );

public void playSound( );

}

class Radio implements Soundable {

public void increaseVolume( ) {

System.out.println("增大收音机音量");

}

public void decreaseVolume( ) {

代码1 //输出减小随身听音量

}

public void stopSound( ) {

System.out.println("关闭收音机");

}

public void playSound( ) {

System.out.println("收音机播放广播");

}

}

class Walkman implements Soundable {

public void increaseVolume( ) {

System.out.println("增大随声听音量");

}

public void decreaseVolume( ) {

System.out.println("减小随声听音量");

}

public void stopSound( ) {

System.out.println("关闭随声听");

}

public void playSound( ) {

System.out.println("随声听发出音乐"); }

}

class Mobilephone implements Soundable {

public void increaseVolume( ) {

System.out.println("增大手机音量");

}

public void decreaseVolume( ) {

System.out.println("减小手机音量");

}

public void stopSound( ) {

System.out.println("关闭手机");

}

public void playSound( ) {

System.out.println("手机发出来电铃声"); }

}

class People {

private String name;

private int age;

public void listen(Soundable s) {

s.playSound( );

}

}

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( );

代码2 //创建手机对象并赋值给soundDevice[2]

System.out.println("你想听什么? 请输入选择：0-收音机 1-随声听 2-手机");

i = scanner.nextInt( );

//开始听声音

sportsman.listen(soundDevice[i]);

soundDevice[i].increaseVolume( );

代码3 //调用stopSound( )方法

}

}

思考：

（1）在InterfaceTest类中，soundDevice[]数组是什么类型的？该数组为什么能存放三种不同的对象Radio、Walkman和Mobilephone呢？

（2）假定要为程序增加一个闹钟类Clock，该类也实现了Soundable接口，能够发出滴答声，将以下的Clock类加入到InterfaceTest.java程序中，并在InterfaceTest类的main（）方法中加入soundDevice[3]=new Clock（）；语句。

class Clock implements Soundable {

public void stopSound( ) {

System.out.println("关闭闹钟");

}

public void playSound( ) {

System.out.println("闹钟发出滴答声");

}

}

修改之后，重新编译InterfaceTest.java并运行它，观察结果。按照常理，闹钟的滴

答声是不可以增大或减小的，如果编译错误，应如何解决？

（三）Java的常用工具类

【实验目的】

（1）了解Java的预定义类；

（2）学习使用Java的常用类；

（3）掌握方法覆盖的使用。

【实验任务】

在该实验中包含3个练习，分别是针对Java中的Math类，基本类型的包装类，日期类Date和Calendar以及动态数组Vector类，通过这些练习仔细体会这些常用的Java类的使用方法。

【实验内容】

练习1：Math类和基本类型的包装类

阅读并分析以下程序，将程序中的代码补充完整，编译并运行程序，查看结果。

// MathTest.java

import java.util.*;

public class MathTest {

public static void main(String args[]) {

Scanner scanner = new Scanner(System.in);

int intData;

double doubleData;

String intString, doubleString;

System.out.print("请输入整数x和实数y: ");

intData = scanner.nextInt( );

//以字符串方式输入实数

doubleString = scanner.next( );

//创建整数对象intObject

Integer intObject = new Integer(intData);

//返回字符串所对应的数值

doubleData = Double.parseDouble(doubleString);

intData = intObject.intValue( );

//将整数对象的值以字符串形式输出

intString = intObject.toString( );

System.out.println("你的输入是：" + intString + ", "+ doubleData);

//开始调用Math类的方法进行运算

int intData1 = Math.abs(intData);

System.out.println("abs(x)x的绝对值: "+Math.abs(intData));

System.out.println("ceil(y)y向上取整: "+Math.ceil(doubleData));

System.out.println("floor(y)y向下取整："+Math.floor(doubleData));

System.out.println("exp(x)e的x次幂: " + Math.exp(intData));

System.out.println("log(x)x的自然对数："+ Math.log(intData1));

System.out.println("max(x,y)x和y中的较大者："+ Math.max(intData,doubleData));

System.out.println("min(x,y)x和y中的较小者："+ 代码1 );

System.out.println("sin(x)x的正弦值：" + 代码2 );//求正弦值

System.out.println("cos(x)x的余弦值：" + 代码3 ); //求余弦值

System.out.println("以x为半径的圆面积："+ Math.PI*intData*intData);

}

}

练习2：日期类Date和Calendar

学习使用Java中常用的操纵时间的类Date和Calendar以及控制日期输入输出格式的类DateFormat，程序会要求用户以规范的格式输入自己的生日日期，然后使用Date类和Calendar类中的方法计算出生日是星期几，年龄以及出生的年份是否是闰年。程序清单如下：

// Birthday.java

import java.util.*; // Date,Calendar,Scanner

import java.text.*; // SimpleDateFormat

public class Birthday {

public static void main(String args[]) throws ParseException {

String birthday, dayOfWeek=" ";

Date date;

Calendar calendar;

Scanner scanner = new Scanner(System.in);

System.out.println("请输入你的生日日期:yyyy-MM-dd");

birthday = scanner.next( );

//创建一个日期格式对象

SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

//获得一个包含当前日期和时间的Calendar子类的实例

calendar = Calendar.getInstance();

int currentYear = calendar.get(Calendar.YEAR);

//按输入的birthday产生一个Date对象

date = dateFormat.parse(birthday);

//将date对象的值传递给calendar对象

calendar.setTime(date);

int days = calendar.get(Calendar.DAY_OF_WEEK);

switch( days ) {

case 1: dayOfWeek = "星期日";break;

case 2: dayOfWeek = "星期一";break;

case 3: dayOfWeek = "星期二";break;

case 4: dayOfWeek = "星期三";break;

case 5: dayOfWeek = "星期四";break;

case 6: dayOfWeek = "星期五";break;

case 7: dayOfWeek = "星期六";break;

}

System.out.println("你的生日是:" + dayOfWeek);

int birthYear = calendar.get(Calendar.YEAR);

if ( 代码 )

System.out.println(birthYear + "年: 是闰年");

else

System.out.println(birthYear + "年: 不是闰年");

int age = currentYear-birthYear;

System.out.println("你现在是: " + age + "岁");

}

}

思考：

（1）程序中的switch语句用于判断是星期几，现在将switch语句中的break语句全部删除，然后编译运行程序，观察会有什么结果？并说明原因。

（2）在输入了正确的生日日期后，程序能返回年龄，现在修改程序，以返回生日日期与当前日期之间相距多少天。

（3）请查询Calendar类的相关方法以显示出当前的精确日期和时间（包括年，月，日，小时，分，秒）。

练习3：动态数组Vector类

Vector是一个动态数组，能根据实际需要动态地扩充数组的大小，同时Vector类中还包含许多方法来操纵数组中的元素，程序中有一个Vector数组，里面包含有几个事先定义的城市名，同时，可以在该数组中增加几个新的城市名，并进行一些交互性的操作。在这一过程中，仔细体会Vector数组的用法。程序清单如下：

// CityVector.java

import java.util.*;

public class CityVector {

static String city[] = { "北京", "上海", "广州", "深圳" };

public CityVector( )

{

Vector vector = new Vector(6);

Scanner scanner = new Scanner(System.in);

String cityName;

int index;

for ( int i = 0; i < city.length; i++ ) {

vector.add( city[i] );

};

// 显示出数组信息

displayVector(vector);

System.out.print("\n请输入数组索引号: ");

index = scanner.nextInt( );

cityName = (String)vector.get(index);

System.out.println("数组["+index+"]的元素值是: "+cityName);

System.out.print("\n请再输入3个你喜欢的城市: ");

for ( int i = 0; i < 3; i++ ) {

cityName = scanner.next();

vector.add(cityName);

}

displayVector(vector);

System.out.print("\n请输入一个你想查询的城市名: ");

cityName = scanner.next( );

if ( vector.contains(cityName) )

System.out.println( "在数组中找到: "+cityName+" 下标是:" + vector.indexOf(cityName));

else

System.out.println( "在数组中没有找到: "+cityName );

System.out.print("\n请输入一个你想删除的城市名: ");

cityName = scanner.next( );

vector.remove(cityName);

System.out.println(cityName + " 已被删除");

displayVector(vector);

}

public void displayVector( Vector vector )

{

System.out.println( "\n数组大小: " + vector.size() +

"\n数组容量: " + vector.capacity() );

if ( vector.isEmpty() )

System.out.print( "数组为空" );

else {

System.out.print( "数组包含: " );

Enumeration contents = vector.elements();

while ( contents.hasMoreElements() )

System.out.print( contents.nextElement() + " " );

}

System.out.println( "\n" );

}

public static void main( String args[] ) {

CityVector application = new CityVector( );

}

}

思考：

（1）程序中Vector数组的原始大小是4，容量是6，而当新增加3个新的城市名后，Vector 数组的容量变成了多少？修改程序以允许用户增加更多的城市，如6个或8个，观察增加之后Vector数组的容量变化。

（2）查询Vector类的方法，以输出数组的第一个和最后一个元素。

06接口与内部类

1.给出如下层次图和程序片段，下列哪个命题是正确的？【选择一项】 Animal Mammal Dog Cat Raccoon Elephant (implements) (implements) ( Washer ) ( Washer ) 1. Cat sunflower; 2. Washer wawa; 3. Elephant pogo; 4. 5. sunflower = new Cat(); 6. wawa = sunflower; 7. pogo = (Elephant)wawa; A第6行导致程序编译失败。 B第7行导致程序编译失败。 C编译通过但是第7行会抛出异常。 D D．以上结果均不是。 2.下列那些命题是不正确的？【选择两项】 A JAVA程序通过接口实现多重继承。 B JAVA里面所有的异常、接口或者其他类，都从Object类扩展而来。C构造方法可以用private修饰，并且可以抛出异常。 D装箱类一共有六个。 3.下列哪些命题为假？【选择三项】 A静态方法只能被类调用，不能被实例调用。 B所有数据类型都可以用==判断恒等。 C equals()方法成立的地方，==也一定成立。 D包含抽象方法的类一定是抽象类。 4.试图编译、运行下列程序，结果是什么？【选择一项】 //Foo.java interface Foo { int k = 0; } //Test.java public class Test implements Foo {

public static void main(String[] args) { int i; Test test = new Test(); i = test.k; i = Test.k; i = Foo.k; } } A编译失败。 B编译成功。 C运行异常。 D以上结果均不是。 5.下列修饰符不能用于顶层类的是哪个【选择一项】。 A public B private C abstract D final 6.哪些命题为真？【选择两项】 A在Java中，implement用于实现接口。 B非抽象类的子类可以声明为abstract。 C超类的所有成员都将由子类继承。 D final类不可以是抽象的。 E如果类中的所有成员都声明为private，则该类不能声明为public。 7.哪些关于接口的命题为真？【选择两项】 A接口允许多重实现接口。 B接口可以被任意数目的其他接口扩展。 C接口可以扩展任意数目的其他接口。 D接口的成员变量从来不会是static。 E接口的方法总会被声明为static。 8.给出下面的程序： 1. interface Base { 2. boolean m1 (); 3. byte m2(short s); 4. } 下面哪两段代码将编译通过? 【选择两项】 A interface Base2 implements Base {} B abstract class Class2 extends Base {

java内部类练习题

内部类练习题 一、按要求填空 1.请在以下代码的基础上完成下面几个小题 （1）在①和②的位置标注出内部类和外部类 （2）在③的位置定义一个count变量用来存放Circle实例的个数，并在④的位置编写语句用来统计Circle实例的个数。 （3）在⑤和⑥处根据注释语句填写代码 （4）在main()⑦的位置上编写语句调用Draw类中的drawSahpe()。 （5）将修改后的完整代码拷贝在下方： class Circle { //① private double radius = 0; ③ public Circle(double radius) { this.radius = radius; ④ } class Draw { //② public void drawSahpe() { ⑤ //输出radius变量的值 ⑥ //输出count变量的值 } } } public class OuterInnerClass { public static void main(String[] args) { ⑦ //编写语句调用Draw类中的drawSahpe() } } 答案： class Circle { //①外部类 private double radius = 0; static int count=0; public Circle(double radius) { this.radius = radius; count++; } class Draw { //②内部类

public void drawSahpe() { System.out.println(radius); System.out.println(count); } } } public class OuterInnerClass { public static void main(String[] args) { Circle objCircle=new Circle(10); Circle.Draw objDraw=objCircle.new Draw(); objDraw.drawSahpe(); } } 2.程序填空，使程序运行结果为 30 20 10 public class Demo{ public static void main (String[] args) { Outer.Inner obj=new Outer().new Inner(); obj.show(); } } class Outer{ public int number=10; class Inner{ public int number=20; public void show() { int number=30; System.out.print( ); System.out.print( ); System.out.print( ); } } } 答案： public class Demo{ public static void main (String[] args) { Outer.Inner obj=new Outer().new Inner(); obj.show();

第五章 Java类的继承、包及接口

第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:不使用匿名内部类来实现抽象方法 abstract class Person { public abstract void eat(); } class Child extends Person { public void eat() { System.out.println("eat something"); } } public class Demo { public static void main(String[] args) { Person p = new Child(); p.eat(); } } 运行结果：eat something 可以看到，我们用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person 类的引用 但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？ 这个时候就引入了匿名内部类 实例2：匿名内部类的基本实现 abstract class Person { public abstract void eat(); } public class Demo { public static void main(String[] args) { Person p = new Person() { public void eat() { System.out.println("eat something"); } }; p.eat(); } } 运行结果：eat something 可以看到，我们直接将抽象类Person中的方法在大括号中实现了 这样便可以省略一个类的书写

实验四 接口和包-实验报告纸

南京信息工程大学实验（实习）报告实验（实习）名称 Java图形界面设计实验（实习）日期 2014.5.14 得分指导教师方巍 院计软院专业网络工程年级二班次一姓名胡啸学号 20121346024 1．实验目的： 1）了解java语言图形界面的设计 2）了解swing和awt包中各个组件与容器 3）了解applet的运行 2．实验内容： （1）编写一个程序实现java的awt包中布局器的应用 （2）编写两个程序，测试java组件的运用与事件响应处理的运用. (3)运行两个applet小程序，了解applet的多媒体处理 实验步骤 一．（1）打开ecplise，新建一个项目001在项目中新建一个包com.g，然后在包中新建一个名为GridLay的类 （2）代码如下 package com.g; import java.awt.*; import javax.swing.*; public class GridLay { private JFrame frame; private JButton b1,b2,b3,b4,b5,b6; public static void main(String args[]){ GridLay that=new GridLay(); that.go(); } void go() { frame=new JFrame("Grid example"); Container contentPane=frame.getContentPane(); contentPane.setLayout(new GridLayout(3,2)); b1=new JButton("grid_1"); b2=new JButton("grid_2"); b3=new JButton("grid_3"); b4=new JButton("grid_4");

(2)java练习(类和接口)

1. （分值：0.7 分）Java 语言中创建一个对象使用的关键字为 A: class B: interface C: new D: create 2. （分值：0.7 分）设有对象x 具有属性a 则访问该属性的方法为 A: a.x B: a.x() C: x.a D: x.a() 3. （分值：0.7 分）以public 修饰的类如：public class Car{…} 则Car( ) A: 可被其它程序包中的类使用 B: 仅能被本程序包中的类使用 C: 不能被任意其它类使用 D: 不能被其它类继承 4. （分值：0.7 分）Java 语言中，只限子类或者同一包中的类的方法能访问的访问权限是( ) A: public B: private C: protected D: <无修饰> 5. （分值：0.7 分）有Java 语句如下，则说法正确的是（）int ［］a,b=new int［3］; A: 此语句是错误的 B: a.length 的值为3 C: b.length 的值为3 D: a.length 和b.length 的值都为3 6. （分值：0.7 分）设有数组定义int[][] x={{1，2}，{3，4，5}，{6}，{}}；，则x.length 的值为( ) A: 3 B: 4 C: 6 D: 7 7. （分值：0.7 分）在Java 语言的java.util 包中，用于语言符号（单词）分析的类是（）A: stringTokenizer B: StringTokenizer C: ToKenizer D: tokenizer 8. （分值：0.7 分）接口的所有变量和方法分别默认为是（） A: final static 和public abstract B: final static 和public final C: public static 和public abstract D: public static 和public final 9. （分值：0.7 分）下列有关Java 的叙述错误的是（） A: 强类型语言 B: 与平台无关

实验七 抽象类、包与接口

实验七抽象类、接口与包 一、实验目的 1、熟练掌握抽象类abstract的概念。 2、熟练掌握接口interface的概念。 3、熟练包package的概念以及编译运行的方法。 二、实验内容与要求 1．编写求解几何图形（如三角形，矩型，圆，多边型）的周长、面积的应用程序，要求用到继承、多态、抽象类、接口、内部类等面向对象程序设计技术的特点。 2、重写上面的程序，要求三角形，矩型，圆，多边型的类放到不同的包中，用包的技术组织程序的设计。同时要求程序能从键盘上接受数据以便求解不同的几何图形的周长面积。提示：从键盘上输入双精度数的一种方法(程序片段) …… public static void main(String args[]) throws IOException { BufferedReader keyin=new BufferedReader(new InputStreamReader(System.in)); String x; x=keyin.readLine(); double a=Double.parseDouble(x); …… ３．练习https://www.wendangku.net/doc/1a17265048.html,ng.Class类的使用，通过一个对象返回一个Class对象，如何获取一个类的名称，如何使用class生成一个类的对象。获取类的描述信息。 4．从命令行输入一个正整数，用递归的方法求出每位数字上的累加和 5、编写一个应用程序，实现以下功能： ①声明一个接口(Calculability)，接口中包含一个方法area()。 ②声明一个三角形类继承该接口，类名为Triangle，类中包含两个变量、一个带参数年的构造方法和一个计算三角形面积的方法： 三角形的底边长w 三角形的高h 构造方法Triangle(double width,double height)。 计算三角形面积的方法area()，该方法覆盖接口(Calculability)的同名方法，计算三角形的面积（w*h/2）。 ③声明一个锥体类（Taper），包含一个接口对象bottom(锥体的底)和一个变量（锥体的高）height，一个带参数的构造方法，一个换底方法getbottom()，一个锥体体积的计算方法volume()。 ④声明一个主类Exp6_1，在主方法中声明接口和锥体类的对象，输出锥体的底面积和锥体的体积（bottom*height/3）。

微型计算机原理与接口技术第四章课后答案

第四章 1. 下列变量各占多少字节？ A1 DW 23H，5876H A2 DB 3 DUP（？），0AH，0DH, ‘$’ A3 DD 5 DUP(1234H, 567890H) A4 DB 4 DUP(3 DUP(1, 2,’ABC’)) 答：A1占4个字节 A2占6个字节 A3占40个字节 A4占60个字节 2. 下列指令完成什么功能？ MOV AX，00FFH AND 1122H+3344H MOV AL，15 GE 1111B MOV AX，00FFH LE 255+6/5 AND AL, 50 MOD 4 OR AX, 0F00FH AND 1234 OR 00FFH 答：（1）将0066H传送给AX （2）将0FFH传送给AL （3）将0FFFFH传送给AX （4）AND AL，02H （5）OR AX，00FFH 3. 有符号定义语句如下： BUF DB 3,4,5,’123’ ABUF DB 0 L EQU ABUF-BUF 求L的值为多少？ 答：L=6 4. 假设程序中的数据定义如下： PAR DW ? PNAME DB 16 DUP(?) COUNT DD ? PLENTH EQU $-PAR 求PLENTH的值为多少？表示什么意义？ 答：PAR的偏移地址为0，PLENTH当前偏移地址$=2+16+4=22， $-PAR=22，故PLENTH 的值为22。 若在PLENTH所在行有变量定义，则$表示该变量的偏移地址，即$表示PLENTH所在行的当前偏移地址。故PLENTH表示从当前行到PAR之间定义的变量所占的字节个数。 5. 对于下面的数据定义，各条MOV指令执行后，有关寄存器的内容是什么？ DA1 DB ? DA2 DW 10 DUP(?) DA3 DB ‘ABCD’ MOV AX, TYPE DA1 MOV BX, SIZE DA2

java实验报告 接口、泛型、枚举、内部类与异常

实验报告 课程名称： Java程序设计成绩评定： 实验项目名称：接口、泛型、枚举、内部类与异常指导教师： 学生姓名：学号：专业班级： 实验项目类型：基础实验地点：实验时间： 一、实验目的与要求： 1、理解接口的定义与实现； 2、知道泛型、枚举型与内部类的基本应用； 3、掌握常用异常的抛出与捕获及处理. 二、实验环境：（硬件环境、软件环境） 1.硬件环境：奔ⅣPC。 2.软件环境：Windows XP 操作系统，JDK6.0。 三、实验内容：（原理、操作步骤、程序代码等） 任务： 1、按照要求完成下述接口及实现类的程序 1)定义名称为PCI（）的接口，包括启动的方法start和关闭的方法stop； 2)定义名称为NetworkCard 的类表示网卡，实现PCI接口，并且其在实现start 方法时输出“sending data……”，在实现stop方法时输出“network stop.” 3)定义名称为SoundCard 的类表示声卡，实现PCI接口；并且其在实现start 方法时输出“dudu……”，在实现stop方法时输出“sound stop.” 4)定义名称为MainBoard 的类表示主板，包含方法public void usePCICard(PCI p)，在方法体内通过p来启动和关闭组件； 5)定义一个包含main方法的Test类，在main方法内创建一个MainBoard 对 象用mb来引用，创建一个NetworkCard对象用nc来引用，创建一个 SoundCard对象用sc来引用，分别通过mb来使用usePCICard(PCI p)启动声 卡和网卡。 2、泛型类程序的调试 调试教材P165的程序8-2，写出程序运行结果，理解泛型类的工作机理及应用。 3、调试运行内部类程序： 在类内部再定义另外一个类，这个另外定义的类就叫内部类。调试教材P171-172程序8-3，写出程序运行结果，理解内部类的定义方法与应用。 4、异常抛出与捕获编程与调试 先调试教材P182、183中的程序9-2和9-3，写出调试结果。然后，自己编写一个能抛出并捕获、处理NullPointerException、NumberFormanException多异常的程序，并调试后写出运行结果。

接口的定义及使用

1、课程名称：接口的定义及使用 2、知识点 2.1、上次课程的主要知识点 1、抽象类的设计是在普通类之上的抽象类； 2、抽象类关键的问题就是约定了子类必须要覆写的抽象方法； 3、抽象类的使用原则： ·抽象类必须有子类，子类利用extends关键字来继承抽象类，一个子类只能够继承一个父类； ·抽象类的子类（如果不是抽象类），那么必须要覆写抽象类中的全部抽象方法； ·抽象类可以利用对象的向上转型机制，通过子类对象进行实例化操作。 2.2、本次预计讲解的知识点 1、接口的基本定义以及使用形式； 2、与接口有关的设计模式的初步认识； 3、接口与抽象类的区别。

3、具体内容（★★★★★★★★★★★★★★） 接口与抽象类相比，接口的使用几率是最高的，所有的设计几乎都是围绕着接口进行的，但是要想把接口彻底闹明白，需要很长一段时间。 3.1、接口的基本概念 接口是一种特殊的类，但是在接口里面的组成与类不同，比类的组成部分简单，主要由抽象方法和全局常量所组成。而接口使用interface关键字来定义。 范例：定义一个接口 当一个接口定义完成之后，需要遵循如下的步骤进行接口的使用： ·接口一定要定义子类，子类利用implements关键字来实现接口，一个子类可以同时实现多个接口； |- 秒杀抽象类的单继承局限，一个抽象类只能够被一个子类所继承； ·接口的子类（如果不是抽象类）那么必须覆写接口中的全部抽象方法； ·接口的对象利用子类对象的向上转型进行实例化操作。 范例：使用接口

但是这个时候会有这样一种比较神奇的操作。 注意：关于接口的组成描述 接口里面在定义的时候就已经明确的给出了开发要求：抽象方法和全局常量，所以以下两种接口的定义从本质上讲是完全一样的。 如果在定义接口方法的时候没有使用public ，那么本质上也不是default 权限，而默认就是public 。 很多时候为了防止一些开发者概念不清晰，所以以后建议大家在定义接口的时候永远都写上public ，但是一般都不会去写abstract 。 现在程序之中出现有类、抽象类、接口，这几者之间的联系就需要注意好了。 一个普通类如果要实现接口又要求继承抽象类，则一定采用先extends 继承抽象类，再implements 实现接口。格式： 范例：观察子类的多继承

Java中局部内部类可以访问它所在方法中定义的final修饰(精)

public class LocalInnerClassTest{ public static void main(String[] args{ Outer obj=new Outer(; //生成一个外部类对象 SuperInner si=obj.outer(; //调用外部类中的outer(方法，返回一个SuperInner类型对象赋值给si si.m1(; //调用被覆盖的方法m1(,输出：Inner's m1( 20 } } /** *定义一个接口SuperInner，内部定义一个抽象方法m1(,无返回类型 */ interface SuperInner{ public void m1(; } /** *定义一个类Outer，内部只定义一个方法outer(，返回类型为SuperInner */ class Outer{ public SuperInner outer({ int a=10; //方法中定义一个局部变量a，并赋值为10 final int b=20; //再定义一个final局部变量b，初始化为20 class Inner implements SuperInner{ //在outer(方法中定义一个局部内部类Inner,实现接口SuperInner public void m1({ //类中只有一个覆盖接口SuperInner的方法m1(

System.out.println("Inner's m1("+a; //编译报错 System.out.println("Inner's m1( "+b; //编译通过，输出：Inner's m1( 20 } } return new Inner(; } } 我们先从主方法开始看代码的执行顺序，先生成一个Outer类对象obj，obj调用本类中方法outer(；程序开始跳到outer(方法内执行程序语句，先后生成局部变量a和b,再定义一个局部内部类Inner，返回一个SuperInner类型的对象。将返回的SuperInner类型对象地址传给SuperInner类型对象si。si再调用m1(方法，因为已经在局部内部类中覆盖了接口中的m1(方法，所以将调用局部内部类中的m1(方法，程序跳到局部内部类中m1(方法内执行程序语句，先输出一段字符串和a，结果编译报错，先将这条程序语句隐藏，执行下面的语句，你会发现编译通过而且输出Inner's m1( 20！ 为什么会这样呢？大家都知道局部变量仅仅在一个范围内有效，在方法调用完就被内存释放，在Outer类对象obj调用outer(方法时，a和b才产生，调用结束后被内存释放，那么b这个值也就不复存在了，为什么还会输出20呢？难道局部变量被final修饰就不会被内存释放而保留？ 其实有部分操作对于程序员是透明的，那是JAVA语言开发者的小把戏，在定义a和b 时 JVM(JAVA虚拟机做了程序员看不到的操作，他将b拷贝了一份给局部内部类，也就是说JVM在局部内部类中定义了一个final int b=20；这个操作程序员是不知道的！当调用m1(方法时输出的20并不是原来outer(方法中定义的b，而仅仅是JVM拷贝的一个副本。那么为什么a没被打印出呢？那是因为JVM并没有拷贝它，因为没有final修饰，说明它可以被修改，如果把a 改为a++，此时JVM就不知道拷贝a还是a++了，所以对于无final修饰的局部变量JVM是不会拷贝传给局部内部类的，自然无法打输出！

第四章 练习题及答案

第四章练习题及答案 一、填空题 1、CPU与I／O接口间的信息一般包括______________三种类型。 答案：数据信息状态信息控制信息 2、CPU通过一个外设接口同外设之间交换的信息包括数据信息、状态信息和_________. 答案：控制信息 3、状态信息表示外设当前所处的_________，例如READY(就绪信号)表示输入设备已准备好信息，BUSY(忙信号)表示输出设备是否能接收数据。 答案：工作状态 4、控制信息是由CPU发出的、用于控制外设接口工作方式以及外设的_________的信息。 答案：启动和停止 5、74LS244是一种__________输出的八缓冲器和线驱动器。 答案：三态 6、74LS245是一种三态输出的__________总线收发器。 答案：八 7、在8086／8088工作于最大模式时，总线周期状态S2、Sl、S0中至少有一个状态为______________. 答案：低电平 8、当LOCK为_______时，其它总线主控部件都不能占用总线。 答案：低电平 9、在DMA期间，LOCK端处于________。 答案：高阻状态 10、在T2、T3、Tw、T4状态时，S6为________，表示8088／8086当前连在总线上。 答案：低电平 11、CPU与内存及I／O装置间传送数据的硬件线路通道称为________。 答案：总线 12、CPU中的总线接口部件BIU，根据执行部件EU的要求，完成CPU与_________________的数据传送。答案：存储器、I／O设备 13、各类微处理器的引脚信号即片总线，例如8086／8088CPU的地址线、数据线和控制线等即构成该芯片的__________。 答案：片总线 14、当存储器的读出时间大于CPU所要求的时间时，为了保证CPU与存储器的周期配合，就要利用_________信号，使CPU插人一个TW状态。 答案：READY 15、片总线通常包括地址总线、数据总线和_________总线等三组总线。 答案：控制 16、地址总线通常是_____总线，由CPU输出，8位微处理器有16条地址总线，16位微处理器有20条或更多。 答案：单向 17、总线通信协议主要是解决信息传输的开始和结束问题，是实现总线__________和信息传送的手段，常用的通信协议有同步方式和异步方式两种。 答案：仲裁 18、8086／8088CPU的数据线和地址线是以_________方式轮流使用的。 答案：分时

java练习(类与接口)

1. （分值：分）Java 语言中创建一个对象使用的关键字为 A: class B: interface C: new D: create 2. （分值：分）设有对象x 具有属性a 则访问该属性的方法为 A: B: () C: D: () 3. （分值：分）以public 修饰的类如：public class Car{…} 则Car( ) A: 可被其它程序包中的类使用 B: 仅能被本程序包中的类使用 C: 不能被任意其它类使用 D: 不能被其它类继承 4. （分值：分）Java 语言中，只限子类或者同一包中的类的方法能访问的访问权限是( ) A: public B: private C: protected D: <无修饰> 5. （分值：分）有Java 语句如下，则说法正确的是（）int ［］a,b=new int［3］; A: 此语句是错误的 B: 的值为3 C: 的值为3 D: 和的值都为3 6. （分值：分）设有数组定义int[][] x={{1，2}，{3，4，5}，{6}，{}}；，则的 值为( ) A: 3 B: 4 C: 6 D: 7 7. （分值：分）在Java 语言的包中，用于语言符号（单词）分析的类是（） A: stringTokenizer B: StringTokenizer C: ToKenizer D: tokenizer 8. （分值：分）接口的所有变量和方法分别默认为是（） A: final static 和public abstract B: final static 和public final C: public static 和public abstract D: public static 和public final 9. （分值：分）下列有关Java 的叙述错误的是（） A: 强类型语言 B: 与平台无关

内部类详解 1、定义 一个类的定义放在另一个类的内部,这个类就叫做内部类

内部类详解 1、定义 一个类的定义放在另一个类的内部，这个类就叫做内部类。 Java代码 1.public class First { 2.public class Contents{ 3. public void f(){ 4. System.out.println("In Class First's inner Class Contents method f()") ; 5. } 6.} 7. } 像这样的，Contents就叫做内部类 内部类了解外围类，并能与之通信(后面详细讲) 2、链接到外围类 创建了内部类对象时，它会与创造它的外围对象有了某种联系，于是能访问外围类的所有成员，不需任何特殊条件。 Java代码 1. public class First { 2.public class Contents{ 3. public void getStr(){ 4. System.out.println("First.str="+str); 5. } 6.} 7.private String str; 8. } 9. 在内部类Contents中，可以使用外围类First的字段str。 那么，它是如何实现的呢？ 是这样的，用外围类创建内部类对象时，此内部类对象会秘密的捕获一个指向外围类的引用，于是，可以通过这个引用来访问外围类的成员。 通常，这些都是编译器来处理，我们看不到，也不用关心这个。 正是因为如此，我们创建内部类对象时，必须与外围类对象相关联。

注：嵌套类(后面会讲到)除外。 3、使用关键字.this与.new 内部类中得到当前外围类对象的引用，可以使用.this关键字，注意与new的区别 Java代码 1. private int num ; 2.public Test2(){ 3. 4.} 5. 6.public Test2(int num){ 7. this.num = num; 8.} 9. 10.private class Inner{ 11. public Test2 getTest2(){ 12. return Test2.this; 13. } 14. 15. public Test2 newTest2(){ 16. return new Test2(); 17. } 18.} 19. 20.public static void main(String [] args){ 21. Test2 test = new Test2(5); 22. Test2.Inner inner = test.new Inner(); 23. Test2 test2 = inner.getTest2(); 24. Test2 test3 = inner.newTest2(); 25. System.out.println(test2.num); 26. System.out.println(test3.num); 27.} 28. 输出结果为5 0 使用.this后，得到时创建该内部类时使用的外围类对象的引用，new则是创建了一个新的引用。 .new关键字

java内部类,抽象类,继承,接口,异常的处理等

序 抽象类的特点： 1，抽象方法一定在抽象类中。 2，抽象方法和抽象类都必须被abstract关键字修饰。 3，抽象类不可以用new创建对象。因为调用抽象方法没意义。 4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。 如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。 抽象类和一般类没有太大的不同。 抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。 抽象类不可以实例化。 特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。 abstract 关键字，和哪些关键字不能共存。 final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。 private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。 而抽象方法出现的就是需要被复写。 static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。 可是抽象方法运行没意义。 抽象类中有构造函数,因为抽象类是一个父类，要给子类提供实例的初始化。 继承： 1，提高了代码的复用性。 2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。 注：不要为了获取其他类的功能，简化代码而继承。 必须是类与类之间有所属关系才可以继承。所属关系 is a。 Java语言中：java只支持单继承，不支持多继承。 因为多继承容易带来安全隐患:当多个父类中定义了相同功能， 当功能内容不同时，子类对象不确定要运行哪一个。 但是java保留这种机制。并用另一种体现形式来完成表示。多实现。 java支持多层继承。也就是一个继承体系

包、接口和事件

包、接口和事件 【课前思考】 1．什么是包？如何创建和使用包？ 2．什么是接口？如何声明和实现接口？ 2．在Java中如何处理事件？JDK1.0和JDK2.0处理事件有什么不同？ 【学习目标】 掌握如何创建和使用包，了解接口的概念，掌握接口的声明及其实现，理解在Java中如何处理事件，掌握AWT各个组件所采用的事件处理接口。 【学习指南】 理解概念，多实践，勤思考，举一反三。 【难重点】 重点： 接口的用法。 难点： 组件所采用的事件处理接口。 9.1 包 利用面向对象技术开发一个实际的系统时，通常需要定义许多类共同工作，为了更好地管理这些类，Java中引入了包的概念。就像文件夹(目录)把各种文件组织在一起，使硬盘更清晰、有条理一样，Java中的包把各种类组织在一起，使得程序功能清楚、结构分明。特别地，使用包可以有利于实现不同程序间类的复用。 包是一种松散的类的集合。一般不要求处于同一个包中的类有明确的相互关系，如包含、继承等，但是由于同一包中的类在缺省情况下可以互相访问，所以为了方便编程和管理，通常把需要在一起工作的类放在一个包里。 Java系统中包括io、lang、applet、awt、math、net、rmi、security、text、sql、util、beans 等包。 9.1.1创建包 在缺省情况下，系统会为每一个.java源文件创建一个无名包，该.java文件中定义的所有类都隶属于这个无名包，它们之间可以相互引用非private的属性或方法。但是由于这个无名包是没有名字的，所以它不能被其他包所引用，即无名包中的类不能被其他包中的类所引用和复用。为了解决这个问题，可以创建有名字的包。 创建包的语句需要使用关键字package，而且应该是整个.java文件的第一个语句。 package 包名； 利用这个语句就可以创建一个具有指定名字的包，当前 .java文件中的所有类都被放在这个包中。例如下面的语句是合法的创建包的语句： package StudentClass; package StudentClass.SubClass; 实际上，创建包就是在当前文件夹下创建一个子文件夹，以便存放这个包中包含的所有类的 .class文件。上面的第二个创建包的语句中的符号“.”代表了目录分隔符，即这个语句创建了两个文件夹。第一个是当前文件夹下的子文件夹StudentClass；第二个是StudentClass下的子文件夹SubClass，当前包中的所有类就存放在这个文件夹里。 【例9-1】 package com.StudentClass; public class specialStudent{ public static void main(String args[]){ System.out.println("Hello package");

Java接口,抽象类,内部类

最近看到论坛里有个帖子在讨论接口和抽象类的区别和作用，这其实也是很多面试官喜欢问的问题，这里我就说说我的总结，顺便说说内部类的作用，当是给刚入门，或者想学习jav a的同学们能更好的理解它们的用法。 2.抽象类(abstract class)，只要类中有一个抽象方法，此类就被标记为抽象类。实际上抽象类 除了被继承之外没有任何意义。 区别 1. 接口是公开(public)的，里面不能有私有的方法或变量,是用于让别人使用的,实现接口的一定 要实现接口里定义的所有方法。 而抽象类是可以有私有方法或私有变量的，实现抽象类可以有选择地重写需要用到的方法， 但是必须实现里面所有的抽象方法。 2. 抽象类在Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。 但是，一个类却可以实现多个interface(java中实现多重继承的方法之一)。 3. 抽象类中可以有自己的数据成员，也可以有非abstarct的成员方法。 而在接口中，只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在interface中一般不定义数据成员），而且所有的成员方法都是抽象的。 4. 抽象类和接口所反映出的设计理念不同。 其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。（组合是"has a"关 系） 5.

接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新 定义，也不能改变其值。 抽象类中的变量默认是friendly 型，其值可以在子类中重新定义，也可以重新赋值。 一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。不是很建议具体类直接实现接口的。还有一种设计模式是面向接口编程，而非面向实现编程。 其实接口是抽象类的延伸，可以将它看做是纯粹的抽象类，就是说接口比抽象类还抽象，还有设计接口的目的就是为了实现C++中的多重继承，不过java团队设计的一样更有趣的东西来实现这个功能，那就是内部类(inner class)。 一.定义 放在一个类的内部的类我们就叫内部类。 二.作用 1.内部类可以很好的实现隐藏,也就是封装性。一般的非内部类，是不允许有private 与prot ected权限的，但内部类可以 2.内部类拥有外围类的所有元素的访问权限 3.可是实现多重继承(这个特点非常重要，个人认为它是内部类存在的最大理由之一) 4.可以避免修改接口而实现同一个类中两种同名方法的调用 三.多重继承的实现

实验4 接口和内部类

实验四接口和内部类 一、实验目的：熟悉JA V A中的接口、内部类、匿名类、异常类的概念及用法。 二、实验要求： 1.设计一个动物声音“模拟器”，希望模拟器可以模拟许多动物的叫声，要求如下： ●编写接口Animal Animal接口有2个抽象方法cry()和getAnimalName()，即要求实现该接口的各种具体的动物给出自己的叫声和种类名称。 ●编写模拟器类Simulator 该类有一个playSound(Animal animal)方法，该方法的参数是Animal类型。即参数animal 可以调用实现Animal接口类重写的cry()方法播放具体动物的声音，调用重写的getAnimalName()方法显示动物种类的名称。 ●编写实现Animal接口的类：Dog和Cat类 各类的UML图如下所示： 在各类中通过构造方法实现对成员变量的初始化。 ●编写主类Application（用户程序） 在主类Application的main方法中至少包含如下代码。 Simulator simulator = new Simulator(); simulator.playSound(new Dog(“藏獒”)); simulator.playSound(new Cat(“加菲猫”)); 2．评价成绩：体操比赛计算选手成绩的办法是去掉一个最高分和最低分后再计算平均分，而学校考察一个班级的某科目的考试情况时，是计算全班同学的平均成绩。Gymnastics类和School类都实现了接口ComputerAverage接口，但实现的算法不同。 编写Java程序实现以上功能。

3．货车的装载量：货车要装载一批货物，货物由三种商品组成：电视、计算机和洗衣机。卡车需要计算出整批货物的重量。 要求有一个ComputeGoodsWeight接口，该接口中有一个方法： public double computeWeight() 有三个实现该接口的类：Television、Computer和WashMachine。这三个类通过实现接口的computeWeight()方法给出自重。 有一个Truck类，该类用ComputeGoodsWeight接口类型的数组作为成员（Truck类面向接口），那么该数组的单元就可以存放Television对象的引用、Computer对象的引用或WashMachine对象的引用。程序能输出Truck对象所装载的货物的总重量。 4．手机专卖店为了促销自己的产品，决定发行内部购物券，但其他商场不能发行该购物券。编写一个MobileShop类（模拟手机专卖店），该类中有一个名字为InnerPurchaseMoney 的内部类（模拟内部购物券）。 程序模板：请按模板要求，将代码替换为Java程序代码。 NewYear.java class MobileShop{ 代码1 //用内部类InnerPurchaseMoney声明对象purchaseMoney1 代码2 //用内部类InnerPurchaseMoney声明对象purchaseMoney2 private int mobileAmount; //手机数量 MobileShop(){ 代码3 //创建价值为20000的purchaseMoney1 代码4 //创建价值为10000的purchaseMoney2 } void setMobileAmount(int m){ mobileAmount=m; } int getMobileAmount(){ return mobileAmount; } class InnerPurchaseMoney{ int moneyValue; InnerPurchaseMoney(int m){ moneyValue=m; } void buyMobile(){ if(moneyValue>=20000){ mobileAmount=mobileAmount-6; System.out.println(“用价值”+moneyValue+”的内部购物券买了3部手机”); } else if(moneyValue<20000&&moneyValue>=10000){ mobileAmount=mobileAmount-3;