day12作业

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

一、 选择题

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代码运行的结果是（D ）。（选择一项）
	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而不产生编译错误的是（CD）。（选择二项）
	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.	以下选项中关于匿名内部类的说法正确的是（ CD ）。（选择二项）

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

二、 判断题（共20个题目，总计10分）

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

三、 简答题

final和abstract关键字的作用。

final 1.修饰类，类不能被继承 2.修饰变量，变量就变成了常量，只能被赋值一次 (~final 修饰的变量叫常量;一般会与public static共用)3. 修饰方法，方法不能被重写

abstract修饰类和方法使其成为抽象的,当不知其具体能做什么时就定义为抽象的

接口和抽象类的联系和区别。

A:成员区别

* 抽象类(和普通类相比,只是可以多定义了抽象方法而已)

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

* 构造方法：有

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

* 接口:

* 成员变量:只可以常量

* 构造方法:无

* 成员方法:只可以抽象

* B:关系区别

* 类与类

* 继承,单继承,多层继承

* 类与接口:

* 实现,单实现,多实现

* 接口与接口多继承

* 继承,单继承,

* C:设计理念区别

* 抽象类被继承体现的是:"is a"的关系.抽象类中定义的是该继承体系的共性功能

* 接口被实现体现的是:"like a "的关系.接口中定义的是该继承体系的扩展功能.

内部类的类型及其特点。

类中的类.

内部类访问特点

* a:内部类可以直接访问外部类的成员，包括私有。

* b:外部类要访问内部类的成员，必须创建对象。

* 外部类名.内部类名对象名 = 外部类对象.内部类对象;

介绍Java垃圾回收机制。

四、 编码题

编写程序描述兔子和青蛙

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

实现思路及关键代码

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

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

属性：名字、颜色、类别（哺乳类、非哺乳类）

方法：吃饭，发出叫声

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

方法：游泳

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

程序运行结果如图所示。

  1 class TestAnimal {
  2 
  3    public static void main(String[] args) {
  4 
  5                Animal a = new Rabbit("美人","黑色","哺乳类");
  6 
  7                System.out.println("那只" + a.getColor() + "的兔子正在" + a.speak());
  8 
  9               
 10 
 11  
 12 
 13                Animal b = new Frog("大兵","绿色","非哺乳类");
 14 
 15               
 16 
 17  
 18 
 19    }
 20 
 21 }
 22 
 23 /*
 24 
 25 1)           分析兔子和青蛙的共性
 26 
 27 2)           根据共性，定义抽象的动物类
 28 
 29 属性：名字、颜色、类别（哺乳类、非哺乳类）
 30 
 31 方法：吃饭，发出叫声
 32 
 33 3)           根据青蛙会游泳 抽象游泳的接口
 34 
 35 方法：游泳
 36 
 37 4)           定义兔子继承动物类，青蛙继承动物同时实现游泳接口
 38 
 39  
 40 
 41 */
 42 
 43 abstract class Animal {
 44 
 45    private String name;
 46 
 47    private String color;
 48 
 49    private String kind;
 50 
 51   
 52 
 53    public Animal(){}
 54 
 55  
 56 
 57    public Animal(String name,String color,String kind) {
 58 
 59                this.name = name;
 60 
 61                this.color = color;
 62 
 63                this.kind = kind;
 64 
 65    }
 66 
 67  
 68 
 69    public String getName(){
 70 
 71                return name;
 72 
 73    }
 74 
 75  
 76 
 77    public void setName(String name) {
 78 
 79                this.name = name;
 80 
 81    }
 82 
 83  
 84 
 85    public String getColor(){
 86 
 87                return color;
 88 
 89    }
 90 
 91  
 92 
 93    public void setColor(String color) {
 94 
 95                this.color = color;
 96 
 97    }
 98 
 99  
100 
101    public String getKind(){
102 
103                return kind;
104 
105    }
106 
107  
108 
109    public void setKind(String kind) {
110 
111                this.kind = kind;
112 
113    }
114 
115  
116 
117    public abstract void eat();
118 
119   
120 
121    public abstract void speak();
122 
123  
124 
125  
126 
127 }
128 
129  
130 
131 interface Swim {
132 
133    public abstract void swim();
134 
135 }
136 
137  
138 
139 class Rabbit extends Animal {
140 
141   
142 
143    public Rabbit() {
144 
145               
146 
147    }
148 
149  
150 
151    public Rabbit(String name,String color,String kind) {
152 
153                super(name,color,kind);
154 
155    }
156 
157  
158 
159    public void eat() {
160 
161                System.out.println("爱吃胡萝卜");
162 
163    }
164 
165  
166 
167    public void speak() {
168 
169                System.out.println("叽叽");
170 
171    }
172 
173  
174 
175   
176 
177   
178 
179 }
180 
181  
182 
183 class Frog extends Animal implements Swim{
184 
185    public Frog() {
186 
187                super();
188 
189    }
190 
191  
192 
193    public Frog(String name,String color,String kind) {
194 
195                super(name,color,kind);
196 
197    }
198 
199  
200 
201    public void eat() {
202 
203                System.out.println("爱吃昆虫");
204 
205    }
206 
207   
208 
209    public void speak() {
210 
211                System.out.println("呱呱");
212 
213    }
214 
215  
216 
217    public void swim() {
218 
219                System.out.println("虽然不是鱼,但青蛙也是游泳高手");
220 
221    }
222 
223  
224 
225   
226 
227   
228 
229 }

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

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

实现思路及关键代码

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

a) 可以演电影

b) 可以演电视剧

c) 可以唱歌

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

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

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

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

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

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

 1 package com.zuikc.eclipse;
 2 import com.zuikc.bean.Artist;
 3 
 4 public class TestArtist {
 5     public static void main(String[] args) {
 6         Artist a = new Artist("马素素");
 7         a.show();
 8         a.drama();
 9         a.film();
10         a.sing();    
11     }
12 }
13 package com.zuikc.bean;
14 
15 public interface Film {
16     public abstract void film();
17 }
18 
19 
20 package com.zuikc.bean;
21 
22 public interface Drama {
23     public abstract void drama();
24 }
25 package com.zuikc.bean;
26 
27 public interface Sing {
28     public abstract void sing();
29 }
30 package com.zuikc.bean;
31 
32 public class Artist implements Sing, Film, Drama {
33     String name;
34     
35     public Artist() {
36         super();
37         
38     }
39     
40     public Artist(String name) {
41         this.name = name;
42     }
43     
44     
45 
46     public String getName() {
47         return name;
48     }
49 
50     public void setName(String name) {
51         this.name = name;
52     }
53 
54     @Override
55     public void drama() {
56         System.out.println("我会演电视剧");
57     }
58 
59     @Override
60     public void film() {
61         System.out.println("我会演电影");
62     }
63 
64     @Override
65     public void sing() {
66         System.out.println("我会唱歌");
67     }
68     
69     public void show() {
70         System.out.println("我叫" + this.name);
71     }
72     
73 
74 }

五、 可选题

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

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

实现思路及关键代码

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

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

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

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

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

1 package com.zuikc.eclipse;
 2 
 3 import com.zuikc.bean.AudioCard;
 4 import com.zuikc.bean.NetCard;
 5 import com.zuikc.bean.VideaCard;
 6 
 7 /*实现思路及关键代码
 8 
 9 1)         定义PCI接口，具有传送数据send()方法
10 
11 2)         定义显卡VideaCard类，实现该接口
12 
13 3)         定义声卡AudioCard类，实现PCI接口
14 
15 4)         定义网卡NetCard类，实现PCI接口
16 
17 5)         定义测试类，让显卡、声卡、网卡发送数据*/
18 public class TestPci {
19     public static void main(String[] args) {
20         VideaCard v = new VideaCard();
21         AudioCard a = new AudioCard();
22         NetCard n = new NetCard();
23         v.send();
24         a.send();
25         n.send();
26     }
27 }
28 package com.zuikc.bean;
29 
30 public interface Pci {
31     public abstract void send();
32 }
33 package com.zuikc.bean;
34 
35 public class VideaCard implements Pci {
36 
37     @Override
38     public void send() {
39         System.out.println("显卡发送数据");
40     }
41 
42 }
43 package com.zuikc.bean;
44 
45 public class AudioCard implements Pci {
46 
47     @Override
48     public void send() {
49         System.out.println("声卡发送数据");
50     }
51     
52 
53 }
54 package com.zuikc.bean;
55 
56 public class NetCard implements Pci {
57 
58     @Override
59     public void send() {
60         System.out.println("网卡发送数据");
61     }
62 
63 }

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

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

实现思路及关键代码：

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

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

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

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

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

  1 package com.zuikc.eclipse;
  2 
  3 import com.zuikc.bean.Paper;
  4 import com.zuikc.bean.Student;
  5 
  6 public class TestComparable {
  7     public static void main(String[] args) {
  8         Student s1 = new Student(1,"小航",12,90);
  9         Student s2 = new Student(2,"小红",13,97);
 10         if(s1.compareTo(s2)>0){            
 11             System.out.println(s2);
 12             System.out.println(s1);
 13         }else{
 14             System.out.println(s1);
 15             System.out.println(s2);
 16         }
 17         
 18         Paper n1 = new Paper(1,"詹姆斯转会","詹姆斯与湖人签约",20000);
 19         Paper n2 = new Paper(2,"高考改革","3+3",10000);
 20         if(n1.compareTo(n2)>0){
 21             System.out.println(n2);
 22             System.out.println(n1);            
 23         }else{
 24             System.out.println(n1);
 25             System.out.println(n2);
 26         }
 27 
 28     }
 29 }
 30 
 31 package com.zuikc.bean;
 32 /*将比较的能力定义为接口，让学生、新闻、商品类都实现该接口。
 33 1)    定义接口Comparable，其中包含唯一的方法int compareTo(Object obj)；返回值>0，表示大于，返回值=0，表示等于，返回值<0，表示小于。
 34 2)    定义学生类，包括学号、姓名、年龄和分数，实现Comparable接口，按照分数倒序排列；
 35 3)    定义新闻类，包括编号（int类型）、标题、内容和点击数，实现Comparable接口，按照编号正序排列；
 36 4)    定义测试类，分别创建两个学生对象、新闻对象，进行比较并输出结果。
 37 */
 38 public interface Comparable {
 39     public abstract int compareTo(Object obj);
 40 }
 41 package com.zuikc.bean;
 42 
 43 public class Student implements Comparable {
 44     int id;
 45     String name;
 46     int age;
 47     int score;
 48     
 49     public Student() {
 50         super();
 51         
 52     }
 53     
 54 
 55     public Student(int id, String name, int age, int score) {
 56         super();
 57         this.id = id;
 58         this.name = name;
 59         this.age = age;
 60         this.score = score;
 61     }
 62     
 63     
 64 
 65 
 66     public int getId() {
 67         return id;
 68     }
 69 
 70 
 71     public void setId(int id) {
 72         this.id = id;
 73     }
 74 
 75 
 76     public String getName() {
 77         return name;
 78     }
 79 
 80 
 81     public void setName(String name) {
 82         this.name = name;
 83     }
 84 
 85 
 86     public int getAge() {
 87         return age;
 88     }
 89 
 90 
 91     public void setAge(int age) {
 92         this.age = age;
 93     }
 94 
 95 
 96     public int getScore() {
 97         return score;
 98     }
 99 
100 
101     public void setScore(int score) {
102         this.score = score;
103     }
104 
105 
106     @Override
107     public int compareTo(Object obj) {
108         Student other = (Student)obj;
109         if (this.score > other.score){
110             return 1;
111         }else if (this.score < other.score){
112             return -1;
113         }
114         else{
115             return 0;
116         }
117         
118     }
119 
120 
121     @Override
122     public String toString() {
123         return "Student [id=" + id + ", name=" + name + ", age=" + age + ", score=" + score + "]";
124     }
125     
126 
127 }
128 package com.zuikc.bean;
129 
130 public class Paper implements Comparable {
131     int nid;
132     String title;
133     String news;
134     int lick;
135 
136     public Paper() {
137         super();
138     }
139     
140     public Paper(int nid, String title, String news, int lick) {
141         super();
142         this.nid = nid;
143         this.title = title;
144         this.news = news;
145         this.lick = lick;
146     }
147     
148     
149     public int getNid() {
150         return nid;
151     }
152 
153     public void setNid(int nid) {
154         this.nid = nid;
155     }
156 
157     public String getTitle() {
158         return title;
159     }
160 
161     public void setTitle(String title) {
162         this.title = title;
163     }
164 
165     public String getNews() {
166         return news;
167     }
168 
169     public void setNews(String news) {
170         this.news = news;
171     }
172 
173     public int getLick() {
174         return lick;
175     }
176 
177     public void setLick(int lick) {
178         this.lick = lick;
179     }
180 
181     @Override
182     public int compareTo(Object obj) {
183         Paper other = (Paper)obj;
184         return this.nid - other.nid;
185     }
186 
187     @Override
188     public String toString() {
189         return "Paper [nid=" + nid + ", title=" + title + ", news=" + news + ", lick=" + lick + "]";
190     }
191 
192 }