C#基础-6

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Wrox4

{
    //继承
    //面向对象有三个重要的概念：继承   封装  多态性


    //继承的类型
    //单重继承：表示一个类可以派生自一个基类
    //多重继承：允许一个类派生自多个类，C#不支持这种，但是它允许接口的多重继承
    //多层继承：允许继承更大的层次结构。类B派生自类A，类C派生自类B，其中类B也称为中间基类
    //接口继承:定义了接口的继承，允许多重继承


    //C#不支持多重继承，但是可以派生自多个接口，因为System.Object是一个公共的基类，它们都有一个基类，有任意多个接口


    //结构是不支持继承的，但是它是派生自System.ValueType的，可以实现接口继承
    //类派生自Object或者自己定义的，还可以继承多个接口



    //实现继承

    //声明派生自另一个类的一个类
    class MyBaseClass
    {
        //
    }
    class MyDerivedClass : MyBaseClass
    {
        //
    }
    //如果派生自接口
    //public class MyDerivedClass1 : MyBaseClass, IInterface1{}



    //d对于结构只能用于接口继承
    //如果类和接口都用于派生，则类必须放在接口的前面
    //如果没有指定基类，那么编译器会假定System.Object是基类
    public  class Position
    {
        public int x { get; set; }
        public int y { get; set; }
    }
    public class Size 
    {
        public int Width { get; set; }
        public int Height { get; set; }
    }
    public class Shape1
    {
        public Position Position { get;  }= new Position();
        public Size Size { get;  }=new Size();
    }
    public class Draw
    {
        public int x { get; set; }
        public int Y { get; set; }
    }

    //虚方法
    //把一个基类方法声明为virtual，就可以在任何派生类中重写该方法
    public class Shape :Shape1
    {
       
        

        public virtual void Draw()=>
        
            Console.WriteLine($"Shape with {Position}and{Size}");
        
        public virtual Size Size { get; set; }
        private Size _size
        {
            get => _size;
            set => _size = value;   
        }
    }

    //C#中在派生类的函数重写另一个函数时，要使用override显示声明
    public class Rectangle : Shape
    {
              
        public override void Draw() =>
            Console.WriteLine($"Rectangle with {Position}and{Size}");
    }
    //成员字段和静态函数不能声明为virtual，它只对类中的实例函数成员有意义




    //多态性
    //使用多态性就可以动态地定义调用地方法，而不是在编译期间定义。vtable编译器创建一个虚拟方法，列出可以在运行期间调用地方法，根据运行期间地类型调用
    class fex1
    {
        public class Position
        {
            public int x { get; set; }
            public int y { get; set; }
            public override string ToString()=> $"{x} {y}";

        }
        public class Size
        {
            public int Width { get; set; }
            public int Height { get; set; }
            public override string ToString()=> $"{Width} {Height}";
        }
        public static void DrawShape(Shape shape) => shape.Draw();

        //DrawShape(r);
    }
    //隐藏方法
    //签名相同的方法在基类和派生类中都进行了声明，但该方法没有分别声明为virtual和override
    //派生类方法就会隐藏基类方法
    class fex2
    {
    

        public class Shape
        {
            
        }
        public class Ellipse : Shape
        {
            public void MoveBy(int x,int y)
            {
                //Position.x += x;
               // Position.y += y;

            }
        }
    }
    //抽象类和抽象方法
    //abstract 抽象类不能实例化，而抽象方法不能直接实现，必须在非抽象的派生类中重写
    class fex3
    {
        class fex4
        {
            public abstract class Shape
            {
               
                public abstract void Resize(int width, int height);
                //public void Resize(float width, float height)
                int result;
               
            }

        }
        
        //从抽象类中派生类别时，需要实现所有抽象成员
        public class Ellipse : Shape
        {
            fex4 fex123 = new fex4();
            public override void Resize(int width, int height)
            {
                Size.Width = width;
                Size.Height = height;

            }
        }
        Shape S1 = new Ellipse();
    }


    //密封类和密封方法
    //如果不应创建派生自某个自定义类的类，那么就应密封，给类添加sealed，不允许创建子类
    sealed class FinalClass
    {
        //
    }
    class DerivedClass : FinalClass
    {
        //
    }
    //sealed不能派生类，提高性能
    class Myclass : MyBaseClass
    {
        //public sealed override void FinaMethod();

    }
    class DerivedClass1 : Myclass
    {
        public override void FinaMethod();
    }
    //要在方法或属性上使用sealed，必须先从基类上把它声明为要重写的方法或属性


    //修饰符
    //public :任何代码都可以访问‘
    //peotected :只有派生类才能访问
    //internal:只能包含它的程序集才能访问
    //private:只能在它所属的类型中访问
    //protected internal:只能在包含它的程序集和派生类型的代码中访问
    //private protected :只允许访问同一程序集中的派生类型，不允许访问其他程序集中的派生类型


    

}