c#中封装、继承与多态

1.封装

封装是一种将数据和方法组合到一个单元中的机制，以实现信息隐藏和访问控制的目的。在C#中，封装通过属性、访问修饰符、方法来实现。

属性是类，结构体，接口的命名成员，类或者结构体中的成员变量及方法称为域，属性是域的扩展。

public class Person
{
    //私有字段
    private string name;
    private int age;
    
    //公有属性，可读可写
    public string Name
    {
        get { return name; }
        set { name = value; }
    }
    
    //公有方法，设置年龄
    public void SetAge(int age)
    {
        this.age=age;
    }
    
    //公有方法，获取年龄
    public int GetAge()
    {
        return age;
    }
}

2.继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

 * base
 * 1.在派生类中调用基类的构造函数
 * 2.在子类中调用基类的方法
 * 3.注意：静态函数中禁止使用base关键字

c#中类只能单继承

 class Shape
    {
        protected int width;
        private int length;
        protected int Length
        {
            get { return length; }
            set { length = value; }
        }
        public Shape()
        {
            Console.WriteLine("父类构造");
        }
        public void Test1()
        {
            Console.WriteLine("父类的测试方法");
        }
    }
    class Rectangle : Shape
    {
        public int GetArea()
        {
            return Length * width;
        }
        public Rectangle(): base()//在派生类中调用基类的构造函数
        {
            Console.WriteLine("子类构造");
        }
        public void Test2()
        {
            base.Test1();//调用基类中的方法
            Console.WriteLine("子类的测试方法");
        }
    }

3.多态

多态是一种允许同一个方法在不同对象上产生不同结果的特性。在C#中，多态通过虚方法、抽象类和接口来实现。

1.动态多态

1.虚函数

在基类中声明为virtual的方法可以在派生类中通过声明为override被重写。当调用被重写的方法时，实际执行的是对应派生类的方方法

public class Shape
{
    public virtual void Read()
    {
        Console.WriteLine("这是一个图形");
    }
}

public class Circle : Shape
{
    public override void Read()
    {
        Console.WriteLine("这是圆形");
    }
}

public class Rectangle : Shape
{
    public override void Read()
    {
        Console.WriteLine("这是矩形");
    }
}

2.抽象类

         1.抽象类中方法只声明不实现，但是在子类中是必须全部实现
         2.抽象类中可以包含非抽象方法，但是抽象方法只能在抽象类中
         3.抽象类中不能使用private访问修饰符
         4.抽象类是不能被直接实例化,可以在派生类中实现实例化

   public abstract class Food
    {
        public abstract void Eat();
    }
    class Water : Food
    {
        public override void Eat()
        {
            Console.WriteLine("喝水");
        }
    }

 class Program
    {
        static void Main(string[] args)
        {
            Water w = new Water();
            w.Eat();
            Food f = new Water();//可以通过派生类间接实例化
        }
    }

3.接口

1.含义与注意事项

接口是一种定义了一组成员的类型，不包含具体的实现。一个类可以实现多个接口，并提供对应成员的具体实现。单继承类，多继承接口。

        1.接口成员是不允许有访问权限修饰符
        2.接口是不能直接实例化，但是可以间接实例化
        3.继承接口类，必须将接口中的成员全部实现，且成员名和接口中定义的名字保持一致
        4.如果一个接口继承了其他接口，那么实现的类就需要实现所有接口成员

interface IMyinterface1
    {
        int num { get; set; }
        void Method1();
    }
    interface IMyinterface2
    {
        void Method2();
    }
    class A : IMyinterface2, IMyinterface1
    {
        public void Method2()
        {
            Console.WriteLine("接口2的方法实现");
        }
        public void Method1()
        {
            Console.WriteLine("接口1的方法实现");
        }
        //接口1的属性实现
        public int num
        {
            get;
            set;
        }
    }

2.接口与抽象类的区别

相同点：

        1.都可以被继承
        2.都不能直接实例化
        3.自身不提供代码实现，具体实现在子类中进行
        4.派生类中必须实现未实现的方法

不同点：

        1.抽象类中可以定义字段，属性，方法的实现，但是接口中只能定义属性，事件，以及方法的声明，不能包含字段
        2.单继承类，多继承接口
        3.接口具有专一性，而不是多功能，否则会造成接口污染

2.静态多态

 函数重载:参数类型不同，参数的个数不同，不能重载只有返回值类型不同的函数
 运算符重载：operator

//运算符重载+举例
        public static TestData operator +(TestData t1, TestData t2)
        {
            TestData t = new TestData();
            t.num = t1.num + t2.num;
            return t;
        }

//可以重载 
+ - * / %
 ++ -- ! ~ 
 == > < >= <= !=
 
 //不能重载
 = -> . new sizeof ?: += -= *= /= %=