抽象类+接口+内部类作业题及答案

抽象类+接口+内部类作业题

一、选择题

1. Person类和Test类的代码如下所示，则代码中的错误语句是（ ）。（选择一项）
   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代码运行的结果是（ ）。（选择一项）
   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. 以下代码中错误的语句是（ ）。（选择一项）
   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的抽象类和抽象方法说法正确的是（ ）。（选择二项）

   A 抽象类中可以含有0个或多个抽象方法
   B. 抽象类中不可以有构造方法
   C. 一个类中若有抽象方法，则这个类必为抽象类
   D. 子类必须重写父类所有的抽象方法

5. 在Java中关于abstract关键字，以下说法正确的是（ ）。（选择两项）

   A abstract类中可以没有抽象方法
   B. abstract类的子类也可以是抽象类
   C. abstract方法可以有方法体
   D. abstract类可以创建对象

6. 以下选项可替换题目中//add code here而不产生编译错误的是（ ）。（选择二项）
   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接口中，下列选项中属于有效的方法声明是（ ）。（选择二项）

   A public void aMethod( );
   B. final void aMethod( );
   C. void aMethod(){ }
   D. private void aMethod( );

8. 以下选项中关于匿名内部类的说法正确的是（ ）。（选择二项）

   A. 匿名内部类可以实现多个接口，或者继承一个父类
   B. 匿名内部类不能是抽象类，必须实现它的抽象父类或者接口里包含的所有抽象方法
   C. 匿名内部类没有类名，所以匿名内部类不能定义构造方法
   D. 匿名内部类可以直接访问外部类的所有局部变量

9. 接口定义正确的说法是（ ）。（选择二项）
   A. 接口中只能定义常量和抽象方法
   B. 接口中可以定义普通方法和普通变量
   C. 接口可以被new，抽象方法不行
   D． 接口不可以被继承，只能被实现，也可以被多个类实现

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

三、简答题
1.final修饰变量、方法、类分别表示什么？
2.final和abstract关键字的作用。
3.接口和抽象类的联系和区别。
4.java中有多继承吗?如果没有，java为什么取消了多继承？
C++中有多继承吗? 单继承相比多继承优势在什么地方?
5.内部类的类型及其特点。
6.介绍Java垃圾回收机制。

四、编码题
1.编写程序描述兔子和青蛙
需求说明：使用面向对象的思想，设计自定义类描述兔子和青蛙。
实现思路及关键代码
1)分析兔子和青蛙的共性
2)根据共性，定义抽象的动物类
属性：名字、颜色、类别（哺乳类、非哺乳类）
方法：吃饭，发出叫声
3)根据青蛙会游泳 抽象游泳的接口
方法：游泳
4)定义兔子继承动物类，青蛙继承动物同时实现游泳接口
程序运行结果如图所示。

2.编写程序描述影视歌三栖艺人
需求说明：请使用面向对象的思想，设计自定义类，描述影视歌三梄艺人。
实现思路及关键代码
1)分析影视歌三栖艺人的特性
a)可以演电影
b)可以演电视剧
c)可以唱歌
2)定义多个接口描述特性
a)演电影的接口-----方法：演电影
b)演电视剧的接口-----方法：演电视剧
c)唱歌的接口-----方法：唱歌
3)定义艺人类实现多个接口
程序运行结果如图2所示。

3.写一个方法对任意引用数据类型数组进行排序。具体要求如下:
1)方法声明为public void sortArr(Object arr[]){ }
2)方法中首先输出排序前数组内容，然后进行排序，最后输出排序后数组内容。
3)可以是冒泡排序或其他算法实现，不直接调用Java提供的方法实现排序。
思路：任意类实现Comparable接口来实现该引用数据类型的元素排序，在sort()方法中将Object强转成Comparable实现两个对象的比较。

五、可选题
1.实现不同符合PCI规范的适配器
需求说明：PCI是一种规范，所有实现了该规范的适配器，必如显卡、声卡、网卡都可以安装到PCI插槽上并工作。模拟实现该功能。

实现思路及关键代码
1)定义PCI接口，具有传送数据send()方法
2)定义显卡VideaCard类，实现该接口
3)定义声卡AudioCard类，实现PCI接口
4)定义网卡NetCard类，实现PCI接口
5)定义测试类，让显卡、声卡、网卡发送数据

2.实现不同引用类型对象的大小比较
需求说明：学生类，新闻类，商品类虽然是完全不同的类，但是都具有比较的能力，比如可以比较两个学生的大小，但需要指定比较的依据是学号、姓名还是成绩等。
实现思路及关键代码：
将比较的能力定义为接口，让学生、新闻、商品类都实现该接口。
1)定义接口Comparable，其中包含唯一的方法int compareTo(Object obj)；返回值>0，表示大于，返回值=0，表示等于，返回值<0，表示小于。
2)定义学生类，包括学号、姓名、年龄和分数，实现Comparable接口，按照分数倒序排列；
3)定义新闻类，包括编号（int类型）、标题、内容和点击数，实现Comparable接口，按照编号正序排列；
4)定义测试类，分别创建两个学生对象、新闻对象，进行比较并输出结果。

抽象类+接口+内部类作业答案

一、选择题

1.C
2.B
3.D
4.AC
5.AB
6.AD
7.AC
8.BC
9.AD

二、判断题

1.√
2.√
3.×
4.√
5.√
6.×
7.√
8.√
9.×
10.√
11.×
12.√
13.×
14.×
15.×

三、简答题

答案略

四、编码题

1.编写程序描述兔子和青蛙
需求说明：使用面向对象的思想，设计自定义类描述兔子和青蛙。

/**
 * 动物类
 * @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.编写程序描述影视歌三栖艺人
需求说明：请使用面向对象的思想，设计自定义类，描述影视歌三梄艺人。

	/**
 * 可演电影接口
 * @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提供的方法实现排序。

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接口
 * @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.实现不同引用类型对象的大小比较

/**
 * 比较接口
 * @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);
		}
	}
}