面向对象测试题

最新推荐文章于 2023-03-15 18:42:11 发布

Hercule2016

最新推荐文章于 2023-03-15 18:42:11 发布

阅读量6k

点赞数 2

分类专栏：测试题文章标签： java 编程语言

本文链接：https://blog.csdn.net/cdut2016/article/details/103855939

版权

测试题专栏收录该内容

2 篇文章 0 订阅

订阅专栏

粗体标出的字体即为答案。
一、填空题每空1分共15分
1．如果一个方法不返回任何值，则该方法的返回值类型为 void 。
2．如果子类中的某个方法名、返回值类型和参数与父类中的某个方法完全一致，则称子类中的这个方法覆盖了父类的同名方法。
3．接口中所有的属性均为静态、final 和公共的
4．抽象方法是一种仅有方法声明，没有具体方法体和操作实现的方法，该方法必须在抽象类之中定义。
5．在Java程序中，通过类的定义只能实现单重继承，但通过接口的定义可以实现多重继承关系。
6．一般Java程序的类主体由两部分组成：一部分是 成员变量 ，另一部分是 成员方法 。
7．分别用 class 关键字来定义类，用 new 关键字来分配实例存储空间。
8．当一个类的修饰符为 final 时，说明该类不能被继承，即不能有子类。
9．在Java中，能实现多重继承效果的方式是接口。

二、选择题每题1分共39分
1．方法内定义的变量（B）。
A．一定在方法内所有位置可见 B．可能在方法的局部位置可见
C．在方法外可以使用 D．在方法外可见
2．方法的形参（ A）。
A．可以没有 B．至少有一个
C．必须定义多个形参 D．只能是简单变量
3．return语句（D）。
A．不能用来返回对象 B．只可以返回数值
C．方法都必须含有 D．一个方法中可以有多个
4．main()方法的返回值类型是（C）。
A．boolean B．int
C．void D．static
5．编译并运行下面的程序，运行结果是（A）。
public class A{
public static void main(String args[]){
A a=new A();
a.method(8);
}
void method(int i){
System.out.println(“int: ”+i);
}
void method(long i){
System.out.println(“long: ”+i);
}
A．程序可以编译运行，输出结果为：“int: 8”
B．程序可以编译运行，输出结果为：“long: 8”
C．程序有编译错误，因为两个method()方法必须定义为静态（static）的
D．程序可以编译运行，但是没有输出
6．能作为类及其成员的修饰符是（D ）。
A．interface B．class
C．protected D．public
7．下列方法定义中，方法头不正确的是（A ）。
A．public static x(double a){…} B．public static int x(double y){…}
C．void x(double d){…} D．public int x(){…}
8．构造方法在（ D ）时被调用。
A．类定义时 B．使用对象的变量时
C．调用对象方法时 D．创建对象时
9．下列哪个类声明是正确的（A ）。
A．public abstract class Car{…} B．abstract private move(){…}
C．protected private number; D．abstract final class H1{…}
10．下列不属于面向对象程序设计的基本特征的是（D ）。
A．抽象 B．封装
C．继承 D．静态
11．请看下面的程序段
class Person{
String name,department;
int age;
public Person(String n){name=n;}
public Person(String n,int a){name=n; age=a;}
public Person(String n, String d, int a ){
//doing the same as two arguments version if constructer
}
下面那个选项可以添加到// doing the same……处（ C ）
A．Person(n,a) B．this(Person(n,a))
C．this(n,a) D．this(name.age)
12．请看下面的程序段
class Test{
private int m;
public static void fun(){
//some code
}
}
方法fun()如何来访问变量m（ C ）
A．将private int m 改成protected int m B．将private int m 改成public int m
C．将private int m 改成static int m D．将private int m 改成int m
13．有一个类A，对于其构造函数的声明正确的是（B ）。
A．void A(int x){…} B．public A(int x){…}
C．A A(int x){…} D．int A(int x){…}
14．请看下面的程序段
public class Test{
long a[]=new long[10];
pubic static void main(String args[]){
System.out.println(a[6]);
}
}
哪一个选项是正确的（ C ）。
A．不输出任何内容 B．输出0
C．当编译时有错误出现 D．当运行时有错误出现
15．关键字（B ）表明一个对象或变量在初始化后不能修改。
A．extends B．final
C．this D．finalize
16．声明为static的方法不能访问（ C）类成员。
A．超类 B．子类
C．非static D．用户自定义类
17．定义类A如下：（重要）
class A{
int a,b,c;
public void B(int x,int y, int z){ a=x;b=y;c=z;}
}
下面对方法B的重载哪些是正确的（C ）。
A．public void A(int x1,int y1, int z1){ a=x1;b=y1;c=z1;}
B．public void B(int x1,int y1, int z1){ a=x1;b=y1;c=z1;}
C．public void B(int x,int y){ a=x;b=y;c=0;}
D．public B(int x,int y, int z){ a=x;b=y;c=z;}
18．编译运行下面的程序，结果是（ B）。（重要）
public class A{
public static void main(String args[]){
B b=new B();
b.test();
}
void test(){
System.out.print(“A”);
}
}
class B extends A{
void test(){
super.test();
System.out.print(“B”);
}
}
A．产生编译错误 B．代码可以编译运行，并输出结果：AB
C．代码可以编译运行，但没有输出 D．编译没有错误，但会产生运行时异常
19．已知类关系如下：
Class Employee{}
Class Manager extends Employee{}
Class Director extends Employee{}
则下列语句正确的是：（A ）。
A．Employee e=new Manager(); B．Director d=new Manager();
C．Director d =new Employee (); D．Manager m=new Director ();
20．接口是Java面向对象的实现机制之一，以下说法正确的是（B ）。
A．Java支持多重继承，一个类可以实现多个接口
B．Java只支持单重继承，一个类可以实现多个接口
C．Java只支持单重继承，一个类可以实现一个接口
D．Java支持多重继承，但一个类只可以实现一个接口
21．下列方法的声明中不合法的是 C 。
A．float area( ){…} B．void area( ){…}
C．area{…} D．int area(int r){…}
22、下面哪个包是编程时不需要导入就可以直接使用的 B 。
A．java.net B．java.lang C．java.sql D．java.util
23、调用构造方法是在 B 。
A．类定义时　　　　　　 B．创建对象时
C．调用对象的方法时　　 D．使用对象的变量时
24、在子类构造方法的哪个地方可以调用其父类的构造方法 B 。
A．任何地方
B．构造方法的第一条语句
C．构造方法的最后一条语句
D．无法在子类构造方法中调用父类的构造方法
解析：当我们在调用相关的构造方法的时候
25、关于Java中的继承，下列说法错误的是 D 。
A．继承是面向对象编程的核心特征，通过继承可以更有效地组织程序结构。
B．继承使得程序员可以在原有类的基础上很快设计出一个功能更强的新类，而不必从头开始，避免了工作上的重复。
C．每一次继承时，子类都会自动拥有父类的属性和方法，同时也可以加入自己的一些特性，使得它更具体、功能更强大。
D．继承一般有多重继承和单一继承两种方式，在单一继承中每一个类最多只有一个父类，而多重继承则可以有多个父类。Java中的类都采用多重继承。
26、当方法中的局部变量与成员变量同名时，必须使用下列哪一个关键字指出成员变量 C 。
A．static B．super C．this D．new
27、什么样的方法不能被重写 B 。
A．私有（private）方法 B．最终（final）方法
C．受保护（protected）的方法 D．以上都不对
28、下列有关抽象类与接口的叙述中正确的是哪一个 C 。
A．抽象类中必须有抽象方法，接口中也必须有抽象方法
B．抽象类中可以有非抽象方法，接口中也可以有非抽象方法
C．含有抽象方法的类必须是抽象类，接口中的方法必须是抽象方法
D．抽象类中的变量定义时必须初始化，而接口中不是
29、从下列程序中你发现了几处错误 C 。
abstract class A{
abstract void f(){};
public abstract void k();
}
class B extends A{
protected void f(){ }
void k(){
System.out.print(“I am subclass”);
}
public static void main(String[] args) {
A a=new A();
a.f();
a.k();
}
}
A．1 B．2 C．3 D．4
解析：首先对于此题来说抽象方法不能有方法体，所以这是第一处错误，而后对于k方法父类中是public,子类中则降低到了默认级别，子类重写方法权限只能扩大而不能缩小。下面还有一点是抽象方法是不能直接调用的。所以应该有三处错误。
30、下列程序运行的结果是 A 。
interface InterfaceA{
String s="good ";
void f();
}
class ClassA implements InterfaceA{
public void f(){
System.out.print(s);
}
}

class ClassB{
void g(InterfaceA a){
a.f();
}
}
public class E {
public static void main(String[] args) {
ClassB b=new ClassB();
b.g(new ClassA());
}
}
A．good B．编译正确，但无运行结果
C．编译错误：b.g(new ClassA()) D．以上都不对
31、下列类的声明中不合法的是A 。
A．class People（）{…} B．class 植物{…}
C．class A{…} D．public class 共有类{…}
32、能作为类的修饰符, 也能作为类成员的修饰符的是 A 。
A．public B．extends C．Float D．static
33、试完成下述程序片段 B 。
public class Point{
int x,y;
public Point(int x,int y){
( )=x;
( )=y;
}
…
}
A．Point.x Point.y B．this.x this.y
C．super.x super.y D．无解
34、在JAVA 中，下列说法正确的是： C 。
A．一个子类可以有多个父类，一个父类也可以有多个子类
B．一个子类可以有多个父类，但一个父类只可以有一个子类
C．一个子类只可以有一个父类，但一个父类可以有多个子类
D．上述说法都不对
35、Father和Son是两个java类，下列哪一选项正确的标识出Father是Son的父类？ D
A．class Son implements Father B．class Father implements Son
C．class Father extends Son D．class Son extends Father
36、重载指的是方法具有相同的名字，但这些方法的参数必须不同。下列哪种说法不属于方法参数的不同 C 。
A．形式参数的个数不同。 B．形式参数的类型不同。
C．形式参数的名字不同。 D．形式参数类型的排列顺序不同。
37、下列有关抽象类与接口的叙述中正确的是哪一个 C 。
A．抽象类中必须有抽象方法，接口中也必须有抽象方法
B．抽象类中可以有非抽象方法，接口中也可以有非抽象方法
C．含有抽象方法的类必须是抽象类，接口中的方法必须是抽象方法
D．抽象类中的变量定义时必须初始化，而接口中不是
38、关于接口的定义和实现，以下描述正确的是A 。
A．接口定义的方法只有定义没有实现
B．接口定义中的变量都必须写明final和static
C．如果一个接口由多个类来实现，则这些类在实现该接口中的方法时采用统一的代码
D．如果一个类实现接口，则必须实现该接口中的所有方法，但方法未必申明为public

三、阅读程序题每空2分共18分（黑体部分为答案）
1、写出运行结果：mainbord:华硕cpu:Intel 。

public class Computer{	
	String mainbord,cpu;
	public Computer(String s1,String s2){	
		mainbord=s1;
		cpu=s2;		
	}
	public static void main(String[]args){	
		Computer c=new Computer("华硕","Intel");
		System.out.println("mainbord:"+c.mainbord+",cpu:"+c.cpu);		
	}	
}

2、写出运行结果： 0 + 1 + 3 + 5 + 7 + 9 = 25 。

public class ExamA {
    private static int arr[] = new int[5];
    public static void main(String args[]) {
        for(int i=arr.length-1;i>=0;i--)
            arr[i] = 2*i+1;
        String output = "0";
        int sum = 0;
        for(int i=0;i<arr.length;i++){
            sum += arr[i];
            output += " + " + arr[i];
        }
        output += " = "+sum;
        System.out.println(output);
        System.exit(0);
    }
}

对于此题来说只需要注意对于output这个变量是一个string类型的，并不是一个int类型的所以这里就是单纯的把output用+=的形式拼接成一个更加上的字符串。

3、写出运行结果： Peteris17yearsold 。

public class Person{	
	String name;
int age;
public Person(String name,int age){	
	this.name=name;
	this.age=age;
}
public static void main(String[]args){	
	Person c=new Person("Peter",17);
	System.out.println(c.name+" is "+c.age+" years old!");
}
}

4、写出运行结果： a=60 b=20 c=30 。

public   class   abc{
public   static   void    main(String   args[ ]) {
SubSubClass   x = new   SubSubClass(10 , 20 , 30);
x.show();
}
}
class   SuperClass{    
int   a,b;
SuperClass(int aa , int   bb){   
a=aa;   b=bb;   
}
void   show( ){   
System.out.println("a="+a+"  b="+b);   
}
}
class    SubClass    extends    SuperClass{   
int c;
SubClass(int   aa,int   bb,int   cc){
     super(aa,bb);
c=cc;
}
 }
class    SubSubClass    extends    SubClass{    
int   a;
SubSubClass(int aa,int   bb,int   cc){    
super(aa,bb,cc);
a=aa+bb+cc;
}
void   show(){ 
System.out.println("a="+a+"  b="+b+"  c="+c);   
}
}

5．下面是一个类的定义，请将其补充完整

class _Student_____{
      String name;
      int age;
   public   Student(___String___ name, int a){
         __this___.name=name;
         age=a;
      }
}

6．下面是一个类的定义，请将其补充完整

  class _A_____{
      String s;
      _private__static___ int a=3;
    public  A(String s){
         this.s=s;
      }
static int getA(){
   			return a;
}
}

四、编程题（4-8选做2题，每题6分）
1．按要求编写一个Java应用程序：（必做，6分）
(1)定义一个接口CanCry，描述会吼叫的方法public void cry()。

 public interface Cancry {
  public void cry();
}

(2)分别定义狗类（Dog）和猫类（Cat），实现CanCry接口。实现方法的功能分别为：打印输出“我是狗，我的叫声是汪汪汪”、“我是猫，我的叫声是喵喵喵”。

public class Cat implements Cancry{

	@Override
	public void cry() {
		System.out.println("我是猫，我的叫声是喵喵喵");
		
	}
  
}

public class Dog implements Cancry{
	@Override
	public void cry() {
		System.out.println("我是狗，我的叫声是汪汪汪");
		
	}
}

(3)定义一个主类G，
①定义一个void makeCry(CanCry c)方法，其中让会吼叫的事物吼叫。
②在main方法中创建狗类对象（dog）、猫类对象（cat）、G类对象（g），用g调用makecry方法，让狗和猫吼叫。

public class G {
  public void makeCry(Cancry c) {
	  c.cry();
  }
  public static void main(String[] args) {
	  Dog dog = new Dog();
	  Cat cat = new Cat();
	  G g = new G();
	  g.makeCry(dog);
	  g.makeCry(cat);
  }
}

2、编写一个Java程序，并满足如下要求：（必做6分）
1）编写一个Car类，具有：
属性：品牌(mark)——String类型
功能：驾驶（void drive( )）

public class Car {
  private String mark;
  
  public Car(String mark) {
	  this.mark = mark;
  }
  
  
  public void drive() {
	  System.out.println("本车正在驾驶");
  }
}

2）定义Car类的子类SubCar，具有：
	属性：价格（price）、速度（speed）——int型
	功能：变速（void speedChange(int newSpeed)），把新速度赋给speed

public class SubCar extends Car{
  private int price;
  private int speed;
  private String mark2;
  
  public SubCar(String mark,int price,int speed) {
	  super(mark);
	  this.price = price;
	  this.speed = speed;
	  this.mark2 = mark;
	  System.out.println("本车的品牌是"+mark);
	  System.out.println(mark+"车的价格是"+price);
	  System.out.println(mark+"原来的速度是"+speed);
  }
  
  public void speedChange(int newSpeed) {
	  this.speed = newSpeed;
	  System.out.println(mark2+"现在的速度是"+newSpeed);
  }
}

3）定义主类E，在其main方法中创建SubCar类的两个对象：aodi和benchi的对象并测试其对象的特性。

public class E {
  public static void main(String[] args) {
	SubCar aodi = new SubCar("奥迪",50,80);
	aodi.drive();
	aodi.speedChange(120);
	SubCar benchi = new SubCar("奔驰",100,90);
	benchi.drive();
	benchi.speedChange(120);
  }
}

4）输出效果如下：

在这里插入图片描述

3．某公司正进行招聘工作，被招聘人员需要填写个人信息，编写“个人简历”的封装类。包括如下属性和对属性进行操作的方法。（必做4分）

String xm;// 姓名
	String xb;// 性别
	int nl;// 年龄
	String jtzz;// 家庭住址
	String xl;// 学历
public class Resume {
	private String xm;// 姓名
	private String xb;// 性别
	private int nl;// 年龄
	private String jtzz;// 家庭住址
	private String xl;// 学历
	public String getXm() {
		return xm;
	}
	public void setXm(String xm) {
		this.xm = xm;
	}
	public String getXb() {
		return xb;
	}
	public void setXb(String xb) {
		this.xb = xb;
	}
	public int getNl() {
		return nl;
	}
	public void setNl(int nl) {
		this.nl = nl;
	}
	public String getJtzz() {
		return jtzz;
	}
	public void setJtzz(String jtzz) {
		this.jtzz = jtzz;
	}
	public String getXl() {
		return xl;
	}
	public void setXl(String xl) {
		this.xl = xl;
	}
	
	
}

4．编写程序，提供实现各种数学计算的方法。包括如下几项。
（1）两个数的加、减、乘、除。
（2）求某数的相反数、倒数、绝对值。
（3）取两数中较大的和较小的。
（4）对浮点数（double型）的计算功能。如：给定浮点数d，取大于或等于d的最小整数，取小于或等于d的最大整数，计算最接近d的整数值，计算d的平方根、自然对数log(d)等。
（5）计算以double型数a为底数，b为指数的幂。
5．编写一个抽象类Shape，声明计算图形面积的抽象方法。再分别定义Shape的子类Circle（圆）和Rectangle（矩形），在两个子类中按照不同图形的面积计算公式，实现Shape类中计算面积的方法。

public abstract class Shape {
  public abstract void getArea();
}
public class Circle extends Shape{
    
	private int radius;
	public Circle(int radius) {
		this.radius = radius;
	}
	@Override
	public void getArea() {
		System.out.println("圆的面积为"+3*radius*radius);
		
	}

}
public class Rectangle extends Shape{
    private int longs;
    private int width;
    
    public Rectangle(int longs,int width) {
    	this.longs = longs;
    	this.width = width;
    }
    
	@Override
	public void getArea() {
		System.out.println("矩形的面积是"+(longs*width));
		
	}
	
	
}

6．定义一个接口，接口中有3个抽象方法如下。
（1）“long fact(int m);”方法的功能为求参数的阶乘。
（2）“long intPower(int m,int n);”方法的功能为求参数m的n次方。
（3）“boolean findFactor(int m,int n);”方法的功能为判断参数m加上参数n的和是否大于100。
定义类实现该接口，编写应用程序，调用接口中的3个方法，并将调用方法所得的结果输出。

public interface Calculate {
  public abstract long fact(int m);
  public abstract long intPower(int m,int n);
  public boolean findFactor(int m,int n);
} 

public class Calculation implements Calculate{

	@Override
	public long fact(int m) {
		int z = 1;
		for(int i = 1;i<=m;i++) {
			z *= i; 
		}
		System.out.println(m+"的阶乘为"+z);
		return z;
	}

	@Override
	public long intPower(int m, int n) {
		int z = 1;
		int t = n;
		while(n>0) {
			z *= m;
			n--;
		}
		System.out.println(m+"的"+t+"次方是"+z);
		return z;
	}

	@Override
	public boolean findFactor(int m, int n) {
		int z = m+n;
		if(z>100) {
			System.out.println(m+"+"+n+"的和大于100");
			return true;
		}
		else {
			System.out.println(m+"+"+n+"的和不大于100");
			return false;
		}
		
	}

}

public class Test {
        public static void main(String[] args) {
			Calculation calculation = new Calculation();
			calculation.fact(4);
			calculation.intPower(3, 3);
			calculation.findFactor(50, 50);
			calculation.findFactor(49, 50);
			calculation.findFactor(51, 50);
		}
}

7．创建一个接口IShape，接口中有一个求取面积的抽象方法“public double area()”。定义一个正方形类Square，该类实现了IShape接口。Square类中有一个属性a表示正方形的边长，在构造方法中初始化该边长。定义一个主类，在主类中，创建Square类的实例对象，求该正方形对象的面积。

8．定义一个人类，包括属性：姓名、性别、年龄、国籍；包括方法：吃饭、睡觉，工作。
（1）根据人类，派生一个学生类，增加属性：学校、学号；重写工作方法（学生的工作是学习）。
（2）根据人类，派生一个工人类，增加属性：单位、工龄；重写工作方法（工人的工作是……自己想吧）。
（3）根据学生类，派生一个学生干部类，增加属性：职务；增加方法：开会。
（4）编写主函数分别对上述3类具体人物进行测试。

Hercule2016

关注

2
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
面向对象测试题

粗体标出的字体即为答案。一、填空题每空1分共15分1．如果一个方法不返回任何值，则该方法的返回值类型为 void 。2．如果子类中的某个方法名、返回值类型和参数与父类中的某个方法完全一致，则称子类中的这个方法覆盖了父类的同名方法。3．接口中所有的属性均为静态、final 和公共的4．抽象方法是一种仅有方法声明，没有具体方法体和操作实现的方法，该方法必须在 ...
复制链接

扫一扫

专栏目录