求教各位详细的给小弟解惑

Question

一、 选择1、有关类Demo，哪句描述是正确的？ 
　　public class Demo extends Base{ 
　　private int count; 
　　public Demo(){ 
　　　System.out.println("A Demo object has been created"); 
　　} 
　　protected void addOne() {count++; } 
　　}  A 当创建一个Demo类的实例对象时，count的值为0。  B 当创建一个Demo类的实例对象时，count的值是不确定的。  C 超类对象中可以包含改变count 值的方法。  D Demo的子类对象可以访问count。 
 
2、当编译和运行下列程序段时，会发生什么？ 
　　class Base {} 
　　class Sub extends Base {} 
　　class Sub2 extends Base {} 
　　public class CEx{ 
　　　public static void main(String argv[]){ 
　　　Base b = new Base(); 
　　　Sub s = (Sub) b; 
　　　} 
　　}  A 通过编译和并正常运行。  B 编译时出现例外。  C 编译通过，运行时出现例外。
4、下面的哪个选项是正确的？ 
　　class ExSuper{ 
　　　String name; 
　　　String nick_name; 
　　　public ExSuper(String s,String t){ 
　　　　name = s;
　　　　nick_name = t; 
　　　} 
　　　　public String toString(){ 
　　　　　return name; 
　　　　} 
　　　} 
　　　public class Example extends ExSuper{ 
　　　　public Example(String s,String t){ 
　　　　super(s,t); 
　　　　} 
　　　　public String toString(){ 
　　　　　return name +"a.k.a"+nick_name;
　　　　} 
　　　　public static void main(String args[]){
　　　　　ExSuper a = new ExSuper("First","1st");
　　　　　ExSuper b = new Example("Second","2nd");
　　　　　System.out.println("a is"+a.toString());
　　　　　System.out.println("b is"+b.toString());
　　　　}
　　}
 A 编译时会出现例外。  B 运行结果为：
　　　　　　　　a is First
　　　　　　　　b is second C 运行结果为：
　　　　　　　　a is First
　　　　　　　　b is Secong a.k.a 2nd
 D 运行结果为：
　　　　　　　　a is First a.k.a 1nd
　　　　　　　　b is Second a.k.a 2nd
5、运行下列程序的结果是哪个？
　　abstract class MineBase {
　　　abstract void amethod(); 
　　　static int i;
　　　} 　　public class Mine extends MineBase
　　{
　　　public static void main(String argv[]){
　　　　int[] ar = new int[5];
　　　　for(i = 0;i < ar.length;i++)
　　　　System.out.println(ar[i]);
　　　}
　　}
 A 打印5个0。  B 编译出错，数组ar[]必须初始化。  C 编译出错， Mine应声明为abstract。  D 出现IndexOutOfBoundes的例外。
二、多项选择1、下面哪个语句是正确的？  A Object o = new Button("A");  B Button b=new Object("B");  C Panel p = new Frame();  D Frame f = new Panel();  E Panel p = new Panel(); 
这题 a 项我不明白对在哪里？

Answer 1

就一题不明白的，为什么要贴上来那么多的题呢？不明白～～～Object是所有类的顶层父类，所以是对的。

Answer 2

1.在创建实例时对基本数据类型默认初始化为0
2。编译通过，但在执行是会抛出一个ClassCastException的异常，也就是说无法进行强制转化
     因为由父类转向子类是不安全的
4.创建2个对象，1个是父类，一个是子类，但都重写了Object类的toString（）方法
1.Object为所有类的父类，声明时为Object类型，但实际类型为Button类型，当以后要用到o对象是要进行强制转换

Answer 3

1 java 类在实例化的时候，所有的变量都会被赋给默认值，int的都是0。
2 子类的实例肯定属于父类，但是属于父类的实例不一定是子类的。
4 a 是ExSuper，而b是Example，它们调用自己的toString函数，如果自类没有toString时，才会调用父类的toString函数。
5 我不知道你的答案是什么，我试了一下，打印出了5个0。
2。1 
    一个button也是一个Object,在java里所有的类都是继承自Object.

Answer 4

Object就是亚当和夏娃……java里所有的类都是Object的子孙所以任何对象都可以用Object来装

Answer 5

　　class   ExSuper{   
　　　String   name;   
　　　String   nick_name;   
　　　public   ExSuper(String   s,String   t)
     {   
　　　　name   =   s; 
　　　　nick_name   =   t;   
　　　}   
　　　　public   String   toString()
        {   
　　　　　return   name;   
　　　　} 
　　　} //执行Exsuper类的时候里面的方法都要再执行一遍么？public   class   Example   extends   ExSuper{   
　　　　public   Example(String   s,String   t){   
　　　　super(s,t);   
　　　　}   //重写了哪个类？
　　　　public   String   toString(){   
　　　　　return   name   + "a.k.a "+nick_name; 
　　　　}   //  这个只是在Example重写了，ExSuper没有被重写吧？
　　　　public   static   void   main(String   args[]){ 
　　　　　ExSuper   a   =   new   ExSuper( "First ", "1st "); 
　　　　　ExSuper   b   =   new   Example( "Second ", "2nd "); 
　　　　　System.out.println( "a   is "+a.toString()); 
　　　　　System.out.println( "b   is "+b.toString()); 
　　　　} 
　　} 

Answer 6

正确答案我都用红色表示出来了。第五题5、运行下列程序的结果是哪个？ 
　　abstract   class   MineBase   { 
　　　abstract   void   amethod();   
　　　static   int   i; 
　　　}   　　public   class   Mine   extends   MineBase 
　　{ 
　　　public   static   void   main(String   argv[]){ 
　　　　int[]   ar   =   new   int[5]; 
　　　　for(i   =   0;i   <   ar.length;i++) 
　　　　System.out.println(ar[i]); 
　　　} 
　　} 
  A   打印5个0。     B   编译出错，数组ar[]必须初始化。     C   编译出错，   Mine应声明为abstract。     D   出现IndexOutOfBoundes的例外。 我运行的情况是 开始编译出错， 给mine 加上 抽象就没事了。公共类也必须是抽象的么？抽象类只能由抽象类继承？

Answer 7

LZ的问题其实就是BRUCE ECKEL大人传说中的"父类引用指向子类对象"....

Answer 8

抽象类并不是只能由抽象类来继承。所谓抽象类是指该类中有方法没有被实现，
如第5题所示：　abstract   void   amethod();   
凡是类中有方法没被实现的都成为抽象类，并注上修饰符：　abstract 。
一旦有类继承抽象类，并且没有将抽象类中的抽象方法重写，那么该子类仍为抽象类，不能被实例化。
如果该子类重写了抽象方法，那么子类就不再是抽象类了。