记录一下笔试时碰到的题目

前天我去一家公司笔试，走了很长一段路才找到了那间公司，到达时已经是满头大汗了，迟了几十分钟。可是见到公司所在的楼的破旧，还有上楼时见到的了无生气的状况，我不由得有点心凉，再加上那位应该算是大妈前台，使我更是失望。最终还是没能应聘到那间公司，说是什么对软件工程的认识还没有达到他们所需要的标准。

还是不发牢骚了，这里说一下笔试时碰到的题目，题目很简单，还是直接贴代码吧。

以下的题目没有特别说明都是求其输出

题目1：try-catch的用法

       public static void Test(object parm1,int i)
        {
            if (parm1 == null)
                throw new ArgumentNullException();
           
            if(i <0)
                throw new ArgumentOutOfRangeException();
        }

        static void Main(string[] args)
        {
            try
            {
                Test(null,-1);
            }
            catch (ArgumentNullException)
            {
               
                Console.WriteLine("1");//只有本行生效
            }
            catch(ArgumentOutOfRangeException)
            {
                Console.WriteLine("2");
            }
            catch(Exception)
            {
                Console.WriteLine("0");
            }
           
            try
            {
                Test("123", -1);
            }
            catch (ArgumentNullException)
            {

                Console.WriteLine("1");
            }
            catch (ArgumentOutOfRangeException)
            {
                Console.WriteLine("2");//只有本行生效
            }
            catch (Exception)
            {
                Console.WriteLine("0");
            }

            try
            {
                Test(null, 10);
            }
            catch (ArgumentNullException)
            {

                Console.WriteLine("1");//只有本行生效
            }
            catch (ArgumentOutOfRangeException)
            {
                Console.WriteLine("2");
            }
            catch (Exception)
            {
                Console.WriteLine("0");
            }

            Console.ReadLine();
        }

题目2：多态的调用

首先来看一个类的代码

interface I
    {
        void Foo();
    }
    public abstract class C:I
    {
        public abstract void Foo();
    }
    public class C1:C, I
    {
         void I.Foo()
        {
           Console.WriteLine("I.Foo");
        }

        public override void Foo()
        {
            Console.WriteLine("C.Foo");
        }
    }
    public class C2:C1,I
    {
        void I.Foo()
        {
            Console.WriteLine("I.Foo");
        }

        public override void Foo()
        {
            Console.WriteLine("C.Foo");
        }
    }
    public class C3 : C2, I
    {
        void I.Foo()
        {
            Console.WriteLine("I.Foo");
        }

        public override void Foo()
        {
            Console.WriteLine("C.Foo");
        }
    }

再来看看调用的代码

static void Main(string[] args)
        {
            I i = null;

            i = new C1();
            i.Foo();

            i = new C2();
            i.Foo();

            i = new C3();
            i.Foo();

            //以上都是输出I.Foo

            ((C3)i).Foo();


            C c = null;

            c = new C1();
            c.Foo();

            c = new C2();
            c.Foo();

            c = new C3();
            c.Foo();

            //以上都是输出C.Foo

            ((I)c).Foo();//输出I.Foo

            Console.ReadLine();

        }

有人说要解释一下，但是我觉得贴出来的这些内容，可能看之前还不知道，可是看了之后一般都会明白

不过我还是尽量打些注释吧

-------------------------------------------------------------------------------

以下为2009-03-12加入的新内容

题目3：多态的构造函数的调用顺序

public abstract class A
        {
            public A()
            {
                Console.WriteLine("A");
            }
            public virtual void Fun()
            {
                Console.WriteLine("A.Fun()");
            }
        }
        public class B : A
        {
            public B()
            {
                Console.WriteLine("B");
            }
            public override void Fun()
            {
                Console.WriteLine("B.Fun");
            }

        }

        public class C : B
        {
            public C()
            {
                Console.WriteLine("C");
            }
            public new void Fun()
            {
                Console.WriteLine("C.Fun()");
            }
        }

        static void Main(string[] args)
        {
            //继承的构造函数可以这样理解
            //必须先构造出父类才可以构造出子类
            //即是先有父亲后有子女
            Console.WriteLine("第一组");
            A temp1 = new B();
            temp1.Fun();
            //第一组输出:A，B，B.Fun()

            Console.WriteLine("第二组");
            B temp2 = new B();
            temp2.Fun();
            //第二组输出:A,B,B.Fun()

            Console.WriteLine("第三组");
            B temp3 = new C();
            temp3.Fun();
            //第三组输出:A,B,C,Fun()

            //又是一个多态的调用
            //通过父类调用子类的方法,一般是调用子类中的方法
            //但是用了new后,子类的方法对于父类为不可见,
            //此时会层层向上,直到找到一个可见的方法
            Console.WriteLine("第四组");
            A temp4 = new C();
            temp4.Fun();
            //第四组输出:A,B,C,Fun()

            Console.ReadLine();
        }

题目4：static的用法

static void Main(string[] args)
        {
            Test test1=new Test();
            Test test2=new Test();

            //很意外，我本以为输出应该为0
            //没想到居然是2
            Console.WriteLine(Test.Count);

            //后来查了一下网络，看到这句话
            //static变量表示该变量属于类，而不是类的实例。可以说是该类的所有实例共享一个static变量。
      
        }
        public class Test
        {
            public static int Count = 0;
           
            public Test()
            {
                Count++;
            }
        }

 

题目5：判断相等

static void Main(string[] args)
        {
            Person person1=new Person();
            Person person2=new Person();

            //==判断分两种
            //1、值类型判断值是否相等
            //2、引用类型判断引用是否相等，string比较特殊，虽然是引用类型但同样使用值类型的判断
            Console.WriteLine(person1==person2);//输出False
            //Eqauls操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。
            //如果有重载，则调用重载的方法
            Console.WriteLine(object.Equals(person1,person2));//True
            //引用判断
            Console.WriteLine(Object.ReferenceEquals(person1,person2));//False

            Hashtable hashtable=new Hashtable();

            hashtable.Add("valueId",person1);
            //这里判断的依据是哈希码
            Console.WriteLine(hashtable.ContainsValue(person2));//True

            string str1 = "test";
            string str2 = "test";

            Console.WriteLine(str1==str2);//True
            Console.WriteLine(str1.Equals(str2));//True
            //摘抄一段网上的解释
            //string对于声明的相同的字符串在堆上只保留一个Copy
            Console.WriteLine(object.ReferenceEquals(str1,str2));//True


            string a = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });
            string b = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });

            Console.WriteLine(a == b);//True
            Console.WriteLine(a.Equals(b));//True
            Console.WriteLine(object.ReferenceEquals(a, b));//使用了new，所以是False

            object g = a;
            object h = b;

            //这个==为什么不是调用string的==呢？我也不清楚
            Console.WriteLine(g == h);//False
            //调用的还是string的Equals方法
            Console.WriteLine(g.Equals(h));//True
            Console.WriteLine(object.ReferenceEquals(g, h));//False
        }
    }
    public class Person
    {
        public string Name=string.Empty;

        public override bool Equals(object obj)
        {
            Person person = obj as Person;
            if (person == null || person.Name !=this.Name)
                return false;

            if (person.Name == Name)
                return true;

                return base.Equals(obj);
        }

        public override int GetHashCode()
        {
            return Name.GetHashCode();
        }

-------------------------------------------------------------------------------

以下为2009-03-25加入的新内容

题目6：static的执行顺序

public class Base
    {
        private int a = Initial("a");
        private static int b = Initial("b");
        private readonly int c = Initial("c");
        public Base()
        {
            Initial("Base");
        }
        public static int Initial(string str)
        {
            Console.WriteLine(str);
            return 0;
        }
       
    }
    public class Child : Base
    {
        private int x = Initial("x");
        private static int y = Initial("y");
        private readonly int z = Initial("z");
        public Child()
        {
            Initial("Child");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Child test=new Child();
            //输出结果是
            //b
            //y
            //x
            //z
            //a
            //c
            //Base
            //Child
        }
    }

从结果我们可以知道：

1、一个类的执行首先是从字段开始，然后再到构造函数。

2、拥有static的标识符的字段拥有很高的权限，它首先编译父类的static字段，再到子类的static字段，

     然后其他字段则是按顺序执行：按先出现先编译，先父类再子类

3、构造函数的执行

题目7：两个不同类型相加的结果

UInt32 a = 6;
Int32 b = -20;
int c ;

int i = (a+b>6)? c=1:c=0;

Console.WriteLine(c);//结果为0

在C#中UInt32和Int32 的运算会先将各数转为Int32，所以a+b结果为-14，小于6，所以c为0

但是在c++中，a+b的运算时将b换算为unsigned型，相加后结果大于6，c为1