一、单项选择题
1．下列不属于面向对象编程的特性的是（ ）。
A．封装 B．继承
C．抽象 D．多态
2．（*）下述概念中不属于面向对象的是（ ）。
A．对象、消息 B．继承、多态
C．类、封装 D．过程调用
3．（*）对象是Java中很重要的概念，下列说法中能准确地描述对象的是（ ）。
A．对象可以理解为一种数据结构，具有操作数据的方法
B．对象是抽象的，类可以通过对象来生成
C．对象只是方法的集合
D．对象是一组具有共同的结构和行为的类
4．（*）下面有关变量及其作用域的陈述哪一项是错误的？（ ）
A．在方法里面定义的局部变量在方法退出的时候被撤销
B．局部变量只在定义它的方法内有效
C．在方法外面定义的实例变量在对象被构造时创建
D．在方法中定义的方法的参变量只要该对象被需要就一直存在
5．下列类的声明中不合法的是（ ）。
A．class Flower{ }
B．class中国人 { }
C．privateclass SuperStar { }
D．public classA { }
6．下列方法的声明中不合法的是（ ）。
A．float play(){ return 1; }
B．void play(intd,e) { }
C．double play(intd) { return 2.0; }
D．int play(intr) { return 1; }
7．下列哪个方法不能与方法publicvoid add(int a){ }重载？（ ）
A．public intadd(int b) { }
B．public voidadd(double b) { }
C．public voidadd(int a, int b) { }
D．public voidadd(float g) { }
8．类Test定义如下：
1．public classTest {
2． floatuse(float a, float b) {
3． }
4．
5．}
将以下哪种方法插入第4行是不合法的？（ ）
A．float use(floata, float b, float c) { }
B．float use(floatc, float d) { }
C．int use(int a,int b) { }
D．float use(inta, int b, int c) { }
9．为了区分重载多态中同名的不同方法，要求（ ）。
A．采用不同的参数列表
B．返回值类型不同
C．调用时用类名或对象名做前缀
D．参数名不同
10．下列有关构造方法描述正确的是（ ）。
A．所有类都必须定义一个构造方法
B．构造方法必须有返回值
C．构造方法必须访问类的非静态成员
D．构造方法可以初始化类的成员变量
11．下列关于构造方法的叙述中，错误的是（ ）。
A．构造方法名与类名必须相同
B．构造方法没有返回值，但不用void声明
C．构造方法不可以重载
D．构造方法只能通过new自动调用
12．设A为已定义的类名，下列声明对象a的语句中正确的是（ ）。
A．public A a =new A( );
B．A a = A( );
C．A a = new A();
D．a A;
13．给出如下类定义：
public class Test {
Test(int i) {
}
}
如果要创建一个该类的对象，正确的语句是（ ）。
A．Test t = newTest();
B．Test t = newTest(5);
C．Test t = newTest("5");
D．Test t = newTest(3.4);
14．（*）下面哪些说法是正确的？（ ）
A．用new运算符来创建的对象，在JVM退出时才会被当做垃圾回收
B．判断一个对象是否可以被垃圾回收的条件为是否还有对该对象的引用
C．Java方法的参数传递规定，使用new来创建的对象为地址传递
D．Java方法支持重载，但方法必须至少参数或返回值的类型不同
15．以下代码的调试结果为（ ）。
class Square {
int a;
void Square() {
a = 10;
}
public static void main(String[] args) {
Square s = new Square();
System.out.println(s.a);
}
}
A．输出10 B．编译错误
C．输出0 D．运行错误
16．下面程序的输出结果是（ ）。
class Test {
int i = 2;
String s = null;
void Test() {
i = 3;
s = "days";
}
public static void main(String args[]) {
Test t = new Test();
System.out.println(t.i + t.s);
}
}
A．2null B．3null
C．3days D．以上都不对
17．编译并运行下面的Java程序，将产生什么结果？（ ）
class A {
int i = 1;
int j;
public static void main(String[] args) {
int k;
A a = new A();
System.out.println(a.i + a.j + k);
}
}
A．0 B．1
C．2 D．出现编译错误
18．如下代码的输出结果是（ ）。
public class Test {
void printValue(int m) {
do {
System.out.println("The value is " + m);
} while (--m > 10);
}
public static void main(String arg[]) {
int i = 10;
Test t = new Test();
t.printValue(i);
}
}
A．The value is8 B．Thevalue is 9
C．The value is10 D．Thevalue is 11
19．如下代码的输出结果是（ ）。
class Point {
int x, y;
Point(int a, int b) {
x = a;
y = b;
}
}
class Test {
public static void main(String[] args) {
Point p1, p2;
p1 = new Point(3, 6);
p2 = new Point(8, 9);
p1 = p2;
System.out.println("p1.x= " + p1.x + ", p1.y = " + p1.y);
}
}
A．p1.x = 3, p1.y = 6 B．p1.x = 3, p1.y= 9
C．p1.x = 8, p1.y = 6 D．p1.x = 8, p1.y= 9
20．下列关于变量的叙述哪个是错误的？（ ）
A．实例变量是类的成员变量
B．在方法中定义的局部变量在该方法被执行时创建
C．实例变量用关键词static声明
D．局部变量在使用前必须被初始化
21．编译和运行下面代码时显示的结果是（ ）。
public class MyClass {
static int i;
public static void main(String argv[]) {
System.out.println(i);
}
}
A．编译错误 B．null
C．1 D．0
22．下列程序运行的结果是（ ）。
public class A {
int z = 2;
staticvoid f(int y) {
y= z;
System.out.println(y);
}
public static void main(String args[]) {
f(1);
}
}
A．1 B．2
C．程序编译错误 D．以上都不对
23．下列程序运行的结果是（ ）。
public class Test {
static short index;
static int age;
public static void setData(long n) {
index = n;
}
public static void main(String args[]) {
setData(9);
System.out.println("index = " + index + "; age= " + age);
}
}
A．index = 9;age = 0 B．index = 0; age = 0
C．index = 0;age = 9 D．以上都不对
24．下列程序运行的结果是（ ）。
class Point {
static int x;
int y;
}
class Test {
public static void main(String args[]) {
Point p1 = new Point();
Point p2 = new Point();
p1.x = 10;
p1.y= 20;
System.out.print(p2.x+ ", ");
System.out.print(p2.y);
}
}
A．0, 0 B．10, 0
C．0, 20 D．10, 20
25．下面关于Java语言中实例方法和类方法的说法，哪一项是对的？（ ）
A．实例方法可以直接通过类名调用
B．类方法可以通过类名调用，不能通过对象调用
C．实例方法可以直接操作实例变量也可以直接操作类变量
D．类方法可以直接操作实例变量也可以直接操作类变量
26．下列程序运行的结果是（ ）。
class People {
float height;
static float weight;
}
class TestPeople {
public static void main(String args[]) {
People baJie;
baJie = new People();
People wuKong = new People();
baJie.height = 10;
People.weight = 200;
System.out.print(wuKong.height + ", ");
System.out.print(wuKong.weight);
}
}
A．0, 200 B．10, 200
C．0.0, 200.0 D．10.0, 200.0
27．（*）下列程序运行的结果是（ ）。
class Counter {
static int total;
int number;
Counter() {
total++;
number++;
}
}
class Statistics {
public static void main(String args[]) {
Counter c = null;
for (int i = 1; i < 3; i++)
c = new Counter();
System.out.println("number = " + c.number + "/ total = " + c.total);
}
}
A．number = 1 /total = 1
B．number = 1 /total = 2
C．number = 2 /total = 2
D．number = 2 /total = 1
28．下面程序运行之后，变量x的值是（ ）。
public class Test {
public static void swap(int a, int b) {
int t = a;
a = b;
b = t;
}
public static void main(String args[]) {
int x = 1;
int y = 2;
swap(x, y);
}
}
A．1 B．2
C．0 D．以上均不对
29．（*）以下代码的输出结果为（ ）。
public class Pass {
static int j = 3;
public static void main(String args[]) {
int i = 5;
Pass p = new Pass();
p.amethod(i);
System.out.println(i + " and " + j);
}
public void amethod(int x) {
x = x * 2;
j = j * 2;
}
}
A．错误：方法参数与变量不匹配
B．5 and 6
C．5 and 3
D．10 and 6
30．（*）下列程序编译和运行的结果是（ ）。
public class Ref {
public static void main(String args[]) {
Ref r = new Ref();
r.show(r);
}
public void show(Ref r) {
int i = 9;
change(r);
System.out.println(i);
}
public void change(Ref r) {
r.i = r.i * 2;
}
}
A．编译出错 B．输出：9
C．输出：18 D．运行出错
31．下列程序的运行结果是（ ）。
public class Test {
public static void test() {
this.print();
}
public static void print() {
System.out.println("3Q");
}
public static void main(String args[]) {
test();
}
}
A．输出3Q B．无输出结果
C．编译错误 D．以上都不对
32．在Java中，用package语句说明一个包时，该包的层次结构必须（ ）。
A．与文件的结构相同 B．与文件目录的层次相同
C．与文件类型相同 D．与文件大小相同
33．在Java中，下面关于包的陈述中正确的是（ ）。
A．包的声明必须是源文件的第一句代码，前面连注释也不能写
B．包的声明必须紧跟在import语句的后面
C．只有公共类才能放在包中
D．可以将多个源文件中的类放在同一个包中
34．为了使包com在当前程序中可见，可以使用的语句是（ ）。
A．import com.*;
B．package com.*;
C．import com;
D．package com;
35．在Java语言中，下列哪个包是编译器自动导入的？（ ）
A．java.util B．java.lang
C．java.io D．java.text
36．可以在下面代码段pointa处写入的是（ ）。
// point a
public class Interesting{
// do something
}
A．String str;
B．static intPI = 3.14;
C．public classMyClass{ // do other thin }
D．import java.awt.*;
37．定义主类的类头时可以使用的访问控制符是（ ）。
A．private B．protected
C．public D．protected、public
38．以下说法中正确的是（ ）。
A．一个类只能引用与它在同一个包中的类，不能引用不同包中的类
B．实际上，创建包就是在当前文件夹下创建一个子文件夹，以便存放这个包中包含的所有类的.class文件
C．使用包可以有利于实现不同程序间类的复用
D．任何情况下，使用其他包中的public类都可以通过import语句来引用
39．关于被私有访问控制符private修饰的成员变量，以下说法正确的是（ ）。
A．可以被三种类访问：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类
B．可以被两种类访问：该类本身、该类的所有子类
C．只能被该类自身访问
D．只能被同一个包中的类访问
40．当类的成员未用访问权限修饰符时，Java认为此成员的访问权限为（ ）。
A．private B．protected
C．public D．以上都不对
41．在Java中，如下不是成员变量和成员方法的访问控制修饰符的是（ ）。
A．static B．public
C．protected D．private
42．下面有关私有变量和私有方法的声明中，哪项叙述是对的？（ ）
A．用关键词private修饰的成员变量和方法，称为私有变量和私有方法
B．用关键词protected修饰的成员变量和方法，称为私有变量和私有方法
C．私有变量和私有方法可以被子类访问
D．私有变量不能通过对象直接访问
43．哪个修饰符定义的方法和变量只在定义它们的类中可见，而在其他的任何类中它们都不可见（ ）。
A．protected B．public
C．private D．noneof the above
44．下面代码执行后的结果是（ ）。
class Test {
private int i;
public static void main(String argv[]) {
Test t = new Test(99);
System.out.println(t.i - 5);
}
Test(int x) {
i = x + 10;
}
}
A．由于i是私有变量，因此产生一个编译失败错误
B．99
C．104
D．109
45．在类E的方法oper()中不可以通过对象t操作的变量是（ ）。
public class Test {
private int i = 10;
public int j = 20;
int k = 30;
}
class E {
void oper() {
Test t = new Test();
}
}
A．i B．j和k
C．j D．k
46．在类Two的方法test()中可以通过对象o操作的变量是（ ）。
package a;
public class One {
private int i = 1;
public int j = 2;
int k = 3;
}
package b;
import a.One;
class Two {
void test() {
One o = new One();
}
}
A．i B．i和k
C．j D．k
47．编译和运行以下两个文件的结果是（ ）。
// 文件A.java
packagea;
public class A {
public void test() {
System.out.println("What a fancy method");
}
}
// 文件 B.java
package b;
import a.*;
public class B {
public static void main(String argv[]) {
A p = new A();
p.test();
}
}
A．两个均通过编译，B运行时输出 What a fancy method
B．没一个通过编译
C．两个均通过编译，但B运行时出错
D．A通过编译，但B出现编译错误
48．（*）根据下面代码定义：
Integer i = new Integer(6);
Long l = new Long(8);
Double d = new Double(9);
下列表达式结果为false的是（ ）。
A．i == l B．i == d
C．i.equals(d) D．d ==l
49．（*）下面哪段程序不能正常运行？（ ）
A．Character c= new Character('a');
B．int i = 1;Integer it = new Integer(i);
C．Boolean b =new Boolean("hello");
D．Long l = newLong("hello");
二、简答题
1．简述面向对象编程的三个主要特征。
2．简述对象与类之间的关系。
3．成员变量与局部变量有什么区别？
4．什么是方法的重载？
5．简述构造方法的特点和功能。
6．简述类变量和实例变量的区别。
7．包有什么作用？如何导入包中的类？
8．简述类、成员变量和成员方法都有几种访问权限？各自代表什么含义？
三、编程题
1．定义立方体类Cube，具有属性边长和颜色，具有方法设置颜色和计算体积，在该类的主方法中创建一个立方体对象，将该对象的边长设置为3，颜色设置为“green”，输出该立方体的体积和颜色。
2．编写Java应用程序，该程序中有梯形类和主类。要求如下：
（1）梯形类具有属性上底、下底、高和面积，具有返回面积的功能，在构造方法中对上底、下底和高进行初始化。
（2）主类用来测试梯形类的功能。
3．按要求编写Java应用程序：
（1）定义描述学生的类Student，有一个构造方法对属性进行初始化，一个outPut方法用于输出学生的信息。
（2）定义主类，创建两个Student类的对象，测试其功能。
4．定义Point类，表示二维坐标中的一个点，有属性横坐标x和纵坐标y，还有用来获取和设置坐标值，以及计算到原点距离平方值的方法。定义一个构造方法初始化x和y。在主类中创建两个点对象，分别使用两个对象调用相应方法，输出x和y的值，以及到原点距离的平方。
5．定义狗类，具有属性：名字和年龄，有行为：喊叫和看门。在主类中创建一个狗对象，名字为“豆豆”，年龄为1岁，输出该对象的名字和年龄，并调用喊叫和看门方法。
6．按要求编写Java应用程序：
（1）定义西游记人物类，有属性：名字、身高和武器，有构造方法初始化属性，还有输出人物详细信息的方法。
（2）在主类的main方法中创建两个西游记人物对象，分别调用方法输出各自的详细信息。
7．定义一个时钟类Clock，用属性时、分、秒来表示时间，在构造方法中对属性进行初始化，成员方法printTime用于显示时钟对象的时间。定义主类TestClock，在主类的main方法中创建多个时钟类的对象，并输出这些对象的时间，格式参照“8：30：0”。
8．（*）定义机动车类，具有属性：车牌号、车速和载重量，具有功能：加速、减速。一个构造方法没有形参，在方法中将车牌号设置为“辽A1234”，速度为100，载重量为50；另一个构造方法用形参为对象的所有属性赋值。
在主类中创建两个机动车对象，创建第一个时调用无参数的构造方法，使其加速10。创建第二个时调用有参数的构造方法，使其车牌号为“辽B5678”，车速为80，载重量为20，并让其减速20。最后输出两辆车的所有信息。
9．（*）按要求编写Java应用程序。
（1）定义Teacher类，具有属性：教师的姓名、年龄、教授的课程以及是否担任班主任，方法printInfo输出教师的姓名、年龄和所教授的课程，构造方法为成员变量赋值。
（2）定义Team类，有属性：班级名称和班主任，有一个输出班级名称的方法，另一个是构造方法，为成员变量赋值。
（3）定义主类TestTeam，创建一个班级对象，输出班级名称和班主任的详细信息。
10．（*）按要求编写Java应用程序：
（1）定义圆形类Circle，具有属性半径，有求面积的方法getArea，在构造方法中用参数对属性进行初始化。圆周率取值为3.14。
（2）定义圆锥类Cone，属性有Circle类型的底bottom和double类型的高height，有求体积的方法getCubage，在构造方法中为属性赋值。
（3）定义主类TestCone，创建圆锥类的对象，并测试其功能。
11．（*）定义一个三角形类，具有属性三条边长a、b、c和是否为合法三角形的标记isLegal，有求周长和求面积的方法，还有一个为成员变量赋值的构造方法，在构造方法中先判断三条边长是否能构成合法的三角形。如果不能构成合法三角形就输出错误提示信息，如果能构成合法三角形，则调用方法计算并输出三角形的周长和面积。
由三条边计算三角形面积的方法：假设p=(a+b+c)/2，面积为p(p-a)(p-b)(p-c)的平方根。系统类java.lang.Math中的方法public static doublesqrt(double a)可以求得参数的平方根。
12．（*）按要求编写Java应用程序：
（1）创建项目chapter3，在该项目下创建包one和包two。在one下定义类A和类B。在包two下定义类B和类C。在one.B的main方法中创建一个类A的对象a。在two.C的main方法中创建一个类A的对象a。
（2）在two.B中添加方法f，定义如下：
public void f(){
System.out.println("Happy everyday.");
}
在two.C中创建two.B的对象b，并调用方法f。
（3）在类A中添加四个成员变量：int型的私有变量i；float型的变量f；char型受保护变量c；double型的公有变量d。
在one.B的main方法中为对象a的成员变量f和d分别赋值为2和3。
在two.C的main方法中为对象a的成员变量d赋值为4。
13．在包one中定义一个类Plus，有一个long add(int m)方法，用来求1 + 2 + … + m的和。在包two中定义一个类Product，有一个long multiply(int n)方法，用来求n!的结果。在包three中定义一个主类C，调用Plus、Product中的方法输出1+ 2 + … + 30的和，以及10！的计算结果。
3.5 精选习题参考答案
一、单项选择题
1．C 2．D 3．A 4．D 5．C 6．B
7．A 8．B 9．A 10．D 11．C 12．C
13．B 14．C 15．C 16．A 17．D 18．C
19．D 20．C 21．D 22．C 23．D 24．B
25．C 26．C 27．B 28．A 29．B 30．A
31．C 32．B 33．D 34．A 35．B 36．D
37．C 38．C 39．C 40．D 41．A 42．A
43．C 44．C 45．A 46．C 47．A 48．C
49．D
二、简答题
1．
面向对象编程的三大特征：封装、继承和多态。封装：通过设置访问权限等方式封装了内部实现细节，使用者只需要知道外部接口。继承：子类可以继承父类的成员，又可以新增自己独有的成员，还可以覆盖父类的成员。多态：同名方法可以具有不同的行为，Java中有两种意义的多态：重载和重写。
2．
万物皆是对象，对象都有属性和行为。属性是对象所拥有的状态、数据，是静态的特征；行为是对象所拥有的功能、对数据的操作，是动态的特征，可能会影响到属性。
类封装了一类对象共有的属性和行为，是对具有相同属性和行为的对象的抽象。类是创建对象的模板，对象是类的具体实例。
3．
（1）定义在类体内、方法外的变量称为成员变量。定义在方法体内部的变量，以及方法的形式参数，是方法所临时使用的变量，称为局部变量。
（2）成员变量在整个类体中都有效。而局部变量的有效范围仅限于定义它的方法体内，具体说明如下：①方法的形式参数：在整个方法体内有效；②方法体内独立定义的变量：在方法体中该变量定义之后的语句中有效；③选择、循环等语句块内定义的变量：只在语句块的{ }内有效。
（3）如果定义的成员变量没赋值，则系统为其提供缺省的初始值。所以成员变量定义后就有了确定的值，就可以使用。而方法的局部变量必须自行定义而且赋值后才能使用。
（4）类成员变量在程序加载进内存时即开辟空间，实例成员变量在创建对象时开辟空间。局部变量只在方法调用时开辟空间，方法执行完毕后空间随即释放。
4．
多个方法名字相同，但参数个数或者类型不同，称为方法重载。方法返回值的类型和参数的名字不参与比较，方法重载是多态的一种体现。当调用方法时，根据传入的实参个数和类型，可以区分出调用的是哪一个方法。
5．
构造方法与所在类的类名完全相同，构造方法没有返回值类型，也不用void修饰。构造方法可以重载，一个类中可以定义多个构造方法。每个类中至少都有一个构造方法，如果未定义构造方法，系统会自动为该类生成一个缺省的没有参数的构造方法，如果类中定义了构造方法，就不再提供其他构造方法。
构造方法用new调用来创建对象，一般在构造方法中初始化成员变量。构造方法不能用static修饰。
6．
（1）使用static关键词修饰的成员变量称为类变量，不用static关键词修饰的成员变量称为实例变量。
（2）类变量可以被同一个类中的类方法和实例方法直接访问，实例变量只能被同一个类中的实例方法直接访问。
（3）不同对象的类变量共享，改变其中一个对象的类变量就同时改变了其他对象的类变量。不同对象的实例变量各自独立，改变其中一个对象的实例变量不会影响其他对象的这个实例变量。
（4）类变量可以通过对象或者类名访问，推荐通过类名访问类变量。实例变量只能通过对象访问，不能通过类名访问。
7．
（1）包的作用：Java语言中的包机制就像文件系统的目录管理一样，通常把需要一起工作的类放在同一个包里，方便管理大量的类。同一个包中不允许有同名类，把同名类放在不同包中可以解决同名冲突。加载类时，通过所属的包来区别。包体现封装机制，同一个包中的类在一般情况下能够相互访问，而不同包中的类相互访问就受到限制。
（2）导入包中的类：同一个包中的类可以直接使用，不需要导入。使用不同包中的类可以通过全称方式导入，但是重复劳动较多，推荐的方法是利用import语句导入该类。导入包中的单个类：import 包名.类名，导入包中根目录下的所有类：import 包名.*，使用*只能导入包中根目录下的所有类，不能导入包中子目录下的类。
8．
类的访问控制修饰符只有public，用public修饰的类称为公有类，不用public修饰的类为默认的友好类。公有类：可以被任何一个包中的类访问。友好类：只能在定义它的那个包中被访问。
成员变量和成员方法有四种访问权限，从高到低依次是public公有的、protected受保护的、默认的和private私有的。public：不管是否在同一个包中，均可访问。protected：同一个包中可以访问，不同包中的子类也可以访问。默认：只能在同一个包中访问。private：只能在定义它的类中访问。
三、编程题
1．
class Cube {
double side; // 边长
String color; // 颜色
// 构造方法
Cube(double side) {
this.side = side;
}
// 计算体积
double getCubage() {
return side * side * side;
}
// 设置颜色
void setColor(String s) {
color = s;
}
// 主方法
public static void main(String args[]) {
Cube c = new Cube(3);
c.setColor("green");
System.out.println("立方体的体积："+ c.getCubage());
System.out.println("立方体的颜色："+ c.color);
}
}
程序的输出结果：
立方体的体积：27.0
立方体的颜色：green
2．
public class Lader{
// 上底、下底、高和面积
double above, bottom, height, area;
// 构造方法
Lader(double a, double b, double h) {
above = a;
bottom = b;
height = h;
}
// 返回面积
double getArea() {
area = (above + bottom) * height / 2;
return area;
}
}
class Shape {
public static void main(String[] args) {
Lader la = new Lader(3, 4, 2);
System.out.println("梯形的面积："+ la.getArea());
}
}
程序的输出结果：
梯形的面积：7.0
3．
public classStudent {
int id; //学号
String name; // 姓名
int age; //年龄
// 构造方法
Student(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
// 输出学生信息
void outPut() {
System.out.println("学号：" +id + "；姓名： " +
name + "；年龄： " +age);
}
}
class TestStudent {
public static void main(String[] args) {
Student yanHui = new Student(1, "颜回",18);
yanHui.outPut();
Student kongMing = new Student(2, "孔明",19);
kongMing.outPut();
}
}
程序的输出结果：
学号：1；姓名： 颜回；年龄： 18
学号：2；姓名： 孔明；年龄： 19
4．
public class Point{
double x, y;// 横坐标、纵坐标
// 构造方法
Point(double x, double y) {
this.x = x;
this.y = y;
}
// 得到横坐标
double getX() {
return x;
}
// 设置横坐标
void setX(double x) {
this.x = x;
}
// 得到纵坐标
double getY() {
return y;
}
// 设置纵坐标
void setY(double y) {
this.y = y;
}
// 计算到原点距离的平方值
double getDistance() {
return x * x + y * y;
}
}
class TestPoint {
public static void main(String[] args) {
Point p1 = new Point(0, 0);
System.out.println("(" +p1.getX() + "," + p1.getY() +
")到原点距离的平方:"+ p1.getDistance());
Point p2 = new Point(1, 2);
System.out.println("(" +p2.getX() + "," + p2.getY() +
")到原点距离的平方:"+ p2.getDistance());
}
}
程序的输出结果：
(0.0,0.0)到原点距离的平方:0.0
(1.0,2.0)到原点距离的平方:5.0
5．
public class Dog {
String name; // 名字
int age; //年龄
// 构造方法
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
// 喊叫
void cry(String s) {
System.out.println("喊叫：" +s);
}
// 看门
void protect() {
System.out.println("看门：Who isit?");
}
}
class TestDog {
public static void main(String[] args) {
Dog doudou = new Dog("豆豆", 1);
System.out.println("名字：" +doudou.name);
System.out.println("年龄：" +doudou.age + "岁");
doudou.cry("汪汪");
doudou.protect();
}
}
程序的输出结果：
名字：豆豆
年龄：1岁
喊叫：汪汪
看门：Who is it?
6．
public classPersonage {
String name; // 名字
float height; // 身高
String weapon; // 武器
// 构造方法
public Personage(String name, float height,String weapon) {
this.name = name;
this.height = height;
this.weapon = weapon;
}
// 显示属性信息
void show() {
System.out.print("名字：" +name);
System.out.print(", 身高：" +height);
System.out.println(", 武器：" +weapon);
}
}
class TestPerson {
public static void main(String[] args) {
Personage baJie = new Personage("猪八戒", 1.7f, "耙子");
baJie.show();
Personage wuKong = new Personage("孙悟空", 1.6f, "金箍棒");
wuKong.show();
}
}
程序的输出结果：
名字：猪八戒, 身高：1.7, 武器：耙子
名字：孙悟空, 身高：1.6, 武器：金箍棒
7．
public class Clock{
int hour, minute, second; // 时、分、秒
// 构造方法
Clock(int hour, int minute, int second) {
this.hour = hour;
this.minute = minute;
this.second = second;
}
// 显示时间
void show() {
System.out.println(hour + ":"+ minute + ":" + second);
}
}
class TestClock {
public static void main(String[] args) {
Clock morning = new Clock(6, 6, 6);
morning.show();
Clock night = new Clock(22, 0, 0);
night.show();
}
}
程序的输出结果：
6:6:6
22:0:0
8．
public class Vehicle {
String id; //车牌号
int speed; //速度
double weight; // 载重量
// 加速
void speedUp(int a) {
speed += a;
}
// 减速
void speedDown(int b) {
speed -= b;
}
// 构造方法
Vehicle() {
id = "辽A1234";
speed = 100;
weight = 50;
}
// 构造方法
Vehicle(String i, int s, double w) {
id = i;
speed = s;
weight = w;
}
}
class TestVehicle {
public static void main(String[] args) {
Vehicle truck = new Vehicle();
truck.speedUp(10);
Vehicle car = new Vehicle("辽B5678",80, 20);
car.speedDown(20);
System.out.println(truck.id + "的车速为" +truck.speed +
", 载重量为" +truck.weight);
System.out.println(car.id + "的车速为" +car.speed +
", 载重量为" +car.weight);
}
}
程序的输出结果：
辽A1234的车速为110, 载重量为50.0
辽B5678的车速为60, 载重量为20.0
9．
// Teacher类
class Teacher {
String name; // 姓名
int age; //年龄
String course; // 教授的课程
boolean isTutor;// 是否担任班主任
// 构造方法
public Teacher(String name, int age, Stringcourse,
boolean isTutor) {
this.name = name;
this.age = age;
this.course = course;
this.isTutor = isTutor;
}
// 输出教师的姓名、年龄和所教授的课程
void printInfo() {
System.out.println(" 姓名：" + name);
System.out.println(" 年龄：" + age);
System.out.println(" 教授的课程：" + course);
}
}
// Team类
class Team {
String className; // 班级名称
Teacher tutor; // 班主任
// 构造方法
Team(String name, Teacher t) {
className = name;
tutor = t;
}
// 输出班级名称
void printName() {
System.out.println("班级名称：" +className);
}
}
// 主类TestTeam
class TestTeam {
public static void main(String args[]) {
Teacher best = newTeacher("super", 35, "Java", true);
Team no1 = new Team("梦之队",best);
// 输出班级名称
no1.printName();
// 输出班主任的详细信息
System.out.println("班主任信息");
no1.tutor.printInfo();
}
}
程序的输出结果：
班级名称：梦之队
班主任信息
姓名：super
年龄：35
教授的课程：Java
10．
// 圆形类
class Circle {
double radius; // 半径
// 构造方法
public Circle(double radius) {
this.radius = radius;
}
// 求面积
public double getArea() {
return 3.14 * radius * radius;
}
}
// 圆锥类
class Cone {
Circle bottom; // 底
double height; // 高
// 构造方法
public Cone(Circle bottom, double height) {
this.bottom = bottom;
this.height = height;
}
// 求体积
double getCubage() {
return 1.0 / 3 * bottom.getArea() *height;
}
}
// 主类
class TestCone {
public static void main(String[] args) {
// 创建圆锥类的对象
Circle c = new Circle(3);
Cone t = new Cone(c, 2);
System.out.println("半径为" +c.radius +
"的圆锥的体积为:" + t.getCubage());
}
}
程序的输出结果：
半径为3.0的圆锥的体积为:18.839999999999996
11．
public classTriangle {
double a, b, c; // 三条边长
boolean isLegal; // 是否为合法三角形的标记
// 构造方法
Triangle(int a, int b, int c) {
// 合法的三角形:任何两条边长之和大于第三条边长
if ((a + b) <= c || (a + c) <= b|| (b + c) <= a) {
// 不能构成合法的三角形,输出错误信息
isLegal = false;
System.out.println("三条边长" +a + ", " + b + ", " +
c + "不能构成合法的三角形");
} else {
// 能构成合法的三角形,初始化三条边长
this.a = a;
this.b = b;
this.c = c;
isLegal = true;
System.out.print("三角形的三条边长："+ a + ", " +
b + ", " + c);
}
}
// 求周长
double getLength() {
return a + b + c;
}
// 求面积
double getArea() {
double p = (a + b + c) / 2;
double area = Math.sqrt(p * (p - a) * (p- b) * (p - c));
return area;
}
}
class Three {
public static void main(String[] args) {
Triangle t1 = new Triangle(1, 2, 3);
if (t1.isLegal) {
System.out.print("; 周长: " +t1.getLength());
System.out.println("; 面积: " +t1.getArea());
}
Triangle t2 = new Triangle(2, 3, 4);
if (t2.isLegal) {
System.out.print("; 周长: " +t2.getLength());
System.out.println("; 面积: " +t2.getArea());
}
}
}
程序的输出结果：
三条边长1, 2, 3不能构成合法的三角形
三角形的三条边长：2, 3, 4; 周长: 9.0; 面积:2.9047375096555625
12．
// 包one中的A.java
package one;
public class A {
private int i; // int型的私有变量i
float f; // float型的变量f
protected char c; // char型受保护变量c
public double d; // double型的公有变量d
}
// 包one中的B.java
package one;
public class B {
public static void main(String[] args) {
// 在one.B的main方法中创建一个类A的对象a
A a = new A();
// 为对象a的成员变量f和d分别赋值为2和3
a.f = 2;
a.d = 3;
}
}
// 包two中的B.java
package two;
public class B {
public void f() {
System.out.println("Happy everyday.");
}
}
// 包two中的C.java
package two;
import one.A;
public class C {
public static void main(String[] args) {
// 在two.C的main方法中创建一个类A的对象a
A a = new A();
// 为对象a的成员变量d赋值为4
a.d = 4;
// two.C中创建two.B的对象b，并调用方法f
B b = new B();
b.f();
}
}
程序的输出结果：
Happy every day.
13．
// Plus.java
package one;
public class Plus {
// 求1 + 2 + … + m的和
public long add(int m) {
long sum = 0;
for (int i = 1; i <= m; i++) {
sum = sum + i;
}
return sum;
}
}
// Product.java
package two;
public classProduct {
// 求n!的结果
public long multiply(int n) {
long result = 1;
for (int i = 1; i <= n; i++) {
result = result * i;
}
return result;
}
}
// C.java
package three;
import one.Plus;
import two.Product;
public class C {
public static void main(String[] args) {
// 输出1 + 2 + … + 30的计算结果
Plus p = new Plus();
System.out.println("1 + 2 + … + 30的结果：" +p.add(30));
// 输出10！的计算结果
Product b = new Product();
System.out.println("10！的结果：" +b.multiply(10));
}
}
程序的输出结果：
1 + 2 + … + 30的结果：465
10！的结果：3628800
2362
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
