C#入门记录08

结构和类

 结构：
    在结构声明中，除非字段被声明为const或者static， 否则无法初始化
    定义： 结构修饰符 struct 结构名{ }
    不支持继承

    类的定义：修饰符 class 类名
 类的修饰符：
    new : 仅允许在嵌套类声明时使用，表明类中隐藏了由基类中继承而来的、与基类中同名的成员
    public: 不限制对该类的访问
    protected：只能从其所在类和所在类的子类（派生类）进行访问
    internal: 只有其所在类才能访问
    private:只有.Net中的应用程序或库才能访问
    abstract：抽象类 不允许建立类的实例
    sealed:密封类，不允许被继承

注意：
    在没有对类进行实例化之前，无法用类名调用类中的方法或字段

类的多态：
    多态使子类的实例可以直接赋予基类的变量，然后直接就可以通过这个变量调用子类的方法
    C#中 类的多态性是通过在子类中重载基类的虚方法或函数成员来试下的

注意：
    virtual修饰符不能与private,Static,abstract或者override修饰符同时使用
    override修饰符 不能与 new, static, virtual修饰符同时使用，并且重写方法只能用于重写基类中的虚方法
    C#中 继承 虚方法 和 重写 结合在一起才能实现多态

    类支持单继承

看详细的实例代码：

/*
 2020-3-6 14:15:27
 结构和类

 结构：
    在结构声明中，除非字段被声明为const或者static， 否则无法初始化
    定义： 结构修饰符 struct 结构名{ }
    不支持继承


    类的定义：修饰符 class 类名
 类的修饰符：
    new : 仅允许在嵌套类声明时使用，表明类中隐藏了由基类中继承而来的、与基类中同名的成员
    public: 不限制对该类的访问
    protected：只能从其所在类和所在类的子类（派生类）进行访问
    internal: 只有其所在类才能访问
    private:只有.Net中的应用程序或库才能访问
    abstract：抽象类 不允许建立类的实例
    sealed:密封类，不允许被继承

注意：
    在没有对类进行实例化之前，无法用类名调用类中的方法或字段

类的多态：
    多态使子类的实例可以直接赋予基类的变量，然后直接就可以通过这个变量调用子类的方法
    C#中 类的多态性是通过在子类中重载基类的虚方法或函数成员来试下的

注意：
    virtual修饰符不能与private,Static,abstract或者override修饰符同时使用
    override修饰符 不能与 new, static, virtual修饰符同时使用，并且重写方法只能用于重写基类中的虚方法
    C#中 继承 虚方法 和 重写 结合在一起才能实现多态

    类支持单继承

 */

using System;
using James_Struct;
using James_Class;

namespace ConsoleApp8
{
    class Program
    {
        static void Main(string[] args)
        {
            //TestStructFunc();

            //TestJames_Class();

            TestJames_Class2();

            Console.ReadKey();

            //Console.WriteLine("Hello World!");
        }

        static void TestStructFunc()
        {
            Rect rect;
            rect.width = 5;
            rect.height = 3;
            Console.WriteLine("矩形的面积为：{0}", rect.Area());

            Rect rect2 = new Rect(6, 4);
            Console.WriteLine("矩形的面积为：{0}", rect2.Area());

        }

        static void TestJames_Class()
        {
            Cars car = new Cars();  //这里构造函数已经执行了

            Car2 car2 = new Car2();
            Console.WriteLine(car2.Add());


        }

        static void TestJames_Class2()  //测试下多态
        {
            MyClass2 c1 = new MyClass2();   //实例化MyClass2
            MyClass1 c2 = (MyClass1)c1;     //子类的对象 实例化 基类对象
            c2.X = 3;
            c2.Y = 5;

            Console.WriteLine(c2.Add());    //因为子类重写了Add方法 实际上还是调用的子类的Add方法 所以结果为14 不是8
            Console.WriteLine(c1.Add());
          
            /*
             当子类从基类继承时，它会获得基类的所有方法、字段、属性和事件。
             若要更改基类的数据和行为，有两种选择
                1、使用新的派生类成员替换基类成员
                2、重写虚拟的基成员

             */
        }

    }
}

namespace James_Struct
{
    public struct Rect
    {
        public double width;
        public double height;
        public Rect(double x, double y) //构造函数
        {
            width = x;
            height = y;
        }

        public double Area()
        {
            return width * height;
        }
    }
}

namespace James_Class
{
    public class Cars
    {
        public int number = 100;
        public string color = "blue";
        private string brand = "JamesFactory";

        public Cars()
        {
            Console.WriteLine("执行构造函数");
            Console.WriteLine(number);
            Console.WriteLine(color);
            Console.WriteLine(brand);
        }
    }

    class Car2 : Cars
    {
        private string brand2;

        public int Add()
        {
            return number;
        }
    }

    //类的多态 概念
    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 virtual int Add()
        {
            return X + Y;
        }
    }

    class MyClass2 : MyClass1
    {
        //不能重写非虚方法或静态方法。重写的基方法必须是 virtual、abstract 或 override 的
        /*public override int Add()   //通过override方法 可以重新实现基类中的方法 也就是重写 基 方法
        {
            int x = 7;
            int y = 7;
            return x + y;
        }*/

        public new int Add()
        {
            int x = 7;
            int y = 7;
            return x + y;
        }
    }

}