c#学习随笔

using System;                       //导入命名空间system中的类
using System.Collections.Generic;   //导入System.Collections.Generic中的类
using System.Linq;
using System.Text;
using System.Threading.Tasks;     
//using 导入命名空间  
//使用微软提供的命名空间,使用里面的类









namespace CShapeDemo    //命名空间CShapeDemo 包含了Program 等若干个类
{


    //接口类
    interface ICatchMice
    {
        void CatchMice();//默认是public ,且不能被private protected限定
    }

    interface IClimbTree
    {
        void ClimbTree();
    }


   abstract public class Pet                                    //父类,当包含abstract时,类也要定义成abstract类
    {
        //构造函数
        public Pet()
        {
        }

        public Pet(string tempName)
        {
            this.name = tempName;
        }


        //行为
        public void printname()
        {
            Console.WriteLine("Pet's name is " + name);
        }

        //重载
        virtual public void Speek() //父类的虚函数
        {
            Console.WriteLine("Pet is Speaking !");
        }

        abstract public void Speek2();//抽象方法


        //非静态数据
        protected string name;

    }


    public class Dog : Pet,ICatchMice,IClimbTree            //子类只能继承1个基类,但是可以继承多个接口类
    {
        //构造函数
        public Dog(string name) : base(name)                // base(name)   是基类的构造函数... 根据参数的类型和个数可以选择不同的父类构造函数
        {
            Num++;//静态计数器
        }

        new public void printname()                         //new 表示子类的这个函数和父类的函数重名,是个签名函数...有没有new都可以实现隐藏...最好是加上new
        {
            Console.WriteLine("宠物的 name is " + name);
        }
        //静态构造函数 :只负责初始化静态成员的数据
        static Dog()                                        //静态构造函数不能加public
        {
            Num = 0;
        }
        //静态函数
        static public void ShowAllDogNum()
        {
            Console.WriteLine("一共创建了{0}个狗", Num);
        }



        //重写                                               //多态会重写,实现子类的差异化
        public override void Speek()                        // public override   和 override public 是同一个意思 就像 const int 一样
        {
           // base.Speek();
            Console.WriteLine("狗叫");
        }

        //抽象方法
       sealed public override void Speek2()                       //抽象方法在子类必须用override关键字实现,实现差异化
        {
            Console.WriteLine("狗子在叫呢");                       //sealed关键字表示该方法被继承的时候,也不允许Dog的子类重写它
        }


        //接口类的方法必须要实现,且 用public修饰
        public void CatchMice()
       {
           Console.WriteLine("老子是狗,不会捉老鼠的");
       }
        public void ClimbTree()
        {
            Console.WriteLine("老子是狗,也不会爬树呀");
        }



        //静态数据
        static int Num;


        //自定义转换
        public static implicit operator Cat(Dog dog)                    //public static implicit operator 特定写法,隐式转换
        {
            //把狗转换成了猫了

            return new Cat(dog.name);
        }


        //委托
        public void WagTail()
        {
            Console.WriteLine("狗狗摇尾巴");
        }
    }

    public class Labrador : Dog
    {
        public Labrador(string name) : base(name)
        {

        }

    }


    //扩展类
    static class PetGuide
    {
        //this+类名A 大概就是 这个函数就像A里面的方法一样,这就是扩展类的含义咯
        static public void HowToFeedDog(this Dog dog)               // this+ 类名的写法  :特定写法
        {
            Console.WriteLine("-------------------");
        }
    }

    public class Cat : Pet
    {
        override public void Speek()       
        {
            //base.Speek();
            Console.WriteLine("猫叫");
        }

        //构造函数
        public Cat(string name) : base(name) 
        {
        }

        //抽象方法
        override public void Speek2()
        {
            Console.WriteLine("猫也会叫了");
        }

        

        //隐式转换
        public static explicit operator Dog(Cat cat)
        {
            return new Dog(cat.name);
        }

        //委托
        public void Innocent()
        {
            Console.WriteLine("傻猫在发呆呢");
        }
    }


    class Program   //类名
    {
        //委托
        delegate void ActCute();


        static void Main(string[] args)
        {
            //多态
            //Pet dog = new Dog();   //父类引用指向 子类对象
            //dog.name = "Hello";
            //dog.printname();
            //dog.Speek();

            //Pet cat = new Cat();
            //cat.name = "World";
            //cat.printname();
            //cat.Speek();

            /////////////////////////////改进方法
            Pet[] pets = new Pet[] { new Dog("Jack"), new Cat("Tom") };     //子类对象 被 父类对象引用
            for (int i = 0; i < pets.Length; i++)
            {
                pets[i].printname();
                pets[i].Speek();
                pets[i].Speek2();
            }



            Dog dog = new Dog("nima");
            dog.CatchMice();
            dog.ClimbTree();

            ICatchMice obj = (ICatchMice)dog;   //子类对象转化成 接口对象
            obj.CatchMice();

            IClimbTree obj2 = (IClimbTree)dog;  //子类对象转化成 接口对象
            obj2.ClimbTree();

            Dog.ShowAllDogNum();//通过类名直接调用静态函数

            Dog dog3 = new Dog("dog3");
            dog3.HowToFeedDog();//使用扩展类的方法



            //测试装箱 , 并且可以验证出这是2个独立的对象,互不影响
            {
                int i = 3;
                object oi = i;                                     //隐式转换
                Console.WriteLine("{0},{1}", i, oi);

                i = 4;
                Console.WriteLine("{0},{1}", i, oi);

                oi = 10;
                Console.WriteLine("{0},{1}", i, oi);

            }

            //拆箱
            {
                int i = 3;
                object oi = i;

                int j = (int)oi;                                    //显式转换
                Console.WriteLine("{0},{1},{2}", i, oi, j);


                i = 11;
                oi = 22;
                j = 33;
                Console.WriteLine("{0},{1},{2}", i, oi, j);
            }





            {
                //自定义转换  :　转换自定义的结构或类

                Dog dog4 = new Dog("Jack");
                dog4.Speek();

                Cat cat4 = dog; //把dog类型转换成了cat类型
                cat4.Speek();


                Dog dog5 = (Dog)cat4;
                dog3.Speek();

            }





            {
                //集合 : 就相当于c++中的stl


                //数组
                List<Dog> list = new List<Dog>();
                list.Add(new Dog("A"));
                list.Add(new Dog("B"));
                list.Add(new Dog("C"));

                list.RemoveAt(1);
                for(int i=0;i<list.Count;++i)
                {

                    list[i].printname();
                }
                list.Clear();



                Console.WriteLine("map---------------");
                //map
                Dictionary<string, Dog> dic = new Dictionary<string, Dog>();
                dic.Add("A",new Dog("A"));
                dic.Add("B",new Dog("B"));
                dic.Add("C",new Dog("C"));

                dic["A"].printname();



                Console.WriteLine("栈---------------");
                //stack 栈  <特点:  先进后出,后进先出> 像羽毛球桶,一边开口
                //出栈  就是出来
                //入栈  就是进去
                //栈顶 
                Stack<Pet> stack = new Stack<Pet>();
                stack.Push(new Dog("A"));
                stack.Push(new Cat("B"));                       //进栈

                stack.Peek().printname();   //获取栈顶信息   
                stack.Pop();                                    //出栈
                stack.Peek().printname();


                Console.WriteLine("队列---------------");
                //队列 <特点: 先进先出>  自来水管,2头开口
                Queue<Pet> queue = new Queue<Pet>();
                queue.Enqueue(new Dog("a"));                     //入队
                queue.Enqueue(new Dog("b"));
                queue.Enqueue(new Dog("c"));

                Pet pet = null;
                pet = queue.Dequeue();                          //出队
                pet.printname();
                pet = queue.Dequeue();
                pet.printname();
                pet = queue.Dequeue();
                pet.printname();
               
            }




            
            {
                Console.WriteLine("队列---------------");
                //委托
                ActCute del = null;
                Dog dog11 = new Dog("A");
                Cat cat11 = new Cat("B");

                del = dog11.WagTail;
                del += cat11.Innocent;  //这里是追加的操作,类似 c++的 <<操作符


                del += () =>
                {
                    //Console.WriteLine("匿名方法---------------");
                   // Console.WriteLine("lambada表达式---------------");
                    Console.WriteLine("do nothing ...这特么的就是 匿名方法和lambada表达式的结合体?");
                };

                del();

            }



            {
                Console.WriteLine("事件---------------");
                //事件
                //发布者:通知某件事情发生的,就是发布者           我发布了微博
                //订阅者:对某事关注的,就是订阅者                 我关注了微博


                //事件触发和注册
                //事件发生时,会通知所有关注该事件的订阅者
                //想在事件发生时被通知,必须注册以表示关注






            }



            //Ctrl+F5 等于c++的 system("pause");
            Console.ReadKey();//这个也相当于是 system("pause");
        }
    }
}