深入.NET平台和C#编程

            Dictionary<string, Book> bic = new Dictionary<string, Book>();
            Book b1 = new Book();
            b1.Name = "小明";
            b1.Score = 10;
            Book b2 = new Book();
            b2.Name = "夏红";
            b2.Score = 100;
            bic.Add("1",b1);
            bic.Add("2", b2);
            foreach (KeyValuePair<string,Book> item in bic)
            {
                Console.WriteLine(item.Key+"\t"+item.Value.Name);
            }
            Console.ReadKey();

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

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            Peole p = new Peole();
            p.Name = "小黄";
            Peole[] ps = new Peole[3];
            ps[0] = p;
        }
    }
}

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

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            int num = 5;//值类型
            //装箱  装换引用类型
            Object obj = num;
            //拆箱
            int result = (int)obj;
            //不能互换,结论ExecuteScalar() Object  Convert.ToInt32();
        }
    }
}

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

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            string str = "今天天气怎样";
            Change(str);
            Console.WriteLine(str);
        }

        private static void Change(string str)
        {
            str += "今天天气不错";
        }
       //加上ref也能改变
    }
}

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

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

            ArrayList list = new ArrayList();
            list.Add("小明");
            list.Add("小明");
            list.Add(1);
            //修改数据
            list[2] = "小红";
            //因为Add方法的参数是Object类型，所以可以添加任何类型的数据
            foreach (string item in list)
            {
                //里氏替换原则
                Console.WriteLine(item);
            }
            //删除集合中的元素
            list.Remove("小红");//按对象删除
            list.RemoveAt(1);//按索引删除
            list.Clear();//全部清除
            Console.ReadKey();
        }
    }
}

//单列：ArrayList
        //Add(Object):可以添加任何类型的数据
        //引发的问题：当我们遍历时，除非将单个元素的类型写成Object
        //Remove(真实的元素本身Object)
        //--根据索引删除RemoveAt(int index);
        //--特性：集合中的元素被删除后，索引会自动维护

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

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

            #region ArrayList
            //ArrayList list = new ArrayList();
            //list.Add("小明");
            //list.Add("小明");
            //list.Add(1);
            ////修改数据
            //list[2] = "小红";
            ////因为Add方法的参数是Object类型，所以可以添加任何类型的数据
            //foreach (string item in list)
            //{
            //    //里氏替换原则
            //    Console.WriteLine(item);
            //}
            ////删除集合中的元素
            //list.Remove("小红");//按对象删除
            //list.RemoveAt(1);//按索引删除
            //list.Clear();//全部清除
            //Console.ReadKey(); 
            #endregion
            #region HashTable
            //Hashtable table = new Hashtable();
            //Student stu = new Student();
            //stu.Name = "小明";
            //stu.Age = 10;
            //table.Add(stu.Name,stu);
            ////只能按key去删除一项 而不能通过下标删除
            //table.Remove(stu.Name);
            ////方案一：通过Key遍历
            //foreach (Object key in table.Keys)
            //{
            //    //Student st = (Student)item;
            //    //Console.WriteLine(item);
            //    Console.WriteLine("Key是"+key);
            //    Student st = (Student)table[key];
            //    Console.WriteLine(st.Age);
            //}
            ////方案二：
            //foreach (Student stu1 in table.Values)
            //{
            //    Console.WriteLine(stu1.Name);
            //}
            ////方案三  key和value看成一个整体  面向的就是table
            //foreach (DictionaryEntry item in table)
            //{
            //    Console.WriteLine(item.Key+""+((Student)item.Value).Name);
            //}
            ////点右键快速监视  查看数据类型的方法
            ////修改数据
            //foreach (string  key in table)
            //{
            //    if (key.Equals("小红"))
            //    {
            //        //修改年龄
            //        Student s = (Student)table[key];
            //        s.Age = 1000;
            //        break;
            //    }
            //}
            ////迭代变量不能改变  只能改变其值 因为改的是迭代变量item的值
            ////而不是和数组相关的某个下标对应的值

            //Console.ReadKey();
            #endregion
            #region 集合自动扩容
            //ArrayList list = new ArrayList();
            //Console.WriteLine("集合中的容量"+list.Capacity);//容量
            //Console.WriteLine("集合中元素的个数"+list.Count);
            ////1.如果集合中元素的个数为0，并没有开辟空间
            ////2.默认如果集合中出现了第一个元素，那么集合的大小4，如果放入第5个元素
            ////那么扩容成8  --->+3
            ////3.如果在小括号中首次定义的时候指定了集合的长度
            ////那么以后扩容的方式变成初次制定数字大小的2倍；
            ////如果没有指定长度，那么遵循更规范
            //Console.ReadKey();
            #endregion
            #region 三元表达式
            int a = 2 == 2 ? 1 : 2;
            #endregion
            #region 集合初始化器
            //ArrayList list = new ArrayList() {"1","2" };
            //ArrayList list2 = new ArrayList() { new Student() {Name="小明",Age=10 }, new Student() { Name = "小行", Age = 10 } };
            //Student stu = new Student() {Name="小红",Age=10};
            #endregion
            #region 泛型单列集合
            ////启动调试F5 开始执行(不调式)Ctrl+F5 一个是最新的文件  一个是上一个文件 
            //List<string> list = new List<string>();
            //list.Add("小行");
            //foreach (string item in list)
            //{
            //    //一个item代表一个集合
            //    Console.WriteLine(item);
            //}
            ////删除 集合中的元素
            //foreach (string item in list)
            //{
            //    if (list.Contains("小红"))//包含
            //    {
            //        list.Clear();
            //        Console.WriteLine("有");
            //    }
            //    else
            //    {
            //        Console.WriteLine("没有");
            //    }

            //}
            #endregion
            #region 泛型双列集合
            Dictionary<string, Student> dic = new Dictionary<string, Student>();
            Student stu = new Student() {Name="小红",Age=10 };
            dic.Add(stu.Name,stu);
            //快速监视查找数据类型--->设置断点-->启动-->选中item-->点右键-->快速监视-->打开窗口找数据类型
            foreach (KeyValuePair<string,Student> item in dic)
            {
                Console.WriteLine(item.Key);
                Console.WriteLine(item.Value.Name);
            }

            #endregion
        }
        
    }
}

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

namespace CASE
{
   public  class dianshi
    {
       public bool isStrat = false;

       //打开的方法
       public void open()
       {
           if (isStrat==false)
           {
               Console.WriteLine("电视以打开");
               isStrat = true;
           }
       }
       //调平的方法
       public void yuong()
       {
           if (isStrat==true)
           {
               Console.WriteLine("电视以调平");
           }
       }
       
       //关闭的方法
       public void close()
       {
           if (isStrat)
           {
               Console.WriteLine("电视以关闭");
           }
       }
    }
}

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

namespace CASE
{
    public class yaokongqi
    {
        //关联绑定电视的状态交互
        //打开
        public void open(dianshi a)
        {
            a.open();
        }
        //挑台
        public void tiaotio(dianshi a)
        {
            a.yuong();
        }
        //关闭
        public void close(dianshi a)
        {
            a.close();
        }
    }
}

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

namespace CASE
{
    public class Program
    {
       
       public static void Main(string[] args)
        {
           //买电视
            dianshi a = new dianshi();
           //买遥控器
            yaokongqi b = new yaokongqi();
           //一系列的遥控器和电视之间的交互
             b.open(a);
             b.tiaotio(a);
             b.close(a);
             Console.ReadKey();
           
        }
    }
}

public class Preson
{
  public Preson()
  {
  }
  public Preson(string name,ing age)
  {
  this.Name=name;
  this.Age=age;
  }
}
public class Student:Preson
{
    public Student()
    {
    }
    //调用父类的构造
    public Student(string name,int age):base(name,age)
    {
    //this.Name=name;
    //this.Age=age;
      this.Sex=sex;
    }

}

new 子类底层原理
1.走到子类构造，不进入构造体
2.转向父类，进入父类构造体执行
3.转向子类构造，执行子类构造体
4.转到Main ,内存中构建出子类对象

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

namespace 联系
{
    public class Person
    {
        public virtual void SayHello()
        {
            Console.WriteLine("你好");
        }
    }
}

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

namespace 联系
{
    public class Chinses:Person
    {
        public override void SayHello()
        {
            Console.WriteLine("中国人你好");
        }
    }
}

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

namespace 联系
{
    public  class Use:Person
    {
        public override void SayHello()
        {
            Console.WriteLine("美国人Hello");
        }

    }
}

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

namespace 联系
{
    class Program
    {
        static void Main(string[] args)
        {
            List<Person> list = new List<Person>();
            Chinses chn = new Chinses();
            Use use = new Use();
            list.Add(chn);
            list.Add(use);
            foreach (Person person in list)
            {    //方式一
                 //person.SayHello();
                 //方式二
                if (person is Chinses)
                {
                    Person a = person as Chinses;
                    a.SayHello();
                }
                if (person is Use)
                {
                    Person b = person as Use;
                    b.SayHello();
                }
            }
            Console.ReadKey();
        }
    }
}

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

namespace 联系
{
    public abstract class Animal
    {
        public Animal()
        {
        }

        //public virtual string name = string.Empty;
        public abstract void Run();
        //虚方法
        public virtual void Jump()
        {
            Console.WriteLine("跑啊 ");
        }
        //重写虚方法
        //public override void Jump()
        //{

        //}
    }
}

is  做类型的判定
父类对象   is   子类对象
List<Person> list=xxx;
foreach(Person item in list){
     if(item is Student)
     {
       Student stu=item as Student
     }
}
实现多态
public class Parsen{
  //特性 :虚方法的出现墓地就是为了让子类重写
  public virtual Eat(){}

}
 public class Child:Person
 {
  public override void Eat(){}
 }
 里氏替换原则:在一个软件中,如果子类替换了父类出现的位置,而对整个软件功能没有影响

 抽象的定义
 虚方法可以选择则性的被子类重写,抽象方法必须让子类重写
 1.抽象类不能实例化
 2.抽象方法不能有方法体,甚至连{}都不能有
 3.抽象方法只能存在于抽象类中
 4.一个类被abstract修饰,就是抽象类
 5.抽象方法存在的目的,就是为了约束子类中方法存在的形式(参数列表返回值)
 6.抽象类不能是静态类(static)或密封类(sealed)
 7.抽象类中的抽象方法必须被子类重写,除非子类是一个抽象类
 8.抽象方法快捷生成建 Ctrl+.(无输入法) Shift+Ait+F1