Java基础之面向对象测试

单选题：（每道题目2分）

1：下列有关类、对象和实例的叙述，正确的是哪一项？( D )

A．类就是对象，对象就是类，实例是对象的另一个名称，三者没有差别

B．对象是类的抽象，类是对象的具体化，实例是对象的另一个名称

C．类是对象的抽象，对象是类的具体化，实例是类的另一个名称

D．类是对象的抽象，对象是类的具体化，实例是对象的另一个名称

 

2：类Student中成员变量声明正确的是哪一项? ( C )

A．class Student

{

    name;

    age;

}

B．class Student

{

    String name= 1.0;

    int age = “26”;

}

C．class Student

{

    Stringname;

    int age;

}

D．class Student

{

    Stringname,int age;

}

 

3：类Student中成员方法声明正确是哪一项？( C )

A：classStudent

   {

       public show(){}

}

B：classStudent

   {

       public void show();

}

C：classStudent

{

       public void show(){}

}

D：classStudent

   {

       show(){}

}

 

4：类Student中构造方法声明正确的是哪一项? ( B)

A：classStudent

   {

       public Student()

}

B：classStudent

   {

       public Student(){}

}

C：classStudent

   {

       public voidStudent(){}

}

D：classStudent

   {

       new Student(){}

}

5：下列哪一项不是面向对象的三大特征之一? ( B )

A：封装

B：抽象

C：继承

D：多态

 

6：下列关于封装说法不正确的是?( D )

A：封装可以提高代码的安全性。

B：封装是指隐藏实现细节，提供公共的访问方式。

C：类或者方法也是封装的一种体现。

D：仅仅private修饰的内容才是封装的体现。

 

7：下列哪个方法和intsum(int a,int b)是重写方法？( B )

A：publicvoid sum(int a,int b)

B：public intsum(int a,int b)        

C：intsum(int a,int b,int c)

D：voidsum(int a,int b,int c)

//方法重写方法返回值，参数列表，方法名都相同，只是方法体的内容不同

8：下列程序的运行结果是：(B)

class Test

{

  private static int x =  10;

  public void show(int x)

  {

     x++;

     System.out.println(x);

  }

  public static void main(String[] args)

  {

     int x = 20;  

     Test t = new Test();

     t.show(x);

  }

}

A：10

B：21

C：11
D：20

 

9：在子类中调用父类中被重写的方法时需要使用哪个关键字？( C )

A．this

B．new

C．super

D．以上都不是

 

10：如果想一个类不能被子类继承的话，用下列哪个修饰符? (D)

A：static

B：abstract

C：private

D：final

 

11：有如下两个类，在main方法中下面哪个做法是错误的?( D )

class Animal{}

class Dog extends Animal{}

A：Animal a =new Animal();

B：Dog d =new Dog();

C： Animal a= new Dog();

D：Dog dog =new Animal();

 

12：下列有关抽象类的叙述正确的是哪项？( C )

A：抽象类中一定含有抽象方法

B：抽象类既能被实例化也能被继承

C：抽象类的声明必须包含abstract关键字

D：抽象类中不能有构造方法

 

13：下列有关接口的叙述错误的是哪项？( D )

A：接口中只能包含抽象方法和常量

B：一个类可以实现多个接口

C：具体类实现接口时必须实现其中的方法

D：接口不能被继承

 

14：下列程序的运行结果是：( c )

class Fu

{

    public int num = 10;

}

 

class Zi extends Fu

{

    public int num = 20;

}

class Test

{

    public static voidmain(String[] args)

    {

       Fu f = new Zi();

       System.out.println(f.num); 

       Zi z = (Zi)f;

       System.out.println(z.num);

    }          //成员变量编译看左边，运行看左边

}

A：10,10

B：20,20

C：10,20

D：20,10

 

15：下列程序的运行结果是：( C )

class Fu

{

    public void show()

    {

       System.out.println("fushow");

    }

}

 

class Zi extends Fu

{

    public void show()

    {

       System.out.println("zishow");

    }

 

    public void method()

    {

       System.out.println("zimethod");

    }

}

class Test

{

    public static voidmain(String[] args)

    {

       Fu f = new Zi();

       f.method();

    }                           //成员方法编译看左边运行看右边

}

A：fu show

B：zi show

C：编译报错

D：zi method

 

16：关于代码块说法错误的是?( C )

A：静态代码块在类加载的时候执行一次，在创建对象的时候不在执行了。

B：构造代码块每次创建对象的时候都会执行。

C：局部代码块是为了限定变量的生命周期。

D：以上说法都不对

 

17：Math类中的方法public static int round(float f)，不能接受下面哪种类型的参数： ( D )

A：byte

B：int

C：long

D：double

 

数据类型：Byte  short    char   int  long   float    double

字节数：    1     2       2     4      8     4        8

 

18：关于抽象类和接口, 以下那个说法有问题：( C )

A：一个类只能继承一个抽象类, 但可以实现多个接口

B：抽象类中可以没有抽象方法, 接口中所有方法必须抽象

C：抽象类中的方法默认是公有的, 接口中方法默认是抽象的

D：抽象类和接口都可以作为函数的形参类型使用, 调用时传入子类对象

 

19：关于内部类说法错误的是(A )

A：内部类不能定义在局部位置。

B：内部类可以定义在成员位置。

C：成员内部类可以用private和static修饰。

D：局部内部类只能访问被final修饰的局部变量。

 

多选题：（每道题目3分）

21：关于静态方法, 以下说法正确的是(A B C )

A、可以使用 类名.方法名调用

B、可以使用 对象.方法名调用

C、不能使用非静态成员            //静态访问静态

D、可以使用静态成员和非静态成员

 

22：关于继承, 以下说法正确的是: （A C D）

A：Java中类只支持单继承, 一个类只能继承一个类, 但是可以有多个子类

B：一个类如果没有自己写无参构造方法, 那么子类将无法继承

C：子类可以当父类用, 父类不可以当子类用

D：子类重写父类方法时访问权限不能更低

 

23：关于abstract不能和哪些关键字共用正确的是( A B C)

A：abstract不可以和private共用

B：abstract不可以和static共用

C：abstract不可以和final共用

D：abstract不可以和public共用

 

24：下列有关抽象方法叙述正确的是哪几项？（A B D）

A：包含抽象方法类的必须定义为抽象类

B：抽象方法没有方法体

C：抽象方法可以包含在任何类中

D：包含抽象方法的类的具体子类必须提供具体的重写方法

25：有如下代码，请问哪些是正确的?(A C D )

class ClassA{}

class ClassB extends ClassA{}

class ClassC extends ClassA{}

以及

ClassA p0 = new ClassA();

ClassB p1 = new ClassB();

ClassC p2 = new ClassC();

ClassA p3 = new ClassB();

ClassA p4 = new ClassC();

A：p0 = p1;     

//相当于ClassA p0= new ClassB(),父类引用指向子类对象

B：p1 = p2;

C：p1 =(ClassB)p3;

D：p2 =(ClassC)p4;

 

简答题：（每道题目3分）

26：什么是面向对象?请举例说明。

面向对象是基于面向过程的一种编程思想，是更符合我们思考的习惯的思想，将复杂问题简单化，让我们从执行者变成了指挥者

面向过程： 抓洗衣粉—找个盆子—将脏衣服放入盆中—接水—洗衣服—晾衣服—收衣服

面向对象：找到洗衣店--给钱--收衣服

27：成员变量和局部的变量区别是什么?

A:在类中的位置不同

           成员变量   类中方法外

           局部变量   方法内或者方法声明上

       B:在内存中的位置不同

           成员变量   堆内存

           局部变量   栈内存    

       C:生命周期不同

           成员变量   随着对象的存在而存在，随着对象的消失而消失

           局部变量   随着方法的调用而存在，随着方法的调用完毕而消失

       D:初始化值

           成员变量   有默认初始化值

           局部变量   没有默认初始化值

28：构造方法的特点是什么?需要注意什么问题?

构造方法的特点：public 类名(){}

方法名和类名相同

没有返回值类型

没有返回值

如果自己不给出构造方法时系统会自动给出无参构造，但是如果自己定义了有参构造，系统就不会给出无参构造

29：方法重写是什么?需要注意什么问题?

方法重写：子类或者实现类中出现了和父类或者接口中一模一样的方法声明的现象。

注意问题：

私有方法不能被重写；方法权限不能更低；静态只能被静态重写；方法名和返回值的类型还有参数列表都相同

30：抽象类和接口的区别是什么?

A:成员区别

     抽象类：

              成员变量：可以是变量，也可以是常量

              构造方法：有构造方法

              成员方法：可以是抽象方法，也可以是非抽象方法

      接口：

              成员变量：只能是常量。默认修饰符 public staticfinal

              成员方法：只能是抽象方法。默认修饰符 public abstract

B:关系区别

      类与类：

              继承关系。只能单继承，可以多层(重)继承。 

      类与接口：

              实现关系。可以单实现，也可以多实现。

              还可以在继承一个类的同时实现多个接口。

接口与接口：

              继承关系。可以单继承，也可以多继承。

C:设计理念区别

       抽象类被继承体现的是："is a"的关系。抽象类定义的是共性功能。

       接口被实现体现的是："like a"的关系。接口定义的是扩展功能。  编程题：（每道题目10分）

扣分项：

    单词拼写错误 1分

    命名不规范 1分

 

31：写一个标准的学生类，包含如下内容：

       成员变量：name,age

       构造方法：无参构造，带两个参数的构造

       成员方法：getXxx()/setXxx()方法。show（）方法用于显示类的成员变量值。

package com.test1;

public class Student {

    //定义成员变量

    String name;

    int age;

    //无参构造

    public Student(){}

    //带参构造

    public Student(String name,int age){

       this.name=name;

       this.age=age;

    }

    //提供getXxx()setXxx()方法

    public String getName() {

       return name;

    }

    public void setName(String name) {

       this.name = name;

    }

    public int getAge(){

       return age;

    }

    public void setAge(int age){

       this.age=age;

    }

    //定义成员方法

    public void show(){

       System.out.println(this.getName()+"  "+this.getAge());

    }

}

 

32：

有一只狗和一只猫。

他们都有睡觉的方法，都仅仅是睡觉。

他们都有运动的方法，狗爱跑步，猫爱跳高。

请用所学知识体现把上面的代码体现出来。

然后在测试类中进行测试。

package com.test2;

//定义一个动物类

public abstract class Animal {

    //定义具体的睡觉方法

    public void sleep(){

       System.out.println("动物需要睡觉");

    }

    //定义抽象的运动方法

    public abstract void sport();

}

package com.test2;

//定义一个狗类

public class Dog extends Animal{

    public void sport() {

       System.out.println("狗爱跑步！");

    }

}

package com.test2;

//定义一个猫类

public class Cat extends Animal{

    public void sport() {

       System.out.println("猫爱跳高！"); 

    }  

}

package com.test2;

//测试类

public class Test {

    public static void main(String[] args) {

       //创建猫的对象

       Cat c = new Cat();

       c.sleep();

       c.sport();

       //创建狗的对象

       Dog d = new Dog();

       d.sleep();

       d.sport();

    }

}

 

33：

我们现在需要做一个学生管理系统，管理员可以对学生进行常见的增删改查操作。请自己分析出这个系统中有哪些类，每个类有哪些成员，以及类与类的关系。

只要有一些基本的想法即可得分。空白无分。

学生类;成员变量：用户名，密码

       成员方法：登录，注册，

管理类：成员变量：用户名，密码

成员方法：登录，注册，增删改查

main