如鵬網面試題（基礎1）

1,不用中間變量交換兩個變量

　　int i = 10;
　　int j = 20;
　　i = i + j;//30
　　j = i - j;//10
　　i = i - j;//20
　　Console.ReadKey("i={0},j={1}",i,j);

 

2,下面是一個由*號組成的4行倒三角形圖案。
　　要求：1、輸入倒三角形的行數，行數的取值3-21之間，對於非法的行數，要求拋出提示“非法行數！”；2、在屏幕上打印這個指定了行數的倒三角形。
　　　　*******

　　　　 *****

　　　　  ***

　　　　   *

　　Console.WriteLine("請輸入三角形的行數");
　　int line = Console.ReadLine();
　　if(line<3||line>21)
　　{
　　　　Throw New Exception("輸入的行數非法")
　　}
　　else 
　　{
　　　　for (int i = line; i > 0; i--)
　　　　{
　　　　　　//循環打印空格
　　　　　　for (int j = 0; j < line - i; j++)
　　　　　　{
　　　　　　　　Console.Write(" ");
　　　　　　}
　　　　　　//循環圖形
　　　　　　for (int k = 2 * i - 1; k > 0; k--)
　　　　　　{
　　　　　　　　Console.Write("*");
　　　　　　}
　　　　　　Console.WriteLine();
　　　　}
　　}

 

3,現有1~10共十個自然數，已隨機放入一個有8個元素的數組nums[8]（ 假如是int[] nums = { 3, 9, 8, 2, 4, 6, 10, 7 };）。
　　要求寫出一個盡量簡單的方案，找出沒有被放入數組的那2個數，並在屏幕上打印這2個數。注意：程序不用實現自然數隨機放入數組的過程

　　常規復雜方法：

 　　　　static void Main(string[] args)
        {
            int[] nums = { 3, 9, 8, 2, 4, 6, 10, 7 };

            //常規方法：先定義一個查詢是否包含的方法，然后去循環整個數組
           
            for (int i = 1; i <10; i++)
            {
                if (!Contains(nums,i))
                {
                    Console.WriteLine(i+"不在數組中");
                }
            }
            Console.ReadKey();
        }
        /// <summary>
        /// 判斷value是否在nums中存在
        /// </summary>
        /// <param name="nums">已知數組</param>
        /// <param name="value">要查找的值</param>
        /// <returns></returns>
        static bool Contains(int[] nums, int value)
        {
            for (int i = 0; i < nums.Length; i++)
            {
                if (nums[i] == value)
                {
                    return true;
                }
            }
            return false;
        }

　　最優方法：創建一個長度為10的bool數組，通過循環對存在的數字賦值為true，然后去循環判斷出來哪個缺少
　　　　int[] nums = { 3, 9, 8, 2, 4, 6, 10, 7 };

　　　　bool[] flags = new bool[10];

　　　　foreach(int num in nums)

　　　　{

　　　　　　flags[num - 1] = true;

　　　　}

　　　　for (int i = 0; i < flags.Length;i++ )

　　　　{

　　　　　　if(!flags[i])

　　　　　　{

　　　　　　　　Console.WriteLine(i+1);

　　　　　　}

　　　　}



　　4,2+5+“8”得到的結果是什么
　　　　答案："78"
　　


　　5, 簡述 private、 protected、 public、 internal 修飾符的訪問權限。

　　　　private : 私有成員, 在類的內部才可以訪問。

　　　　protected : 保護成員，該類內部和繼承類中可以訪問。

　　　　public : 公共成員，完全公開，沒有訪問限制。

　　　　internal: 當前程序集內可以訪問。

　　6,public static const int A = 1;這段代碼有錯誤么？

　　　　錯誤：const不能被修飾為static ；因為定義為常量 （const ）后就是靜態的（static ）。

　　7,string str = null 與 string str =””說明其中的區別。

　　　　string str = null 是不給他分配內存空間,而string str = \"\" 給它分配長度為空字符串的內存空間。

　　　　string str = null沒有string對象，string str = “”有一個字符串對象。

　　　　string s3 = string.Empty;//反編譯發現，string.Empty就是構造函數中Empty = "";


　　8,下面程序的執行結果是什么？

　　　　

        　　 bool b = false;
            if (b=true)
            {
                Console.WriteLine("www.baidu.com");
            }
            else
            {
                Console.WriteLine("www.rupeng.com");
            }
            Console.ReadKey();            

 

　　　　輸出是：www.baidu.com

　　　　　　因為不是if(b==true)

　　　　　　b=true是一個賦值表達式，賦值表達式的值為賦值之后左邊的值


　　9,關於靜態構造函數、構造函數的題，寫出下面程序的輸出結果

　　 class Program
    {
        
        static void Main(string[] args)
        {
            A b = new B();
            b.fun2();
            Console.ReadKey();
        }
    }
    class A
    {
        static A()
        {
            Console.WriteLine("A靜態構造函數");
        }
        public A()
        {
            Console.WriteLine("A構造函數");
            fun1();
        }
        public virtual void fun1()
        {
            fun2();
        }

        public virtual void fun2()
        {
            Console.WriteLine("fun2 in A");
        }
    }
    class B : A
    {
        static B()
        {
            Console.WriteLine("B靜態構造函數");
        }
        public B() { Console.WriteLine("B構造函數"); }
        public override void fun2()
        {
            Console.WriteLine("fun2 in B");
        }
　　}

　　　　答案：

　　　　　　B靜態構造函數

　　　　　　A靜態構造函數

　　　　　　A構造函數

　　　　　　fun2 in B

　　　　　　B構造函數

　　　　　　fun2 in B

　　　　解釋：構造函數在對象創建時調用

　　　　　　1、先執行子類的靜態構造函數，再執行父類的靜態構造函數；

　　　　　　2、先執行父類的（非靜態）構造函數，再執行子類的（非靜態）構造函數；




10,下面的程序執行結果是什么？

　　　　class Person
　　　　{
　　　　　　public int Age {get;set;}
　　　　}
　　　　int i1 = 20;
　　　　int i2 = i1;
　　　　i1++;
　　　　Console.WriteLine(i2);//值傳遞，打印出傳遞時的i1的值，20

　　　　Person p1 = new Person();
　　　　p1.Age = 20;
　　　　Person p2 = p1;
　　　　p1.Age++;
　　　　Console.WriteLine(p2.Age);//引用傳遞，堆中只有一個對象，p2的引用指向了p1，

　　　　答案：
　　　　　　20
　　　　　　21

　　　　解析：引用類型和值類型的區別
　　　　　　1，值傳遞，將值賦值一份，賦值給被傳遞的對象

　　　　　　2，引用傳遞，傳遞的是引用，對象還是原來的那個

　　11，下面程序的執行結果是什么？

　　　　int i = 10;
　　　　Console.WriteLine(i++);//10
　　　　Console.WriteLine(++i);//12
　　　　Console.WriteLine(i=20);//20
　　　　Console.WriteLine(i==20);//true

　　　　解析：++運算符的運算先后的問題

　　　　　　　需要注意，計算的時候值是一直在變化的

　　12,重寫（override）與重載（overload）的區別

 

　　　　　　重寫（override）是子類可以編寫一個和父類同樣的方法（名字、參數、返回值必須完全一樣，父類方法需要是virtual方法）
　　　　　　重載（overload）是一個類中方法的名稱相同，但是參數個數或參數類型不同。


　　13,屬性和public字段的區別是什么

　　　　屬性可以對設值、取值的過程進行非法值控制，比如年齡禁止設值負數，而字段則不能進行這樣的設置。

　　　　使用反編譯工具反編譯可以看出，屬性內部本質上就是set_***、get_***方法。

　　　　雖然一般情況下get讀取的值就是set設置的值，但是可以讓get讀取的值不是set設置的值的，

　　14,面向對象的語言具有什么特性？各是什么含義？

　　　　封裝性、繼承性、多態性。

　　　　封裝性：類對外部提供public方法，調用者不用關心類內部的運行機制；

　　　　繼承性：子類繼承自父類，子類可以繼承父類所有非private成員，實現代碼重用；

　　　　多態性：子類中可以覆蓋（override）父類中的virtual方法；
　　　　　　　　父類類型的變量可以指向子類類型的對象，調用的方法如果子類override了，則調用的是子類的實現；

　　15 、以下的C#代碼，試圖用來定義一個接口：

　　　　public interface IFile 
　　　　{ 
　　　　　　int A; 
　　　　　　int delFile() 
　　　　　　{ 
　　　　　　　　A = 3; 
　　　　　　} 
　　　　　　void disFile(); 
　　　　} 

　　　　關於以上的代碼，以下描述錯誤的是( )。

　　　　A：以上的代碼中存在的錯誤包括：不能在接口中定義變量，所以int A代碼行將出現錯誤；
　　　　B：以上的代碼中存在的錯誤包括：接口方法delFile是不允許實現的，所以不能編寫具體的實現函數；
　　　　C： 代碼void disFile();聲明無錯誤，接口可以沒有返回值；
　　　　D：代碼void disFile();應該編寫為void disFile(){}；

　　　　正確答案是：D
　　　　答案解析：
　　　　　　接口中不能定義方法的實現，即使是{}也是空實現，也是不行的；

　　16，C#中的接口和類有什么異同。

　　　　不同：
　　　　　　非抽象類可以實例化（也就是new），而接口不能直接實例化
　　　　　　接口不能對定義的方法進行實現
　　　　　　接口可以多繼承，類只能單繼承

　　　　相同：
　　　　　　接口、類和結構體都可以從多個接口繼承
　　　　　　接口和類都可以包含事件、所引起、方法和屬性（提示：接口只能定義方法（只能定義行為，不能定義實現也就是字段），因為事件、索引器、屬性本子上都是方法，
　　　　　　所以接口中也可以定義事件、索引器、屬性）


　　17，您在什么情況下會用到虛方法？它與接口有什么不同？

　　　　答案解析：
　　　　　　子類重新定義父類的某一個方法時，必須把父類的方法定義為virtual

　　　　　　在定義接口中不能有方法體，虛方法可以。

　　　　　　實現時,子類可以不重新定義虛方法，但如果一個類繼承接口，那必須實現這個接口。

　　18，傳入某個屬性的set方法的隱含參數的名稱是什么？
　　　　value ，類型和屬性所聲明的類型相同

　　19，C#支持多重繼承么？

　　　　答案解析：
　　　　　　類之間不支持，接口之間支持。類對接口叫做實現，不叫繼承。 類是爹、接口是能力，可以有多個能力，但不能有多個爹。

　　20，C#中所有對象共同的基類是什么？
　　　　System.Object

　　21,接口是一種引用類型，在接口中可以聲明（ ），但不可以聲明公有的域或私有的成員變量。

　　　　A：方法、屬性、索引器和事件；
　　　　B：索引器和字段；
　　　　C：事件和字段；
　　　　D：以上都不可以

　　　　正確答案是：A
　　　　答案解析：
　　　　　　接口中不能聲明字段只能聲明方法，屬性、索引器和事件最終都編譯生成方法。

　　　　　　接口中不能定義字段（也叫成員變量）

　　22,C#構造函數可以被繼承嗎？

　　　　C#中的構造函數無法繼承，子類如果想聲明和父類一樣的構造函數必須顯式聲明和調用；

　　23,構造函數可以被Override嗎？
　　　　子類無法繼承父類的構造函數，因此也就無法override的說法。子類可以定義和父類參數一樣的構造函數，如果想調用父類的這個構造函數，則必須顯式使用this去調用。

　　24,什么是多態？什么是虛方法？什么是抽象方法？什么是重載？

　　　　答案解析：
　　　　　　多態：子類中可以定義和父類中完全一樣的方法（要求父類中的方法需要是virtual），這就是override；
　　　　　　　　　　父類類型的變量可以指向子類類型的對象，調用父類方法的時候，如果子類已經override了這個方法，則調用子類的實現；

　　　　　　虛方法：一個有方法體的方法，可以被子類override；

　　　　　　抽象方法：沒有方法體的方法，必須被子類實現；

　　　　　　重載：一個類中可以有重名的方法，只要參數的個數或者類型不一樣即可；

　　25,編寫一個單例（Singleton）類。

　　　　把構造函數設置為private，設置一個public、static的對象實例

　　　　public FileManager
　　　　{
　　　　　　private FileManager(){}
　　　　　　public readonly static FileManager Instance = new FileManager();
　　　　}

 

　　26,下面程序的執行結果是什么？

    　　class Person
    　　{
        　　public DateTime Birthday = DateTime.Now;
    　　}

        static void Main(string[] args)
        {
            Person p1 = new Person();//假如這一刻是1：00：00
            Console.WriteLine(DateTime.Now);
            Thread.Sleep(1000 * 10);//休息10秒
            Console.WriteLine(DateTime.Now);//寫出當前時間
            Console.WriteLine(p1.Birthday);//寫出p1的Birthday屬性的值
            Console.ReadKey();
        }

　　　　答案解析：
　　　　　　01:00:00

　　　　　　1:00:10

　　　　　　01:00:00

　　　　　　因為成員變量的初始化是在對象new的時候初始化的，之后不會每次訪問成員變量的時候都初始化；

　　27，有一個Person類定義如下：

　　　　class Person
　　　　{
　　　　　　public static int A = 30;
　　　　　　static Person()//靜態構造函數在static字段初始化完成后執行
　　　　　　{

　　　　　　　　//靜態構造函數只執行一次
　　　　　　　　A++;
　　　　　　}
　　　　　　public int B = A++;//字段的初始化賦值代碼只是在new一個對象的時候執行，而不是每次用字段的時候都執行
　　　　　　public Person()
　　　　　　{
　　　　　　　　B++;
　　　　　　}
　　　　}

　　　　那么下面程序的執行結果是什么？

　　　　　　

　　　　　　Person p1 = new Person();
　　　　　　Console.WriteLine(p1.B);//32
　　　　　　Console.WriteLine(Person.A);//32
　　　　　　Console.WriteLine(p1.B);//32
　　　　　　Console.WriteLine(Person.A);//32

　　　　　　Person p2 = new Person();
　　　　　　Console.WriteLine(p2.B);//33
　　　　　　Console.WriteLine(Person.A);//33

 

　　28,

　　　　int i = 2000;
　　　　object o = i;
　　　　i = 2001;
　　　　int j = (int)o;
　　　　Console.WriteLine("i={0}.o={1},j={2}",i,o,j);

　　　　輸出結果是什么？

　　　　答案解析：
　　　　　　答案：i=2001,o=2000,j=2000

　　　　　　因為int是值類型，是復制傳遞

　　29，一個數組：1,1,2,3,5,8,13,21...+m，求第30位數是多少？分別用遞歸和非遞歸實現；(常考！！！)

　　　　遞歸寫法：寫遞歸要確定兩個：遞歸的終止條件；遞歸表達式

　　　　static int F(int n)
　　　　{
　　　　　　if()
　　　　　　{
　　　　　　　　return 1;
　　　　　　}
　　　　　　if(n==2)
　　　　　　{
　　　　　　　　return 1;
　　　　　　}
　　　　　　return F(n-2)+F(n-1);
　　　　}

　　　　非遞歸寫法：

　　　　　　int n = Convert.ToInt32(Console.ReadLine());
　　　　　　if(n<=0)
　　　　　　{
　　　　　　　　Console.WriteLine("必須大於0");
　　　　　　　　return;
　　　　　　}
　　　　　　if(n==1)
　　　　　　{
　　　　　　　　Console.WriteLine("1");
　　　　　　　　return;
　　　　　　}
　　　　　　int[] data = new int[n];
　　　　　　data[0] = 1;
　　　　　　data[1] = 1;
　　　　　　for(int i=2;i<n;i++)
　　　　　　{
　　　　　　　　data[i] = data[i-1]+data[i-2];
　　　　　　}
　　　　　　Console.WriteLine(data[n-1]);

 

　　30,下面哪些語句能夠正確地生成5個空字符串？（多選題）

　　　　A：String a[]=new String[5] ; for(int i=0 ;i<5 ;a[i++]="");
　　　　B：String a[]={"","","","",""};
　　　　C：String a[5];
　　　　D：String []a=new String[5] ; for(int i=0; i<5;a[i++]=null) ;

　　　　正確答案是：AB
　　　　答案解析：
　　　　　　""和null不一樣，""是長度為0的字符串對象，也就是“空字符串”，null表示“沒有對象”

　　　　　　for(int i=0 ;i<5 ;a[i++]="");按照for循環的“三段的作用”是可以實現給a數組每個元素賦值為""的作用，雖然這種寫法不常見；

 

　　31，
　　　　類Test1定義如下：

　　　　　　1．public class Test1{

　　　　　　2． public float aMethod（float a，float b）{ return 0;}

　　　　　　3．//這里插入代碼

　　　　　　4．}

　　　　將以下哪種方法插入第3行的位置是不合法的？

 

　　　　A：public float aMethod （ float a ， float b ， float c ） { return 0;}
　　　　B：public float aMethod （ float c ， float d ） { return 0;}
　　　　C：public int aMethod （ int a ， int b ） { return 0;}
　　　　D：private float aMethod （ int a ， int b ， int c ） { return 0;}

　　　　正確答案是：B
　　　　答案解析：
　　　　　　這個考的就是“重載”，參數的類型或者個數不同就能構成重載。如果只是參數名不一樣，是不能構成重載的；

　　32，
　　　　下面的程序中，temp的最終值是什么？

　　　　long temp=(int)3.9;

　　　　temp%=2;

　　　　A：0
　　　　B：1
　　　　C：2
　　　　D：3

　　　　正確答案是：B
　　　　答案解析：
　　　　　　double轉換為int是截斷，不會四舍五入。(int)3.9轉換為3，再賦值給long類型的temp，隱式轉換為long類型的3；

　　　　　　temp%=2等價於temp=temp%2;

　　　　　　3除以2的余數是1

　　33，下面代碼的運行結果

    class Program
    {
        static void Main(string[] args)
        {
            new Alpha();
            new Base();
            Console.ReadKey();          
        }
    }
    public class Base
    {
        public Base()
        {
            Console.WriteLine("Base");
        }
    }
    public class Alpha:Base
    {

    }

　　　　A：Base
　　　　B：BaseBase
　　　　C：運行異常
　　　　D：沒有輸出

　　　　答案：B
　　　　　　子類繼承父類，子類中沒有方法，則執行父類的方法

　　34，
　　　　接口和抽象類描述正確的有？（多選·）
　　　　A：抽象類沒有構造函數
　　　　B：接口沒有構造函數
　　　　C：抽象類不允許多繼承
　　　　D：接口中的方法可以有方法體

　　　　正確答案是：BC
　　　　答案解析：
　　　　　　抽象類可以有構造函數，所以A是錯誤的；


　　35，以下對抽象類描述正確是？
　　　　A：抽象類沒有構造方法
　　　　B：抽象類必須提供抽象方法
　　　　C：有抽象方法的類一定是抽象類
　　　　D：抽象類可以通過new關鍵字直接實例化

　　　　正確答案是：C
　　　　答案解析：
　　　　　　一個類有抽象方法則類必須是抽象類，但是抽象類可以沒有抽象方法（雖然這么說沒什么意義，但是語法上是允許的）；

　　36，以下對重載描述錯誤的是：
　　　　A： 方法重載只能發生在一個類的內部
　　　　B：構造方法不能重載
　　　　C：重載要求方法名相同，參數列表不同
　　　　D：方法的返回值類型不是區分方法重載的條件

　　　　正確答案是：B


　　37，下面代碼執行結果是什么？

 class Program
    {
        static void Main(string[] args)
        {
            A ab = new B();
            ab = new B();
            Console.ReadKey();
        }
    }
    class A
    {
        static A()
        {
            Console.WriteLine("1");
        }
        public A()
        {
            Console.WriteLine("2");
        }
    }
    class B:A
    {
        static B()
        {
            Console.WriteLine("a");
        }
        public B()
        {
            Console.WriteLine("b");
        }
    }

　　　　答案解析：a12b2b
　　　　　　　　靜態構造函數會在對象創建的時候后執行並且在程序運行期間只執行一次，子類繼承父類的時候執行完子類的靜態構造函數會去執行父類的靜態構造函數和非靜態構造函數，然后才是子類自己的非靜態構造函數


　　38,在C#中關於數組的定義，哪個正確（多選題）

　　　　A：int[] numbers1=new int[5]{1,2,3,4,5};
　　　　B：string[] names=new string[];
　　　　C：string[] names2 = {"aa","rupeng.com","如鵬網"};
　　　　D：int[,] numbers=new int[,]{{1,2,3},{4,5,6}};

　　　　正確答案是：ACD
　　　　答案解析：
　　　　　　D是二維數組的聲明方法，二維數組在編程中很少用，了解即可。


　　39,執行完下面語句int[] x = new int[20];后，說法正確的是？

　　　　A： x[20]為0//不存在
　　　　B： x[19]未定義//是最后一個元素
　　　　C： x[0]為空//默認是0
　　　　D：x[19]為0

　　　　正確答案是：D
　　　　答案解析：
　　　　　　數組下標從0開始，因此最后一個元素為“數組長度-1”，int數組元素默認值是0；

　　40，以下關於C#中繼承的敘述正確的是？

　　　　A：一個類只能實現一個接口
　　　　B：一個類不能同時繼承一個類和實現一個接口
　　　　C：類只允許單一繼承
　　　　D：接口只允許單一繼承

　　　　正確答案是：C
　　　　答案解析：
　　　　　　一個類實現多個接口，一個接口可以從多個接口繼承，一個類只能有一個父類。

　　41，下列說法錯誤的有？（多選題）

　　　　A：在類方法中可用 this 來調用本類的類方法
　　　　B：在類方法中調用本類的類方法時可直接調用
　　　　C：在類方法中只能調用本類中的類方法
　　　　D：在類方法中絕對不能調用實例方法

　　　　正確答案是：ACD
　　　　答案解析：
　　　　　　注意“類方法”指的是“static方法”，“實例方法”指的是“非static方法”

 

　　42，下列說法錯誤的有？（多選題）

　　　　A：數組是一種對象
　　　　B：數組屬於一種原始類型
　　　　C：int number=[]={31,23,33,43,35,63}
　　　　D：數組的大小可以任意改變

　　　　正確答案是：BCD
　　　　答案解析：
　　　　　　數組不是原始數據類型，而是一種對象；數組的長度聲明后就不能改變；

　　43， 以下敘述正確的是：

　　　　A：接口中可以有虛方法。
　　　　B：一個類可以實現多個接口。
　　　　C：接口不能被實例化。
　　　　D：接口中可以包含已實現的方法。

　　　　正確答案是：B、C

　　44，下列描述錯誤的是
　　　　A，類不可以多重繼承而接口可以
　　　　B，抽象類自身可以定義成員而接口不可以
　　　　C，抽象類和接口都不能被實例化
　　　　D，一個類可以有多個基類和多個基接口

　　　　正確答案是：D

　　45，abstract class和interface有什么區別?

　　　　相同點：
　　　　　　都不能被直接實例化，但都可以通過繼承實現其抽象方法
　　　　不同點：
　　　　　　接口支持多繼承，抽象類不能實現多繼承

　　　　接口只能定義方法的聲明，不能定義方法的實現。抽象類即可以定義方法的聲明，還可能提供實現
　　　　接口只包含方法Method、屬性Property、索引器Index、事件Event的簽名，但不能定義字段和包含實現的方法
　　　　抽象類可以定義字段、屬性、包含有實現的方法

　　46 、
　　　　byte、char、int基本類型的取值范圍？

　　　　答案解析：
　　　　　　byte：1個字節[0,255]

　　　　　　char：一遍2個字節，而且字符沒有負值，范圍為[0,65535]

　　　　　　int:-(2的31次方) 到 (2的31次方-1)

 

　　47，構造函數（constructor）是否可被重寫（override）？

　　　　答案解析：
　　　　　　構造函數不能被繼承，因此不能被重寫，但可以被重載

　　48，
　　　　1）short s1 = 1; s1 = s1 + 1;有錯嗎?

　　　　2）short s1 = 1; s1 += 1;有錯嗎？

　　　　答案解析：
　　　　　　對於short s1 = 1; s1 = s1 + 1;由於1是int類型，因此s1+1運算結果也是int 型，需要強制轉換類型才能賦值給short型。因此（1）有錯；

　　　　　　而short s1 = 1; s1 += 1;可以正確編譯，因為s1+= 1;相當於s1 = (short)(s1 + 1);其中有隱含的強制類型轉換。因此（2）沒錯

　　49，下面的代碼運行結果是什么？

　　　　class Program
　　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　Child test = new Child();
　　　　　　　　Console.WriteLine(test.getName());
　　　　　　}
　　　　}

　　　　class Father
　　　　{
　　　　　　private String name = "father";
　　　　　　public String getName()
　　　　　　{
　　　　　　　　return name;
　　　　　　}
　　　　}

　　　　class Child:Father
　　　　{
　　　　　　private String name = "child";
　　　　}

　　　　答案解析：
　　　　答案：father

　　　　　　　　public String getName() {

　　　　　　　　　　return name;

　　　　　　　　}

　　　　訪問的是Father類的name字段，父類不能訪問子類的private字段

　　50,下面程序執行的結果是什么？

　　　　class Program 
　　　　{
　　　　　　String str = "good";
　　　　　　char[] ch = {'a','b','c'};
　　　　　　public void change(String str,char[] ch)
　　　　　　{
　　　　　　　　str = "test ok";
　　　　　　　　ch[1] = 'g'; 
　　　　　　}
　　　　　　static void Main(String[] args)
　　　　　　{
　　　　　　　　Program ex = new Program();
　　　　　　　　ex.change(ex.str,ex.ch);//change的結果沒有傳遞出來
　　　　　　　　Console.Write(ex.str+"and");
　　　　　　　　Console.Write(ex.ch);
　　　　　　}
　　　　}

 

　　　　答案解析：
　　　　　　答案：goodandagc

　　　　　　方法內部對參數變量重新指向不會改變外部傳入變量的指向
　　　　　　數組是引用傳遞，ch[1]=‘g’改變的是成員變量指向的對象

　　51，下面代碼的運行結果為？

　　　　String s;

　　　　Console.WriteLine("s="+s);

 

　　　　A：輸出"s="
　　　　B：輸出"s=null"
　　　　C：編譯失敗
　　　　D：得到NullPointerException異常

　　　　正確答案是：C
　　　　答案解析：
　　　　局部變量必須初始化才能讀取


　　52，abstract可以修飾下面哪些（多選題）

　　A：類
　　B：方法
　　C：字段
　　D：枚舉

　　正確答案是：AB
　　答案解析：
　　abstract類是抽象類；abstract方法是抽象方法；字段（成員變量）是不能寫成abstract的，意義的；枚舉也一樣不能abstract。


　　53，在C#中，下列不能通過編譯的語句是？

　　A：String s="rupeng"+".com";
　　B：String s = "rupeng"+88;
　　C：int a=3+5;
　　D：float f=5+5.5;

　　正確答案是：D
　　答案解析：
　　　　5.5是double類型，因此無法隱式轉換為精度低的float

　　54，下C#代碼段，沒有錯誤的是？

　　A：byte b=257;
　　B：bool b = null;
　　C：float f=1.3;
　　D：int i=12;
　　
　　正確答案是：D
　　答案解析：
　　A：257超過了byte最大值255

　　B：bool等這些值類型 不能為null

　　C：float要寫成1.3f

　　55，有關類Demo，哪些描述是正確的？（多選題）

　　　　public class Demo:Base
　　　　{
　　　　　　private int count;
　　　　　　protected void addOne()
　　　　　　{
　　　　　　　　count++;
　　　　　　}
　　　　}

　　　　A：當創建一個Demo類的實例對象時，count的值為0；
　　　　B：當創建一個Demo類的實例對象時，count的值不確定；
　　　　C：超類對象中不可以包含改變count值的方法；
　　　　D：Demo的子類對象可以訪問Count

　　　　正確答案是：AC
　　　　答案解析：
　　　　　　成員變量int類型默認值是0，所以A對B錯。

　　　　　　“超類”就是“父類”，父類肯定無法寫改變子類private變量的代碼，所以C對；


　　56,精確保存一個值為“53.21458961”的數需要什么數據類型？

　　　　A：int
　　　　B：long
　　　　C：double
　　　　D：float

　　　　正確答案是：C
　　　　答案解析：
　　　　　　小數只能用float或者double，double精度比float高，所以要精確保存肯定首選double


　　57,下列哪種說法不正確？

　　　　A：一個子類的對象可以接收父類對象能接收的消息；
　　　　B：當子類對象和父類對象能接收同樣的消息時，他們針對消息產生的行為可能不同
　　　　C：父類比它的子類的方法更多；
　　　　D：子類在構造函數中可以使用base()來調用父類的構造函數


　　　　正確答案是：C
　　　　答案解析：
　　　　　　“接收消息”是比較學術的說法，其實指的“其他類調用這個類的方法”

　　　　　　其他類能夠調用的父類的方法，肯定也是可以通過子類來調用的，所以A是正確的；

　　　　　　B也是正確的，這就是多態，子類如果override了父類的方法，則父類類同樣方法的實現可能不一樣；

　　　　　　C是肯定是錯誤的，子類繼承了父類的方法，哪怕子類一個方法不寫，也是和父類方法一樣多；

　　　　　　D，語法上是這樣的


　　58,當父類的引用變量指向子類對象時，對於同名的方法調用哪個？

　　　　A：先調用父類的方法再調用子類的方法
　　　　B：調用子類的方法
　　　　C：調用父類的方法
　　　　D：先調用子類的方法再調用父類的方法

　　　　正確答案是：B
　　　　答案解析：
　　　　　　分析多態程序題的口訣：父類類型變量可以指向子類類型對象，子類可以override父類的方法，調用方法的時候調用子類的實現；

　　59,下面的代碼下划線的位置，應該填什么類型？

　　　　int x=4;

　　　　___ i = (x > 4) ? 99.9 : 9;

　　　　A：double
　　　　B：int
　　　　C：float
　　　　D：String


　　　　正確答案是：A
　　　　答案解析：
　　　　　　由於冒號兩邊數據類型不一致（左邊是小數，所以應該是double），編譯器將三元運算符表達式的類型處理成精度更高的類型double


　　60,下列哪種說法是正確的？(多選題)

　　　　A：實例方法可以直接調用超類的實例方法；
　　　　B：實例方法可以直接調用超類的類方法
　　　　C：實例方法可以直接調用其他類的實例方法
　　　　D：實例方法可直接調用本類的類方法；


　　　　正確答案是：ABD
　　　　答案解析：
　　　　　　“實例方法”指的就是“非靜態方法”，“類方法”指的就是“static方法”

　　　　　　“直接調用”指的就是“類名.方法名”這種不通過對象調用的方法；


　　61,對於下面的代碼運行之后foo的值是什么？

　　　　int index = 1;

　　　　bool[] test = new bool[3];

　　　　bool foo = test[index];

　　　　A：0
　　　　B：null
　　　　C：false
　　　　D：true

　　　　正確答案是：C
　　　　答案解析：
　　　　　　bool數組元素默認值是false，int數組元素默認值是0，對象數組元素默認值是null


　　62,對於下面的代碼運行之后foo的值是什么？

　　　　int index = 1;

　　　　string[] test = new string[3];

　　　　string foo = test[index];

　　　　A：""
　　　　B：null
　　　　C："foo"
　　　　D：true

　　　　正確答案是：B
　　　　答案解析：
　　　　　　對象類型數組的默認值是null

　　63,聲明抽象類的關鍵字是______________；抽象類不能______________；

　　　　答案解析：abstract 實例化