C#-从入门到精通-第9章 结构和类

【结构】
语法：

结构修饰符  struct  结构名
{
}

class Program
    {
        public struct Rect//定义一个矩形结构
        {
            public double width;//矩形的宽
            public double height;//矩形的高
            /// <summary>
            /// 构造函数，初始化矩形的宽和高
            /// </summary>
            /// <param name="x">矩形的宽</param>
            /// <param name="y">矩形的高</param>
            public Rect(double x, double y)
            {
                width = x;
                height = y;
            }
            /// <summary>
            /// 计算矩形面积
            /// </summary>
            /// <returns>矩形面积</returns>
            public double Area()
            {
                return width * height;
            }
        }
        static void Main(string[] args)
        {
            Rect rect1;//创建矩形结构
            rect1.width = 5;//为矩形宽赋值
            rect1.height = 3;//为矩形高赋值
            Console.WriteLine("矩形面积为：" + rect1.Area());
            Rect rect2 = new Rect(6, 4);//使用构造函数实例化矩形结构
            Console.WriteLine("矩形面积为：" + rect2.Area());
        }

    }

【构造函数】
定义一个类之后，C#就会隐式的创建一个默认的构造函数，如果想创建多个构造函数，就得把默认的构造函数显式的写出来。

class Program
    {
        public int x = 3;//定义int型变量，作为加数
        public int y = 5;//定义int型变量，作为被加数
        public int z = 0;//定义int型变量，记录加法运算的和
        public Program()
        {
            z = x + y;//在构造函数中为和赋值
        }
        static void Main(string[] args)
        {
            Program program = new Program();//使用构造函数实例化Program对象
            Console.WriteLine("结果：" + program.z);//使用实例化的Program对象输出加法运算的和
        }

    }

【析构函数】
相当于垃圾回收。
当某个类的实例被看作无效，并且满足析构条件时，就会直接调用析构函数。
一个类只能有一个析构函数，并且无法调用析构函数，他是自动调用的。

class Program
    {
        ~Program()	//析构函数
        {
            Console.WriteLine("析构函数自动调用");//输出一个字符串
        }
        static void Main(string[] args)
        {
            Program program = new Program();//实例化Program对象
        }

    }

输出结果为“析构函数自动调用”

【类的面向对象特性】
1.类的封装
以类作为数据封装的基本单位，可以使数据和方法封装成单一元素。

/// <summary>
    /// 自定义类，封装加数和被加数属性
    /// </summary>
    class MyClass
    {
        private int x = 0;//定义int型变量，作为加数
        private int y = 0;//定义int型变量，作为被加数
        /// <summary>
        /// 加数
        /// </summary>
        public int X
        {
            get
            {
                return x;
            }
            set
            {
                x = value;
            }
        }
        /// <summary>
        /// 被加数
        /// </summary>
        public int Y
        {
            get
            {
                return y;
            }
            set
            {
                y = value;
            }
        }
        /// <summary>
        /// 求和
        /// </summary>
        /// <returns>加法运算和</returns>
        public int Add()
        {
            return X + Y;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyClass myclass = new MyClass();//实例化MyClass的对象
            myclass.X = 3;//为MyClass类中的属性赋值
            myclass.Y = 5;//为MyClass类中的属性赋值
            Console.WriteLine(myclass.Add());//调用MyClass类中的Add方法求和
            Console.ReadLine();
        }
    }

2.类的继承
任何类都可以从另外一个类继承，这个类拥有它继承的类的所有成员。被继承的类称为父类或基类。C#只支持单继承不支持多重继承，多重继承由接口来实现。

/// <summary>
    /// 自定义类
    /// </summary>
    class MyClass1
    {
        private int x = 0;//定义int型变量，作为加数
        private int y = 0;//定义int型变量，作为被加数
        /// <summary>
        /// 加数
        /// </summary>
        public int X
        {
            get
            {
                return x;
            }
            set
            {
                x = value;
            }
        }
        /// <summary>
        /// 被加数
        /// </summary>
        public int Y
        {
            get
            {
                return y;
            }
            set
            {
                y = value;
            }
        }
        /// <summary>
        /// 求和
        /// </summary>
        /// <returns>加法运算和</returns>
        public int Add1()
        {
            return X + Y;
        }
    }
    /// <summary>
    /// 自定义类，该类继承自MyClass1
    /// </summary>
    class MyClass2 : MyClass1
    {
        private int z = 0;//定义int型变量，作为第二个被加数
        /// <summary>
        /// 被加数
        /// </summary>
        public int Z
        {
            get
            {
                return z;
            }
            set
            {
                z = value;
            }
        }
        /// <summary>
        /// 求和
        /// </summary>
        /// <returns>加法运算和</returns>
        public int Add2()
        {
            return X + Y + Z;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyClass1 myclass1 = new MyClass1();	//实例化MyClass1的对象
            MyClass2 myclass2 = new MyClass2();	//实例化MyClass2的对象
            myclass1.X = 3;	//为MyClass1类中的属性赋值
            myclass1.Y = 5;	//为MyClass1类中的属性赋值
            myclass2.X = 3;	//使用MyClass2类对象调用基类中的属性并赋值
            myclass2.Y = 5;	//使用MyClass2类对象调用基类中的属性并赋值
            myclass2.Z = 7;	//为MyClass2类中的属性赋值
            Console.WriteLine(myclass1.Add1());	//调用MyClass1类中的Add1方法求和
            Console.WriteLine(myclass2.Add1());	//使用MyClass2类对象调用基类中的方法
            Console.WriteLine(myclass2.Add2());	//调用MyClass2类中的Add2方法求和
        }
    }

3.类的多态
比如说一个学生类，可以有多个子类，小学生类、中学生类、大学生类等等。
这里就可以说成，小学生是学生。

class Myclass1
{
}
class Myclass2
{
}
Myclass2 c2 = new Myclass2();
Myclass1 c1 = (Myclass1)Myclass2;//使用子类的对象实例化基类的对象

这里c1其实仍然指向的是Myclass2。如果用c1调用类中的方法的话，还是调用的Myclass2中的方法。