Peter勇

我不知道 但我可以学会。做自己喜欢的事情,就是这样!http://fml710.xyz/

《.NET程序员面试秘籍》读书笔记

1. 简述 private、 protected、 public、 internal 修饰符的访问权限。

     private :设置类或类的成员为私有,在类的内部才可以访问。有时要访问私有成员时,可通过get和set属性访问器读取或者修改。

     protected :保护成员,该类内部和继承类(子类)中可以访问。(即使子类和基类不在同一个程序集中)

     public : 公共成员,完全公开,没有访问限制。须谨慎使用,滥用会影响类的封装性。 

     internal:  在同一命名空间(程序集)内可以访问。C#默认的类访问修饰符即为internal。(默认的修饰符,可缺省,最常用)

2. 描述sealed修饰符的作用

  用于修饰类、实例方法和属性。sealed修饰类时,该类无法被继承,所以该类也被称为密封类。而abstract类(抽象类)必须被继承才有意义,所以二者是相互排斥,无法共用的。密封方法会重写基类的方法,sealed用于修饰实例被重写的虚方法或虚属性时,表示该方法或属性无法再被重写。

3、举例说明简单工厂模式的作用

       在软件系统中,经常面临“一系列相互依赖对象”的创建工作,为了绕过常规对象的创建方式(即用new创建),利用工厂模式,提供一种“封装机制”来减少功能调用程序和“多系列具体对象创建工作”的耦合性。



         简单工厂模式,在工厂类中封装创建对象的实现部分。在应用接口的程序中广泛应用。如下例:

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace BaseFactory  
{  
    //声明一个图书接口  
    interface IBook  
    {  
        //声明未实现的图书类型方法bookType()  
        void bookType();  
    }  
    //实现图书接口的A类图书  
    class BookA : IBook  
    {  
        public void bookType()  
        {  
            Console.WriteLine("A类书籍");  
        }  
    }  
    //实现图书接口的B类图书  
    class BookB : IBook  
    {  
        public void bookType()  
        {  
            Console.WriteLine("B类书籍");  
        }  
    }  
    //实例化各类图书对象的工厂  
    class PublishFactory  
    {  
        private IBook bka = new BookA();  //封装创建对象的实部分
        private IBook bkb = new BookB();  
        public IBook getBook(int i)  
        {  
            switch (i)  
            {  
                case 1:  
                    return bka;  
                case 2:  
                    return bkb;  
                default:  
                    return bka;  
            }  
        }  
    }  
    public class BasicFactory  
    {  
        static void Main(string[] args)  
        {  
            PublishFactory pf = new PublishFactory();  
            Console.Write("请输入编号(1或2):");  
            int i = int.Parse(Console.ReadLine());  
            //根据输入的不同参数获得不同的图书对象  
            IBook obj = pf.getBook(i);  
            obj.bookType();  
        }  
    }  
  
}  

接口反映了面向对象编程的一个特性,即多态,多态即通过相同的方法得到不同的实现。如上面的h1.getFav()和h2.getFav();

接口反映了面向对象编程的另个特性,即封装,使用者可以不清楚接口成员实现的细节。

解释: 接口类型obj可以引用不同类的实例,以致相同的bookType方法有不同的表现;使用者只知道传递数字来使用不同接口的不同功能,对内部实现一无所知。实现了更好的封装。

(此例已经够说明了)

运行结果:

        为了处理更复杂的情况,可以将产品再次细分为多个类,用抽象类进行归纳,完成同类产品中共用代码的复用,工厂类也相应地分为多个类,用抽象类进行归纳。如下例:

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace LxFactory  
{  
    //声明一个人类接口  
    interface Ihuman  
    {  
        void getFav();        //声明未实现的爱好方法getFav()  
        string getStatus();   //声明未实现的身份状态(孩子,成年人)方法  
    }  
  
    //声明一个抽象类Children,并实现接口的部分方法  
    abstract class Children : Ihuman  
    {  
        protected string _status = "孩子";  
        //实现接口Ihuman中的getStatus()方法  
        public string getStatus()  
        {  
            return _status;  
        }  
        //将接口Ihuman中的getFav()方法映射到抽象方法  
        abstract public void getFav();  
    }  
    //声明一个抽象类Adult,并实现接口的部分方法  
    abstract class Adult : Ihuman  
    {  
        protected string _status = "成年人";  
        //实现接口Ihuman中的getStatus()方法  
        public string getStatus()  
        {  
            return _status;  
        }  
        //将接口Ihuman中的getFav()方法映射到抽象方法  
        abstract public void getFav();  
    }  
  
    //声明男孩类Boy,继承小孩类Children,重写爱好方法getFav()  
    class Boy : Children  
    {  
        public override void getFav()  
        {  
            Console.WriteLine("男孩,我喜欢游戏!");  
        }  
    }  
    //声明女孩类Girl,继承小孩类Children,重写爱好方法getFav()  
    class Girl : Children  
    {  
        public override void getFav()  
        {  
            Console.WriteLine("女孩,我喜欢布娃娃!");  
        }  
    }  
    //声明男人类Man,继承成人类Adult,重写爱好方法getFav()  
    class Man : Adult  
    {  
        public override void getFav()  
        {  
            Console.WriteLine("男人,我喜欢编程!");  
        }  
    }  
    //声明女人类Woman,继承成人类Adult,重写爱好方法getFav()  
    class Woman : Adult  
    {  
        public override void getFav()  
        {  
            Console.WriteLine("女人,我喜欢逛街!");  
        }  
    }  

    //声明一个抽象工厂,分别创建相应类的实例  
    abstract class HumanFactory  
    {  
        protected Ihuman h1 = new Boy();  
        protected Ihuman h2 = new Man();  
        protected Ihuman h3 = new Girl();  
        protected Ihuman h4 = new Woman();  

        //创建一个方法,根据不同输入返回一个接口的引用  
        abstract public Ihuman getHuman(int i);  
    }  
    //声明可以实例化各种类的工厂Factory1,继承类HumanFactory,重写抽象方法getHuman()  
    class Factory1 : HumanFactory  
    {  
        //根据不同输入获得不同对象所属接口的引用  
        public override Ihuman getHuman(int i)  
        {  
            switch (i)  
            {  
                case 1:  
                    return h1;  
                case 2:  
                    return h2;  
                default:  
                    return h1;  
            }  
        }  
    }  
    //声明可以实例化各种类的工厂Factory1,继承类HumanFactory,重写抽象方法getHuman()  
    class Factory2 : HumanFactory  
    {  
        //根据不同输入获得不同对象所属接口的引用  
        public override Ihuman getHuman(int i)  
        {  
            switch (i)  
            {  
                case 1:  
                    return h3;  
                case 2:  
                    return h4;  
                default:  
                    return h3;  
            }  
        }  
    }  
    public class LxFactory  
    {  
        static void Main(string[] args)  
        {  
            //使用工厂1  
            Console.WriteLine("男性中有两种人,请选择编号【1】男孩【2】男人:");  
            int input1 = Int32.Parse(Console.ReadLine());  
            Factory1 f1 = new Factory1();  
            Ihuman h1 = f1.getHuman(input1);  
            h1.getFav();  
            Console.WriteLine("我的身份是:{0}", h1.getStatus());  
  
            //使用工厂2  
            Console.WriteLine("女性中有两种人,请选择编号【1】女孩【2】女人:");  
            int input2 = Int32.Parse(Console.ReadLine());  
            Factory2 f2 = new Factory2();  
            Ihuman h2 = f2.getHuman(input2);  
            h2.getFav();  
            Console.WriteLine("我的身份是:{0}", h2.getStatus());  
        }  
    }  
  
}  

运行结果:

 

4、访问关键字this和base有什么作用

this用于引用类的当前实例(this仅限于构造函数和方法成员中使用,静态成员与实例无关,所以静态成员中不能用this)

base用于派生类访问基类成员(基类被重写的方法和基类的构造函数)

5、简述程序集和应用程序域

程序集

一个.NET应用程序可以由多个程序集拼装而成的。程序集,简单来说,就是一个以公共语言运行库(CLR)为宿主的、版本化的、自描述的二进制文件。尽管显示中.NET程序集和以往Win32二进制文件(包括遗留的COM服务对象)的文件扩展名(*.exe或*.dll)完全相同,但是两者的内部构成几乎完全不同。

程序集可以促进代码重用、确定类型边界、可版本化的单元、自描述的、可配置的。

n CIL代码

程序集的核心部分包含CIL代码,这些CIL代码是独立于平台和CPU的中间语言。运行时,程序集内部的CIL代码才被编译成特定平台和CPU的指令。

n 类型元数据

元数据完整的描述了程序集内含另行和引用外部类型的格式。

n 程序集清单

详细记录了程序集中的每一个模块,构建程序集的版本以及该程序集引用的所有外部程序集。

n 可选的嵌入资源

 

      NET平台下,程序集并没有直接加载进进程中(传统的Win32程序是直接承载的)。.NET可执行程序(程序集)承载在进程的一个逻辑分区中,术语称应用程序域(简称AppDomain)。一个进程可以拥有多个应用程序域,应用程序域的全部目的就是提供隔离性,相比较与传统的:(代码, AppDomain.currentDomain)

1.应用程序域是.NET平台操作系统独立性的关键特性。这种逻辑分区将不同操作系统表现加载可执行程序的差异抽象化了。

2.和一个完整的进程相比,应用程序域的CPU和内存占用要小的多。

3.应用程序域为承载的应用程序提供了深度的隔离。一个失败,其他不会失败。

单个进程可以承载多个应用程序域,每个程序域都和该进程的其他程序域隔离开来,无法相互访问。在线程启动的时候,CLR将自动创建这个特定的应用程序域(默认应用程序域)。然后根据需要创建其他程序域。

 
 

两边都有mscorlib.dll(程序集),因为所有关键程序集会被CLR自动加载到每一个应用程序域中。

6、简述结构和类的区别

  答:(1)结构是值类型(传递的是数据的副本),类是引用类型。所以结构的实例化可以不用new运算符。

(值类型变量一旦超出作用域即被销毁,而应用类型由内存垃圾处理机制完成收集)

(2)结构不能声明无参数的构造函数(默认构造函数)和析构函数。类可以同时有构造函数和析构函数。

(3)结构不支持继承,也无法派生其他的结构或类,(但结构可以实现接口)。而类支持继承。

7、C#函数的参数 修饰符(out、params、ref)的作用

(1)无修饰符,表示按值传递

(2)out修饰,eg. 函数 static void equal(out int a,out int b,out int c)

{ a=2; b=a*100; c=b*100; Console.WriteLine("a、b、c的值分别为:{0}、{1}、{2}",a,b,c);}

     表示按引用 传递参数,实际参数(调用的函数里的参数)传递前不需要赋初值,函数(定义的函数)必须将其赋值。也可以看出out能用于一次调用返回多个值

(3)params修饰,表示形式参数 可以为不确定个数的一组实际参数,这些实际参数必须具有相同的数据类型。

   void text(params string[] txt){}

(4)ref修饰,类似out参数。也表示按引用 传递参数,不过实际参数传递前需要赋初值。


8、如何使用C#的对象构造器

  这是一种新的构造并初始化对象的方法,使用时只需将初始化成员的语句用逗号分隔,位置紧跟在构造函数后面。

 eg. Snake a=new Snake("眼镜蛇"){nm="蟒蛇",Len=10,Wei=20 };

  后面大括号就是对象构造器。。列出了 对象a 的初始化值。  这种方式非常灵活的初始化对象成员,无需定义过多的重载构造函数。


9、如何判断类型实现了某个接口  (as/is关键词)

ClassA a=new ClassA();  

var msg=a as ITest;    

 class  ClassA:ITest{ 类体}

if(msg==null)

{"未实现"}

 else {"实现了"}

或者用 a is ITest


10、数组列表和数组有什么区别

非常相似,但是数组列表(即ArrayList类, 位于System.Collection下)的容量可以动态变化;有点类似StringBuilder类。。

ArrayList.Add(); ArrayList.Insert(); ArrayList.AddRange();-----

  数组(即Array类,位于System下,)在初始化时要指定容量,并且指定后无法更改。



阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/bigpudding24/article/details/44853549
个人分类: 读书笔记
想对作者说点什么? 我来说一句

《C#与.NET程序员面试宝典》

2012年03月05日 48.73MB 下载

没有更多推荐了,返回首页

不良信息举报

《.NET程序员面试秘籍》读书笔记

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭