如鹏网面试题（基础1）_.NET_编程开发_程序员俱乐部

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 实例化