[正文]面向对象-封装，继承，多态

封装

一个类中：一些字段，属性，方法等不想全部可以被调用，在外面又需要调用这些资源。
这时就需要在类中有一个特定的入口和出口，在外面调用入口，出口返回这个私有的资源。


如：
class A{

        private string name;

        public string Nmae
        {
            get { return name1; }
            set { name1 = value; }
        }
}

//name是一个私有的资源，我们定义一个公开的Nmae来实现，访问私有的name。
//这个私有的资源可以是字段，属性，也可以是方法，类。


继承

子类B继承父类A,那么子类B也就可以调用父类A的资源。

所有的类都默认继承Objiect类，所以所有的类都具有Objiect类的资源。


多态


A类和B类都有一个打开txt文件的方法。

A可以1秒读取100个文件。
B可以1秒读取1000个文件。

同是 读取 的功能，但能力的执行结果却不相同。

同一个能力，在不同的对象中有着不同的结果，这就是多态。


例子：

    public class 类
    {
        //私有 只有在本类的作用域中可被访问
        private string name1;

        //protected保护 在本类和继承这个类的对象可被访问
        public string Nmae1
        {
            get { return name1; }
            set { name1 = value; }
        }

        //在本程序集中可被访问，其他程序集引用时，无法访问
        internal void a() { }

        //公开
        public string this[int i]//索引器
        {
            get { return i.ToString(); }
            set { name1 = value; }
        }

        //虚方法
        public virtual void aa()
        {
            this.name1 = "000001";
        }
    }

    public class B : 类, ID
    {
        public B()
        {
            base.a();//调用父类中的a()
        }
        //B() : base()//调用父类中的构造函数
        //{
        //    a();//调用父类中的a()
        //}
        public void B1()
        {
        }
        public string b = "123456";


        //重写
        public override void aa()
        {
            this.Nmae1 = "111111";
        }

        //隐式使用接口
        public void D1()
        {
        }


        public void D2()
        {
        }
    }

    public class BB : C, ID
    {
        public void B1()
        {
        }
        public string b = "123456";

        //调用抽象类中的方法
        public override string C2()
        {
            return "123456";
        }

        //显式的使用接口
        void ID.D1()
        {
        }

        void ID.D2()
        {
        }
    }


    /// <summary>
    /// 抽象类
    /// </summary>
    public abstract class C
    {
        //抽象类中是可以存在非抽象方法和字段的
        public string c1 = "c1";
        public string C1()
        {
            return "C1";
        }
        public abstract string C2();
    }


    /// <summary>
    /// 接口
    /// </summary>
    public interface ID
    {
        void D1();
        void D2();
    }


抽象方法和接口中的方法中，都是没有可实现的方法体的。

抽象类不能被实例化，只能被继承时，调用其方法。

类B和类BB中都实现了接口ID，所以B和BB中有了相同的方法名，但这个方法究竟会得出什么样得结果
就要看实现这个类中，自己中的 方法体 是怎么写的了。

由此我们定义了，D1和D2两个方法，但没有具体的实现，
只有引用了这个接口的类，才可以把 具体的实现的功能 写上。


隐式使用接口和显式使用接口的区别:

B b1= new B(); //b1可以调用D1()和D2()
ID ib1 =new B(); //ib1只能调用D1()和D2()


BB b2= new BB(); //b2不能调用D1()和D2()

ID ib2 =new BB(); //ib2只能调用D1()和D2()

作者：FengYang

博客地址：http://blog.csdn.net/qq_28140365

版权声明：如果感觉文章哪里写的不对或者存在疑问，欢迎留言，共同学习、进步！

蓝色字体为链接