黑马程序员《.NET 方法》

------- Windows Phone 7手机开发、.Net培训、期待与您交流！ -------

(1)关于常量

定义常量的语句：const 数据类型 常量名称=值；

何为常量？

常量在程序的运行过程中是不会发生变化的量，如果在程序中强制修改它的值就会发生错误。如果想要修改它，只能在定义是修改。

常量的命名规范：常量的名称必须具有一定的实际意义。常量名称最好以大写字母来命名，中间可根据意义的连接性用下划线做连接，每个常量定义的右侧最好有一些简单的注释。常量名称最好不要超过25个字符，否则可读性差。

例如：const double PI=3.1415926;//定义了一个常量PI

(2)枚举

枚举的作用：

第一：限制用户不能随意赋值，只能在定义枚举时列举的值中选择

第二：不需要死记每一个值是什么，只需要选择相应的值

注意：

定义枚举时，值不能死int类型，枚举类型的变量都可以强制转换成int类型，枚举的值在定义时是有一个默认编号的，默认编号从0开始。

命名规范：我们定义一个枚举时要列尽这个类型的所有可能的值。它的定义一般与类定义在一个级别，这样在同一命名

空间下的所有类都可以使用这个枚举了。

语法：enum 类名{值1，值2，值3......}

例如：   enum gender
    {
        男,女
    }
    class Program
    {
        static void Main(string[] args)
        {
            gender sex;
            sex = gender.男;//赋值时只能是枚举中定义的
            switch (sex)
            {
                case gender.男:
                    Console.WriteLine("男");
                    break;
                case gender.女:
                    Console.WriteLine("女");
                    break;
            }
            Console.ReadKey();

如何把一个字符串转换成枚举类型？

语法：(自定义的类型)(Enum.Parse(typeof(自定义类型),s））

s是待转换的字符串

例如：enum choice
    {
        是, 否
    }
    class Program
    {
        static void Main(string[] args)
        {
            choice input;
            Console.WriteLine("请输入您的选择");
            string s = Console.ReadLine();
            try   //异常捕捉
            {
                input = (choice)(Enum.Parse(typeof(choice), s));//枚举类型的转换
                Console.WriteLine("您的选择为：" + input);
            }
            catch  //程序一旦出错，跳进catch中执行catch代码
            {
                Console.WriteLine("您的输入有误，请重新输入");
            }
            Console.ReadKey();

(3)结构的使用

我们为什么要使用结构？

比如说我们要存储一个人的信息，包括年龄，性别，名字，我们要声明一组变量，那么当我们要存储n个人的信息时，就要声明n组变量，太麻烦，这时我们就可以使用结构。

语法：访问修饰符  struct 结构名

{

定义结构成员

}

 

例如：

 public enum Gender
    {
        男,
        女,
    }
    public struct Person //结构体的语法，访问修饰符常用public
    {
        public string name;//结构成员
        public Gender sex;
        public int age;
    }//以上定义了一个名称为person的结构

    class Program
    {
        static void Main(string[] args)
        {
            Person onePerson;//声明了一个人的变量
            onePerson.name = "张三";
            onePerson.age = 20;
            onePerson.sex = Gender.男;
            Console.WriteLine("我叫{0}，今年{1}，我是{2}性", onePerson.name,
                onePerson.age, onePerson.sex);
            Person secPerson;
            secPerson.name = "李四";
            secPerson.age = 26;
            secPerson.sex = Gender.男;
            Console.WriteLine("我叫{0}，今年{1}，我是{2}性", secPerson.name,
                   secPerson.age, secPerson.sex);
            Console.ReadKey();

(4)数组

数组可以帮我们一次声明多个类型的变量，这些变量在内存中连续存储的。

语法：数据类型[] 数组名=new 数据类型[数组长度]

我们可以通过下标（索引）来访问数组，比如我们要个数组的第一个元素赋值3，则可以写成 数组名[0]=3。

int 类型数组一旦声明，里面的每一个元素都被初始化成了0。

注意：

下面有几种写法：

int[] nums=new int[3]{5,3,8}  

int[] nums=new int[5]{5,3,8}  

int[] nums=new int[]{5,3,8}

只有第一种写法是对的，第二个声明了数组长度为5却赋了三个值，最后一个是空数组却赋了值。

(5)方法（函数）

我们为什么要定义一个方法？

当我们在一个程序中反复的写了同样的代码，那一般情况下我们可以把需要重复写的代码定义在一个方法中，用的时候只需要调用就行了，为我么编程省去了不必要的麻烦。

定义方法的语法：

访问修饰符  返回类型  方法名(参数列表)

{方法的主体}

访问修饰符：我们常用的有public  private 

返回值类型：我们编写的方法是实现专门处理的模块，可供他人调用，在调用后可以返回一个值，这个返回值的数据类型就是方法的返回类型，可以使Int float double  bool  string,如果没有返回值则用void。

方法名：每个自定义的方法都要有一个名称，方法的名称应该具有明确的定义，这样在别人调用时，就能知道明确的功能。

参数列表：调用方法时，我们可以向方法中传递参数，这些参数构成了参数列表，如果没有参数就不用参数列表。

方法的主体：方法的主体部分就是这个方法实现某一特定功能的代码，自定义方法时，应该写方法的声明，包括访问修饰符，返回类型，方法名，参数猎豹，然后再写方法的主体。

方法的命名一般用Pascal命名法，每个单词的首字母大写。

方法的调用原则：

对于静态方法，如果在同一个类中，在调用时我们直接写名字调用就行了。就是    方法名()

如果不在同一个类中，必须要写出方法所在的类名   就是   类.方法名()

下面参照一个方法的定义：

 class Program
    {
        static void Main(string[] args)
        {
            ShowUi();//调用方法，具体参考调用规则
            int[] scores = { 93, 34, 67, 86, 54, 87, 98, 53, 82 };
            for (int i = 0; i < scores.Length - 1; i++)//外层循环控制比较几趟
            {
                for (int j = 0; j < scores.Length - 1 - i; j++)//内层循环控制比较几次
                {
                    if (scores[j] > scores[j + 1])
                    {
                        int temp = 0;//负责把小的数移动到前面，如果降序排列则改为<
                        temp = scores[j];
                        scores[j] = scores[j + 1];
                        scores[j + 1] = temp;
                    }
                }
            }
            for (int i = 0; i < scores.Length; i++)
            {
                Console.WriteLine(scores[i]);
            }
            Console.ReadKey();
            Console.Clear();

            ShowUi();
            Console.WriteLine("按任意键退出");
            Console.ReadKey();

        }
        /// <summary>
        /// 用于显示软件界面的一个方法
        /// </summary>
        public static void ShowUi()
        {
            Console.WriteLine("*****************");
            Console.WriteLine("*    欢迎你     *");
            Console.WriteLine("*****************");
        }
如上所示：方法和Main方法在同一个类中，那么调用时我们直接写   方法名()  调用就行了。

(6)参数的传递

变量的作用域：在方法中定义的变量称为局部变量，其作用域从定义开始到其所在的大括号结束为止，一个变量一旦定义在方法外，类的里面，就叫做类的字段，这个变量就可以被本类的所有方法所访问，但要注意，静态方法只能访问静态字段。

调用者和被调者之间是如何传递变量的值的？

情况一：当被调用者想得到调用者方法中的变量时，则可以让调用者通过参数的形式给被调用者。

例如：//传参数的简单示例,被调用者访问调用者中的参数
        static void Main(string[] args)
        {
            int a = 3;
            Test(a);//调用者   把a传给被调用者中的a去，不会出现重复定义，因为涉及
            //到a的作用域问题   此方法中a的作用域到大括号结束就结束了
            Console.WriteLine(a);
        }
        public static void Test(int a)//被调用者    括号中的参数用于接收调用者传过来的数据
        {
            a = a + 1;
            Console.WriteLine(a);
        }

情况二：假如调用者要访问被调用者中的变量时，可以通过返回值返回，并且在调用者所在的方法中定义一个变量来接收。

例如：

//此程序是调用者访问被调用者中的参数
        static void Main(string[] args)
        {
            Console.WriteLine("您确定要关机吗？y/n");
            string s=ReadAnswer();
                if(s=="y")
            {
                Console.WriteLine("正在关机");
            }
            else
            {
                 Console.WriteLine("不关机");
            }            
        }

        public static string  ReadAnswer()   //这里的返回值类型是字符串类型，所以用string
        {
            string reasult = "";
            do
            {
                reasult = Console.ReadLine();
                if (reasult!= "y" && reasult!= "n")
                {
                    Console.WriteLine("输入有误，请重新输入");
                }
            } while (reasult != "y" && reasult!= "n");
            return reasult; 

      }
(7)方法的重载

方法重载的特点？

一般在同一个类中，方法名相同，但参数的个数或者类型不同，才能构成方法的重载。

举例来更好的理解方法重载：

我们常用的Console.WriteLine()方法，提供了输出的多种重载方法。

Console.WriteLine(1);

Console.WriteLine(2.0);

Console.WriteLine("hello");

Console.WriteLine("hello,{0}",name);

第一个方法接收一个整型参数，第二个方法接收一个浮点型参数，第三个方法接收一个参数，第四种方法接收两个参数。这就是方法重载的案例。

(8)方法中返回多个值

我们知道一个方法只能返回一个值，那么如果我们要返回多个值时该怎么办？

这里我们就需要用的out，它一般用在有多个返回值的场所。

例如： // 写一个MyTryParse 方法，要求用户传入一个字符串，如果这个字符串能转化成int类型
        //则方法返回true,并且转换后的int类型数据通过方法的参数传出，如果字符串不能转化成int类型
        //则方法返回false,那么out传出的参数将没有意义，那么在方法中随意赋一个值就行了
        static void Main(string[] args)
        {
            string s = "123";
            int re;
            if (IntTryParse(s, out re))//尝试转换并返回转换后的值
            {
                Console.WriteLine("转换成功" + re);
            }
            else
            {
                Console.WriteLine("转换失败");
            }
            Console.ReadKey();
        }
        public static bool IntTryParse(string s, out int result)//定义tryparse方法
        {
            result = 0;
            try
            {
                result = Convert.ToInt32(s);
                return true;
            }
            catch
            {
                return false;
            }
        }

 

 

总结： 易错点  难点

成员访问级别：

字段，方法，属性都可以叫做类的成员，它们都需要定义访问级别，访问级别的用处在于控制成员在那些地方可以被访问，这样达到面向对象中“封装”的目的。

public:可以在任何地方被访问

internal:只能在本项目中被访问

private:只能值本类中被访问

protected:只能在本类和子类中被访问

在一个类中定义变量或方法时，没有写访问修饰符，那么默认的访问修饰符为private，在类级别，不写访问修饰符则默认为internal。

 

out ref区别：

out用于传出值，所以方法中必须对out修饰的参数进行赋值，ref可以理解是双向的，既可以传入，也可以传出，在传参过程中，如果参数有out或ref修饰的话，那么改变方法中的参数变量的值，调用者方法中变量的值也会相应改变。

 

------- Windows Phone 7手机开发、.Net培训、期待与您交流！ -------