类的面向对象特性

类的封装

namespace ConsoleApp1
{
    class MyClass
    {
        private int x = 0;
        private int y = 0;
        public int X
        {
            get
            {
                return x;
            }
            set
            {
                x = value;
            }
        }
        public int Y
        {
            get
            {
                return y;
            }
            set
            {
                y = value;
            }
        }
        public int Add()
        {
            return X + Y;
        }
    }
    class Program
    {
        static void Main()
        {
            MyClass myclass = new MyClass();
            myclass.X = 3;
            myclass.Y = 5;
            Console.WriteLine(myclass.Add());
        }
    }
}

类的继承

在c#中一次只允许继承一个类，不能同时继承多个类
利用类的继承机制，用户可以通过增加、修改或替换类中的方法对这个类进行扩充
使用：来标识两个类的继承关系，子类不能访问基类的私有成员，可访问公共成员
只有子类才能访问protected成员，基类和外部代码都不能访问

namespace ConsoleApp1
{
    class MyClass1
    {
        private int x = 0;
        private int y = 0;
        public int X
        {
            get
            {
                return x;
            }
            set
            {
                x = value;
            }
        }
        public int Y
        {
            get
            {
                return y;
            }
            set
            {
                y = value;
            }
        }
        public int Add1()
        {
            return X + Y;
        }
    }
    class MyClass2 : MyClass1
    {
        private int z = 0;
        public int Z
        {
            get
            {
                return z;
            }
            set
            {
                z = value;
            }
        }
        public int Add2()
        {
            return X + Y + Z;
        }
    }
    class Program
    {
        static void Main()
        {
            MyClass1 myclass1 = new MyClass1();
            MyClass2 myclass2 = new MyClass2();
            myclass1.X = 3;
            myclass1.Y = 5;
            myclass2.X = 3;
            myclass2.Y = 5;
            myclass2.Z = 7;
            Console.WriteLine(myclass1.Add1());
            Console.WriteLine(myclass2.Add1());
            Console.WriteLine(myclass2.Add2());
        }
    }
}

8
8
15

重构
子类与父类的成员方法返回值、方法名称、参数类型及个数完全相同，唯一不同的是方法实现内容

类的多态

多态使子类的实例可以直接赋予基类的变量（这里不需要进行强制类型转换），然后直接就可以通过这个变量调用子类的方法
利用多态可以使程序具有良好的扩展性，并可以对所有类对象进行通用的处理。

namespace ConsoleApp1
{
    class Program
    {
        private Program[] qtest = new Program[6];
        private int nextIndex = 0;
        public void draw(Program q)
        {
            if (nextIndex < qtest.Length)
            {
                qtest[nextIndex] = q;
                Console.WriteLine(nextIndex);
                nextIndex++;
            }
        }
        static void Main()
        {
            Program q = new Program();
            q.draw(new Square());
            q.draw(new Parallelogramgle());
        }
    }
    class Square : Program
    {
        public Square()
        {
            Console.WriteLine("正方形");
        }
    }
    class Parallelogramgle : Program
    {
        public Parallelogramgle()
        {
            Console.WriteLine("平行四边形");
        }
    }
}