C# 面向对象之封装与多态详解

很多时候我们都会说面向对象有三大特征：封装、继承、多态

那么它们具体是什么意思呢

继承前面已经将了 本文主要将封装与多态

封装是什么？

在C#中，我们用类来抽象某一具体的事物，那么这是事物本身会具有一些属性和一些行为

例如人类类（Person）每个人都有名字、性别、年龄、头发，眼睛的颜色等等这些属性，同时

每个人的兴趣爱好、所从事的工作等等。

很多时候不一定希望别人能够直接获取我们的个人信息 所以我们需要将这些成员字段设置为

private,并提供public的get和set函数（C#有属性功能）

同时我们把类的一系列行为放入一个个函数中，在需要时调用相应的函数即可，在外部只能看见我们函数的执行，而不是直接看见代码，也降低程序的耦合。

 class Program
    {
      
       
        static void Main(string[] args)
        {

            //Tiger t = new Tiger("胖虎");
            // t.PrintName();
            Person p = new Person("李四",18,"钓鱼");

            //p._name   报错不能直接访问私有成员
            Console.WriteLine(p.Name); //通过属性Name访问_name相当于string getName()             
                                                                    {return _name}

            p.Name = "张三"; //通过属性Name修改_name 相当于 void setName(string name)
                                                                     { _name=name}

            Console.WriteLine(p.Name);

            p.MyHobby();  //通过调用函数代替代码输出_hobby

        }
        class Person
        {
            private string _name;
            private int _age;
            private string _hobby;

            public Person(string name,int age,string hobby)
            {
                _name = name;
                _age = age;
                _hobby = hobby;
            }

            public string Name   //C#中的属性 相当于提供了get,set接口
            {
                get { return _name; }
                set { _name = value; }
            }

            public int Age  
            {
                get { return _age; }
                set { _age = value; }
            }

            public void MyHobby()
            {
                Console.WriteLine("我的兴趣爱好是：{0}",_hobby);
            }

        }
}

什么是多态？

多态就是同一行为的不同表现形式，不同派生类对象对来自基类的同一方法(行为)的重写，使不对派生类对象对这一行为的具体实践不同

动态又有静态多态和动态多态的说法

静态多态

在编译阶段的多态，也叫编译期多态。如函数重载，运算符重载

动态多态

即运行时多态 在程序运行时判断所引用的实际类型，根据具体的类型来调用相应的方法

主要通过派生类重写基类的virtual/abstract方法来实现

  class Program
    {
     
       
        static void Main(string[] args)
        {
            //有点类似C++ 父类指针指向子类对象
            //但在C#中没有明确指针 所以是派生类初始化基类 但这里anil是一个引用类型 本身存储的 
            //是一个指向堆区的地址
            Animal anil = new Tiger("胖虎"); 
            anil.Eat();
            ((Tiger)anil).Test();  
            ((Tiger)anil).Test("cs");  //函数重载
            anil = new Cat("汤姆");    //指向不同派生类对象

            anil.Eat();  //调用同一方法
           
        }
        

        class Animal
        {
            public Animal(string name)
            {
                _name = name;
            }
            protected string _name;
            public void PrintName()
            {
                Console.WriteLine(_name);
            }
            public virtual void Eat()
            {
                Console.WriteLine("animal eat");
            }
            

        }
        class Tiger:Animal
        {
            public  Tiger(string name):base(name)
            {

            }
            public void Test()
             {
                Console.WriteLine("test函数1");
              }

            public void Test(string s)  //通过形参列表重载Test
            {
                Console.WriteLine("重载test函数：{0}",s);
            }
           public  override void Eat() //重写基类函数
           {
            Console.WriteLine("tiger eat");
            }
            public new void PrintName()
           {
                Console.WriteLine("print tiger name:{0}",_name);

           }
          
        }
        class Cat:Animal
        {
            public Cat(string name):base(name)
            {
                
            }
            public override void Eat() //重写基类函数
            {
                //base.Eat();
                Console.WriteLine("cat eat");
            }

        }

       
    }

抽象类

C#抽象类与C++抽象类相似

抽象类不能被实例化 只能被继承

继承了抽象类的派生类必须实现派生类中用abstract修饰的方法

抽象类中可以定义普通方法，普通类中不能用abstract修饰函数

抽象类中不能使用private修饰符(private修饰的成员不能被继承)

     abstract class A
        {
            public abstract void Test(); //使用abstract修饰的函数只需要声明不需要函数体

        }

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

    
        static void Main(string[] args)

        {
            A a=new A();//报错 抽象类不能实例化
            B b=new B();
             b.Test();
        }