Java习题2

单选题

（1）对下列代码，描述正确的是（A）。

public class Test{

int arr[] = new int[10];

public static void main(){

System.out.println(arr[1]);

}

}

A．编译时出错 B．编译时正确而运行时出错

C．输出0 D．输出null

判断题

（1）Java语言中的数组元素下标总是从0开始，下标可以是整数或整型表达式。（T）

单选题

（1）对象的特征在类中表示为变量，称为类的（B）。

A．对象 B．属性 C．方法 D．数据类型

（2）类与对象的关系是（A）。

A．类是对象的抽象 B．对象是类的抽象

C．对象是类的子类 D．类是对象的具体实例

（3）在Java中,关于构造方法，下列说法错误的是（C）。

A．构造方法的名称必须与类名相同 B．构造方法可以带参数

C．构造方法不可以重载 D．构造方法绝对不能有返回值

（4）不允许作为类及类成员的访问控制符的是（D）。

A．public B．private C．protected D．static

（5）关于包说法不正确的是（A）。

A．一个Java文件中只能有一个import语句

B．使用package关键字可以指定类的所属的包

C．包在物理上的表现形式是嵌套的文件目录

D．导入包需要使用的关键字import

（6）如果一个类的成员变量只能在所在类中使用，则该成员变量必须使用的修饰是（C）。A．public B．protected C．private D．static

（7）访问修饰符作用范围由大到小是（D）。

A．private-default-protected-public B．public-default-protected-private

C．private-protected-default-public D．public-protected-default-private

（8）以下对重载描述错误的是（B）。

A．方法重载只能发生在一个类的内部

B．构造方法不能重载

C．重载要求方法名相同，参数列表不同

D．方法的返回值类型不是区分方法重载的条件

（9）A派生出子类B，B派生出子类C，并且在Java源代码中有如下声明：

A a0=new A（）;

A a1=new B（）;

A a2=new C（）;

问以下哪些说法是正确的（D）。

A．只有第一行能通过编译

B．第1、2行能通过编译，但第3行编译出错误

C．第1、2、3行能通过编译，但第2、3行运行时出错

D．第1行、第2行和第3行的声明都是正确的

（10）下列选项中，用于在定义子类时声明父类的关键字是（C） 。

A．interface B．package C．extends D．abstract

（11）给定如下java代码，编译时会在（D）出现错误。

class Parent{

}

class Child extends Parent{

public static void main（String args[]）{

Parent p1=new Child()；//第一行

Parent p2=new Parent()；//第二行

Child c1=new Child()；//第三行

Child c2=new Parent()；//第四行

}

}

A．第一行 B．第二行 C．第三行 D．第四行

（12）在Java中，由Java编译器自动导入，而无需在程序中用import导入的包是（C）。

A．java.applet B．java.awt C．java.lang D．java.util

（13）指出下列哪个方法与方法public void add(int a){}为不合法的重载方法（A）。

A．public void add(int a) B．public void add(Stringa)

C．public void add(int a，int b) D．public void add(float a)

（14）下面哪个修饰符修饰的变量是所有同一个类生成的对象共享的（C）。

A．public B．private C．static D．final

（15）Java语言的类间的继承关系是（B）。

A．多重的 B．单重的 C．线程的 D．不能继承

（16）关于以下程序段，正确的说法是(C)。

String s1=“a”+“b”;

String s2=new String（s1）；

If(s1==s2）

System.out.println(“= = is succeeded”);

if(s1.equals(s2))

System.out.println(“.equals() is succeeded”);

A．行4与行6都将执行 B．行4执行，行6不执行

C．行6执行，行4不执行 D．行4、行6都不执行

（17）下面哪个函数是public void aMethod(){...}的重载函数（D）。

A．void aMethod( ){...} B．public int aMethod(){...}

C．public void aMethod( ){...} D．public int aMethod(int m){...}

（18）下列代码段编译和运行的结果是（C）。

public static void main(String args[]){

String str = “null”;

if(str==null){

System.out.println(“null”);

}else if(str.length()==0){

System.out.println(“zero”);

} else {

System.out.println(“some”);

}

}

A．null B．zero C．some D．编译错误

（19）在创建对象时必须（C）。

A．不用声明对象，直接使用对象

B．先声明对象，然后才能使用对象

C．先声明对象，为对象分配内存空间，对对象初始化，然后才能使用对象

D．上述说法都对

（20）在Java中，关于构造方法，下列说法错误的是（C）。

A．构造方法的名称必须与类名相同

B．构造方法可以带参数

C．构造方法不可以重载

D．构造方法绝对不能有返回值

（21）下列方法定义中，正确的是（A）。

A．int x( ){ char ch= a ; return (int)ch;} B．void x( ){ .return true; }

C．int x( ){ .return true; } D．int x( int a, b){ return a+b; }

（22）下列最终属性i的定义中，正确的是（B）。

A．static final int i=100; B．final int i=1.2;

C．final i= w ; D．final char i;

（23）在Java语言中，下列关于类的继承的描述，正确的是（B）。

A．一个类可以继承多个父类

B．一个类可以具有多个子类

C．子类可以使用父类的所有方法

D．子类一定比父类有更多的成员方法

（24）对象的特征在类中表示为变量，称为类的（B）。

A．对象 B．属性 C．方法 D．数据类型

（25）关于类加载以下说法正确的是（A）。

A．得到某个类的全名字符串，是可以加载这个类的

B．从*.java文件可以加载

C．无法在运行时动态加载一个类

D．以上说法都不对

（26）设i、j、k为类x中定义的int型变量名，下列类x的构造函数中不正确的是（B）。

A．x( int m){ } B．void x( int m){ }

C．x( int m, int n){ } D．x( int h,int m,int n){ }

（27）定义类头时能使用的修饰符是（C）。

A．private B．static C．abstract D．protected

（28）关于被私有访问控制符private修饰的成员变量，以下说法正确的是（C）。

A．可以被三种类所引用：该类自身与它在同一个包中的其他类、在其他包中的该类的子类

B．可以被两种类访问和引用：该类本身、该类的所有子类

C．只能被该类自身所访问和修改

D．只能被同一个包中的类访问

（29）下列关于构造方法的叙述中，错误的是（C） 。

A．Java语言规定构造方法名与类名必须相同

B．Java语言规定构造方法没有返回值，但不用void声明

C．Java语言规定构造方法不可以重载Java

D．语言规定构造方法只能通过new自动调用

（30）以下关于继承的叙述正确的是（A）。

A．在Java中类只允许单一继承

B．在Java中一个类只能实现一个接口

C．在Java中一个类不能同时继承一个类和实现一个接口

D．在Java中接口只允许单一继承

（31）Java语言的类间的继承关系是（B）。

A．多重的 B．单重的 C．线程的 D．不能继承的

（32）有关Java中的类和对象，以下说法错误的是（B）。

A．同一个类的所有对象都拥有相同的特征和行为

B．类和对象一样，只是说法不同

C．对象是具有属性和行为的实体

D．类规定了对象拥有的特征和行为

（33）以下哪个过程不一定会执行（D）。

public class ObjectTest {

public static void main(String[] args) {

//对象的声明

String string;

//对象的实例化

string = String.class.toString();

//对象的使用

System.out.println(string);

//对象的销毁

string = null;

}

}

A．对象的声明 B．对象的实例化

C．对象的使用 D．对象的销毁

（34）下列哪一种说法是正确的（D）。

A．实例方法可直接调用超类的实例方法

B．实例方法可直接调用超类的类方法

C．实例方法可直接调用其余类的实例方法

D．实例方法可直接调用本类的类方法

（35）下列关于构造方法constructor说法正确的有（C）。

A．class中的constructor不可省略

B．constructor必须与class同名，但方法不能与class同名

C．constructor在一个对象被new时执行

D．一个class只能定义一个constructor

（36）下列选项中关于Java中super关键字的说法正确的是（A）。

A．super关键字是在子类对象内部指代其父类对象的引用

B．super关键字不仅可以指代子类的直接父类，还可以指代父类的父类

C．子类通过super关键字只能调用父类的方法，而不能调用父类的属性

D．子类通过super关键字只能调用父类的属性，而不能调用父类的方法

（37）下列说法哪个是正确的（B）。

A．创建对象y一定要用new

B．属性可以是简单变量，也可以是一个对象

C．属性必须是简单变量

D．对象中必有属性和方法

多选题

（1）在Java中，下面对于构造函数的描述错误的是（BC）。

A．类不一定要显式定义构造函数

B．构造函数的返回类型是void

C．如果构造函数不带任何参数，那么构造函数的名称和类名可以不同

D．一个类可以定义多个构造函数

（2）关于类的描述正确的是（BC）。

A．在类中定义的变量称为类的成员变量，在别的类中可以直接使用

B．局部变量的作用范围仅仅在定义它的方法内，或者是在定义它的控制流块中

C．可以使用stringBuffer sb="这里是字符串"声明并初始化StringBuffer对象sb

D．String类提供了许多用来操作字符串的方法：连接，提取，查询等

（3）面向对象的特征（ABCD）。

A．继承 B．抽象 C．多态 D．封装

（4）Java中的final关键字有哪些用法（ABC）。

A．修饰类：表示该类不能被继承

B．修饰方法：表示该方法不能被重写

C．修饰变量：表示变量只能一次赋值以后不能被修改（常量）

D．修饰捕获异常，用于无论是否出现异常，都会执行代码

（5）以下说法正确的是（AB）。

A．this指针可以调用本类的属性

B．调用一个类中的属性可以使用get和set方法

C．Java中继承一个类要使用extend关键字

D．Java中一个方法默认的修饰符是private

判断题

（1）即使一个类中未显式定义构造函数，也会有一个缺省的构造函数，缺省的构造函数是无参函数，函数体为空。（T）

（2）由继承性可知，程序中子类拥有的成员数目一定大于等于父类拥有的成员数目。（F）

（3）子类所继承父类的成员都可以在子类中访问。（F）

（4）成员方法的重载和覆盖是同一回事。（F）

（5）在Java语言中，声明包语句的关键字为package，引入包语句的关键字为import。（T）

（6）可以使用obj1==obj2来判断两个对象是否相等。（F）

（7）类中要调用父类中的变量或者方法时应该使用super关键字。（T）

（8）可以在子类构造方法中通过this关键字调用基类的构造方法。（T）

（9）Java语言支持类的继承，但不支持类的多重继承。（T）

（10）定义自己的类加载器，需从ClassLoader类派生。（T）

（11）Field的实例描述一个字段，它只与类关联，与类是实例并无关系。（T）

（12）用static声明的成员变量在整个应用程序执行期间都有效。（T）

（13）一个类中的属性不设置get和set方法，其它对象就无法使用这个属性。（F）

（14）创建一个对象的关键字是class。（F）

填空题

（1）创建一个名为mypackage的包的语句是 package mypackage; ，该语句应该放在程序的位置为： 应该在程序第一句 。

（2）下面程序段被执行后，s1的值是 12 ，s2的值是 1234 ，s3的值是 1234 。

s1="12";

String s2=s1.concat("34");

String s3=s1+"34";

（3）下面程序运行后s1的值为 abc ，s2的值为 def 。

String s1="abc";

String s2="def";

s2.toUpperCase();

s1.concat(s2);

（4）子类对父类继承来的属性重新定义称为 重写 ，子类对自身拥有的同名方法的重新定义称 重载 。

（5）在Java语言中， 包 是组织Java程序中类的一种手段，其作用与Windows系统中的文件夹 类似。创建包的语句必须是文件的第 一 条语句。

（6）Java类中，如果类的定义者没有显式的定义任何构造方法，系统将自动提供一个 无参默认 构造方法。默认的构造方法没有 参数 ，也没有返回值，类A的构造方法为：publicA(){}

（7）用 static 修饰的变量叫静态变量，它可以通过类的 类名 和 对象 两种方式来访问。

（8）若子类对父类中的同名同参方法进行重新定义，我们称子类 重写 了父类的同名方法。

（9）Java中用类创建一个对象包括对象的声明和为对象 实例化 两个步骤。

（10）如果在子类中想使用被子类隐藏的父类的成员变量或方法可以使用关键字 super 。

（11）导入my.package包中的所类的命令是 import 。

（12）构造方法是一种特殊的成员方法，构造方法名与 类名 相同，并且此方法 无 （有/无）返回值。

（13）JAVA语言中提供了两种类型的字符串类来处理字符串，它们是 String 、StringBuffer 和 StringBuilder 。

（14）Java中所有类都是 Object 类的子类。

（15）在Java源文件中class、import和package语句的顺序是 package、import、class 。

（16）当类中的成员定义采用static关键字修饰时，则称该成员为类的（静态/实例） 静态 成员。

（17）面向对象编程的三个基本特性是 封装 、 继承 和 多态 。

（18）在Java中，声明静态方法、静态属性用的关键字是 static 。

（19）同一个类中多个方法具有相同的方法名，不同的 参数 称为方法重载。

（20）"I like Java、Math、and English very much、 so does Tom."对于字符串以顿号作为分隔符，则该字符串有 2 个单词。

（21） new 关键字的作用是根据对象的类型分配内存空间。当对象拥有内存空间时，会自动调用类中的 构造方法 为对象 实例化 。

（22）类由 属性 和 方法 组成。

（23）Java中参数的两种传递方式有 值 传递和 引用 传递

（24）引用父类对象需要使用什么关键字 super

（25）创建一个的类关键字是 class

（26）面向对象三大基本特征： 封装 、 继承 、 多态

（27）使用 private 关键字修饰的类成员称为私有成员。私有成员只能在 本类 中使用

简答题

（1）String和StringBuilder、StringBuffer的区别？

Java平台提供了两种类型的字符串：String和StringBuffer/StringBuilder，它们可以储存和操作字符串。

1）String是只读字符串，也就意味着String引用的字符串内容是不能被改变的。

2）StringBuffer/StringBuilder类表示的字符串对象可以直接进行修改。

3）StringBuilder是Java 5中引入的，它和StringBuffer的方法完全相同，区别在于它是单线程，而StringBuffer是多线程的。

（2）是否可以继承String类？

不能；String类被final修饰，因此不能被继承。

（3）重载和重写的区别。

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。

重载(Overloading)：重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型作为重载函数的区分标准。

重写(Overriding)：重写的时候，父类中需要被重写的方法要求与子类中的定义某一方法有相同的方法名、参数类型和个数和返回类型，且子类函数的访问修饰权限不能少于父类。

（4）构造器（constructor）是否可被重写（override）?

构造器不能被继承，因此不能被重写，但可以被重载。

（5）数组有没有length()方法？String有没有length()方法？

数组没有length()方法，有length 的属性。String有length()方法。JavaScript中，获得字符串的长度是通过length属性得到的，这一点0.75和Java混淆。

（6）重载（Overload）和重写（Override）的区别？

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的参数列表，有兼容的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。重载对返回类型没有特殊的要求，不能根据返回类型进行区分。

（7）描述引用、对象、类，三者之间的关系。

类是一个模板，它描述一类对象的行为和状态；对象是类的一个实例，具有状态和行为；引用是存放某一对象起始地址的地址。

（8）Java中的final关键字有哪些用法？

1）修饰类：表示该类不能被继承

2）修饰方法：表示方法不能被重写

3）修饰变量：表示变量只能一次赋值以后值不能被修改（常量）

（9）值传递和引用传递的区别?

1）一个是针对基本数据类型，一个针对引用数据类型

2）值传递传递的是值，引用传递传递的是地址

3）值传递是拷贝了一份新的值给形式参数，在方法中进行操作不会影响原来的值；而引用传递的是地址，两个引用指向同一个地址，因此方法中改变了这个地址中的数据，那么原来的数据也会改变。

编程题

（1）定义并测试一个代表员工的Employee类。

描述：员工属性包括编号、姓名、基本薪水和薪水增长额，还包括计算增长后的工资总额。

class Employee {

private int empno ; //雇员编号

private String ename ; //雇员姓名

private double sal ; //基本工资

private double rate ; //工资增长额

public Employee() {

}

public Employee(int empno, String ename, double sal, double rate) {

super();

this.empno = empno;

this.ename = ename;

this.sal = sal;

this.rate = rate;

}

public String toString() {

return "雇员编号：" + this.empno + "，雇员姓名：" + this.ename + "，基本工资：" + this.sal ;

}

public void growthin() { //增长薪水

this.sal = this.sal * this.rate ;

}

}

public class TestDemo {

public static void main(String args[]) {

Employee emp = new Employee(7369, "SMITH", 1000, 1.5);

emp.growthin() ; //工资增长

System.out.println(emp);

}

}

（2）编写并测试一个代表地址的Address类。

描述：地址信息由国家、省份、城市、街道和邮编组成，并可以返回完整的地址信息。

class Address {

private String national;

private String provincial;

private String city;

private String street;

private String zipcode;

public Address() {

}

public Address(String national, String provincial, String city,

String street, String zipcode) {

super();

this.national = national;

this.provincial = provincial;

this.city = city;

this.street = street;

this.zipcode = zipcode;

}

public String toString() {

return "国家：" + this.national + "，省份：" + this.provincial + "，城市："

+ this.city + "，街道：" + this.street + "，邮政编码：" + this.zipcode;

}

}

public class TestDemo {

public static void main(String args[]) {

Address ad = new Address("中国", "北京", "北京市", "MLDN", "100088");

System.out.println(ad);

}

}

（3）建立一个人类（Person）和学生类（Student），其功能要求：

描述：建立一个人类（Person）和学生类（Student），其功能要求：

1）Person中包含4个保护型的数据成员name、address、sex、age，分别为字符串、字符串、字符及整型，表示姓名、地址、性别和年龄。一个4参构造方法、一个无参构造方法及一个输出方法用于显示4种属性。

2）Student继承Person，并增加输出成员math、english存放数学和英语成绩。一个6参构造方法、一个两参构造方法，一个无参构造方法，重写输出方法用于显示全部6种属性。

class Person {

private String name ;

private String address ;

private char sex ;

private int age ;

public Person() {

}

public Person(String name, String address, char sex, int age) {

super();

this.name = name;

this.address = address;

this.sex = sex;

this.age = age;

}

public String toString() {

return "姓名：" + this.name + "，地址：" + this.address + "，性别：" + this.sex

+ "，年龄：" + this.age;

}

}

class Student extends Person {

private double math ;

private double english ;

public Student() {

}

public Student(String name, String address, char sex, int age, double math,

double english) {

super(name, address, sex, age);

this.math = math;

this.english = english;

}

public String toString() {

return super.toString() + "，数学成绩：" + this.math + "，英语成绩：" + this.english;

}

}

public class TestDemo {

public static void main(String args[]) {

Student stu = new Student("张三", "北京西城区甲11号德外大街德胜科技园美江大厦 A座 - 6层", '男', 25, 90.0, 99.0);

System.out.println(stu);

}

}

（4）设计一个Dog类。

描述：有名字、颜色、年龄等属性，定义构造方法来初始化类的这些属性，定义方法输出Dog信息。编写应用程序使用Dog类。

class Dog {

private String name ;

private String color ;

private int age ;

public Dog() {

}

public Dog(String name, String color, int age) {

super();

this.name = name;

this.color = color;

this.age = age;

}

public String toString() {

return "狗的名字：" + this.name + "，狗的颜色：" + this.color + "，狗的年龄：" + this.age ;

}

}

public class TestDemo {

public static void main(String args[]) {

Dog dog = new Dog("金毛", "金黄色", 3);

System.out.println(dog);

}

}

（5）编写程序从字符串“want you to know one thing”中统计出字母“n”的出现次数。

描述：输出格式为：字母n的出现次数：“n的次数”

public class TestDemo {

public static void main(String args[]) {

String str = "want you to know one thing" ; //定义字符串

int sum = 0 ;

while (str.indexOf("n") != -1) { //是否还有字母n

sum ++ ; //数据统计量增加

str = str.substring(str.indexOf("n") + 1); //改变字符串内容

}

System.out.println("字母n的出现次数：" + sum);

}

}

（6）下面是一个java源文件，改正其中的错误，使其能够编译和运行。

package com.briup.md01;

public class Test1 {

public static void main(String[] args) {

System.out.println("What's wrong with this program?");

}

}

public class TestAnother1 {

public static void main(String[] args) {

System.out.println("What's wrong with this program?");

}

}

改：

package com.briup.md01;

public class Test1 {

public static void main(String[] args) {

System.out.println("What's wrong with this program?");

}

}

//一个.java文件中不能出现两个public修饰的类

class TestAnother1 {

public static void main(String[] args) {

System.out.println("What's wrong with this program?");

}

}

（7）下面是一个Java源文件，改正其中的错误。

package com.briup.md01;

public class Test3 {

public static void main(String args) {

System.out.println("What's wrong with this program?");

}

}

改：

package com.briup.md01;

public class Test3 {

//main方法声明不正确 参数类型不匹配

public static void main(String[] args) {

System.out.println("What's wrong with this program?");

}

}

（8）改下面是一个Java源文件，改正其中的错误。

package com.briup.md01;

public class Testing2 {

public static main(String[] args) {

System.out.println("What's wrong with this program?");

}

}

改：

package com.briup.md01;

public class Testing2 {

//main方法声明不正确，缺失返回值

public static void main(String[] args) {

System.out.println("What's wrong with this program?");

}

}