七、C#笔记

/// <summary>
/// 第十一章：理解参数数组
/// </summary>
namespace Chapter11
{
    class Program
    {
        static void Main(string[] args)
        {
            //11.1 回顾重载
            /*
             * 重载是指在同一作用域中声明两个或更多同名方法，适合对不同类型的实参执行相同的操作。
             * 但是没有照顾到所有的情况，发生变化的不是参数类型而是参数的数量，重载就力不从心了
             * params关键字声明参数允许只写一个方法就能接受数量可变的参数
             */

            //11.2使用数组参数
            ///11.2.1声明参数数组
            /*
             * params关键字对方法的影响是，调用该方法时，可传递任意数量的整数实参，而不必担心创建数组的问题
             */
            int min = Min(1,2);//自动把1，2变成那一个数组
            /*
             * 关于参数数组需注意：
             * 1.只能为一维数组使用params关键字，不能用于多维数组。
             * 2.不能依赖param关键字重载方法
             * 3.不允许为参数数组指定ref或out修饰符
             * 4.params数组必须是方法最后一个参数。（意味着每个方法只能有一个参数数组）
             * 5.非params方法总是优先于params方法
             */
             ///11.2.2使用params object[]
             /*
              * 这样的使用意味着任何参数都逃不出去：
              * 1.不向它传递任何实参，编译器将传递长度为0的object数组
              * 2.可以传递null作为实参
              * 3.传递一个实际的数组
              * 4.传递不同类型的实参，也会自动包装
              */
              ///11.2.3使用参数数组
              
            //11.3比较参数数组和可选参数
            /*
             * 区别：
             * 1.获取可选参数的方法仍然有固定参数列表，不能传递一组任意的实参，
             * 编译器会生成代码，在方法运行前，为任何遗漏的实参在栈上插入默认值
             * 2.使用参数数组的方法相当于有一个完全任意的参数列表，没有任何参数有默认值
             */
        }

        public static int Min(params int[] paramList)
        {
            if (paramList == null || paramList.Length == 0)
            {
                throw new ArgumentException("Util.Min:实参数量不足");
            }
            int currentMin = paramList[0];
            foreach(int i in paramList)
            {
                if (i < currentMin)
                {
                    currentMin = i;
                }
            }
            return currentMin;
        }

    }
}
 

/// <summary>
/// 第十二章：使用继承
/// </summary>
namespace Chapter12
{
    public class Program
    {
        static void Main(string[] args)
        {
            //12.1什么是继承
            //12.2使用继承
            Horse horse = new Horse("aa");
            horse.Trot();//可以调用自己的方法
            horse.Breathe();//可以调用父类的方法
            horse.SuckleYoung();
            ///12.2.1复习System.Object类（所有的类都是Object子类）
            ///12.2.2调用基类构造器
            ///12.2.3类的赋值
            //Whale whale = horse;//错误，类型不同，是同类
            Mammal mammal = horse;//合法，是基类
            ///12.2.4声明新方法
            horse.Talk();
            ///12.2.5声明虚方法
            /*
             * 虚方法用viryual关键字标记
             * object的tostring也是这样
             * （虚方法：隐藏方法在基类中实现）
             */
            ///12.2.6声明重写方法
            /*
             * 派生类用override关键字重写基类的虚方法.
             * 
             * 使用virtual和override关键字声明多态性的方法时，必须遵守以下重要规则：
             * 虚方法不能私有
             * 虚方法和重写方法的签名必须完全一致
             * 只能重写虚方法
             * 如派生类不用override关键字声明方法，就不是重写基类方法，而是隐藏方法。
             * 重写方法隐式成为虚方法，可在派生类中被重写
             */
            ///12.2.7理解受保护的访问
            /*
             *protected:
             * 如果类A派生自类B，就能访问B的受保护的成员。也就是说，在派生类A中，B的受保护成员实际是公共的。
             * 如果类A不从类B派生，就不能访问B的受保护成员。也就是说，在A中，B的受保护成员实际的私有的。
             */

            //12.3创建扩展方法
            /*
             * 扩展方法允许添加静态方法来扩展现有的类型。引用被扩展类型的数据，即可调用扩展方法。
             * 扩展方法在一个静态类中定义，被扩展类型必须是方法的第一个参数，而且必须附加this关键字                                                       
             */
            int x = 591;
            x.ConverToBase(1);//Util
        }

    }
}
 

namespace Chapter12.Mouble
{
    public class Whale:Mammal
    {
        public void Swim()
        {

        }
    }
}

namespace Chapter12.Mouble
{
    static class Util
    {
        public static int ConverToBase(this int i, int baseToConvertTo)
        {
            if (baseToConvertTo < 2 || baseToConvertTo > 10)
                throw new ArgumentException($"{baseToConvertTo.ToString()}");
            int rusult = 0;
            int iterations = 0;
            do
            {
                int nextDigit = i % baseToConvertTo;
                i /= baseToConvertTo;
                rusult += nextDigit * (int)Math.Pow(10, iterations);
                iterations++;
            }
            while (i != 0);
            return rusult;
        }
    }
}

namespace Chapter12.Mouble
{
    public class Mammal
    {
        public void Breathe()
        {

        }

        public void SuckleYoung()
        {

        }

        public void Talk()
        {

        }
    }
}
 

namespace Chapter12.Mouble
{
    public class Horse:Mammal
    {
        public void Trot() { }
        /// <summary>
        /// 12.2.2调用基类构造器
        /// </summary>
        /// <param name="name"></param>
        public Horse(String name):base()
        {
            
        }
        /// <summary>
        /// 12.2.4声明新方法
        /// 使用new关键字消除警告
        /// </summary>
        new public void Talk()//马的talk区别与别的哺乳动物
        {
            Console.WriteLine("aa");
        }
        /// <summary>
        /// 12.2.6声明重写方法
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            string temp = base.ToString();
            return base.ToString();
        }
    }

}

/// <summary>
/// 12.2使用继承
/// </summary>
namespace Chapter12.Mouble
{
    class DrivedClass: BaseClass
    {

    }
}

namespace Chapter12.Mouble
{
    class DerivedSubClass
    {
    }
}
 

namespace Chapter12.Mouble
{
    internal class BaseClass
    {
    }
}