JAVA各章习题及答案- 副本

更新时间：2024-03-25 00:08:01 阅读量：综合文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

java一共有多少章推荐度：
相关推荐

面向对象程序设计—Java语言习题答案

第1章

一、选择题

1．下列选项中，不属于Java语言特点的一项是（ C ）。

（A）分布式（B）安全性（C）编译执行（D）面向对象

【解析】Java程序采用解释执行的方法。在系统编译运行Java程序时，Java编译器将Java程序转化为字节码，在运行时，解释器将编译得到的字节码进行解释执行。 2．在Java语言中，（ C ）是最基本的元素？

（A）方法（B）包（C）对象（D）接口【解析】构成Java程序的基本元素类（抽象的对象）。

3．编译一个定义了3个类和10个方法的Java源文件后，会产生（ D ）个字节码文件？扩展名是（ D ）？

（A）13个字节码文件，扩展名为.class （B）1个字节码文件，扩展名为.class （C）3个字节码文件，扩展名为.java （D）3个字节码文件，扩展名为.class 【解析】源文件中的每一个类编译后都会生成一个字节码文件，字节码文件的扩展名是.class。

4．在创建Applet应用程序时，需要用户考虑问题是（ B ）。

（A）窗口如何创建（B）绘制的图形在窗口中的位置（C）程序的框架（D）事件处理

【解析】创建Applet程序时必须继承系统类Applet，而Applet类中已经包含了如何创建窗口以及事件处理等内容，这类程序的框架也都是固定的，而绘制图形在窗口中的位置则需要由用户确定。

5．Java语言属于（ B ）种语言？

（A）面向机器的语言（B）面向对象的语言（C）面向过程的语言（D）面向操作系统的语言【解析】Java语言是一种纯面向对象的语言。

6．下列关于Application和Applet程序的说法中不正确的一项是（ B ）。

（A）Application使用解释器java.exe （B）Application不使用独立的解释器（C）Applet在浏览器中运行（D）Applet必须继承Java的Applet类

【解析】Application程序包含main()方法，它是一种独立执行的程序，因此必须使用独立的解释器解释执行。

7．下列选项中，不属于Java核心包的一项是（ A ）。

（A）javax.swing （B）java.io （C）java.utile （D）java.lang

【解析】凡是以java开头的包都是Java核心包，以javax开头的包则属于Java扩展包。 8．下列描述中，不正确的是（ A ）。

（A）不支持多线程（B）一个Java源文件不允许有多个公共类

（C）Java通过接口支持多重继承（D）Java程序分为Application和Applet两类【解析】Java是支持多线程的语言。

9．阅读下列代码，选出该代码段正确的文件名（ C ）。

class A{ void method1(){ System.out.println(\ } }

public class B{ void method2(){ System.out.println(\ } public static void main(String[] args){ System.out.println(\ } }

（A）A.java （B）A.class （C）B.java （D）B.class

【解析】Java源文件名必须和公共类的名字完全一样，源文件的扩展名为.java。 10．编译下面源程序会得到哪些文件（ D ）？

class A1{ }

class A2{ }

public class B{ public static void main(String[] args){ } }

（A）只有B.class文件（B）只有A1.class和A2.class文件（C）编译不成功（D）A1.class、A2.class和B.class文件

【解析】由于该程序包含3个类，每个类编译后都会生成1个字节码文件，因此编译后会生成以这3个类名命名的字节码文件。二、填空题

1．Java程序的编译和执行模式包括2点，是半编译和半解释。

2．Java语言支持 TCP/IP 协议，从而使得Java程序在分布式环境中能够很方便地访问处于不同地点的对象。

3．开发Java程序的一般步骤是：源程序编辑、生成字节码和解释执行。

4．每个Java Application程序可以包括许多方法，但是必须有且只能有一个 main() 方法，统一格式为 public static void main(String[] args) ，它是程序执行的入口。 5．JVM把字节码程序与各种不同的操作系统和硬件分开，使得Java程序独立于平台。 6．在Java程序中，能在WWW浏览器上运行的是 Applet 程序。 7．Java源程序文件和字节码文件的扩展名分别为 .java 和 .class 。

8．如果在Java程序中需要使用java.utile包中的所有类，则应该在程序开始处加上 import java.utitle.* 语句。

三、编程题

1．编写一个Java Application类型的程序，输出“This is my first Java Application！”。

【编程分析】要编写Java Application类型的程序，需要在JCreator中创建一个Java Application类型的工程，这时JCreator会自动创建程序框架，该框架包含一个公共类，其中包含一个main()方法。删除main()方法中自动生成的代码，编写自己的代码即可。由于该程序要求输出一句话，因此在main()方法中直接调用System.out.println()或System.out.print()方法即可实现。【参考程序】

public class X3_1 { public static void main(String args[]){ System.out.println(\ } }

【运行结果】

This is my first Java Application!

2．编写一个Java Applet类型的程序，输出“这是我的第一个Java Applet类型的程序”。【编程分析】要编写一个Java Applet类型的程序，首先利用JCreator创建一个Java Applet类型的工程，该工程自动创建两个文件，一个源文件（.java文件）和一个HTML文件（.html文件），源文件中包含一个公共类，其中包含两个方法，即init()方法和paint()方法，由于该程序只是要求输出一句话，因此只要将paint()方法中g.drawString()方法的第一个参数修改为要输出的内容即可。如果不是利用JCreator开发工具，而是利用J2SDK，则用户需要自己编写HTML文件。【参考程序】

import java.awt.*;

import java.applet.*;

public class X3_2 extends Applet { public void paint(Graphics g) { g.drawString(\这是我的第一个Java Applet类型的程序\ } }

【运行结果】

第4章

一、选择题

1．下列哪种类成员修饰符修饰的变量只能在本类中被访问？（ D ）（A）protected （B）public （C）default （D）private 【解析】只有私有访问权限修饰符才能限制变量只能在本类中被访问。 2．在Java语言中，哪一个包中的类是自动导入的？（ A ） A）java.lang B）java.awt C）java.io D）java.applet

【解析】只有java.lang包中的类能够被自动导入。

3．给出下面的程序代码：

public class X4_1_3 { private float a; public static void m ( ){ }

}

如何使成员变量a被方法m( )访问（ C ）

（A）将private float a改为protected float a（B）将private float a改为public float a （C）将private float a改为static float a （D）将private float a改为float a

【解析】static类型的方法只能访问static类型的数据成员。

4．有一个类B，下面为其构造方法的声明，正确的是（ B ）。（A）void B(int x) {} （B）B(int x) {} （C）b(int x) {} （D）void b(int x) {}

【解析】构造方法没有类型，且方法名与类名相同。

5．下面关于类的说法，不正确的是（ C ）。（A）类是同种对象的集合和抽象（B）类属于Java语言中的复合数据类型（C）类就是对象（D）对象是Java语言中的基本结构单位

【解析】类是对象的抽象，对象是类的实例，因此类和对象是有区别的。

6．下面关于方法的说法，不正确的是（ C ）。（A）Java中的构造方法名必须和类名相同

（B）方法体是对方法的实现，包括变量声明和合法语句

（C）如果一个类定义了构造方法，也可以用该类的默认构造方法（D）类的私有方法不能被其他类直接访问

【解析】类中一旦用户定义了构造方法，该类默认的构造方法就不存在了，除非用户再自定义该类的默认构造方法。

7．关于内部类，下列说法不正确的是（ A ）。（A）内部类不能有自己的成员方法和成员变量（B）内部类可用private或protected修饰符修饰

（C）内部类可以作为其他类的成员，而且可访问它所在的类的成员（D）除static内部类外，不能在类内声明static成员

【解析】内部类也可以有自己的成员方法和变量。

8．定义外部类时不能用到的关键字是（ C ）。（A）final （B）public （C）protected （D）abstract 【解析】定义外部类不能使用protected修饰符。

9．为AB类定义一个无返回值的方法f，使得使用类名就可以访问该方法，该方法头的

形式为（ D ）

（A）abstract void f() （B）public void f() （C）final void f() （D）static void f()

【解析】只有static类型的方法才可以直接使用类名来引用。

10．定义一个公有double型常量PI，哪一条语句最好？（ B ）

（A）public final double PI; （B）public final static double PI=3.14; （C）public final static double PI; （D）public static double PI=3.14;

【解析】用public final static来定义常量，既可以节省存储空间，又可以保证数值不会被改变。二、填空题

1．对象是对事物的抽象，而类是对对象的抽象和归纳。

2．从用户的角度看，Java源程序中的类分为两种：系统定义的类和用户自己定义的类。

3．一个类主要包含两个要素：数据成员和成员方法。 4．创建包时需要使用关键字 package 。

5．类中的构造方法是一个特殊的方法，该方法的方法名和类名相同。

6．如果用户在一个自定义类中未定义该类的构造方法，系统将为这个类定义一个默认构造方法。这个方法没有形式参数，也没有任何具体语句，不能完成任何操作。

7．静态数据成员被保存在类的内存区的公共存储单元中，而不是保存在某个对象的内存区中。因此，一个类的任何对象访问它时，存取到的都是相同（相同/不同）的数值。

8．静态数据成员既可以通过对象名来访问，也可以通过类名直接访问它。

9．定义常量时要用关键字 final ，同时需要说明常量的数据类型并指出常量的具体值。

10．方法体内定义变量时，变量前不能加修饰符；局部变量在使用前必须明确赋值，否则编译时会出错；而类变量在使用前可以不用赋值，它们都有一个默认的值。

11．static方法中只能引用 static 类型的数据成员和 static 类型的成员方法；而非static类型的方法中既可以引用 static 类型的数据成员和成员方法，也可以引用非static 类型的数据成员和成员方法。

12．引用static类型的方法时，可以使用类名做前缀，也可以使用对象名做前缀。 13．当程序中需要引用java.awt.event包中的类时，导入该包中类的语句为 import java.awt.event.*。

14．定义类时需要 class 关键字，继承类时需要 extends 关键字，实现接口时需要关键字 implements 。三、编程题

1．编一个程序，程序中包含以下内容：一个圆类(Circle)，包含：

属性：圆半径radius；常量：PI。

方法：构造方法；求面积方法area()；求周长方法：perimeter()。主类(X4_3_1)，包含：

主方法main()，在主方法中创建圆类的对象c1和c2并初始化，c1的半径为100，c1的半径为200，然后分别显示两个圆的面积和周长。

【编程分析】按照要求创建Circle类，其中的半径可以定义为int类型，PI定义为final static

double类型，求面积和周长的方法都应定义为double类型，在构造方法中对radius进行初始化。

【参考答案】

public class X4_3_1 {

public static void main(String[] args) { Circle c1 = new Circle(100); Circle c2 = new Circle(200);

System.out.println(\ System.out.println(\ } }

class Circle{ int radius; final static double PI=3.14; Circle(int r){ radius = r; } double area(){ return PI*radius*radius; } double perimeter(){ return 2*PI*radius; } }

【运行结果】

c1.area() = 31400.0 c1.perimenter() = 628.0 c2.area() = 125600.0 c2.perimenter() = 1256.0 2．编一个程序，程序中包含以下内容：

一个学生类（Student），包含：

属性：学号s_No，姓名s_Name，性别s_Sex，年龄s_Age。

方法：构造方法，显示学号方法showNo()，显示姓名方法showName()，显示性别方法showSex()，显示年龄方法showAge()，修改年龄方法modifyAge()。

主类(X4_3_2)，包含：主方法main()，在其中创建两个学生对象s1和s2并初始化，两个对象的属性自行确定，然后分别显示这两个学生的学号、姓名、性别、年龄，然后修改s1的年龄并显示修改后的结果。

【编程分析】按照要求首先编写Student类，其中的属性和方法根据实际情况选择相应的类型和权限修饰符，要通过方法来修改年龄，因此s_Age属性应该为private类型，否则可以直接在主类中进行修改，就没有必要使用方法了。【参考答案】

public class X4_3_2 {

public static void main(String[] args) {

Student s1 = new Student(101,\张三\男\ Student s2 = new Student(102,\李四\女\

System.out.println(\第1个学生的信息为：\ s1.showNo(); s1.showName(); s1.showSex(); s1.showAge();

System.out.println(\第2个学生的信息为：\ s2.showNo(); s2.showName(); s2.showSex(); s2.showAge();

System.out.println(\修改第1个学生的年龄：\ s1.modifyAge(24);

System.out.println(\第1个学生的年龄修改为：\ s1.showAge(); } }

class Student{ private int s_No; private String s_Name; private String s_Sex; private int s_Age; Student(int no, String name, String sex, int age){ s_No = no; s_Name = name; s_Sex = sex; s_Age = age; } void showNo(){ System.out.println(\学号：\ } void showName(){ System.out.println(\姓名：\ } void showSex(){ System.out.println(\性别：\ } void showAge(){ System.out.println(\年龄：\ } void modifyAge(int newAge){ s_Age = newAge; } }

【运行结果】第1个学生的信息为：学号：101 姓名：张三性别：男年龄：18

第2个学生的信息为：学号：102 姓名：李四性别：女年龄：16

修改第1个学生的年龄：第1个学生的年龄修改为：年龄：24

第5章

一、选择题

1．已知有下面类的说明：

public class X5_1_1 extends x{ private float f =10.6f; int i=16; static int si=10;

public static void main(String[] args) { X5_1_1 x=new X5_1_1(); } }

在main()方法中，下面哪条语句的用法是正确的？（ A ） A．x.f B．this.si C．X5_1_1.i D．X5_1_1.f

【解析】由于x是在main方法内部定义的对象，因此它可以引用类的非static类型的属性，因此选A，而this和super不能在main方法中使用，使用类名只能引用本类的静态属性，因此B、C、D不对。

2．下列程序的运行结果是（ C ）。

public class X5_1_2 extends x{

int ab(){ static int aa=10; aa++; System.out.println(aa); }

public static void main(String[] args) { X5_1_2 x=new X5_1_2(); x.ab(); } }

A．10 B．11 C．编译错误 D．运行成功，但不输出【解析】方法体内的局部变量不能使用static修饰符。 3．下面关于接口的说法中不正确的是（ C ）。 A．接口中所有的方法都是抽象的

B．接口中所有的方法都是public访问权限

C．子接口继承父接口所用的关键字是implements D．接口是Java中的特殊类，包含常量和抽象方法【解析】子接口继承父接口所用的关键字也是extends，只有类实现接口时才使用implements。 4．区分类中重载方法的依据是（ A ）。 A．形参列表的类型和顺序 B．不同的形参名称 C．返回值的类型不同 D．访问权限不同【解析】形参表的类型和顺序不同时区分重载方法的唯一标志。

5．子类对象能否直接向其父类赋值？父类对象能否向其子类赋值？（ B ） A．能，能 B．能，不能 C．不能，能 D．不能，不能【解析】子类对象可以直接赋值给父类对象，而父类对象不能直接赋值给子类对象。 6．Java语言类间的继承关系是（ A ）。 A．单继承 B．多重继承 C．不能继承 D．不一定【解析】Java语言类间的继承关系是单继承，但一个类可以实现多个接口。 7．Java语言接口间的继承关系是（ B ）。 A．单继承 B．多重继承 C．不能继承 D．不一定【解析】Java语言接口间的继承关系允许多重继承。 8．一个类实现接口的情况是（ A ）。 A．一次可以实现多个接口 B．一次只能实现一个接口 C．不能实现接口 D．不一定【解析】Java语言允许一个类一次实现多个接口。 9．定义外部类的类头时，不可用的关键字是（ C ）。 A．public B．final C．protected D．abstract 【解析】定义外部类时不能使用protected关键字。

10．如果局部变量和成员变量同名，如何在局部变量作用域内引用成员变量？（ B ）

A．不能引用，必须改名，使它们的名称不相同 B．在成员变量前加this，使用this访问该成员变量 C．在成员变量前加super，使用super访问该成员变量 D．不影响，系统可以自己区分【解析】this可以用来引用本类对象。 11．下面说法不正确的是（ B ）。

A．抽象类既可以做父类，也可以做子类 B．abstract和final能同时修饰一个类

C．抽象类中可以没有抽象方法，有抽象方法的类一定是抽象类或接口 D．声明为final类型的方法不能在其子类中重新定义

【解析】abstract和final不能同时修饰一个类，因为abstract类需要子类，而final类不能有子类。

二、填空题

1．消息就是向对象发出服务请求，是对数据成员和成员方法的引用。 2．在面向对象系统中，消息分为两类公有消息和私有消息。

3．在面向对象程序设计中，采用继承机制可以有效地组织程序结构。充分利用已有的类

来创建更复杂的类，大大提高程序开发的效率，提高代码的复用率，降低维护的工作量。 4．数据成员的隐藏是指在子类中重新定义一个与父类中已定义的数据成员名完全相同的

数据成员。

5．子类可以重新定义与父类同名的成员方法，实现对父类方法的覆盖。 6．子类在重新定义父类已有的方法时，应保持与父类完全相同的方法名、返回值类型和

参数列表，否则就不是方法的覆盖，而是子类定义自己特有的方法，与父类的方法无关。 7．this代表了当前对象的一个引用，super表示的是当前对象的直接父类对象的引用。 8．抽象类不能创建对象，该工作由抽象类派生的非抽象子类来实现。

9．如果父类中已有同名的abstract方法，则子类中就不能（能/不能）再有同名的抽象

方法。

10．abstract类中不能有 private 访问权限的数据成员或成员方法。

11． interface 是声明接口的关键字，可以把它看成一个特殊类。接口中的数据成员默认的

修饰符是 public static final ，接口中的成员方法默认的修饰符是 public abstract 。 12．如果实现某接口的类不是abstract的抽象类，则在类的定义部分必须实现该接口的

所有抽象方法；如果实现某接口的类是abstract的抽象类，则它可以不实现该接口所有的方法。但是对于这个抽象类任何一个非抽象的子类而言，它们父类所实现的接口中的所有抽象方法以及自身所实现接口中的抽象方法都必须有实在的方法体。 13．包的作用有两个，一是划分类名空间，二是控制类之间的访问。

14．封装也称信息隐藏，是指类的设计者只为类的使用者提供类的可以访问的部分（包

括类的数据成员和成员方法），而把类中的其他成员隐藏起来，使用户不能访问的机制。

15．Java提供了4种访问权限来实现封装机制，即 private 、 protected 、默认和 public 。 16．Java中提供两种多态机制，重载与覆盖。

17．当一个构造方法需要调用另一个构造方法时，可以使用关键字 this ，同时这个调用语

句应该是整个构造方法的第一条可执行语句。

18．如果子类自己没有构造方法，那么父类也一定没有（有/没有）带参的构造方法，此

时它将继承父类的无参构造方法作为自己的构造方法；如果子类自己定义了构造方法，则在创建新对象时，它将先执行父类的构造方法，然后再执行自己的构造方法。 19．对于父类的含参数构造方法，子类可以通过在自己的构造方法中使用 super 关键字来调用它，但这个调用语句必须是子类构造方法的第一条可执行语句。

20．创建一个名为myPachkage的包的语句为 package myPackage; ，该语句应该放在程序第一行位置。三、编程题

1．编写一个实现方法重载的程序。

【编程分析】重载的含义就是在一个类中定义多个具有相同方法名，不同参数列表的方法。在下面程序中的类中定义了三个同名方法area，分别用于求圆、矩形和三角形的面积。三个方法具有不同的参数。【参考程序】

public class X5_3_1{ public double area(double radius){ return Math.PI*radius*radius; } public double area(double width, double height){ return width*height; } public double area(double a, double b, double c){

double s = (a+b+c)/2; return Math.sqrt(s*(s-a)*(s-b)*(s-c)); } public static void main(String[] args){ X5_3_1 shape = new X5_3_1(); System.out.println(\ System.out.println(\ System.out.println(\ } }

【运行结果】

The area of circle is: 314.1592653589793 The area of rectangle is: 200.0

The area of triangle is: 72.61843774138907 2．编写一个实现方法覆盖的程序。

【编程分析】方法覆盖是指在子类中重新定义了父类中的方法。本例中在Shape类、Circle类、Cylinder类中都定义了area方法，而且Cylinder类继承了Circle类、Circle类继承了Shape类，从而实现了area方法的覆盖。【参考程序】

abstract class Shape { abstract protected double area(); }

class Circle extends Shape{ float r;

public Circle(float a) { r=a; }

public double area(){ System.out.print(\ \ return Math.PI*r*r; } }

class Cylinder extends Circle { float h;

public Cylinder(float a,float b) { super(a); h=b; }

public double area() { System.out.print(\ \ return 2*Math.PI*r*r+2*Math.PI*r*h; } }

public class EX5_3_2 { public static void main(String args[]) { Circle cl=new Circle(3); Cylinder cd=new Cylinder(2,5); System.out.println(cl.area()); System.out.println(cd.area()); } }

【运行结果】

Calculate the area of circle: 28.274333882308138 Calculate the area of cylinder: 87.96459430051421 3．编写一个实现数据成员隐藏的程序。【编程分析】数据成员的隐藏是指子类和父类都有一个相同的数据成员，当子类对象调用该数据成员时，默认调用子类的该成员，而不是父类的该成员，相当于隐藏了父类的该成员。本例中Hide类中定义了数据成员x，该类的子类X_5_3_3中也定义了数据成员x，当子类对象调用x时，调用的是子类的x，而不是父类的x。【参考程序】

public class X5_3_3 extends Hide { int x = 200; public static void main(String args[]) { X5_3_3 obj = new X5_3_3 (); System.out.println(\// 数据成员的隐藏 } }

class Hide{ int x = 100; }

【运行结果】

x = 200

4．编写一个使用this和super关键字的程序。

【编程分析】this关键字表示当前对象本身，而super关键字则是当前对象的直接父类对象。本例程序中定义了两个类X1和X2，其中都定义了成员变量x、y。此时就需要区分父类与子类的成员变量，采用super引用父类的成员变量和方法。

注意：父类和子类中都定义了show()方法，如果没有特别指定，则是调用当前类的方法。【参考程序】

public class X5_3_4{ public static void main(String[] args){ X2 x = new X2(5); x.setY(); x.show(); System.out.println(\// 输出父类数据成员y System.out.println(\ // 输出子类数据成员y } }

class X1{ int x,y; X1(int i){ x=i; y=x*2; } int getY(){ return y; } void show(){ System.out.println(\ } }

class X2 extends X1{ int x,y; X2(int j){ super(3); // 利用super来调用父类的构造方法 this.x=j; // 利用this来调用本类的数据成员x } void show(){ System.out.println(\// 输出父类和子类的属性x } void setY(){ y=super.x+this.x; // 引用父类和子类中的数据成员x } }

【运行结果】

super.x=3 this.x=5 super.y=6 this.y=8

5．编写一个人类Person，其中包含姓名、性别和年龄的属性，包含构造方法以及显示姓名、性别和年龄的方法。再编写一个学生类Student，它继承Person类，其中包含学号属性，包含构造方法以及显示学号的方法。最后编写一个主类X5_3_5，包含main()方法，在main()方法中定义两个学生s1和s2并给他们赋值，最后显示他们的学号、姓名、性别以及年龄。

【编程分析】本题主要考察类的继承问题。

第一步：定义Person类。

第二步：定义Student类，该类继承Person类。第三步：定义主类。【参考程序】

public class X5_3_5 {

public static void main(String[] args) {

Student s1=new Student(\

Student s2=new Student(\ s1.show(); s1.showID(); s2.show(); s2.showID(); } }

class Person{ String name; String sex; int age;

public Person(String n,String s,int a){ name = n; sex = s; age = a; }

void show(){

System.out.println(\ System.out.println(\ System.out.println(\ } }

class Student extends Person{ String sID;

public Student(String n,String s,int a,String sid){ super(n,s,a); sID = sid; }

void showID(){

System.out.println(\ } }

【运行结果】

name: Zhangsan sex: Male age: 20 sID: 102A name: Lisi sex: Female age: 18 sID: 108S

6．编一个程序，包含以下文件。

（1）Shape.java文件，在该文件中定义接口Shape，该接口在shape包中。属性：PI。

方法：求面积的方法area()。

（2）Circle.java文件，在该文件中定义圆类Circle，该类在circle包中，实现Shape接口。属性：圆半径radius。

方法：构造方法；实现接口中求面积方法area()；求周长方法perimeter()。（3）“Cylinder.java”文件，在该文件中定义圆柱体类Cylinder，该类口在cylinder包中，

继承圆类。

属性：圆柱体高度height。

方法：构造方法；求表面积方法area()；求体积方法volume()。

（4）X5_3_6.java文件，在该文件中定义主类X5_3_6，该类在默认包中，其中包含主方法main()，在主方法中创建两个圆类对象cir1和cir2，具体尺寸自己确定，并显示圆的面积和周长；再创建两个圆柱体类的对象cy1和cy2，具体尺寸自己确定，然后分别显示圆柱体cy1和cy2的底圆的面积和周长以及它们各自的体积和表面积。

【编程分析】本题主要考察接口、包、继承、封装等问题。编程步骤如下：

第一步：首先创建p1包，在其中创建Shape接口

// Shape.java文件

package p1; // 创建p1包 public interface Shape{ // 定义Shape接口 … }

第二步：创建Circle类和Cylinder类，它们都定义在p2包中。

// Circle.java文件

package p2; // 创建p2包 import p1.*;

public class Circle implements Shape{ // 定义实现Shape接口的Circle类 … }

// Cylinder.java文件 package p2;

public class Cylinder extends Circle{ // 创建继承Circle类的Cylinder类 … }

第三步：创建主类，在其中的main()方法中创建对象，实现相应的功能。

// X5_3_6.java文件 package p3; import p2.*;