Java面向对象试题
java面向对象练习题
java面向对象练习题# Java面向对象练习题一、选择题1. 在Java中，以下哪个关键字用于定义类的访问权限为“仅包内可见”？- A. public- B. private- C. protected- D. 默认（不写访问修饰符）2. 以下哪个是Java中的构造方法？- A. 与类名相同，没有返回类型的方法- B. 与类名不同，没有返回类型的方法- C. 与类名相同，有返回类型的方法- D. 与类名不同，有返回类型的方法3. 在Java中，哪个关键字用于实现类的继承？- A. extends- B. implements- C. override- D. abstract4. 以下哪个是Java中类的成员变量？- A. 局部变量- B. 实例变量- C. 静态变量- D. 方法参数5. 以下哪个是Java中的多态性？- A. 接口- B. 继承- C. 封装- D. 抽象类二、简答题1. 解释Java中的封装性，并给出一个封装的类的例子。
2. 描述Java中接口和抽象类的区别。
3. 什么是Java中的继承？请举例说明如何使用继承。
三、编程题1. 创建一个名为`Person`的类，包含姓名（name）、年龄（age）和性别（gender）三个属性。
为每个属性提供getter和setter方法。
2. 编写一个名为`Student`的类，它继承自`Person`类，并添加一个名为`studentID`的属性。
为`studentID`提供getter和setter方法，并重写`toString`方法以返回学生的详细信息。
3. 创建一个接口`Movable`，包含一个方法`move()`。
然后创建一个名为`Car`的类实现该接口，并提供`move`方法的具体实现。
四、综合应用题1. 设计一个简单的银行账户系统，包含以下类：- `Account`：基本账户类，包含账户ID、账户余额和存款（deposit）与取款（withdraw）方法。
《Java面向对象程序设计》考试卷及答案带注释
一、单选题（每小题1分，共30分）1．在MyEclipse中，（）视图可以将项目中包含的文件及层次结构展示出来。
CA) Package B)Declaration C)Navigator D) Console2．下列标识符中，正确的是（）。
CA)class B) 123_rr C) _lei D) test&123．下列的（）选项可以正确用以表示八进制值8。
0x代表16进制，0代表8进制 D A）0x8 B）0x10 C）08 D）0104．以下哪个不是Java的原始数据类型（）DA) int B) boolean C) float D) Char引用数据类型5．下列有关Java布尔类型的描述中，正确的是（）AA)一种基本的数据类型，它的类型名称为booleanB)用int表示类型C)其值可以赋给int类型的变量D)有两个值，1代表真，0代表假6．在Java中，不属于整数类型变量的是( ) AA) double 浮点型B) long C) int D) byte7．以下do-while语句构成的循环执行次数是（）。
Bint k=0;do { ++k ;}while(k<1);A) 一次也不执行B) 执行1次C) 无限次D) 有语法错误，不能执行8．表达式(1/0<1)&& (12==0) 的值为（）。
逻辑运算结果只有true和false两种 BA) true B) false C) 0 D) 运行时抛出异常9．以下（）表达式不可以作为循环条件 AA) i=5 B )i<3 C) count==i D) bEqual=str.equals("q") 10．下列数组初始化正确的是（） DA) int score[5] = {90,12,34,77,56};B) int[5] score = new int[];C) int[] score = new int[5]{90,12,34,77,56};D) int score[] = new int[]{90,12,34,77,56};11．若有定义：byte[] x={11,22,33,-66};其中0≤k≤3，则对x数组元素错误的引用是（） CA) x[5-3] B) x[k] C) x[k+5] D) x[0]12．以下代码的输出结果是（）。
Java面向对象试题_百度文库
Java面向对象试题共30道题，每题3分，满分90分，60分算及格，不及格的要补考。
1 在Java中，如果父类中的某些方法不包含任何逻辑，并且需要有子类重写，应该使用（）关键字来申明父类的这些方法。
(选择一项a Finalb Staticc Abstractd Void2 给定两个java程序，如下：public interface Face{int counter = 40;}public class Test implements Face{private static int counter;public static void main(String[]args{System.out.println(++counter;}}Test.java 的编译运行结果是（）。
(选择一项a 40b 41c 0d 13 给定java代码，如下：public class Test{static int i;public int aMethod( {i++;return i;}public static void main(String [] args{Test test = new Test( ;test.aMethod( ;System.out.println(test.aMethod( ;}}编译运行后，输出结果是（）。
(选择一项a 0b 1c 2d 34 给定java代码，如下：abstract class Shape{abstract void draw( ;}要创建Shape类的子类Circle，以下代码正确的是（）。
(选择二项a class Circle extends Shape{int draw( {}}b abstract class Circle extends Shape{}c class Circle extends Shape{void draw( ;d class Circle extends Shape{void draw( {}}5 给定java代码，如下：class Parent{public void count( {System.out.println(10%3;}}public class Test extends Parent{ public void count(int i{System.out.println(10%i;}public static void main(String[]args{ Parent p = new Test( ;p.count(3;}}编译运行，结果是（）。
java面向对象考试题及答案
java面向对象考试题及答案一、选择题（每题2分，共10分）1. 在Java中，以下哪个关键字用于定义一个类？A. classB. structC. interfaceD. enum答案：A2. 以下哪个选项是Java中类的成员变量？A. 方法B. 构造函数C. 属性D. 包答案：C3. 在Java中，哪个关键字用于实现类的继承？A. extendsB. implementsC. importD. package答案：A4. 在Java中，以下哪个关键字用于定义一个接口？A. classB. structC. interfaceD. enum答案：C5. 在Java中，以下哪个关键字用于定义一个枚举类型？A. classB. structC. enumD. interface答案：C二、填空题（每题2分，共10分）1. 在Java中，一个类可以继承另一个类的______方法。
答案：public2. 当一个类实现了一个接口，它必须提供接口中所有方法的______实现。
答案：具体3. Java中的______关键字用于定义一个包。
答案：package4. 在Java中，______关键字用于声明一个方法，该方法没有返回值。
答案：void5. 在Java中，______关键字用于声明一个方法，该方法返回一个布尔值。
答案：boolean三、简答题（每题5分，共20分）1. 简述Java中构造函数的作用。
答案：构造函数是类的特殊方法，用于在创建对象时初始化对象的状态。
它具有与类同名的名称，并且没有返回类型。
2. 描述Java中接口和抽象类的区别。
答案：接口是完全抽象的，不能包含任何实现细节，而抽象类可以包含实现细节。
接口中的方法默认是public和abstract的，而抽象类可以有非抽象方法。
一个类可以实现多个接口，但只能继承一个抽象类。
3. 什么是Java中的多态性？请举例说明。
答案：多态性是指允许不同类的对象对同一消息做出响应的能力。
java面向对象试题及答案
java面向对象试题及答案1. 试题一题目：什么是面向对象编程？请简要描述面向对象编程的优势和特点。
答案：面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，将程序中的数据和操作数据的方法进行了封装，使得程序更加模块化和易于理解。
面向对象编程的主要特点包括封装、继承和多态。
封装使得数据和对数据的操作集中在一个对象中，可以隐藏内部实现细节，提供公共的接口进行访问，增加了程序的安全性和灵活性。
继承允许新建的类继承已有类的属性和方法，通过扩展和重写已有类的功能，减少了代码的重复性，提高了代码的复用和可维护性。
多态允许不同的对象对相同的消息作出不同的响应，通过接口和抽象类的使用，实现了更加灵活和可扩展的程序设计。
面向对象编程的优势包括了代码的重用性、可维护性、可扩展性和灵活性。
通过封装和继承的应用，可以减少代码重复，提高开发效率，并且通过多态的应用，可以实现程序的灵活性，方便后续的扩展和修改。
2. 试题二题目：什么是类？请简要描述类的特点和组成部分。
答案：类是面向对象编程中的核心概念，是对一类具有相同属性和行为的对象进行抽象和封装的模板。
类是用来创建对象的蓝图，可以通过实例化类来创建对象。
类的特点包括了封装、继承和多态。
类通过封装将属性和方法进行了封装，提供了公共的接口与外部进行交互，隐藏了内部实现细节。
继承允许新建的类继承已有类的属性和方法，在原有基础上进行修改和扩展。
多态允许不同的对象对相同的消息作出不同的响应，实现了程序的灵活性和可扩展性。
类的组成部分包括了属性（Field）和方法（Method）。
属性（也称为成员变量）用于描述对象的状态，可以是基本类型或其他类的对象。
方法用于描述对象的行为，可以是处理属性的操作，也可以是其他业务逻辑的实现。
3. 试题三题目：请简要解释传值和传引用的区别，并用代码示例说明。
答案：传值和传引用是在方法调用时，参数传递的两种方式。
Java面向对象测试试题
Java面向对象测试试题一、单选题1. 下面哪个关键字可以用来声明一个抽象类？A) abstractB) finalC) privateD) protected2. 在Java中，一个类可以同时继承多个类吗？A) 可以B) 不可以3. 在Java中，接口的成员变量默认是什么修饰符？A) privateB) protectedC) publicD) 默认不写修饰符4. 下面哪种访问权限修饰符可以让子类访问父类的成员变量？A) privateB) protectedC) publicD) 默认不写修饰符5. 下面哪个关键字可以用来声明一个常量？A) constantB) finalC) staticD) default二、填空题1. 在Java中，可以通过____关键字来引入其他包中的类。
2. 在Java中，____关键字可以用来防止重写一个方法。
3. 在Java中，____关键字表示当前对象的引用。
4. 在Java中，____关键字用于表示父类。
三、编程题请编写一个Java类，实现一个矩形的类，要求具有以下功能：1. 拥有长度和宽度两个属性。
2. 拥有计算矩形面积的方法。
3. 能够输出矩形的属性信息。
```javapublic class Rectangle {private double length;private double width;public Rectangle(double length, double width) {this.length = length;this.width = width;}public double getArea() {return length * width;}public void printInfo() {System.out.println("Length: " + length);System.out.println("Width: " + width);}}```使用上述代码，可以创建一个矩形对象并调用相应方法来获取矩形的面积和属性信息。
java面向对象考题和答案
1.下面代码的输出结果是:public class Main {public static void main(String[] args) { int n = 100;int m = 200;System.out.println(f(n,m));System.out.println(n);}public static int f(int m, int n) {n = m+n;return n;}}A.300300B.100100C.300100D.1003002.程序执行的结果是：public class Test {public static void main(String[] args) {int x = 6;Test p = new Test();p.doStuff(x);System.out.println(" main： x = " + x); }void doStuff(int x) {System.out.println(" doStuff：x =" + x++); }}A.doStuff：x =7main： x = 7B.doStuff：x =7main： x = 6C.doStuff：x =6main： x = 7D.doStuff：x =6main： x = 63.下列关于JVM的内存结构描述正确的是：A.类的各种信息在方法区中保存B.堆用于存放程序运行过程当中所有的局部变量C.栈用于存储使用new关键字创建的对象D.数组属于JVM的内存结构4.下列代码的输出结果是：public class Test {public void print(char c) {System.out.println("c");}public void print(int i) {System.out.println("i");}public void print(double d) {System.out.println("d");}public void print(String s) {System.out.println("s");}public static void main(String[] args) { Test test=new Test();test.print('5');}}A.cB.iC.dD.s5.程序执行的结果是：public class Test {String name="Tom";public Test(String name){name=name;}public static void main(String [] args){ Test t = new Test("Jack");System.out.println();}}A.nullB.TomC.JackD." "6.关于构造方法，下列说法错误的是:A.构造方法不可以进行方法重写B.构造方法用来实例化一个新的对象C.构造方法具有和类名相同的名称D.构造方法不返回任何数据类型7.关于 Java 中继承的特点，下列说法正确的是:A.使类的定义复杂化B.Java 只支持单继承，不可多继承，但可以通过实现接口来达到多继承的目的C.子类继承父类的所有成员变量和方法，包括父类的构造方法D.不可以多层继承，即一个类不可以继承另一个类的子类8.下列代码运行的结果是：class Foo {public int a;public Foo() {a = 3;}public void addFive() {a += 5;}}class Bar extends Foo {public int a;public Bar() {a = 8;}public void addFive() {this.a += 5;}}public class TestFoo {public static void main(String[] args) {Foo foo = new Bar();foo.addFive();System.out.println("Value: " + foo.a);}}A.Value: 3B.Value: 8C.Value: 13D.Value: 189.下列代码编译和运行的结果是：class Person {String name = "No name";public Person(String nm) {name = nm;}}class Employee extends Person {String empID = "0000";public Employee(String id) {empID = id;}}public class EmployeeTest {public static void main(String[] args) {Employee e = new Employee("4321");System.out.println(e.empID);}}A.输出：0000B.输出：4321C.代码public Employee(String id) {行，出现编译错误D.抛出运行时异常10.下列代码的运行结果是：public class Animal {public String noise() {return "peep";}public static void main(String[] args) {Animal animal = new Dog();Cat cat = (Cat)animal;System.out.println(cat.noise());}}class Dog extends Animal {public String noise() {return "bark";}}class Cat extends Animal {public String noise() {return "meow";}}A.peepB.barkC.meowD.抛出运行时异常11.下列代码编译和运行的结果是：public class A {public void start() {System.out.println("TestA");}}public class B extends A {public void start() {System.out.println("TestB");}public static void main(String[] args) {( (A) new B( ) ).start();}}A.输出：TestAB.输出：TestBC.输出：TestA TestBD.编译错误12.请看下列代码：class One {void foo() {}}class Two extends One {// insert method here}下列选项中的代码，放置在<插入代码>处无编译错误的是： A.int foo() { /* more code here */ }B. protected void foo() { /* more code here */ }C. public void foo() { /* more code here */ }D. private void foo() { /* more code here */ }13.下列选项中，不属于Java 的访问修饰符的是：A.privateB.protectedC.friendlyD.public14.下列代码的输出结果是：class Foo {private int x;public Foo(int x) {this.x = x;}public void setX(int x) {this.x = x;}public int getX() {return x;}}public class Gamma {static Foo fooBar(Foo foo) {foo = new Foo(100);return foo;}public static void main(String[] args) {Foo foo = new Foo(300);System.out.print(foo.getX() + "-");Foo fooFoo = fooBar(foo);System.out.print(foo.getX() + "-");System.out.print(fooFoo.getX() + "-");foo = fooBar(fooFoo);System.out.print(foo.getX() + "-");System.out.print(fooFoo.getX());}}A.300-100-100-100-100B.300-300-100-100-100C.300-300-300-100-100D.300-300-300-300-10015.下列代码运行的结果是：public class Base {public static final String FOO = "foo";16.class Sub extends Base {public static final String FOO = "bar";}public static void main(String[] args) {Base b = new Base();Sub s = new Sub();System.out.print(Base.FOO);System.out.print(Sub.FOO);System.out.print(b.FOO);System.out.print(s.FOO);System.out.print(((Base) s).FOO);}}A.foofoofoofoofooB.foobarfoobarbarC.foobarfoofoofooD.foobarfoobarfoo16.关于下列代码说法正确的是：public class ItemTest {private final int id;public ItemTest(int id) {this.id = id;}public void updateId(int newId) {id = newId;}public static void main(String[] args) {ItemTest fa = new ItemTest(42);fa.updateId(69);System.out.println(fa.id);}}A.编译错误B.运行时抛出异常C.运行后，fa对象属性id的值没有改变，应然是42D.运行后，fa对象属性id的值改变成新的值6917.请看下列代码编译和运行的结果是：public class Student {private String name="sun";public static void main(String[] args) {Student[] students=new Student[2];System.out.println(students[0].name);System.out.println(students.length);}}A.sun 2B.null 2C.null 1D.运行时抛出NullPointerException异常18.下列代码的输出结果是：abstract class Vehicle {public int speed() {return 0;}}class Car extends Vehicle {public int speed() {return 60;}}class RaceCar extends Car {public int speed() {return 150;}}public class TestCar {public static void main(String[] args) {RaceCar racer = new RaceCar();Car car = new RaceCar();Vehicle vehicle = new RaceCar();System.out.println(racer.speed() + ", " + car.speed() + ", " + vehicle.speed());}}A.0, 0,0B.150, 60, 0C.150, 150, 150D.抛出运行时异常19.请看下列代码：public abstract class Employee {protected abstract double getSalesAmount();public double getCommision() {return getSalesAmount() * 0.15;estA() {}}class Sales extends Employee {<插入代码>}在<插入代码>处填入的方法正确的是：A.double getSalesAmount() { return 1230.45; }B.public double getSalesAmount() { return 1230.45; }C.private double getSalesAmount() { return 1230.45; }D.protected double getSalesAmount() { return 1230.45; }20.关于下列代码说法正确的是：public interface A {public void doSomething(String thing);}public class AImpl implements A {public void doSomething(String msg) {}}public class B {public A doit() {return null;}public String execute() {return null;}}public class C extends B {public AImpl doit() {return null;}public Object execute() {return null;}}A. 所有类和接口都编译成功B.类B编译失败C.类Aimpl编译失败D.类C编译失败21.关于下列代码说法正确的是：interface A {public void aMethod();}interface B {public void bMethod();}interface C extends A, B {public void cMethod();}class D implements B {public void bMethod() {}}class E extends D implements C {public void aMethod() {}public void bMethod() {}public void cMethod() {}}A.编译失败B.如果定义D e = new E();, 那么 e.bMethod();调用D类的bMethod()方法C.如果定义D e = (D)(new E());, 那么 e.bMethod();调用D类的bMethod()方法D.如果定义D e = (D)(new E());, 那么 e.bMethod();调用E类的bMethod()方法22.请看下列代码：public class UserRequest {public void request(ServletAction action) {action.doService();}public static void main(String[] args) {UserRequest user = new UserRequest();user.request(new ServletAction() {public void doService() {System.out.println("处理请求");}});}}如果上述代码采用回调模式编写，下列关于ServletAction的定义正确的是：A. public static class ServletAction {public void doService();}B.public final class ServletAction {public void doService();}C.public class ServletAction {public void doService();}D. public interface ServletAction {public void doService();}23.下列代码运行的结果是：public class Hello {String title;int value;public Hello() {title += "World";}public Hello(int value) {this.value = value;title = "Hello";}public static void main(String[] args) { Hello c = new Hello(5);System.out.println(c.title);}}A.HelloB. Hello WorldC. Hello World 5D.运行后无输出24.请看下列代码编译和运行的结果是：interface TestA {String toString();}public class Test {public static void main(String[] args) {System.out.println(new TestA() {public String toString() {return "test";}});}}A.输出：testB.输出：nullC.代码System.out.println(new TestA() {行，编译出错D.代码public String toString() {行，编译出错25.请看下列代码：1)public class Outer {2) void fn(int i) {3) class Inner {4) void print() {5) System.out.println(i);6) }7) }8) Inner in = new Inner();9) in.print();10) }11)}12)class Test {13) public static void main(String args[]){14) Outer out=new Outer();15) out.fn(100);16) }17)}关于上述代码说法正确的是:A.在第5行出现编译错误，fn方法的参数必须用final修饰B.在第3行出现编译错误，在方法的内部不能写类C.在第8行出现编译错误，在方法的内部不能实例化Inner类的对象D.运行代码，控制台输出1002,正确答案:D 3,正确答案:A 4,正确答案:A 5,正确答案:B6,正确答案:B 7,正确答案:B 8,正确答案:A 9,正确答案:C 10,正确答案:D11,正确答案:B 12,正确答案:BC 13,正确答案:C 14,正确答案:B 15,正确答案:D16,正确答案:A 17,正确答案:D 18,正确答案:C 19,正确答案:BD 20,正确答案:D22,正确答案:D 23,正确答案:A 24,正确答案:A 25,正确答案:A。
java面向对象考题和答案
1.下面代码的输出结果是:2.public class Main {3. public static void main(String[] args) {4. int n = 100;5. int m = 200;6. System.out.println(f(n,m));7. System.out.println(n);8. }9. public static int f(int m, int n) {10. n = m+n;11. return n;12. }13.}A.300300B.100100C.300100D.1003002.程序执行的结果是：3.public class Test {4. public static void main(String[] args) {5. int x = 6;6. Test p = new Test();7. p.doStuff(x);8. System.out.println(" main： x = " + x);9. }10. void doStuff(int x) {11. System.out.println(" doStuff：x =" + x++);12. }13.}A.doStuff：x =7B. main： x = 7B.doStuff：x =7main： x = 6C.doStuff：x =6main： x = 7D.doStuff：x =6main： x = 63.下列关于JVM的内存结构描述正确的是：A.类的各种信息在方法区中保存B.堆用于存放程序运行过程当中所有的局部变量C.栈用于存储使用new关键字创建的对象D.数组属于JVM的内存结构4.下列代码的输出结果是：5.public class Test {6. public void print(char c) {7. System.out.println("c");8. }9.10. public void print(int i) {11. System.out.println("i");12. }13.14. public void print(double d) {15. System.out.println("d");16. }17. public void print(String s) {18. System.out.println("s");19. }20. public static void main(String[] args) {21. Test test=new Test();22. test.print('5');23. }24.}A.cB.iC.dD.s5.程序执行的结果是：6.public class Test {7. String name="Tom";8. public Test(String name){9. name=name;10. }11. public static void main(String [] args){12. Test t = new Test("Jack");13. System.out.println();14. }15.}A.nullB.TomC.JackD." "6.关于构造方法，下列说法错误的是:A.构造方法不可以进行方法重写B.构造方法用来实例化一个新的对象C.构造方法具有和类名相同的名称D.构造方法不返回任何数据类型7.关于 Java 中继承的特点，下列说法正确的是:A.使类的定义复杂化B.Java 只支持单继承，不可多继承，但可以通过实现接口来达到多继承的目的C.子类继承父类的所有成员变量和方法，包括父类的构造方法D.不可以多层继承，即一个类不可以继承另一个类的子类8.下列代码运行的结果是：class Foo {public int a;public Foo() {a = 3;}public void addFive() {a += 5;}}class Bar extends Foo {public int a;public Bar() {a = 8;}public void addFive() {this.a += 5;}}public class TestFoo {public static void main(String[] args) {Foo foo = new Bar();foo.addFive();System.out.println("Value: " + foo.a);}}A.Value: 3B.Value: 8C.Value: 13D.Value: 189.下列代码编译和运行的结果是：10.class Person {11. String name = "No name";12.13. public Person(String nm) {14. name = nm;15. }16.}17.class Employee extends Person {18. String empID = "0000";19.20. public Employee(String id) {21. empID = id;22. }23.}24.public class EmployeeTest {25. public static void main(String[] args) {26. Employee e = new Employee("4321");27. System.out.println(e.empID);28. }29.}A.输出：0000B.输出：4321C.代码public Employee(String id) {行，出现编译错误D.抛出运行时异常10.下列代码的运行结果是：11.public class Animal {12. public String noise() {13. return "peep";14. }15. public static void main(String[] args) {16. Animal animal = new Dog();17. Cat cat = (Cat)animal;18. System.out.println(cat.noise());19. }20.}21.class Dog extends Animal {22. public String noise() {23. return "bark";24. }25.}26.class Cat extends Animal {27. public String noise() {28. return "meow";29. }30.}A.peepB.barkC.meowD.抛出运行时异常11.下列代码编译和运行的结果是：public class A {public void start() {System.out.println("TestA");}}public class B extends A {public void start() {System.out.println("TestB");}public static void main(String[] args) {( (A) new B( ) ).start();}}A.输出：TestAB.输出：TestBC.输出：TestA TestBD.编译错误12.请看下列代码：class One {void foo() {}}class Two extends One {// insert method here}下列选项中的代码，放置在<插入代码>处无编译错误的是： A.int foo() { /* more code here */ }B. protected void foo() { /* more code here */ }C. public void foo() { /* more code here */ }D. private void foo() { /* more code here */ }13.下列选项中，不属于Java 的访问修饰符的是：A.privateB.protectedC.friendlyD.public14.下列代码的输出结果是：15.class Foo {16. private int x;17. public Foo(int x) {18. this.x = x;19. }20. public void setX(int x) {21. this.x = x;22. }23. public int getX() {24. return x;25. }26.}27.public class Gamma {28. static Foo fooBar(Foo foo) {29. foo = new Foo(100);30. return foo;31. }32. public static void main(String[] args) {33. Foo foo = new Foo(300);34. System.out.print(foo.getX() + "-");35. Foo fooFoo = fooBar(foo);36. System.out.print(foo.getX() + "-");37. System.out.print(fooFoo.getX() + "-");38. foo = fooBar(fooFoo);39. System.out.print(foo.getX() + "-");40. System.out.print(fooFoo.getX());41. }42.}A.300-100-100-100-100B.300-300-100-100-100C.300-300-300-100-100D.300-300-300-300-10015.下列代码运行的结果是：16.public class Base {17. public static final String FOO = "foo";18.class Sub extends Base {19. public static final String FOO = "bar";20.}21. public static void main(String[] args) {22. Base b = new Base();23. Sub s = new Sub();24. System.out.print(Base.FOO);25. System.out.print(Sub.FOO);26. System.out.print(b.FOO);27. System.out.print(s.FOO);28. System.out.print(((Base) s).FOO);29. }30.}31.A.foofoofoofoofooB.foobarfoobarbarC.foobarfoofoofooD.foobarfoobarfoo16.关于下列代码说法正确的是：17.public class ItemTest {18. private final int id;19. public ItemTest(int id) {20. this.id = id;21. }22. public void updateId(int newId) {23. id = newId;24. }25. public static void main(String[] args) {26. ItemTest fa = new ItemTest(42);27. fa.updateId(69);28. System.out.println(fa.id);29. }30.}A.编译错误B.运行时抛出异常C.运行后，fa对象属性id的值没有改变，应然是42D.运行后，fa对象属性id的值改变成新的值6917.请看下列代码编译和运行的结果是：18.public class Student {19. private String name="sun";20. public static void main(String[] args) {21. Student[] students=new Student[2];22. System.out.println(students[0].name);23. System.out.println(students.length);24. }25.}A.sun 2B.null 2C.null 1D.运行时抛出NullPointerException异常18.下列代码的输出结果是：19.abstract class Vehicle {20. public int speed() {21. return 0;22. }23.}24.class Car extends Vehicle {25. public int speed() {26. return 60;27. }28.}29.class RaceCar extends Car {30. public int speed() {31. return 150;32. }33.}34.public class TestCar {35. public static void main(String[] args) {36. RaceCar racer = new RaceCar();37. Car car = new RaceCar();38. Vehicle vehicle = new RaceCar();39. System.out.println(racer.speed() + ", " + car.speed() + ", "40. + vehicle.speed());41. }42.}A.0, 0,0B.150, 60, 0C.150, 150, 150D.抛出运行时异常19.请看下列代码：public abstract class Employee {protected abstract double getSalesAmount();public double getCommision() {return getSalesAmount() * 0.15;estA() {}}class Sales extends Employee {<插入代码>}在<插入代码>处填入的方法正确的是：A.double getSalesAmount() { return 1230.45; }B.public double getSalesAmount() { return 1230.45; }C.private double getSalesAmount() { return 1230.45; }D.protected double getSalesAmount() { return 1230.45; }20.关于下列代码说法正确的是：public interface A {public void doSomething(String thing);}public class AImpl implements A {public void doSomething(String msg) {}}public class B {public A doit() {return null;}public String execute() {return null;}}public class C extends B {public AImpl doit() {return null;}public Object execute() {return null;}}A. 所有类和接口都编译成功B.类B编译失败C.类Aimpl编译失败D.类C编译失败21.关于下列代码说法正确的是：interface A {public void aMethod();}interface B {public void bMethod();}interface C extends A, B {public void cMethod();}class D implements B {public void bMethod() {}}class E extends D implements C {public void aMethod() {}public void bMethod() {}public void cMethod() {}}A.编译失败B.如果定义D e = new E();, 那么 e.bMethod();调用D类的bMethod()方法C.如果定义D e = (D)(new E());, 那么 e.bMethod();调用D类的bMethod()方法D.如果定义D e = (D)(new E());, 那么 e.bMethod();调用E类的bMethod()方法22.请看下列代码：public class UserRequest {public void request(ServletAction action) {action.doService();}public static void main(String[] args) {UserRequest user = new UserRequest();user.request(new ServletAction() {public void doService() {System.out.println("处理请求");}});}}如果上述代码采用回调模式编写，下列关于ServletAction的定义正确的是：A. public static class ServletAction {public void doService();}B.public final class ServletAction {public void doService();}C.public class ServletAction {public void doService();}D. public interface ServletAction {public void doService();}23.下列代码运行的结果是：24.public class Hello {25. String title;26. int value;27. public Hello() {28. title += "World";29. }30. public Hello(int value) {31. this.value = value;32. title = "Hello";33. }34. public static void main(String[] args) {35. Hello c = new Hello(5);36. System.out.println(c.title);37. }38.}A.HelloB. Hello WorldC. Hello World 5D.运行后无输出24.请看下列代码编译和运行的结果是：25.interface TestA {26. String toString();27.}28.public class Test {29. public static void main(String[] args) {30. System.out.println(new TestA() {31. public String toString() {32. return "test";33. }34. });35. }36.}A.输出：testB.输出：nullC.代码System.out.println(new TestA() {行，编译出错D.代码public String toString() {行，编译出错25.请看下列代码：1)public class Outer {2) void fn(int i) {3) class Inner {4) void print() {5) System.out.println(i);6) }7) }8) Inner in = new Inner();9) in.print();10) }11)}12)class Test {13) public static void main(String args[]){14) Outer out=new Outer();15) out.fn(100);16) }17)}关于上述代码说法正确的是:A.在第5行出现编译错误，fn方法的参数必须用final修饰B.在第3行出现编译错误，在方法的内部不能写类C.在第8行出现编译错误，在方法的内部不能实例化Inner类的对象D.运行代码，控制台输出100A1,正确答案:C2,正确答案:D3,正确答案:A4,正确答案:A5,正确答案:B6,正确答案:B7,正确答案:B8,正确答案:A9,正确答案:C10,正确答案:D11,正确答案:B12,正确答案:BC13,正确答案:C14,正确答案:B15,正确答案:D16,正确答案:A 17,正确答案:D 18,正确答案:C 19,正确答案:BD 20,正确答案:D21,正确答案:D 22,正确答案:D 23,正确答案:A 24,正确答案:A 25,正确答案:A。
Java面向对象测试试题(经典)
《使用Java实现面向对象编程》阶段测试-笔试试卷一、选择题(共25题，每题4分，满分100分)1) 在Java类中，使用以下（）声明语句来定义公有的int型常量MAX。
A. public int MAX = 100;B. final int MAX = 100;C. public static int MAX = 100;D. public static final int MAX = 100;2) 在Java中，以下关于方法重载的说法中错误的是（）。
A. 方法重载要求方法名称必须相同B. 重载方法的参数列表必须不一致C. 重载方法的返回类型必须一致D. 一个方法在所属的类中只能被重载一次3) 给定Java代码如下所示，在横线处新增以下（）方法，是对cal方法的重载。
public class Test{public void cal(int x, int y, int z) {}}A. public int cal(int x, int y, float z){ return 0; }B. public int cal(int x, int y, int z){ return 0; }C. public void cal(int x, int z){ }D. public void cal(int z, int y, int x){ }4) 在Java中，下面对于构造函数的描述正确的是（）。
A. 类必须显式定义构造函数B. 构造函数的返回类型是voidC. 构造函数和类有相同的名称，并且不能带任何参数D. 一个类可以定义多个构造函数5) 下面Java代码的运行结果是（）。
class Penguin {private String name=null; // 名字private int health=0; // 健康值private String sex=null; // 性别public void Penguin() {health = 10;sex = "雄";System.out.println("执行构造方法。
java面向对象试题及答案
JAVA面向对象一：填空1、_____ 是JVM自带的一个线程（自动运行着的程序），用于回收没有任何引用所指向的对象。
2、_____空间用于存储使用new关键字所创建的对象；_____空间用于存储程序运行时在方法中声明的所有的局部变量；_____用于存放类的信息（包括方法），方法有_____份。
3、面向对象三大特征：_____,_____,_____.4、下面是一个类的定义，请将其补充完整。
class _____ {String name;int age;Student( _____ s, int i) {name=s;age=i;}}5、Java 语言的接口是特殊的类，其中包含______常量和_______方法。
6.如果子类中的某个方法的名字、__________和参数列表与它的父类中的某个方法完全一样，则称子类中的这个方法覆盖了父类的同名方法。
7. Java 仅支持类间的单重继承，接口可以弥补这个缺陷，支持_____重继承.8. 接口中所有方法均为________和________的。
9. Java语言中，表示一个类不能再被继承的关键字是________。
10.Java语言中，表示一个类A继承自父类B，并实现接口C的语句是_________________。
11、以下代码的输出结果是________________。
int i=9;char c=’a’;char d=(char)(c+i);System.out.println(d);12.继承主要强调子类在父类的基础上取”长”补”短”,而______主要强调的是类与类之间的传输13、我们在java程序中,把关键字________加到方法名称的前面,来实现子类调用父类的方法14.java语言中,调用方法时,参数传递是_____调用,而不是地址调用15.接口是一种只含有抽象方法或______的一种特殊抽象类16.abstract方法_______(不能或能)与final并列修饰同一个类17.创建一个类就是创建一个新的数据类型，而类在java中属于_____数据类型。
JAVA面向对象程序设计(期末考试试题及答案)
JAVA面向对象程序设计(期末考试试题及答案)一、选择题（每题5分，共30分）1. 下列哪个不是Java基本数据类型？A. intB. charC. StringD. boolean答案：C2. 下列哪个操作符用于取模？A. %B. /C.D. &答案：A3. 下列哪个关键字用于定义接口？A. classB. interfaceC. extendsD. implements答案：B4. Java中，下列哪个方法可以实现字符串的截取？A. substring(int start, int end)B. substring(int start, int length)C. substring(int index)D. substring(int index, int length)答案：A5. 下列哪个方法用于判断字符串是否为空？A. isEmpty()B. isBlank()C. isEmptyD. isNull()答案：B6. 下列哪个方法用于获取字符串长度？A. length()B. lengthC. size()D. getSize()答案：A二、填空题（每题5分，共30分）1. 在Java中，所有的类都是_______类的子类。
答案：Object2. Java中定义接口时，需要使用_______关键字。
答案：interface3. 在Java中，定义抽象类时需要使用_______关键字。
答案：abstract4. Java中，字符串比较可以使用_______方法。
答案：equals()5. 在Java中，若要实现字符串的翻转，可以使用_______类。
答案：StringBuilder6. 下列哪个方法用于判断字符串是否以指定的字符串开头？答案：startsWith(String prefix)三、编程题（共40分）1. 编写一个Java程序，实现一个简单的计算器功能，包括加、减、乘、除四种运算。
java面向对象程序设计考试题及答案
java面向对象程序设计考试题及答案一、选择题（每题2分，共10分）1. 在Java中，以下哪个关键字用于定义类的属性？A. staticB. finalC. privateD. public答案：C2. 以下哪个方法用于在Java中创建对象？A. newB. createC. makeD. construct答案：A3. 哪个关键字用于在Java中定义一个方法？A. functionB. methodC. defineD. procedure答案：B4. 在Java中，哪个关键字用于实现类的继承？A. extendsB. inheritC. deriveD. base答案：A5. Java中接口和抽象类的主要区别是什么？A. 接口没有构造方法，抽象类有B. 接口可以有实现，抽象类不能C. 接口不能有属性，抽象类可以D. 接口可以有私有方法，抽象类不可以答案：A二、填空题（每空1分，共10分）1. 在Java中，一个类可以继承另一个类的属性和方法，这种特性称为____。
答案：继承2. Java中，一个类只能继承一个父类，这是Java的____特性。
答案：单继承3. 当一个类实现了一个接口时，它必须实现接口中所有的____方法。
答案：抽象4. Java中，____关键字用于声明一个类是抽象的。
答案：abstract5. 在Java中，____关键字用于声明一个方法没有具体的实现。
答案：abstract三、简答题（每题10分，共20分）1. 请简述Java中封装的概念及其重要性。
答案：封装是面向对象编程中的一个核心概念，它指的是将对象的状态（属性）和行为（方法）结合在一起，并隐藏对象的内部实现细节。
封装的重要性在于它提高了代码的安全性和可维护性，使得对象的内部状态不会被外部代码随意访问和修改，从而保护了对象的完整性。
2. 描述Java中多态的概念及其作用。
答案：多态是面向对象编程中的一个特性，它允许不同类的对象对同一消息做出响应。
java面向对象程序设计期末考试题及答案
java面向对象程序设计期末考试题及答案一、选择题（每题2分，共20分）1. 在Java中，以下哪个关键字用于声明一个类？A. classB. interfaceC. structD. enum答案：A2. Java中的继承是？A. 单继承B. 多继承C. 无继承D. 混合继承答案：A3. 下列哪个是Java中的访问修饰符？A. privateB. protectedC. publicD. 以上都是答案：D4. Java中哪个关键字用于实现多态？A. abstractB. finalC. staticD. override答案：D5. Java中接口和抽象类的主要区别是？A. 接口可以有构造方法B. 抽象类可以有构造方法C. 接口不能有构造方法D. 抽象类不能有构造方法答案：C6. 在Java中，下列哪个是正确的方法重载？A. 方法名相同，参数列表不同B. 方法名不同，参数列表相同C. 方法名和参数列表都相同D. 方法名相同，返回类型不同答案：A7. 下列哪个不是Java的集合框架中的接口？A. ListB. SetC. MapD. Stream答案：D8. Java中，下列哪个是线程安全的单例模式实现？A. 懒汉式B. 饿汉式C. 双重检查锁定D. 以上都是答案：B9. Java中，下列哪个是正确的异常处理关键字？A. tryB. catchC. finallyD. 以上都是答案：D10. 在Java中，下列哪个是正确的泛型使用方式？A. List<String> list = new ArrayList<>();B. List list = new ArrayList<>();C. List<String> list = new ArrayList<Integer>();D. List list = new ArrayList<String>();答案：A二、填空题（每题2分，共20分）1. Java中，一个类可以继承______个父类。
Java面向对象期末考试题
Java期末考试题选择题(每题2分，共20分)1.在Java中，下列哪个选项是合法的变量名？(2分)A. 3xB. _nameC. $valueD. -age2.Java中boolean类型的取值是什么？(2分)A. 0 和1B. true 和falseC. yes 和noD. on 和off3.Java中，数组的第一个元素的下标是多少？(2分)A. 0B. 1C. -1D. 取决于数组的长度4.下列哪个关键字用于定义不可变的变量？(2分)A. staticB. constC. finalD. immutable5.Java中，继承是使用哪个关键字实现的？(2分)A. implementsB. extendsC. inheritsD. derives6.抽象类的特点是什么？(2分)A. 可以实例化B. 必须包含至少一个抽象方法C. 不能包含具体方法D. 可以包含具体方法7.使用哪个方法可以获取字符串的长度？(2分)A. length()B. size()C. lengthD. getSize()8.在Java中，++i比i++的效率高。
(2分)A. 正确B. 错误9.在Java中，所有类都直接或间接继承自Object类。
(2分)A. 正确B. 错误10.StringBuffer类是线程安全的。
(2分)A. 正确B. 错误填空题(每题2分，共20分)1.在Java中，使用关键字______声明类变量。
(2分)2.使用______关键字可以跳出当前循环。
(2分)3.______方法用于在字符串末尾添加新的字符串，而不改变原字符串。
(2分)4.Java中，如果子类的方法与父类的方法相同，这种机制称为______。
(2分)5.在Java中，一个类可以实现多个______。
(2分)6.使用______关键字可以声明一个方法可能抛出的异常。
(2分)7.______是Java中用于生成文档注释的注释方式。
(2分)8.在Java中，使用______和______关键字可以定义一个二维数组。
Java面向对象程序设计模拟试题2及答案
Java面向对象程序设计模拟试题2一、单项选择题(本大题共15小题，每小题1分，共15分)1.JVM是指A. Java开发工具B. Java虚拟机C. Java运行环境D. Java编程接口2.Java字节码文件的扩展名是A. cB. exeC. javaD. class3.在Java中，byte型变量所占的字节数是A. 1B. 2C. 4D. 84.给定下面代码段，输出j的值是多少int i = 1, j = 0 ;switch(i) {case 1:j += 6;case 2:j += 1;case 3:j += 2;}System.out.println(j);A. 2B. 6C. 7D. 95.给定下面代码段，程序运行结果是public class Test { static void leftshift(int i, int j){i <<= j;}public static void main(String[] args){ int i = 4, j = 2;leftshift(i,j);System.out.println("i = "+ i);}}A. i = 1B. i = 2C. i = 3D. i = 46.执行下列程序段后a和b的值为class AB{int a , b ;public void init(int x){a = x ;int b = 5 ;}public void display(){ System.out.println("a = "+a+" b = "+b);}}public class ABTest{public static void main(String[] args){AB ab = new AB();ab.init(6);ab.display() ;}}A. a = 5 b = 5B. a = 0 b = 0C. a = 6 b = 5D. a = 6 b = 07.下列程序段的运行结果为int [][]x ={{1,2},{3,4,5},{6,7,8,9}};int[][]y = x;System.out.println(y[2][1]);A. 3B. 4C. 6D. 78.执行下列语句后输出的结果是String s = "COMPUTER";System.out.println(s.indexOf(‘M’));A. 0B. 1C. 2D. 39.下面程序运行结果为class AA{AA(int a){System.out.print(a);}}class BB extends AA{BB(String s){super(88);System.out.print(s);}}public class ConstructorDemo{public static void main(String[] args){ BB b = new BB("hello");A. 该程序有编译错误B. 88helloC. hello88D. hello10.下面程序运行结果为class Super{public int i = 0;public Super(String text){ i = 1;}}public class Sub extends Super{ public Sub(Stringtext){ super“(”);i = 2;}public static void main(String[]args){ Sub sub = new Sub("Hello");System.out.println(sub.i);}}A. 该程序有编译错误B. 编译成功输出0C.编译成功输出1D.编译成功输出211.下面代码在运行时会产生什么异常int m = 100;System.out.println(m / 0);A. ClassNotFoundExceptionB. MathExceptionC. ArithmeticExceptionD. NullPointerException12.有下列一段代码，执行后输出结果为。
java面向对象程序设计练习题(有答案)
满分：100 分姓名：班级：学号：1. 填空题 ( 5.0 分 )面向对象三大特征______ ______ ______正确答案：封装继承多态2. 填空题 ( 5.0 分 )使用static 修饰的变量称为静态变量，静态变量可以有两种访问方式，分别是对象名.静态变量名和______正确答案：类名.静态变量名3. 单选题 (4.0 分 )下面关于java 中类的说法哪个是不正确的A. 构造函数是类中的特殊方法B. 类一定要声明为public 的，才可以执行C. 在软件设计中，类，就是一个模板，它定义了通用于一个特定种类的所有对象的属性(变量)和行为(方法)D. 一个java 文件中可以有多个class 定义(但只能有一个public 修饰的类)正确答案：B4. 单选题 ( 4.0 分 )关于类中可以包含的内容，如下说法错误的是()A. 类中可以包含属性和方法B. 类中可以直接包含代码块C. 类中可以嵌套定义类D. 类中不能包含其他类正确答案：D5. 单选题 ( 4.0 分 )构造方法是否可被重写和重载()A. 不能重写，可以重载B. 可以重写，不能重载C. 不能重写，不能重载D. 可以重写，可以重载正确答案：A6. 单选题 ( 4.0 分 )关于封装的好处，以下错误的是()A. 隐藏实现的细节B. 方便修改的实现C. 只能通过规定方法访问D. 实现代码复杂化正确答案：D7. 单选题 ( 4.0 分 )在Java 中，下面描述正确的是()A. 一个子类可以有多个父类，一个父类也可以有多个子类B. 一个子类可以有多个父类，但一个父类只可以有一个子类C. 一个子类只可以有一个父类，但一个父类可以有多个子类D. 以上说法都不对正确答案：C8. 单选题 ( 4.0 分 )Java 语言的类间的继承关系是A. 多重的B. 单继承C. 线程的D. 不能继承正确答案：B9. 单选题 ( 4.0 分 )以下关于this 和super 关键字的说法错误的是()A. this 关键字指向当前对象自身，super 关键字指向当前对象的直接父类B. 在main 方法中可以存在this 或者super 关键字，但不能同时存在。
java面向对象期末试题及答案
java面向对象期末试题及答案一、选择题（共10题，每题2分，共20分）1. 下列选项中，不属于Java的基本数据类型的是：A) intB) doubleC) booleanD) String答案：D2. 下列选项中，哪个关键字表示一个类不能被继承：A) finalB) staticC) privateD) abstract答案：A3. 在Java中，抽象类的特点是：A) 可以直接实例化B) 可以包含具体方法C) 可以被继承D) 可以实现多重继承答案：C4. 下列选项中，哪个关键字表示一个方法可以被子类重写：A) staticB) finalC) privateD) abstract答案：D5. 在Java中，接口的特点是：A) 可以包含成员变量B) 可以被实例化C) 可以包含具体方法D) 可以被类直接继承答案：B6. 下列选项中，哪个关键字表示一个方法或类只能被同一个包内的其他类访问：A) protectedB) publicC) privateD) default答案：D7. 在Java中，多态的实现方式是通过：A) 继承B) 接口C) 抽象类D) 重载答案：A8. 下列选项中，哪个关键字表示一个方法可以在同一个类中多次定义，但参数列表必须不同：A) staticB) finalC) privateD) overloading答案：D9. 在Java中，使用关键字“this”表示的是：A) 调用当前对象的方法B) 调用父类的方法C) 调用子类的方法D) 调用类的静态方法答案：A10. 下列选项中，哪个关键字表示一个方法不能被子类重写：A) finalB) abstractC) privateD) protected答案：A二、填空题（共5题，每题4分，共20分）1. 在Java中，创建对象的关键字是________。
答案：new2. 在Java中，使用关键字________定义了一个类的成员变量只能被本类的方法访问。
java面向对象试题及答案
java面向对象试题及答案# Java面向对象试题及答案一、选择题1. 在Java中，以下哪个关键字用于定义类？- A. class- B. interface- C. enum- D. package答案：A2. 以下哪个是Java中的继承特性？- A. 一个类可以继承多个类- B. 类可以继承接口- C. 接口可以继承类- D. 接口可以继承多个接口答案：D3. 以下哪个是Java中封装的体现？- A. 使用public关键字- B. 使用private关键字- C. 使用static关键字- D. 使用final关键字答案：B4. 在Java中，哪个关键字用于实现多态？- A. abstract- B. final- C. override- D. implements答案：C5. 以下哪个是Java的构造方法的特点？- A. 可以有返回类型- B. 可以有多个同名的构造方法- C. 必须有返回类型- D. 必须与类名相同答案：D二、简答题1. 简述面向对象编程的三大特性，并给出Java中的例子。
面向对象编程的三大特性是封装、继承和多态。
- 封装：封装是将对象的实现细节隐藏起来，只暴露出一个可以被外界访问的接口。
例如，在Java中，可以通过使用private关键字来隐藏类的成员变量，只通过public方法来访问这些变量。
- 继承：继承允许新创建的类（子类）继承现有类（父类）的属性和方法。
例如，如果有一个`Animal`类，可以创建一个`Dog`类继承`Animal`类。
- 多态：多态允许同一个接口接受不同的数据类型。
在Java中，可以通过重写父类的方法来实现多态。
例如，`Animal`类有一个`makeSound()`方法，而`Dog`类可以重写这个方法来发出狗的叫声。
2. 解释Java中的接口和抽象类的区别。
接口和抽象类都是Java中实现抽象化的方式，但它们有以下区别： - 接口可以包含抽象方法和默认方法，但不能有具体实现。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Java面向对象试题共30道题，每题3分，满分90分，60分算及格，不及格的要补考。
1) 在Java中，如果父类中的某些方法不包含任何逻辑，并且需要有子类重写，应该使用（）关键字来申明父类的这些方法。
(选择一项)a) Finalb) Staticc) Abstractd) Void2) 给定两个java程序，如下：public interface Face{int counter = 40;}public class Test implements Face{private static int counter;public static void main(String[]args){System.out.println(++counter);}}Test.java 的编译运行结果是（）。
(选择一项)a) 40b) 41c) 0d) 13) 给定java代码，如下：public class Test{static int i;public int aMethod( ){i++;return i;}public static void main(String [] args){Test test = new Test( );test.aMethod( );System.out.println(test.aMethod( ));}}编译运行后，输出结果是（）。
(选择一项)a) 0b) 1c) 2d) 34) 给定java代码，如下：abstract class Shape{abstract void draw( );}要创建Shape类的子类Circle，以下代码正确的是（）。
(选择二项) a) class Circle extends Shape{int draw( ){}}b) abstract class Circle extends Shape{}c) class Circle extends Shape{void draw( );d) class Circle extends Shape{void draw( ){}}5) 给定java代码，如下：class Parent{public void count( ){System.out.println(10%3);}}public class Test extends Parent{public void count(int i){System.out.println(10%i);}public static void main(String[]args){ Parent p = new Test( );p.count(3);}}编译运行，结果是（）。
(选择一项)a) 1c) 3.333333333333335d) 编译错误6) 给定java程序Test.java,如下：import java.util.ArrayList;private class Testing extends ArrayList{private void aMethod( ){}}public class Test extends Testing{}现在该程序编译无法通过，错误原因是（）(选择一项)a) ArrayList不能被继承b) 一个Test.java文件中不能声明两个类c) Test的继承语法有错误d) Testing不能被声明为private7) 给定java程序，如下：public class Test{private static final int counter=10;public static void main(String [] args){System.out.println(++counter);}}编译运行Test.java，结果是（）(选择一项)b) 11c) 编译错误d) 运行时出现异常8) 在java中，以定义了两个接口B和C，要定义一个实现这两个接口的类，以下语句正确的是（）(选择一项)a) interface A extends B,Cb) interface A implements B,Cc) class A implements B,Cd) class A implements B,implements C9) 给定一个Java程序代码，如下：public class Test{int count = 9;public void count1(){int count =10;System.out.println("count1="+count);}public void count2(){System.out.println("count2="+count);}public static void main(String args[]){Test t=new Test();t.count1();t.count2();}行编译后，输出结果是（）。
（选择一项）a) count1=9count2=9b) count1=10count2=9c) count1=10count2=10d) count1=9count2=1010) 在JAVA中，com包中某类的方法使用下列（）访问修饰符修饰后，可以被com.db包中的子类访问，但不能被com.db中其他类访问。
（选择一项）a) Privateb) protecte0c) Publicd) Fridndly11) 给定如下java 代码，以下（）修饰符可以填入下划线处。
（选择二项）class Parent{protected void eat(){}}class Child extends Parent{_________ void eat(){}}b) Privatec) 什么也不填d) Public12) 在Java中，下面关于抽象类的描述正确的是（）。
（选择两项）a) 抽象类可以被实例化b) 如果一个类中有一个方法被声明为抽象的，那么这个类必须是抽象类c) 抽象类中的方法必须都是抽象的d) 声明抽象类必须带有关键字abstract13) 给定如下Java代码,以下（）方法可以加入Child类中。
（选择两项）Public class Parent{int change(){…}}Class Child extends Parent{}a) public int change(){}b) int chang(int i){}c) private int change(){}d) abstract int change(){}14) 在java中，在定义类时加上修饰符（）可以实现该类不能被实例化。
（选择一项）a) Finalb) Publicc) Private15) 在java中，下面（）的陈述是正确的。
（选择二项）a) 私有方法不能被重载b) 静态方法能被重载c) 公有方法被重写后的访问修饰符可以变成privated) 一个被重写的方法不能抛出一个在基类中不被检查的异常16) 分析下面的java代码输出结果为（）。
（选择一项）Class Point{Int x,y;Point(int x,int y){This.x=x;This.y=y;}Public ststic void main(String[] args){Point pt1,pt2;Pt1=new Pint (3,3);Pt2=new Pint(4,4);System.out.print(pt1.x+pt2.x);}}a) 6b) 34c) 8d) 717) 在java中，以下程序的输出结果是（）。
（选择一项）Class Point{Int x;Boolean y;Void output(){System.out.println(x);System.out.println(y);}Public static void main(String[] args){Piont pt =new Point();Pt.output();}}a) 运行错误b) 0Turec) 0Falsed) 018) 给定java代码如下，编译运行结果是（）。
（选择一项）public class Test extends Parent{public int count(){return 1%9;}public static void main(String[] args){System.out.println(count());}}a) 编译错误b) 运行时出现例外c) 正常运行，输出1d) 正常运行，输出019) 1、在Java中，如果父类中的某些方法不包含任何逻辑，并且需要有子类重写，应该使用（）关键字来申明父类的这些方法。
(选择一项)a) finalb) staticc) abstractd) void20) 在Java接口中，下列选项里有效的方法声明是（）（选择二项）a) public void aMethod();b) void aMethod();c) static void aMethod();d) protected void aMethod();21) 给定java代码，如下：String s=null;s.concat(“abc”); 运行时，会产生（）类型的异常。
（选择一项）a) ArithmeticExceptionb) NullPointerExceptionc) IOExceptiond) EOFException22) 在java中，下面捕获异常的语句正确的是（）。
（选择二项）a) try{}finally{}b) try{}c) try{try{}d) try{try{}finally{}}catch(Exception ex){}23) 给定一段Java代码，如下：运行后，输出结果将是（）（选择一项）public class Test{public static void main(String []args){int a[] = {0,1,2,3,4};int sum = 0;try{for (int i=1;i<6;i++){sum = wum + a[i];}System.out.println("sum="+sum);}catch (ArrayIndexOutOfBoundsException e){System.out.println("数组越界");}Finally{System.out.println("程序结束");}}}a) sum = 10程序结束b) sum = 10c) 数组越界程序结束d) 数组越界24) 给定java代码，如下：编译运行，结果是（）（选择一项）public static void main (String [] args){String s;System.out.println(“s=”+s);}a) 编译错误b) 编译通过，但出现运行时错误c) 正常运行，输出s=nulld) 正常运行，输出s=25) 关于Java的异常处理，以下说法正确的是（）。