02---Net基础加强

将普通日期格式：“2014年7月8日”转换成汉字日期格式：“二零一四年七月八日”。（暂时不考虑10日，13日，23日）

   class Program
    {
        static void Main(string[] args)
        {
            string date = "2014年7月8日";
            date = ConvertDate(date);
            Console.WriteLine(date);
            Console.ReadKey();
        }

        private static string ConvertDate(string date)  //字符串具有不可变性，不能直接修改字符串
        {
            //将字符串转换成一个真正的char数组
            char[] chs = date.ToCharArray();
            for (int i = ; i < date.Length; i++)
            {
                switch (chs[i])
                {
                    case '':
                        chs[i] = '零';
                        break;
                    case '':
                        chs[i] = '一';
                        break;
                    case '':
                        chs[i] = '二';
                        break;
                    case '':
                        chs[i] = '三';
                        break;
                    case '':
                        chs[i] = '四';
                        break;
                    case '':
                        chs[i] = '五';
                        break;
                    case '':
                        chs[i] = '六';
                        break;
                    case '':
                        chs[i] = '七';
                        break;
                    case '':
                        chs[i] = '八';
                        break;
                    case '':
                        chs[i] = '九';
                        break;
                }
            }
            //把char数组转换成字符串
            return new string(chs);
        }
    }

创建一个Person类，属性：姓名、性别、年龄；方法：SayHi() 。

 class Person
    {
        private string _name;
        public string Name
        {
            get
            {
                return _name;
            }
            set
            {
                _name = value;
            }
        }

        public bool Gender { get; set; }
        public int Age { get; set; }

        public virtual void SayHi()  //加上virtual，子类才能重写它
        {
            Console.WriteLine("Hi!!!!!!");
        }
    }

再创建一个Employee类继承Person类，扩展属性Salary，重写SayHi方法。

 class Employee:Person
    {
        public decimal salary{get;set;}

        public override void SayHi()
        {
            Console.WriteLine("重写了子类中的方法"); ;
        }
    }

请编写一个类：ItcastClass，该类中有一个私有字段_names.数据类型为字符串数组，数组长度为5，并有5个默认的姓名。要求：为ItcastClass编写一个索引器，要求该索引器能够通过下标访问_names中的内容。

  class ItcastClass
    {
        private string[] _names = { "杨中科", "苏坤", "科比" };

        public string this[int index]  //索引器
        {
            get
            {
                return _names[index];
            }

            set
            {
                _names[index] = value;
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            ItcastClass itcast = new ItcastClass();
            //Console.WriteLine(itcast._names[0]);//没有索引器的情况下得这样写！
            Console.WriteLine(itcast[]);
            Console.WriteLine(itcast[]);
            Console.ReadKey();
        }
    }

属性和索引

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

namespace _02属性和索引
{
    class Person
    {

        private string _name;
        public string Name
        {
            get {return _name ;}
            set { _name = value; }
        }

        //属性就是一个字段和两个方法
        public int Age
        {
            get;
            set;
        }
    }

    class MyClass
    {
        public string Name
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }
        public string Email
        {
            get;
            set;
        }

        //public string Item//在增加的时候不能用Item这个词   因为在索引器中它自动生成了Item属性
        //{
        //    get;
        //    set;
        //}

        public string this[int index]
        {
            get
            {
                string result = "";
                switch (index)
                {
                    case :
                        result=this.Name;
                        break;
                    case :
                        result = this.Age.ToString();
                        break;
                    case :
                        result = this.Email;
                        break;
                }
                return result;
            }
        }

        public string this[string key]   //重载
        {
            get
            {
                string result = "";
                switch (key)
                {
                    case "name":
                        result = this.Name;
                        break;
                    case "age":
                        result = this.Age.ToString();
                        break;
                    case "email":
                        result = this.Email;
                        break;
                }
                return result;
            }
        }
    }
}

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

namespace _02属性和索引
{
    class Program
    {
        static void Main(string[] args)
        {
            //MyClass mc = new MyClass();
            //mc.Name = "叶长重";
            //mc.Age = 18;
            //mc.Email = "826217795@qq.com";
            //Console.WriteLine(mc.Name);
            //Console.WriteLine(mc.Age);
            //Console.WriteLine(mc.Email);
            //Console.ReadKey();

            MyClass mc = new MyClass();
            mc.Name = "叶长重";
            mc.Age = ;
            mc.Email = "826217795@qq.com";
            Console.WriteLine(mc[]);
            Console.WriteLine(mc[]);
            Console.WriteLine(mc[]);

            Console.WriteLine(mc["name"]);
            Console.WriteLine(mc["age"]);
            Console.WriteLine(mc["email"]);

            Console.ReadKey();
        }
    }
}

编程遍历WinForm窗体上所有TextBox控件并给它赋值为“叶长种”。

  public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //控件继承Control类
            foreach (Control item in this.Controls)
            {
                //判断当前控件是否为文本框
                if (item is TextBox)
                {
                    ((TextBox)item).Text = "叶长种";
                }
            }
        }
    }

使用WinForm窗体，制作一个简单的计算器，默认值为“请选择”。要求具有+、-、*、/功能！

 public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            this.cboCaoZuoFu.SelectedIndex = ;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //校验用户选择的“操作符”
            if (cboCaoZuoFu.SelectedIndex > )
            {
                int n1 = Convert.ToInt32(txtNumber1.Text.Trim());
                int n2 = Convert.ToInt32(txtNumber2.Text.Trim());
                //int n2 = int.Parse(textBox2.Text.Trim());//这个也可以
                switch (cboCaoZuoFu.Text)
                {
                    case "+":
                        lblResult.Text = (n1 + n2).ToString();
                        break;
                    case "-":
                        lblResult.Text = (n1 - n2).ToString();
                        break;
                    case "*":
                        lblResult.Text = (n1 * n2).ToString();
                        break;
                    case "/":
                        lblResult.Text = (n1 / n2).ToString();
                        break;
                    default:
                        break;
                }
            }
            else
            {
                MessageBox.Show("请选择操作符");
            }
        }
    }

随机点名器：

     private void button2_Click(object sender, EventArgs e)
        {
            Random r = new Random();
            MessageBox.Show(r.Next(,).ToString());
        }

什么是方法重载。（方法重载1.方法名必须一致。2，方法参数列表不同）

请将字符串数组（“中国”，“美国”，“巴西”，“澳大利亚”，“加拿大”）中的内容反转，然后输出反转后的数组，不能用数组的Reverse()方法。

 class Program
    {
        static void Main(string[] args)
        {
            string[] names = { "中国", "美国", "巴西", "澳大利亚", "加拿大" };

            //Array.Reverse(names);

            ReverseArray(names);
            for (int i = ; i < names.Length; i++)  //快捷键 打上for再按Tab键
            {
                Console.WriteLine(names[i]);
            }
            Console.ReadKey();
        }

        private static void ReverseArray(string[] names) //数组本身就是引用类型，不需要返回值
        {
            for (int i = ; i < names.Length / ; i++)
            {
                string temp = names[i];
                names[i] = names[names.Length -  - i];
                names[names.Length -  - i] = temp;
            }
        }
    }

.net程序基本编写、执行流程(c#)

          1>编写c#代码,保存为.cs文件。
          2>通过csc.exe程序来将.cs文件编译为.net程序集（.exe或.dll）。此时的exe或dll并不是机器码（cpu不可理解）。【>csc /out:c:\a.exe c:\program.cs】
          3>程序运行时通过JIT编译（Just In Time）即时编译，将程序集编译为cpu能理解的机器码，这时cpu才能执行。（这个编译过程会与当前机器有关（根据当前机器的内存、cpu等））。ngen.exe  

面向对象（OO） 

          什么是面向对象？一种分析问题的方式（增强了程序的可扩展性）。
          面向对象三大特性：封装、继承、多态。
          什么是类？什么是对象？类和对象的区别？如何写一个汽车类？
          类是模具，创建对象的模具，抽象的。
          类是一种数据类型，用户自定义的数据类型
          类组成：字段、属性、方法、构造函数等
          对象是具体的，是类的具体实例。对象具有属性(特征)和方法(行为)
          类中包含了数据(用字段表示)与行为（用方法（函数、功能）表示，方法为一块具有名称的代码）  （先用类后有对象）

添加一个教师类和一个学生类：

 public class Teacher
    {
        //构造函数特点：1、函数名和类名完全一样 2、不能有返回值，哪怕是void 3、一般访问修饰符为public
        public Teacher()
        {

        }
        //构造函数重载
        public Teacher(string name)
        {
            this.Name = name;
        }

        public Teacher(string name, int Age)
        {
            this.Name = name;
            this.Age = Age;
        }

        public string Name { get; set; }
        public int Age { get; set; }
        public void Teach()
        {
            Console.WriteLine("上课。。。");
        }
    }

 class Student
    {
        public string Name { get; set; }
        public string SId { get; set; }
        public void shangke()
        {
            Console.WriteLine("上课。。。");
        }
    }

  class Program
    {
        static void Main(string[] args)
        {
            //当写好一个类以后就会有一个默认的无参的构造函数。
            Teacher t = new Teacher();
        }
    }

猜拳游戏：

玩家类：

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

    namespace 猜拳游戏
    {
        public class Player
        {
            //用来存储结果的属性
            public string FistName
            {
                get;
                set;
            }
            //出拳的方法  1表示剪刀 2表示石头 3表示布
            public int ShowFist(string fist)
            {
                int result = -;
                this.FistName = fist;
                switch (fist)
                {
                    case "剪刀":
                        result = ;
                        break;
                    case "石头":
                        result = ;
                        break;
                    case "布":
                        result = ;
                        break;
                }
                return result;
            }
        }
    }

计算机类：

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

    namespace 猜拳游戏
    {
        public class Computer
        {
            public string FistName
            {
                get;
                set;
            }
            //计算机的出拳方式
            public int ShowFist()
            {
                Random rdm = new Random();
                int result = rdm.Next(, );// [1,4)
                switch (result)
                {
                    case :
                        this.FistName = "剪刀";
                        break;
                    case :
                        this.FistName = "石头";
                        break;
                    case :
                        this.FistName = "布";
                        break;
                }
                return result;
            }
        }
    }

裁判类：

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

    namespace 猜拳游戏
    {
        public class CaiPan
        {
            public string PanDuanShuYing(int playerFist, int computerFist)
            {
                if (playerFist == computerFist)
                {
                    return "棋逢对手";
                }
                if (playerFist - computerFist == - || playerFist - computerFist == )
                {
                    return "恭喜你获胜";
                }
                else
                {
                    return "下次加油！";
                }
            }
        }
    } 

Form代码：

 using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Windows.Forms;

    namespace 猜拳游戏
    {
        public partial class Form1 : Form
        {
            public Form1()
            {
                InitializeComponent();
            }

            //用户单击剪刀
            private void btnjiandao_Click(object sender, EventArgs e)
            {
                // new一个玩家对象
                Player P1 = new Player();
                // 调用玩家出拳
                int playerFist = P1.ShowFist("剪刀");
                lblPlayer.Text = P1.FistName;
                // new一个计算机对象
                Computer computer = new Computer();
                //调用计算机出拳
                int computerFist = computer.ShowFist();
                lblComputer.Text = computer.FistName;
                //调用裁判
                CaiPan cp = new CaiPan();
                lblResult.Text = cp.PanDuanShuYing(playerFist, computerFist);
            }

            private void btnshitou_Click(object sender, EventArgs e)
            {
                // new一个玩家对象
                Player P1 = new Player();
                // 调用玩家出拳
                int playerFist = P1.ShowFist("石头");
                lblPlayer.Text = P1.FistName;
                // new一个计算机对象
                Computer computer = new Computer();
                //调用计算机出拳
                int computerFist = computer.ShowFist();
                lblComputer.Text = computer.FistName;
                //调用裁判
                CaiPan cp = new CaiPan();
                lblResult.Text = cp.PanDuanShuYing(playerFist, computerFist);
            }

            private void btnbu_Click(object sender, EventArgs e)
            {
                // new一个玩家对象
                Player P1 = new Player();
                // 调用玩家出拳
                int playerFist = P1.ShowFist("布");
                lblPlayer.Text = P1.FistName;
                // new一个计算机对象
                Computer computer = new Computer();
                //调用计算机出拳
                int computerFist = computer.ShowFist();
                lblComputer.Text = computer.FistName;
                //调用裁判
                CaiPan cp = new CaiPan();
                lblResult.Text = cp.PanDuanShuYing(playerFist, computerFist);
            }
        }
    }

提取方法，封装Form代码：

 using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Windows.Forms;

    namespace 猜拳游戏
    {
        public partial class Form1 : Form
        {
            public Form1()
            {
                InitializeComponent();
            }

            //用户单击剪刀
            private void btnjiandao_Click(object sender, EventArgs e)
            {
                StartGame("剪刀");
            }
            private void btnshitou_Click(object sender, EventArgs e)
            {
                StartGame("石头");
            }
            private void btnbu_Click(object sender, EventArgs e)
            {
                StartGame("布");
            }
            private void StartGame(string item)
            {
                // new一个玩家对象
                Player P1 = new Player();
                // 调用玩家出拳
                int playerFist = P1.ShowFist("item");
                lblPlayer.Text = item;
                // new一个计算机对象
                Computer computer = new Computer();
                //调用计算机出拳
                int computerFist = computer.ShowFist();
                lblComputer.Text = computer.FistName;
                //调用裁判
                CaiPan cp = new CaiPan();
                lblResult.Text = cp.PanDuanShuYing(playerFist, computerFist);
            }

        }
    }

或者把三个按钮都设置成 btnjiandao_Click事件，代码如下 同样能实现

 using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Windows.Forms;

    namespace 猜拳游戏
    {
        public partial class Form1 : Form
        {
            public Form1()
            {
                InitializeComponent();
            }

            //用户单击剪刀
            private void btnjiandao_Click(object sender, EventArgs e)
            {
                Button btn = (Button)sender;
                StartGame(btn.Text);
            }

            private void StartGame(string item)
            {
                // new一个玩家对象
                Player P1 = new Player();
                // 调用玩家出拳
                int playerFist = P1.ShowFist("item");
                lblPlayer.Text = item;
                // new一个计算机对象
                Computer computer = new Computer();
                //调用计算机出拳
                int computerFist = computer.ShowFist();
                lblComputer.Text = computer.FistName;
                //调用裁判
                CaiPan cp = new CaiPan();
                lblResult.Text = cp.PanDuanShuYing(playerFist, computerFist);
            }
        }
    }

Ctrl+Tab 快捷键切换窗口

变量作用域

  class Program
    {
        static void Main(string[] args)
        {
            M();
            M1();
            M2();
            Console.ReadKey();
        }

        static int n = ;

        private static void M()
        {
            Console.WriteLine(n);
        }

        private static void M1()
        {
            n++;
            Console.WriteLine(n);
        }

        private static void M2()
        {
            n++;
            Console.WriteLine(n);
        }
    }

上述运行结果为：10  11  12  类中成员的默认访问修饰符是 private的。

访问修饰符：  private（最严格） 、protected、internal  、protected internal 、 public

 class Program
    {
        static void Main(string[] args)
        {

        }
    }

    //类不写访问修饰符默认就是internal
    public class Person
    {

        public string Name
        {
            get;
            set;
        }

        public int Age
        {
            get;
            set;
        }

        public string Email   //protected写入保护 只能内部继承
        {
            get;
            set;
        }

        //类中的成员，默认访问修饰符为 private  其它类中访问不到
        //private 只限于当前类内部可以访问
        int x = ;

        //当前类内部以及所有的子类
        protected int y = ;

        //当前程序集内部
        internal int z = ;

        //共用
        public int zz = ;

    }

添加引用和导入命名空间   ：

第一步：添加引用（前提） 添加程序集

第二步： namespace 导入命名空间快捷键 Shift+Alt+F10     *//ctrl+e+d(格式化代码)

为什么在另一个项目中建的类，添加引用后还是不能使用？（类中的访问修饰符默认：internal改为public）

“参数”与“返回值”

参数的个数，类型与返回值没有任何半毛钱关系！

变量作用域

大括号之内有效

函数内部声明的变量，（局部变量）使用之前，必须声明并且赋值！ 类的成员变量有默认值的，数字类型是0，引用类型是null，布尔类型是false

构造函数

构造函数的命名必须和类名完全相同，而一般方法则不能和类名相同。构造函数是在创建给定类型的对象时执行的类方法。构造函数具有与类相同的名称，它通常初始化新对象的数据成员。

封装

类和对象本身就是封装的体现

1.属性封装了字段

2.方法的多个参数封装成了一个对象

3.一大堆代码封装到了一个方法中

4.将一些功能封装到几个类中

5.将一些具有相同功能的代码封装到了一个程序集种（dll、exe），并且对外提供统一的接口。（属性名，方法名等.）

    class Program
    {
        static void Main(string[] args)
        {
            MyClass mc = new MyClass();
            //mc.Name = "aaaaaaaaaa";
        }

        class MyClass
        {
            private int _age;

            private string _name;

            public string Name
            {
                get
                {
                    if (_age > )
                    {
                        return _name;
                    }
                    return "太小了没有名字，Baby";
                }
                set
                {
                    if (value.Length > )
                    {
                        throw new Exception("名字太长");
                    }
                    else
                    {
                        _name = value;
                    }
                }
            }
        }
    }

封装的稳定性

 class Program
    {
        static void Main(string[] args)
        {
            MyClass mc = new MyClass();
            mc.Name = "叶长种";
            Console.WriteLine(mc.Name);
            Console.ReadKey();
        }

        class MyClass
        {
            private int _age = ;

            private string _name;

            public string Name
            {
                get
                {
                    if (_age > )
                    {
                        return File.ReadAllText("uname.txt");
                    }
                    return "太小了没有名字，Baby";
                }
                set
                {
                    if (value.Length > )
                    {
                        throw new Exception("名字太长");
                    }
                    else
                    {
                        File.WriteAllText("uname.txt", value);
                    }
                }
            }
        }
    }

继承

继承是类与类之间的关系   判断是否合理：子类 is a 父类    子类是父类的扩展    好处代码重用

单根性：一个子类只能有一个父类

传递性：多级继承

BaseClass->基类   Parent Class ->父类

DerivedClass->派生类  ChildClass -> 子类      derived英 [di'raivd]

在实例化子类对象时，会调用子类构造函数，但是在调用子类构造函数前，会调用父类的构造函数（默认情况下会调用父类中无参数的构造函数。）

构造函数不能被继承。解决办法1.在父类中始终拥有一个无参数的构造函数。2.在子类中手动调用父类中的某个构造函数 {：base（） }

举例:

 class Program
    {
        static void Main(string[] args)
        {
            Son son = new Son("hhh", , "A");
            Daughter daughter = new Daughter("ttt", , "B");
            Console.WriteLine(son.LastName);
            Console.ReadKey();
        }
    }

    public class Father
    {
        public Father(string lastName, double property, string bloodType) //构造函数
        {
            this.LastName = lastName;
            this.Property = property;
            this.BloodType = bloodType;

        }
        public string LastName
        {
            get;
            set;
        }

        public double Property
        {
            get;
            set;
        }

        public string BloodType
        {
            get;
            set;
        }

    }

    public class Son : Father
    {
        public Son(string lastName, double property, string bloodType)
            : base(lastName, property, bloodType)
        {

        }
        public void PlayGame()
        {
            Console.WriteLine("游戏中......");
        }
    }

    public class Daughter : Father
    {
        public Daughter(string lastName, double property, string bloodType)
            : base(lastName, property, bloodType)
        {

        }
        public void Dance()
        {
            Console.WriteLine("跳舞中......");
        }
    }

举例：

  class Program
    {
        static void Main(string[] args)
        {

        }
    }

    public class Vehicle //汽车
    {

        public string Brand
        {
            get;
            set;
        }

        public double Color
        {
            get;
            set;
        }

        public void Run()
        {

            Console.WriteLine("汽车在行驶中。。。。。");
        }

    }

    public class Truck : Vehicle //卡车
    {

        public double Weight
        {
            get;
            set;
        }
        public void LaHuo()
        {
            Console.WriteLine("拉货中......");
        }
    }

    public class Car : Vehicle //轿车
    {

        public int Passenger
        {
            get;
            set;
        }
        public void ZaiHuo()
        {
            Console.WriteLine("载货......");
        }
    }

访问级别约束

 class Program
    {
        static void Main(string[] args)
        {
            Student stu = new Student();
            stu.Name = "叶长种";
            Console.WriteLine(stu.Name);
            Console.ReadKey();
        }
    }

    class Person //  父类默认为 private  父类不能比子类的可访问性低，此种情况会出错
    {

        public string Name
        {
            get;
            set;
        }
    }
    public class Student : Person  //
    {

    }

访问级别约束

  class Program
    {
        static void Main(string[] args)
        {

        }
    }

    class Person
    {

        public string Name
        {
            get;
            set;
        }
    }
    public class MyClass  // 与上面会出现同样的问题 可访问性不一致
    {
        public void Say(Person per)
        { Console.WriteLine(per.Name); }
    }

访问级别约束

  class Program
    {
        static void Main(string[] args)
        {

        }
    }

    class Person
    {

        public string Name
        {
            get;
            set;
        }
    }
    public class MyClass  // 与上面会出现同样的问题 可访问性不一致
    {
        public Person Say()
        {
            return new Person();
        }
    }

通过继承实现多态   override(子类重新父类) overload(方法重载，一个类中多个重名的方法)   关键字sealed不能被继承

  class Program
    {
        static void Main(string[] args)
        {
            //里氏替换原则
            //Person p = new Person();
            //Chinese cn = new Chinese();

            //需要一个父类类型对象，可以赋值一个子类对象，这样可以，叫做：“里氏替换”，但反过来不可以
            //Person p = new Chinese();

            //但是,下面可以
            //Person p = new Chinese("叶长种");
            //Chinese cn =(Chinese) p;
            //Console.WriteLine(cn.Name);
            //Console.ReadKey();

            //下面不可以，显示为空，因为类型转换必须保证p对象确实是一个Chinese类型对象才行
            //Person p = new Person();
            //p.Name = "叶长重";
            //Chinese cn = (Chinese)p;
            //Console.WriteLine(cn.Name);
            //Console.ReadKey();
        }
    }

    public class Person
    {

        public string Name
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }
        public string Email
        {
            get;
            set;
        }

    }
    public class Chinese : Person  // 与上面会出现同样的问题 可访问性不一致
    {
        public Chinese(string name)
        {
            this.Name = name;
        }
        public string HuKou
        {
            get;
            set;
        }
    }