Java经典练习题

Java基础试题

一、选择题

1．编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为( B )。

A. .java

B. .class

C. .html

D. .exe

2、设x = 1 , y = 2 , z = 3，则表达式y＋＝z－－/＋＋x 的值是( A )。

A. 3

B. 3. 5

C. 4

D. 5

3、main方法是Java Application程序执行的入口点，关于main方法的方法头以下哪项是合法的（B）？

A、public static void main（）

B、public static void main（String args[] ）

C、public static int main（String [] arg ）

D、public void main（String arg[] ）4

4.Which of the following is not a valid comment:D

a. /** comment */

b. /* comment */

c. /* comment

d. // comment

5. Java中char类型的数据长度为 :C

（A）8位（B）16位（C）32位（D）64位

6.下面哪个表达式是错误的:B

（A）int i = 100;

（B）float f = 100.0;

（C）Object o = “Hello world”;

（D）char c = ‘\u1234’;

7.下面哪个语句是正确的:C

（A）byte s = 256;

（B）String s = ‘Hello world’;

（C）int x = 012;

（D）char c = “a”;

8.下列叙述中，正确的是:A

A）声明变量时必须指定一个类型

B）Java认为变量number与Number相同

C）Java中唯一的注释方式是"//"

D）源文件中public类可以有0或多个

9.下列属于合法的Java标识符是:D

A）"ABC" B）&5678 C）+rriwo D）saler

10.下面哪个标识符是不合法的:D

（A）s1 （B）$1 （C）_1 （D）1s

11．在switch(expression)语句中，expression的数据类型不能是:A

A）double B）char C）byte D）short

12．已知：int[] a = new int[100];在下列给出的数组元素中，非法的是:D

A）a[0] B）a[1] C）a[99] D）a[100]

13．下列的哪个赋值语句是不正确的？: A

A．float f = 11.1; B．double d = 5.3E12;

C．float d = 3.14f ; D．double f=11.1E10f;

14．下列的哪个赋值语句是正确的？D

A．char a=12; B．int a=12.0;

C．int a=12.0f; D．int a=（int）12.0;

15．下面关于数组的定义错误的是（B）

A) int a[]={1,2,3,4,5,6}; B) int a[6]={1,2,3,4,5,6}

C) int[][] a; D）int [] a=new int[6];

（以下为多项选择）

16．下面哪些代码可以正确编译（ AC）

（A）double d = 1.0;

int i = 1;

if(d == i) {

System.out.println(“Hello world”);

}

（B）int i = 1;

int j = 2;

if(i = 1 && j = 2) {

System.out.println(“Hello world”);

}

（C）boolean b1 = true, b2 = false;

if(b1 == b2) {

System.out.println(“Hello world”);

（D）int i = 0;

if(i) {

System.out.println(“Hello world”);

}

17.下面的哪些声明是合法的？AC

（A）int a[]; （B）int a[5]; （C）int[] a; （D）int a[] = [5];

18.下面哪些类型是Java的基本数据类型ABD

（A）int （B）boolean （C）String（D）double

二、填空题

1..JVM是（Java虚拟机），JDK是（Java开发工具包），appletviewer是(小应用程序阅览器) 。

2. Java源程序经编译生成的字节码文件的扩展名为（class）

3. Java语言的主要贡献者是（James Gosling（詹姆斯·戈士林））。

4．在JDK中，Java语言的编译命令是_____Javac.exe_______，Java语言的执行命令是java .exe_______。

5．写出以下表达式的结果：

1) 5 % 6 / 3 =（1）

2) true && false =（false）

3) 5 >> 3 =（0）

4) 12 ^ -4 =（-16 ）

6.设有数组定义：int a［］= { 11 , 22 , 33 , 44 , 55 , 66 , 77 , 88 , 99 }; 则执行下列几个语句后的输出结果是33 66 99。

for ( int i = 0 ; i < a.length ; i ++ ）

if（a［i］%3==0 ）System.out.print（a［i］+" "）;

三、简答题

1.swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?

switch（expr1）中，expr1是一个整数表达式。因此传递给switch 和case 语句的参数应该是int、short、char 或者byte。long,String 都不能用于swtich中的表达式（JDK 7以后可以作用于String）。

2.一个".java"源文件中是否可以包括多个类？有什么限制？

可以。必须只有一个类名与文件名相同

3．简述Java语言实现平台无关(跨平台)性的原理。

J Java程序经过编译，会生成字节码文件，而字节码可以在任何安装了Java虚拟机的平台上运行，Java虚拟机类似一个模拟执行环境，在不同的操作系统上拥有不同的Java虚拟机实现，但是这些Java虚拟机遵循统一的规范来解释class文件，并将class文件中的指令转换为本地操作系统对应的指令，这样就实现了相同的class文件可以通过Java虚拟机转换为对应操作系统上的对应指令，实现class文件，即Java程序的跨平台性。

4．说明Java语言中三种注释的语法格式，以及用途。

Java语言中注释的语法有三种：单行注释、多行注释和文档注释。

1）单行注释，单行注释指只能书写一行的注释。用于对于代码进行简单的说明，单行注释的语法格式为：//注释内容

2）多行注释：多行注释指可以书写任意多行的注释。多行注释一般用于说明比较复杂的内容，例如程序逻辑或算法实现原理等。多行注释的语法格式为：

/* 注释内容*/

3）文档注释：文档注释指可以被提取出来形成程序文档的注释格式，这是Java语言有特色的注释格式。一般对于程序程序的结构进行说明，例如类、属性、方法和构造方法进行说明，文档注释的语法格式为：

/** 注释内容*/

5．请把以下英文翻译成中文：

When you compile a program written in the Java programming language, the compiler converts the human-readable source file into

platform-independent code that a Java Virtual Machine can understand. This platform-independent code is called Bytecode.

当你在编译Java编程语言编写的程序，编译器转换成平台无关的代码，Java虚拟机能够理解人类可读的源文件。这个平台无关的代码被称为字节码。

}

第二章

注意问题:

main函数是Java应用程序执行的入口。

(int)23.7结果为23

(int)-45.89f结果为-45

+”除字符串相加功能外，还能把非字符串转换成字符串，如：“x”+123;的结果是“x123”。

如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。但被模数是负数就另当别论了

1，三元运算符

class TernaryOp

{

public static void main(String args[])

{

int salary,daysPresent = 30;

salary = daysPresent == 20 ? 2000 : 3000;

System.out.println("您本月薪资为 $"+salary);

}

}

２，编写一个程序，这个程序从键盘上输入2个数，然后求这2个数的和，程序结束。

提示：调用System.in.read()；可以读取到一个从键盘上输入字符对应的整数。通过这个程序，你一定能体会到在什么

import java.io.*;

public class Ch1 {

public static void main(String[] args) throws IOException{ BufferedReader ke

=new BufferedReader(new InputStreamReader(System.in));

String x;

int p,q,m;

System.out.print("请输入第一个数");

x=ke.readLine();

p=Integer.parseInt(x);

System.out.print("请输入第二个数");

x=ke.readLine();

q=Integer.parseInt(x);

m=p+q;

System.out.println("两个数的和为:"+m);

}

}

３，数组

public class Lo {

public static void main(String[] args) {

int[] aa={32,55,69};

for(int i=0;i

System.out.print(aa[i]+”“);

}

System.out.println( );}

}

４，输入一个年份，判断它是不是闰年。

闰年: 能被4整除但不能被100整除，或者能被400整除。

public class ex3_1

{

public static void main(String[ ] args) throws IOException{ int year;

boolean IsLeapYear;

System.out.println("Enter the year:");

BufferedReader in =new BufferedReader(

new InputStreamReader(System.in));

year=(new Integer(in.readLine())).intValue(); IsLeapYear=((year%4==0 && year%100 != 0)||(year%400 == 0));

if (IsLeapYear)

{

System.out.print(year);

System.out.println( "is a leap year");

}

else

{

System.out.print(year);

System.out.println( "is not a leap year");

}

}

}

５，输入两个整数比较大小

import java.io.*;

public class ex3_2

{

public static void main(String[ ] args)throws IOException

{

int x,y;

BufferedReader in = new BufferedReader(

new InputStreamReader(System.in));

System.out.println("Enter x and y:");

x=(new Integer(in.readLine())).intValue();

y=(new Integer(in.readLine())).intValue();

if (x!=y)

if (x>y) System.out.println("x>y");

else System.out.println("x

else System.out.println("x=y");

}

}

６，已知一个学生的分数，给出其分数等级。90-100分为Ａ级；80-89分为B 级；70-79分为Ｃ级；60-69分为D级；0-59分为E级

public class IfElseDemo {

public static void main(String[] args) {

int testscore = 76;

char grade;

if (testscore >= 90) { grade = 'A'; }

else if (testscore >= 80) { grade = 'B'; }

else if (testscore >= 70) { grade = 'C'; }

else if (testscore >= 60) { grade = 'D'; }

else { grade = 'F'; }

System.out.println("Grade = " + grade);

}

}

７，输入0～6之间的某一个整数，然后把它转换成星期输出。(0对应星期日）import java.io.*;

public class ex3_3

{

public static void main(String[ ] args)throws IOException

{

int day;

BufferedReader in =new BufferedReader(

new InputStreamReader(System.in));

day=(new Integer(in.readLine())).intValue();

switch (day)

{

case 0: System.out.println("Sunday"); break;

case 1: System.out.println("Monday"); break;

case 2: System.out.println("Tuesday"); break;

case 3: System.out.println("Wednesday"); break;

case 4: System.out.println("Thursday"); break;

case 5: System.out.println("Friday"); break;

case 6: System.out.println("Saturday"); break;

default:

System.out.println("Day out of range Sunday ..Saturday" );

break;

}

}

}

８，打印九九乘数表

public class MultiTable {

public static void main(String[] args){

for (int i=1; i<=9;i++) {

for (int j=1; j<=i;j++)

System.out.print(" "+i+"*"+j+"="+i*j);

System.out.println();

}

}

}

９，输入一个整数，输出它所有的因数

import java.io.*;

public class ex3_7

{

public static void main(String[ ] args) throws IOException{ int n,k;

BufferedReader in =new BufferedReader(

new InputStreamReader(System.in));

System.out.println("Enter a positive integer: ");

n=(new Integer(in.readLine())).intValue();

System.out.print("Number "+n+" Factors ");

for (k=1; k <= n; k++)

if (n % k == 0) System.out.print(k + " ");

System.out.println();

}

}

１０，计算数列1,2,…,10 的和。

public class ex3_4

{

public static void main(String[ ] args)

{

int i=1, sum=0;

while(i<=10) {

sum+=i;

i++;

}

System.out.println("sum="+sum);

}

}

１１，计算存款收益：假设银行中存款10000元，按11.25%的利率，一年后连本带利将变为11125元。你若将此款继续存入银行，试问多长时间就会连本带利翻一番

import java.text.*;

public class Examp3_4 {

public static void main(String[] args){

double original,money,interest;

int years = 0;

original = money= 10000;

interest = 11.25 / 100;

System.out.println("year money");

while (money < 2 * original) {

years = years + 1;

money = money + (interest * money);

System.out.println(" " + years + " " +

new

DecimalFormat("0.00").format(money));

}

System.out.println();

System.out.println(" 第 " + years + " 年存款额达到 " +

new DecimalFormat("0.00").format(money) + "元。");

}

}

１２编写一个程序用选择法对数组a[]={20,10,50,40,30,70,60,80,90,100}进行由大到小的排序。

import java.io.*;

public class SelectSort

{

public static void main(String args[])

{

int a[]={20,10,50,40,30,70,60,80,90,100};

int temp;

for (int i=0; i

for (int j=i+1; j

{

if (a[i]

temp=a[i];

a[i]=a[j];

a[j]=temp;

}

}

for (int k=0;k

{

System.out.println("a["+k+"]:"+a[k]);

}

}

}

第３，４章

一、

1.利用接口继承完成对生物、动物、人三个接口的定义。其中生物接口定义呼吸抽象方法；

2.动物接口除具备生物接口特征之外，还定义了吃饭和睡觉两个抽象方法；

3.人接口除具备动物接口特征外，还定义了思维和学习两个抽象方法。

4.定义一个学生类实现上述人接口。（25分）

1 interface Biology

{

void breath();

}

interface Animal extends Biology

{

void eat();

void sleep();

}

interface Human extends Animal

{

void think();

void study();

}

class Student implements Human

{

void breath()

{

System.out.println(“breathing”);

}

void eat()

{

System.out.println(“eating”);

}

void sleep()

{

System.out.println(“sleeping”);

}

void think()

{

System.out.println(“thinking”);

}

void study()

{

System.out.println(“study”);

}

}

二、

1、定义一个接口CanFly，描述会飞的方法public void fly();

2、分别定义类飞机和鸟，实现CanFly接口。

3、定义一个测试类，测试飞机和鸟。测试类中定义一个makeFly()方法，让会飞的事物飞起来。

4、然后在main方法中创建飞机对象和鸟对象，并在main方法中调用makeFly()方法，让飞机和鸟起飞。

interface CanFly

{

public void fly();

}

class AirPlane implements CanFly

{

public void fly()

{

System.out.println(“airplane is flying”);

}

}

class Bird implements CanFly

{

public void fly()

{

System.out.println(“Bird is flying”);

}

}

class Test

{

static makeFly(CanFly obj)

{

obj.fly();

}

public static void main(String[] args)

{

AirPlane ap = new AirPlane();

Bird b = new Bird();

makeFly(ap);

makFly(b);

}

}

三、

实现一个名为Person的类和它的子类Employee，Manager是Employee的子类，设计一个接口Add用于涨工资，普通员工一次能涨10％，经理能涨20％。

具体要求如下：

（1）Person类中的属性有：姓名name（String类型），地址address（String类型），定义该类的构造方法；

（2）Employee类中的属性有：工号ID（String型），工资wage（double类型），工龄（int 型），定义该类的构造方法；

（3）Manager类中的属性有：级别level（String类型）定义该类的构造方法；

（4）编写一个测试类，产生一个员工和一个经理给该员工和经理涨工资，并输出其具有的信息。

实现代码：

class Person{ //Person类

private String name; //姓名

private String address; //地址

public Person(String n,String a){ //定义该类的构造方法this.setName(n);

this.setAddress(a);

}

public void setName(String n){

https://www.360docs.net/doc/367729389.html, = n;

}

public void setAddress(String a){

this.address = a;

}

public String getName(){

return https://www.360docs.net/doc/367729389.html,;

}

public String getAddress(){

return this.address;

}

}

class Empolyee extends Person{ //Employee是Person的子类private int employeeNo; //工号

private double pay; //工资

private int age; //工龄

public Empolyee(String name,String address,int empolyeeNO, double pay,int age){ //定义该类的构造方法super(name,address); //引用父类的构造方法

this.setEmployeeNo(empolyeeNO);

this.setPay(pay);

this.setAge(age);

}

public void setEmployeeNo(int e){

this.employeeNo = e;

}

public void setPay(double p){

this.pay = p;

}

public void setAge(int a){

this.age = a;

}

public int getEmployeeNo(){

return this.employeeNo;

}

public double getPay(){

return this.pay;

}

public int getAge(){

return this.age;

}

}

class Manager extends Empolyee{ //Manager是Employee的子类

private int level; //级别

public Manager(String name,String address,int empolyeeNO,double pay,

int age,int level){ //定义该类的构造方法

super(name,address,empolyeeNO,pay,age); //引用父类的构造方法

this.setLevel(level);

}

public void setLevel(int l){

this.level = l;

}

public int getLevel(){

return this.level;

}

public void printInfo(){ //输出员工信息

System.out.println("姓名："+this.getName()+",工号："+this.getEmployeeNo()

+",工龄："+this.getAge()+",级别："+this.getLevel()

+",地址："+this.getAddress());

System.out.println("原工资："+this.getPay());

System.out.println("涨工资后的工资："+new Add().addPay(this.getLevel(),

this.getPay()));

}

}

class Add{ //设计一个Add类用于涨工资

public double addPay(int level,double pay){

if(level==0){ //0表示普通员工

pay = (1+0.1)*pay;

}

else if(level==1){ //1则表示经理

pay = (1+0.2)*pay;

}

else{ //操作无效

System.out.println("级别只能为0或1，0表示普通员工，1则表示经理，操作无效！");

}

return pay;

}

}

public class ExtendsDemo {

public static void main(String[] args) {

Manager m1 = new Manager("张三","南京路",0001,2000,10,0);

Manager m2 = new Manager("李四","长江路",0002,3000,15,1);

m1.printInfo();

System.out.println("************************************************");

m2.printInfo();

}

}

四、

1、用面向对象的思想定义一个接口Area，其中包含一个计算面积的方法CalsulateArea()

2、然后设计MyCircle和MyRectangle两个类都实现这个接口中的方法CalsulateArea()（

3、分别写出两个类中的构造方法并计算圆和矩形的面积

4、在Circle类中增加方法改变圆的半径，在Circle类中增加fitsInside方法判断一个圆是否在一个矩形内，

５、最后写出测试以上类和方法的程序。

五、

编写一个完整的Java程序——复数类Complex，使两个复数，如 1+2i 和3+4i 相加产生一个新的复数 4+6i 。

复数类Complex必须满足如下要求：

（1）、复数类Complex 的属性有：

realPart : int型，代表复数的实数部分

imaginPart : int型，代表复数的虚数部分

定义该类的构造方法

（2）、复数类Complex 的方法有：

构造方法一，将复数的实部和虚部都置0

构造方法二，形参 r 为实部的初值，i为虚部的初值。

（3）complexAdd方法: 将当前复数对象与形参复数对象相加，所得的结果仍是一个复数值，返回给此方法的调用者。

（4）toString( ) 方法: 把当前复数对象的实部、虚部组合成 a+bi 的字符串形式，其中a和b分别为实部和虚部的数据。

答案：public class Complex{

private int realPart;

private int imagePart;

public Complex(int r,int i){

this.realPart = r;

this.imagePart = i;

}

public Complex(){

this(0,0);

}

public Complex addComplex(Complex c){

this.realPart+=c.realPart;

this.imagePart+=c.imagePart;

return this;

}

public String toString(){

return this.realPart+"+"+this.imagePart+"i";

}

public static void main(String args[]){

Complex c1 = new Complex(2,6);

Complex c2 = new Complex(4,2);

System.out.println("c1 = "+c1);

System.out.println("c2 = "+c2);

System.out.println("c1 + c2 = "+c1.addComplex(c2));

}

}

第5章

第６章

1，用\继承Thread类的方法在新线程中完成计算某个整数的阶乘public class Ex8_1 {

public static void main( String [] args ) {

System.out.println("main thread starts");

FactorialThread thread=new FactorialThread(10);

thread.start();

System.out.println("main thread ends " );

}

}

class FactorialThread extends Thread {

private int num;

public FactorialThread( int num ) {

this.num=num;

}

public void run() {

int i=num;

int result=1;

System.out.println("new thread started" );

while(i>0) {

result=result*i;

i=i-1;

}

System.out.println("The factorial of "+num+" is "+result);

System.out.println("new thread ends");

}

}

运行结果

main thread starts

main thread ends

new thread started

The factorial of 10 is 3628800

new thread ends

2，使用Runnable接口实现上述程序功能

public class Ex8_1{

public static void main( String [] args ) {

System.out.println("main thread starts");

FactorialThread t=new FactorialThread(10);

new Thread(t).start();

System.out.println("new thread started,main thread ends " );

}

}

class FactorialThread implements Runnable {

private int num;

public FactorialThread( int num ) {

this.num=num;

}

public void run() {

int i=num;

int result=1;

while(i>0) {

result=result*i;

i=i-1;

}

System.out.println("The factorial of "+num+" is "+result);

System.out.println("new thread ends");

}

}

3，用两个线程模拟存票、售票过程

假定开始售票处并没有票，一个线程往里存票，另外一个线程则往出卖票

我们新建一个票类对象，让存票和售票线程都访问它。本例采用两个线程共享同一个数据对象来实现对同一份数据的操作

public class Ex8_7 {

public static void main(String[] args) {

Tickets t=new Tickets(10);

new Consumer(t).start();

new Producer(t).start();

}

}

class Tickets {

int number=0; //票号

int size; //总票数

boolean available=false; //表示目前是否有票可售

public Tickets(int size) //构造函数，传入总票数参数

{

this.size=size;

}

}

class Producer extends Thread

{

Tickets t=null;

public Producer(Tickets t)

{ this.t=t; }

public void run()

{

while( t.number < t.size)

{

System.out.println("Producer puts ticket "

+(++t.number));

t.available=true;

}

}

}

class Consumer extends Thread //售票线程

{

Tickets t=null;

int i=0;

public Consumer(Tickets t)

{ this.t=t; }

public void run()

{

while(i

{

if(t.available==true && i<=t.number)

System.out.println("Consumer buys ticket "+(++i));

if(i==t.number)

t.available=false;

}

}

}

4，线程不断显示递增整数，按下回车键则停止执行

import java.io.*;

public class Ex8_12{

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

TestThread t=new TestThread();

t.start();

new BufferedReader(new InputStreamReader(System.in))

.readLine(); //等待键盘输入t.stopme(); //调用stopme方法结束t线程

}

}

class TestThread extends Thread{

private boolean flag=true;

public void stopme() { //在此方法中控制循环条件

flag=false;

}

public void run() {

int i=0;

while(flag) {

System.out.println(i++); //如果flag为真则一直显示递增整数}

}

}