C#超进阶-面向对象三大特性

高效学习C#

功法心得：

本周学习面向对象的三大特性，表面看起来比较容易理解，但是应用到实际上面，根本不知道如何上手。

建议	我们在学习某一阶段的知识的时候，千万不要把某一个项目或者大部分知识堆积起来，然后再拆分总结；我们总是以为我们在当时理解了，就证明后期也理解了，殊不知我们错过了很多当时我们的疑问自己思考点；这些才是最宝贵的资源，所以利用起博客这一工具，及时整理阶段性的知识，寻找其中的联系，最后我们才能清晰了解我们学到了些什么。
补充	或许当时你理解错了，或许在他人看起来很低级，但是请不要介意，因为读者殊不知在你有了新的理解或者认识后，会及时整理博客的内容，博客表面上看是展示，但实际上却是检验以及督促自己好好整理学到的知识。

功法秘籍：

封装

封装	针对于面向对象语言编程的过程中好像我们处处都在使用这个特性
作用	减少了大量的冗余代码；将错综复杂的功能封装起来，提供一个对外的接口，会使用即可

例如：console.writeLine();平时使用的很简单的“类”，起初以为是方法，但是后来发现智能提示中标识为“class”；同样也印证了---静态类.方法，不需要讲类实例化即可使用；同时也做到了类的封装，不需要让使用者知道内部是如何调用的，只要会使用即可。

例如：定义类中存在的字段、属性、函数、构造函数同样也是封装到类里面。

字段	存储数据
属性	保护字段（get、set）
函数	保护对象的行为
构造函数	初始化对象，给对象的每个属性进行赋值

继承

继承	每个类都有“相同的”属性标识和行为特性，非特有的表现形式；子类/派生类“继承”父类/基类。
作用	减少类中的冗余代码；类与类之间产生关系，为“多态”打下基础。
特性	单根性：子类仅可以继承一个父类；传递性：无限极继承。

static void Main(string[] args)
   {
      Animal[] animals = { new Cat(), new Dog(), new Pig() };
      for (int i = 0; i < a.Length; i++)
      {
          animals[i].Drink();
          animals[i].Eat();
      }
      Console.ReadKey();
	}

	abstract class Animal
    {
        public void Eat()
        {
            Console.WriteLine("动物用牙齿嚼东西");
        }

        public void Drink()
        {
            Console.WriteLine("动物用舌头喝水");
        }
    }

    class Cat : Animal
    {
  
    }
    class Dog : Animal
    {

    }

里式转换	子类赋值给父类；父类中装子类的对象，但是不可以使用子类的成员，因此将父类转变为对象的子类对象。
关键字	is：返回bool类型，指示是否可以做这个转换；as：转换成功，则返回对象，否则返回null。
作用	子类看做父类，针对父类进行编程，写出多个子类通用的代码。

	static void Main(string[] args)
        {
            Person person = new Student();

            //if (person is Teacher)
            //{
            //    ((Teacher)person).TeacherSayHello();
            //}
            //else
            //{
            //    Console.WriteLine("转换失败");
            //}

            Student s = person as Student;//将person转换为student对象
            if (s != null)
            {
                s.StudentSayHello();
            }
            else
            {
                Console.WriteLine("转换失败");
            }
            Console.ReadKey();
	}

多态

多态	不同对象接收到相同消息时，会产生不同的行为（有联系：虚函数和抽象类；无联系：实现接口）；同一个类在不同场合下回产生不同的行为特性（父类调用子类的不同函数）
作用	不同的子类对象都当做父类来看，可以屏蔽不同子类对象之间的差异，写出同用的代码；
涵盖	虚方法：virtual override；抽象类：abstract override （在继承特性的基础上进行了扩充，具有相同的属性以及行为但是可以实现不同的表现形式）。-----------（虚方法和抽象类两者解决里式转换后必须强转为子类对象才可以使用子类的方法） 备注：父类没有办法确定子类如何实现方法（减少耦合）；子类继承父类，必须重写这个抽象父类的所有抽象成员。

//一、里式转换和虚方法的区别

class Program
{
    static void Main(string[] args)
    {
        //里式转换实现以下方式
        //Employee[] emps = { emp, m, p };
        //for (int i = 0; i < emps.Length; i++)
        //{
            //if (emps[i] is Manager)
            //{
            //    ((Manager)emps[i]).DaKa();  
            //}
            //else if (emps[i] is Programmer)
            //{
            //    ((Programmer)emps[i]).DaKa();
            //}
            //else
            //{
            //    emps[i].DaKa();
            //}
        //    emps[i].DaKa();
        //}
        //虚方法实现以下方式
        Employee emp = new Programmer();//new Manager(); //new Employee();
        emp.DaKa();
        Console.ReadKey();
    }
}
class Employee
{
    public virtual void DaKa()
    {
        Console.WriteLine("我是员工");
    }
}
class Manager : Employee
{
    public override void DaKa()
    {
        Console.WriteLine("我是经理");
    }
}
class Programmer : Employee
{
    public override void DaKa()
    {
        Console.WriteLine("我是程序员");
    }
}
}

//二、抽象类的使用方式

class Program
    {
        static void Main(string[] args)
        {
            //抽象类不允许创建对象
            Animal animal = new Cat(); //new Dog();
            animal.Bark();
            Console.ReadKey();
        }
    }

    abstract class Animal
    {
        public abstract void Bark();
    }

    class Dog : Animal
    {

        public override void Bark()
        {
            Console.WriteLine("小狗旺旺的叫");
        }
    }

    class Cat : Animal
    {
        public override void Bark()
        {
            Console.WriteLine("小猫喵喵的叫");
        }
    }