Java抽象类接口、内部类题库

一、    选择题

1.

Person类和Test类的代码如下所示,则代码中的错误语句是(  C  。(选择一项)

 

public class Person {

public String name;

public Person(String name) {

this.name = name;

}

}

public class Test {

public static void main(String[] args) {

final Person person = new Person("欧欧");

person.name = "美美";

person = new Person("亚亚");

}

}

A.

final Person person = new Person("欧欧");

B.

person.name = "美美";

C.

person = new Person("亚亚");

D.

没有错误

2.

如下Java代码运行的结果是(  B  )。(选择一项)

 

public class Test {

final int age;

public Test(){

age=10;

}

public static void main(String[ ] args) {

System.out.println(new Test().age);

}

}

A

输出:0

B.

输出:10

C.

输出:null

D.

运行时出现异常

3.

以下代码中错误的语句是(   D  )。(选择一项)

public class Something{

public static void main(String[] args){

final Other o=new Other();

new Something().addOne(o);//1

}

public void addOne( Other o){

o.i++;//2

o =  new Other();//3

}

}

class Other{

public int i;

}

A

1

B.

2

C.

3

D.

没有错误

4.

下列选项中,关于Java的抽象类和抽象方法说法正确的是(  AC  )。(选择二项)

A

抽象类中可以含有0个或多个抽象方法

B.

抽象类中不可以有构造方法

C.

一个类中若有抽象方法,则这个类必为抽象类

D.

子类必须重写父类所有的抽象方法

5.

Java中关于abstract关键字,以下说法正确的是(  AB  )。(选择两项)

A

abstract类中可以没有抽象方法

B.

abstract类的子类也可以是抽象类

C.

abstract方法可以有方法体

D.

abstract类可以创建对象

6.

以下选项可替换题目中//add code here而不产生编译错误的是(  AD  )。(选择二项)

 

public abstract class MyClass{

public int constInt=5;

//add code here

public void method( ){

}

}

A

public abstract void method(int a);

B.

constInt =constInt+5;

C.

public int method( );

D.

public abstract void anotherMethod( );

7.

Java接口中,下列选项中属于有效的方法声明是(  AC  )。(选择二项)

A

public void aMethod( );

B.

final void aMethod( );

C.

void aMethod(){ }

D.

private void aMethod( );

8.

以下选项中关于匿名内部类的说法正确的是(  BC   )。(选择二项)

A.

匿名内部类可以实现多个接口,或者继承一个父类

B.

匿名内部类不能是抽象类,必须实现它的抽象父类或者接口里包含的所有抽象方法

C.

匿名内部类没有类名,所以匿名内部类不能定义构造方法

D.

匿名内部类可以直接访问外部类的所有局部变量

二、    判断题(共20个题目,总计10分)

  1. 声明为final的类不能是超类。(  T  )
  2. 使用final修饰的变量将变成常量,其中不能再被改变;使用final修饰的方法将无法被子类重载;使用final修饰的类将无法再被其他类继承。(  T  )
  3. 抽象方法不能含有方法体,并且必须定义在抽象类中。(  F  )
  4. 抽象类是指在class前加使用abstract关键字修饰,且可以存在抽象方法和普通方法的类。(  T  )
  5. 接口中只有常量,没有变量;只有抽象方法,并且全部都是public方法。(  T  )
  6. 抽象类和接口都不能实例化,都没有构造方法。(  F  )
  7. 接口并不要求实现类和接口在概念本质上一致的,仅仅是实现了接口定义的约定或者能力而已。接口定义了“做什么”,而实现类负责完成“怎么做”,体现了功能(规范)和实现分离的原则。(  T  )
  8. 内部类作为外部类成员,权限修饰符和其他成员一样,可声明为private、默认、protected或public。(  T  )
  9. 匿名内部类适合创建那种只需要使用一次的类,它可以实现一个或多个接口,或者继承一个父类。(  F  )
  10. 对于物理连接,比如数据库连接、输入流输出流、Socket连接等,垃圾回收机制无能为力,必须手动关闭才可以。(  T  )
  11. 垃圾回收机制回收任何对象之前,总会先调用它gc( )方法,该方法是Object类提供的方法。不要主动调用某个对象的该方法,应该交给垃圾回收机制调用。(  F  )

三、    简答题

  1. final和abstract关键字的作用。
  2. 接口和抽象类的联系和区别。
  3. 内部类的类型及其特点。

四、    编码题

1.编写程序描述兔子和青蛙

需求说明:使用面向对象的思想,设计自定义类描述兔子和青蛙。

实现思路及关键代码

1)         分析兔子和青蛙的共性

2)         根据共性,定义抽象的动物类

属性:名字、颜色、类别(哺乳类、非哺乳类)

方法:吃饭,发出叫声

3)         根据青蛙会游泳 抽象游泳的接口

方法:游泳

4)         定义兔子继承动物类,青蛙继承动物同时实现游泳接口

程序运行结果如图所示。

 /**
*
* 动物类
*
* @author Administrator
*
*/
public abstract class Animal
{
private String name;//名字
private String color;//颜色
private String type;//类别(哺乳类、非哺乳类)
public Animal()
{
super();
}
public Animal(String name, String color, String type)
{
super();
this.name = name;
this.color = color;
this.type = type;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public String getColor()
{
return color;
}
public void setColor(String color)
{
this.color = color;
}
public String getType()
{
return type;
}
public void setType(String type)
{
this.type = type;
}
/**
*
* 发出叫声
*
*/
public abstract void shout();
/**
*
* 吃饭
*
*/
public abstract void eat();
}
/**
*
* 游泳接口
*
* @author Administrator
*
*/
public interface Swimmable
{
/**
*
* 游泳
*
*/
public void swim();
}
public class Frog extends Animal implements Swimmable
{
public Frog()
{
super();
}
public Frog(String name, String color, String type)
{
super(name, color, type);
}
@Override
public void shout()
{
System.out.println("那只" + super.getColor()
+ "的,名字叫" + super.getName() + "的青蛙正在呱呱的叫");
}
@Override
public void eat()
{
System.out.println("青蛙是" + super.getType() + ",爱吃昆虫");
}
@Override
public void swim()
{
System.out.println("虽然不是鱼,但是青蛙也是游泳高手");
}
}
public class Rabbit extends Animal
{
public Rabbit()
{
super();
}
public Rabbit(String name, String color, String type)
{
super(name, color, type);
}
@Override
public void shout()
{
System.out.println("那只" + super.getColor()
+ "的,名字叫" + super.getName() + "的兔子正在叽叽的叫");
}
@Override
public void eat()
{
System.out.println("兔子是" + super.getType() + ",爱吃胡萝卜");
}
}
public class Test
{
public static void main(String[] args)
{
Animal rabbit = new Rabbit("美人", "黑色", "哺乳类");
rabbit.shout();
rabbit.eat();
System.out.println("====================");
Animal frog = new Frog("大兵", "绿色", "非哺乳类");
frog.shout();
frog.eat();
Swimmable swimer = (Swimmable) frog;
swimer.swim();
}
}

2.编写程序描述影视歌三栖艺人

需求说明:请使用面向对象的思想,设计自定义类,描述影视歌三梄艺人。

实现思路及关键代码

1)         分析影视歌三栖艺人的特性

a)         可以演电影

b)         可以演电视剧

c)         可以唱歌

2)         定义多个接口描述特性

a)         演电影的接口-----方法:演电影

b)         演电视剧的接口-----方法:演电视剧

c)         唱歌的接口-----方法:唱歌

3)         定义艺人类实现多个接口

程序运行结果如图2所示。

 /**
*
* 可演电影接口
*
* @author Administrator
*
*/
public interface Filmable
{
/**
*
* 演电影
*
*/
public void actFilm();
}
/**
*
* 会唱歌接口
*
* @author Administrator
*
*/
public interface Singable
{
/**
*
* 唱歌
*
*/
public void sing();
}
/**
*
* 会演电视剧接口
*
* @author Administrator
*
*/
public interface TVable
{
/**
*
* 演电视剧
*
*/
public void showTV();
}
public class Star implements Filmable, TVable, Singable
{
private String name;//姓名
public Star()
{
super();
}
public Star(String name)
{
super();
this.name = name;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
@Override
public void sing()
{
System.out.println("我会唱歌");
}
@Override
public void showTV()
{
System.out.println("我能演电视剧");
}
@Override
public void actFilm()
{
System.out.println("我能演电影");
}
public void introduce()
{
System.out.println("大家好,我是" + name);
}
}
public class Test
{
public static void main(String[] args)
{
Star star = new Star("马素素");
star.introduce();
star.actFilm();
star.showTV();
star.sing();
}
}

3.写一个方法对任意引用数据类型数组进行排序。具体要求如下:

1)        方法声明为public  void sortArr(Object arr[]){  }

2)        方法中首先输出排序前数组内容,然后进行排序,最后输出排序后数组内容。

3)        可以是冒泡排序或其他算法实现,不直接调用Java提供的方法实现排序。

思路:任意类实现Comparable接口来实现该引用数据类型的元素排序,在sort()方法中将Object强转成Comparable实现两个对象的比较。

 public void sort(Object[] arr)
{
//输出排序前数组
for (int i = 0; i < arr.length; i++)
{
System.out.println(arr[i]);
}
//大循环,一共n个元素,达到最终有序,至多n-1趟比较
Object temp;
for (int i = 0; i < arr.length - 1; i++)
{
//定义一个符号量
boolean flag = true;//没有交换,有序
//小循环
for (int j = 0; j < arr.length - 1 - i; j++)
{
//如果前一个大于后一个
Comparables c1 = (Comparables) arr[j];
Comparables c2 = (Comparables) arr[j + 1];
if (c1.compareTo(c2) > 0)
{
//交换
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
//修改符号量
flag = false;//交换过,无序
}
}
//判断经过此趟循环后是否已经有序
if (flag)
{
break;//退出外层循环,省略后续趟循环
}
}
//输出排序后数组
for (int i = 0; i < arr.length; i++)
{
System.out.println(arr[i]);
}
}

五、    可选题

1.实现不同符合PCI规范的适配器

需求说明:PCI是一种规范,所有实现了该规范的适配器,必如显卡、声卡、网卡都可以安装到PCI插槽上并工作。模拟实现该功能。

实现思路及关键代码

1)         定义PCI接口,具有传送数据send()方法

2)         定义显卡VideaCard类,实现该接口

3)         定义声卡AudioCard类,实现PCI接口

4)         定义网卡NetCard类,实现PCI接口

5)         定义测试类,让显卡、声卡、网卡发送数据

 class a
{
/**
*
* PCI接口
*
* @author Administrator
*
*
*
*/
public interface PCI
{
/**
*
* 传输数据
*
*/
public void send();
}
public class VideoCard implements PCI
{
@Override
public void send()
{
System.out.println("使用PCI接口传输视频数据");
}
}
public class SoundCard implements PCI
{
@Override
public void send()
{
System.out.println("使用PCI接口传输声音数据");
}
}
public class NetCard implements PCI
{
@Override
public void send()
{
System.out.println("使用PCI接口传输网络数据");
}
}
public class Test
{
public static void main(String[] args)
{
PCI p1 = new VideoCard();
p1.send();
PCI p2 = new SoundCard();
p2.send();
PCI p3 = new NetCard();
p3.send();
}
}
}

2.实现不同引用类型对象的大小比较

需求说明:学生类,新闻类,商品类虽然是完全不同的类,但是都具有比较的能力,比如可以比较两个学生的大小,但需要指定比较的依据是学号、姓名还是成绩等。

实现思路及关键代码:

将比较的能力定义为接口,让学生、新闻、商品类都实现该接口。

1)         定义接口Comparable,其中包含唯一的方法int compareTo(Object obj);返回值>0,表示大于,返回值=0,表示等于,返回值<0,表示小于。

2)         定义学生类,包括学号、姓名、年龄和分数,实现Comparable接口,按照分数倒序排列;

3)         定义新闻类,包括编号(int类型)、标题、内容和点击数,实现Comparable接口,按照编号正序排列;

4)         定义测试类,分别创建两个学生对象、新闻对象,进行比较并输出结果。

 /**
*
* 比较接口
*
* @author Administrator
*
*
*
*/
public interface Comparable
{
/**
*
* 比较
*
* @param obj 另外一个对象
*
* @return 比较的结果 >0 大于 =0 等于 <0 小于
*
*/
public int compareTo(Object obj);
}
public class News implements Comparable
{
private int nid;//编号
private String title; //标题
private String contents;//内容
private String type;//新闻类别
public News()
{
super();
}
public News(int nid, String title, String contents, String type)
{
super();
this.nid = nid;
this.title = title;
this.contents = contents;
this.type = type;
}
/**
*
* 按照新闻编号正序排列
*
*/
public int compareTo(Object obj)
{
News other = (News) obj;
return this.nid - other.nid;
}
@Override
public String toString()
{
return "News [nid=" + nid + ", title=" + title + ", contents="
+ contents + ", type=" + type + "]";
}
}
public class Student implements Comparable
{
private int id;
private String name;
private int age;
private double score;
public Student()
{
super();
}
public Student(int id, String name, int age, double score)
{
super();
this.id = id;
this.name = name;
this.age = age;
this.score = score;
}
/**
*
* 按照学生成绩降序排序
*
*/
public int compareTo(Object obj)
{
Student other = (Student) obj;
if (this.score > other.score)
{
return -1;
} else if (this.score < other.score)
{
return 1;
} else
{
return 0;
}
}
@Override
public String toString()
{
return "Student [id=" + id + ", name=" + name + ", age=" + age
+ ", score=" + score + "]";
}
}
public class Test
{
public static void main(String[] args)
{
//
Student stu1 = new Student(11, "小红", 18, 97d);
Student stu2 = new Student(12, "小东", 20, 98d);
if (stu1.compareTo(stu2) > 0)
{
System.out.println(stu2);
System.out.println(stu1);
} else
{
System.out.println(stu1);
System.out.println(stu2);
}
//
News news1 = new News(33, "恒大亚冠", "恒大亚冠小组被淘汰", "体育");
News news2 = new News(44, "上海尚学堂", "请原谅我的姗姗来迟", "IT");
if (news1.compareTo(news2) > 0)
{
System.out.println(news2);
System.out.println(news1);
} else
{
System.out.println(news1);
System.out.println(news2);
}
}
}
上一篇:Java数据结构和算法之链表


下一篇:C语言参数传递