java试题

static修饰的变量和方法都可以通过类名直接访问，而无需创建对象。正确
A、正确
B、错误

2、使用父类作为方法参数实现多态，可以减少类中方法的个数，减少代码量，
更可以提高代码的可扩展性和可维护性。正确

错误
正确
3、编译并且运行如下java程序，执行结果（我是动物、我是猫、我是波斯猫）
class Animal{
   public Aniaml(){
    System.out.println("我是动物");
   }
}
class Cat extends Animal{
   public Cat(){
     System.out.println("我是猫");  
   }  
}
class PersiaCat extends Cat{
   public PersiaCat(){
     System.out.println("我是波斯猫");  
   }  
}
public class Test{
   public static void main(String args[]){
     Animal animal=new PersiaCat(); 
   }  
}
4、接口分离原则的核心思想是：一个对象应该对其他对象尽可能少的了解。(正确)
错误

正确

5、在java中，关于多态的说法错误的是（D）
A.简单说，多态是用基类的引用指向子类的对象
B、多态只能用在方法的参数中
C、使用多态可以解决项目中紧耦合的问题
D、Object类中的equals（Object obj）方法，就是体现了多态

6、在如下所示的java代码中，this关键字是指（B）
public class Person{
private String name;
public void setName(String name){
this.name=name;
  }
}
A、Person类
B、Person类自身对象的引用
C、setName（）方法的参数name
D、setName（）方法

7、以下程序的运行结果是（   C ）。
class Test {
     public static void main(String args[]) {
         int i = 99;
         mb_operate(i);
         System.out.print(i + 100);
     }

     static void mb_operate(int i) {
         i += 100;
     }
}

A     99100

B     299

C     199

D     99

8、以下程序运行的结果是（    B ）。
public class Foo {
     public static void main(String args[]) {
         String s;
         System.out.println("s=" + s);
     }
}
A      null

B      编译错误

C     s=null

D     s=s
9、（多）在java中，关于对象类型转换说法正确的是（AD）
A、对象的类型转换有向下转型和向上转型
B、向下转型时自动进行的，也称隐式转换
C、向上转型容易方法错误
D、向下转型可以使用instanceof操作符来判断转型的合法性
10、给定如下Java代码，编译运行结果是（   A   ）。
class Base {
     Base(int i) {
         System.out.println("Base");
     }
}
class Son extends Base {
     public static void main(String[] args) {
         Son s = new Son();
     }
     Son() {
         System.out.println("Son");
     }
}
A     编译错误

B     Base
      Son

C     Son

D     Base

11、Java中有如下代码片段，运行的结果为（   D ）。
public class Test {
     public static void main(String[] args) {
         Child child = new Child();
         System.out.println("main.");
     }
}
class Parent {
     Parent() {
         System.out.println("to construct Parent.");
     }
}
class Child extends Parent {
     Child() {
         System.out.println("to construct Child.");
     }
}
A     to construct Child.
       main.

B     to construct Parent.
      main.

C     to construct Child.
     to construct Parent.
    main.

D     to construct Parent.
      to construct Child.
      main.

12、以下选项中，（   B C   ）选项放到程序的横线处会引起编译错误。
class Super{
     public float getNum(){
         return 3.0f;
     }
}
public class Sub extends Super{
     _____________________    
}
A     public double getNum(float d){return 4.0d;}
B     public getNum(double d){}
C     public void getNum(){}
D     public float getNum(){return 4.0f;}

13、（多）下面选项中关于Java中静态变量和静态方法的说法正确的是（B D    ）。
A     静态方法中可以出现this和super关键字
B     静态变量有两种访问方式：通过类名直接访问或通过对象名访问
C     在静态方法中可以直接访问静态成员，也可以直接访问非静态成员
D     不管new多少个对象，一个类的static变量在内存中只有一份

 

14、（多）以下Java代码中，（ BD   ）会产生编译错误。
class A{}
class B extends A{
   public B(int i){}
}
A     class A{}
class B extends A{}
B     class A{
     public A(int i){}
}
C     class B extends A{}
D     class A{
     public A(int i){}
}
15、下列选项中，关于java的抽象方法和抽象类说法错误的是（B）
A、抽象类和抽象方法都通过abstract关键字来修饰
B、abstract可以用来修饰类和方法，也可以用来修饰构造方法
C、抽象类中可以有一个或多个抽象方法，也可以没有抽象方法
D、子类必须重写父类所有的抽象方法才能实例化，否则子类还是一个抽象类

16、（多）以下选项中关于Java中构造方法的说法错误的是（ ABD   ）。
A构造方法不能带返回参数
B构造方法不可以重载
C类必须显式定义构造函数
D构造方法的名称必须与类名相同

17、（多）以下选项中关于各种面向对象设计原则的说法正确的是（AB C   D ）。 这个说我选的啊，不知道啊
A     组合/聚合复用原则的核心思想是：优先使用组合，其次才考虑继承
B     依赖注入原则的核心思想是要依赖于抽象，而不是依赖于具体实现
C     里氏替代原则的核心思想是：任何父类出现的地方都可以用它的子类来替代
D     开闭原则的核心思想是：对扩展开放，对修改关闭

18、在Java中，Object类是所有类的父类，用户自定义类默认扩展自Object类，下列选项中的（ A  ）方法不属于Object类的方法。
A     trim( )
B     toString( )
C     getClass()
D     equals(Object obj)

19、下列选项中关于Java中super关键字的说法错误的是（ D ）。
A     子类的构造方法中可以同时出现super和this关键字

B     子类可以通过super关键字调用父类的public和protected方法
C     super关键字不仅可以指代子类的直接父类，还可以指代父类的父类
D     super关键字是在子类对象内部指代其父类对象的引用

 

20、（多）给定如下Java代码，以下（   C D ）方法可以添加到Child类中。
class Parent {
     public int change() {
         return 0;
     }
}
class Child extends Parent {
     //在此处添加代码
}
A     public double change() {return 0;};
B     public void change() {}
C     public int chang(int i) {return 0;}
D     public int change() {return 0;}

21、下面代码经过（   AB  ）修改后，成员变量m 能被方法fun()直接访问。
public class Test {
     private   int m;
     public static void fun() {
         System.out.println(m);
     }
}
A      将public static void fun() 改为 public void fun()
B     将private int m 改为 static int m
C     将private int m 改为 public int m
D     将private int m 改为protected int m

22、（多）以下选项中（ A D）是public void example(){...}的重载方法。
A     public int example ( int m , float f){...}
B     public void example2(){...}
C     public int example(){...}
D     public void example( int m){...}

23、(多)下面java代码中，横线处可以填写的语句是（AD）
A、public abstract void print();
B、public abstract void print(){};
C、private void save（）;
D、void print（）;

24、（多）在java中，下面（BC）实现了方法重载。
A、public String print（String info）{}
   public int print（String info）{}
B、public String print（String info）{}
   public String print（String info,String name）{}
C、public String print（String info）{}
   public String print（String info，int count）{}
D、public String print（String info）{}
   private String print（String info）{}

27、（多）阅读下面的java代码，横线处填写（BD）不能保证程序运行。
  class Person{
  private int age;
  private String name;
  public Person(){
}
public Person(String name,int age){
this.name=name; 
this.age=age;
  }
}
public Student extends Person(){
private String grade;
public Student(String name,int age,String grade)
     -------------
  }
public static void main(String []args){
   Student stu=new Student("阿强",23,"Y2")
   }
}
A、this.name=name;
   this.age=age;
   this.grade=grade;
 
B、super(name,age)
   this.grade=grade
C、super();
   this.grade=grade;
D、this.grade=grade;
   super(name,age);
26、下列选项中关于Java中类和对象的说法错误的是（   A   ）。
A     类的某个对象被赋值后，该类所有对象都被赋予此值
B     对象是类的实体，同一个类可以有多个实体，也就是多个对象
C     在Java中使用class关键字定义类，使用new关键字来创建对象
D     类是具有相同属性和共同行为的一组对象的集合

27、在Java中，有如下代码：
public class Animal {
public Animal(){
System.out.println("嗷呜！");
}
}
public class Dog extends Animal {
public Dog(){
System.out.println("汪！");
}
public static void main(String[] args) {
new Dog();
}
}
运行main()方法后输出结果是（ B ）。
A     汪！
      嗷呜！
B     嗷呜！
     汪！
C     汪！
D     嗷呜！

28、下面的程序中定义了一个java接口，其中包含（）处错误。
public interface Shape{
int MAX_SIZE=20;
void calculate(){
System.out.println("calculate....");
}
private int getSize();
void setSize(int i);
}
A、1
B、2
C、3
D、4

29、In Java,( A ) must much exactly for overloaded methods to compile correctly
A     The parameter list
B     The exceptions thrown
C     The return type
D    None of the above

30、In   Java，the implementation details of a tightly encapsulated class should have 
    ( C ) accessibility.
A、 public  
B、 protected   
C、 private  
D、none   of   above

31、In Java,which of the following statement is true(   B   ) .
A、the overriding  method must has the same
name、name of arguments and return types

B、the overriding method must has the same
name of arguments  and return types(or subtypes)
 
C、the overriding method must has the same
name number and type of arguments .
D、A method cannot be overloaded to be less public in a child class

32、在Java中，有如下代码：( D )
public class Animal {
public void shout(String s ){
System.out.print("叫一声！");
}
}
public class Dog extends Animal {
public void shout(){
System.out.println("汪！");
}
public static void main(String[] args) {
Animal dog = new Dog();
dog.shout();
}
}
运行Dog类的main()方法，输出结果是（）。
A     运行时错误
B     编译错误
C     汪！
D     叫一声！
33、（多）在java中，关于继承的说法正确的是（AD）
A、一个子类只能继承一个父类
B、一个子类只能继承多个父类，并与逗号隔开
C、子类可以继承父类的所有成员
D、子类不能继承父类的构造方法
34、在Java中，有如下代码：
public interface Human {
abstract public void info();
public void speak();
}
public abstract class Child implements Human {
}
34下面描述正确的是（ C ）。
A     编译错误，Child类需要实现speak方法，同时写出info()方法
B     编译错误，因为Child类没有实现speak()和info()方法
C     编译无错误
D     编译错误，因为Child类没有实现speak()方法

35、在Java中，下面代码输出结果是（D）。
public class ShowNum {
private void locate(double d, long l){
System.out.println("double-long");
}
private void locate(long l, int i){
System.out.println("long-int");
}
public static void main(String[] args) {
new ShowNum().locate(2.0, 4);
}
}
A     运行时错误
B     编译错误
C     long-int
D     double-long

36、在Java中，有如下代码：
public class Calculator {
public int value;
public void calculate(){
philsun23
value += 7;
}
}
public class MultiCalculator extends Calculator{
public void calculate(){
value -= 3;
}
public void calculate(int num){
calculate();
super.calculate();
value *= num ;
}
public static void main(String[] args) {
Calculator calculator = new MultiCalculator();
calculator.calculate(2);
System.out.println(calculator.value);
}
}
运行MultiCalculator类的main()方法后，输出内容是（ A ）。
A     编译错误
B     -12
C     28
D     8

37、在Java中，以下代码编译运行结果是（ B ）。
public class Animal {
public Animal(String s){
System.out.println("嗷呜！");
}
}
public class Dog extends Animal {
public Dog(String s){
System.out.println("汪！");
}
public static void main(String[] args) {
Dog dog = new Dog("c");
}
}
A     编译错误
B     嗷呜！
      汪！
C     嗷呜！
D     汪！

38、在Java中，运行main()方法后如下代码输出内容是（ B ）。
class Base {
int i = 99;
public void method(){
System.out.println("Base的方法");
}
Base(){
method();
}
}
public class Type extends Base{
int i = -1;
public static void main(String[] args){
Base b = new Type();
System.out.println(b.i);
b.method();
}
public void method(){
System.out.println("Type的方法");
}
}
A     Base的方法
99
Type的方法

B     Type的方法
99
Type的方法

C     Type的方法
-1
Type的方法

D     Base的方法
-1
Base的方法  

39、(多)在Java中，有如下代码：(A  C)
public class Animal {
public Animal(){
System.out.println("嗷呜！");
}
}

public class Dog extends Animal {
public Dog(){
             横线处填写（）会输出“嗷呜！”.
}
public static void main(String[] args) {
Dog dog = new Dog();
}
}

A     什么都不填

B     this.super();

C     super();

D     this();

40、在一个类文件中的关键字package，import，class出现的可能顺序是（ D ）。
A     package ，class ，import    

B     import ，package ，class

C     class   ，import   ，package

D     package ，import ，class