0505.Net基础班第二十天（基础加强总复习）

1、new关键字 1)、创建对象 2)、隐藏从父类那里继承过来的成员

2、访问修饰符 public:公开的，公共的 private:私有的，只能在当前类的内部访问，类中成员们，如果不加访问修饰符，默认就是private procteced：受保护的，可以在当前类的内部访问，也可以在该类的子类中访问 internal：在当前项目中都可以访问。 protected internal： 能够修饰类的访问修饰符只有两个，internal和public

3、常用的关键字 this 1、当前类的对象 2、调用自己的构造函数 base 调用父类的成员 new 1、创建对象 2、隐藏父类的成员 virtual 标记一个方法是虚方法 abstract 抽象的 override 重写 interface 接口 partial 部分类 sealed 密封类：不允许被继承 return 1、在方法中返回要返回的值 2、立即结束本次方法 break 跳出当前循环 continue 结束本次循环，回到循环条件进行判断 static 静态的 struct 结构 enum 枚举 const 常量

4、字符串 1、字符串的不可变性 2、字符串可以看做是char类型的只读数组

5、集合 ArrayList Hashtable List<T> Dictionary<TKey,TValue>

6装箱或者拆箱 装箱：就是将值类型转换为引用类型 拆箱:就是将引用类型转换为值类型。 值类型:bool int double char struct enum decimal 引用类型：string 数组 集合 interface object 自定义类 拆箱或者装箱的两种类型必须具有继承关系

7、结构和类的区别 1、类当中写了一个新的构造函数之后，默认的无参数的就被干掉了。 但是在结构中，写了一个新的构造函数之后，默认的那个无参数的还在。 在结构的构造函数当中，必须给所有的字段赋值，这样也就限制了结构中最多 只能有两个构造函数，一个是默认的无参数的构造函数，一个是全参数的构造函数。

2、结构的new关键字只干了一件事儿，就是调用结构的构造函数。

3、结构不能继承于类，而类也不能继承于结构。 结构不具备面向对象的特征。 而类才是面向对象的产物。

4、如果不给结构创建对象的话，不允许调用结构中的非静态方法。

01面向对象复习

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

namespace _01面向对象复习
{
    class Program
    {
        static void Main(string[] args)
        {
            //this 
            //new
            Person p = new Person();
           
        }
    }

    public class Person
    {

        protected string _name;
        internal int _age;
    }

    internal class Teacher : Person
    {
        public void T()
        { 
            
        }
    }
}

02关键字的用法

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)
        {
            //partial
        }
    }

    /// <summary>
    /// 密封类
    /// </summary>
    public sealed class Teacher:Person
    {

    }
    

    public partial class Person
    {
        private string _name;
    }

    public partial class Person
    {
        public void T()
        {
            //   _name;
        }
    }
}

03抽象类练习

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

namespace _03抽象类练习
{
    class Program
    {
        static void Main(string[] args)
        {
            MobileDisk md = new MobileDisk();
            Mp3 mp3 = new Mp3();
            UDisk u = new UDisk();

            Computer cpu = new Computer();
            cpu.MS = mp3;
            cpu.CPURead();
            cpu.CPUWrite();
            Console.ReadKey();
        }
    }

    /// <summary>
    /// 抽象的移动存储设备父类
    /// </summary>
    public abstract class MobileStorage
    {
        public abstract void Read();
        public abstract void Write();
    }
    public class MobileDisk : MobileStorage
    {
        public override void Read()
        {
            Console.WriteLine("移动硬盘在读取数据");
        }

        public override void Write()
        {
            Console.WriteLine("移动硬盘在写入数据");
        }
    }
    public class UDisk : MobileStorage
    {
        public override void Read()
        {
            Console.WriteLine("U盘在读取数据");
        }
        public override void Write()
        {
            Console.WriteLine("U盘在写入数据");
        }
    }
    public class Mp3 : MobileStorage
    {
        public void PlayMusic()
        { 
            Console.WriteLine("Mp3自己可以播放音乐");
        }

        public override void Read()
        {
            Console.WriteLine("Mp3读取数据");
        }

        public override void Write()
        {
            Console.WriteLine("Mp3写入数据");
        }
    }


    public class Computer
    {

        public MobileStorage MS
        {
            get;
            set;
        }
        public void CPURead()
        {
            this.MS.Read();
        }

        public void CPUWrite()
        {
            this.MS.Write();
        }
    }
}

04虚方法和抽象类

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

namespace _04虚方法和抽象类
{
    class Program
    {
        static void Main(string[] args)
        {
        }
    }
    public abstract class Person
    {
        private string _name;

        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        public Person(string name)
        {
            this.Name = name;
        }
        public Person()
        { 
        
        }
        public  virtual void SayHello()
        { 
            
        }
        public abstract   double Test(string name);

      //  public abstract void Test();
    }

    public class Student : Person
    {

        public override double Test(string name)
        {
            return 123;
        }
       // public abstract void M();
        //public  void SayHello()
        //{
            
        //}
    }
}

05接口复习

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
namespace _05接口复习
{
    class Program
    {
        static void Main(string[] args)
        {
            //alt+shift+F10
          //  File
            //接口是什么？什么时候使用接口？使用接口的目的是什么？多态
            //鸟会飞 飞机也会飞

            IFlyable fly = new Plane();//new Bird();
            fly.Fly();
            Console.ReadKey();
        }
    }
    public interface IFlyable
    {
        void Fly();
    }

    public class Bird
    {
        //public void Fly()
        //{
        //    Console.WriteLine("大多数鸟都会飞"); 
        //}
    }
    //public class QQ : Bird
    //{

    //}

    public class Maque : Bird, IFlyable
    {
        /// <summary>
        /// 这个函数是父类的？还是子类自己的？还实现接口的？
        /// </summary>
        public void Fly()
        {
            Console.WriteLine("鸟会飞");
        }
        void IFlyable.Fly()
        {
            Console.WriteLine("实现的接口的飞方法");
        }
    }

    public class Plane : IFlyable
    {
        public void Fly()
        {
            Console.WriteLine("飞机会飞");
        }
    }
}

06面向对象练习

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

namespace _06面向对象练习
{
    class Program
    {
        static void Main(string[] args)
        {
            //作业：定义父亲类Father(姓lastName,财产property,血型bloodType),
            //儿子Son类(玩游戏PlayGame方法),女儿Daughter类(跳舞Dance方法)，
            //调用父类构造函数(:base())给子类字段赋值

            //Son son = new Son("张三",10m,"AB");
            //son.PlayGame();
            //son.SayHello();
            //Daughter d = new Daughter("张梅梅", 100m, "O");
            //d.SayHello();
            //d.Dance();
            //Console.ReadKey();

            //作业：定义汽车类Vehicle属性（brand(品牌),color（颜色））方法run，
            //子类卡车(Truck) 属性weight载重  方法拉货，轿车 (Car) 属性passenger载客数量  方法载客

            //Truck truck = new Truck("解放牌卡车", "绿色", 30000);
            //Car car = new Car("奔驰", "黑色", 5);
            //truck.LaHuo();
            //car.LaKe();
            //Console.ReadKey();

        }
    }

    /// <summary>
    /// 汽车的父类
    /// </summary>
    public class Vehicle
    {
        public string Brand
        {
            get;
            set;
        }

        public string Color
        {
            get;
            set;
        }

        public void Run()
        {
            Console.WriteLine("我是汽车我会跑");
        }

        public Vehicle(string brand, string color)
        {
            this.Brand = brand;
            this.Color = color;
        }
    }


    public class Truck : Vehicle
    {
        public double Weight
        {
            get;
            set;
        }
        public Truck(string brand, string color, double weight)
            : base(brand, color)
        {
            this.Weight = weight;
        }


        public void LaHuo()
        {
            Console.WriteLine("我最多可以拉{0}KG货物",this.Weight);
        }
    }


    public class Car : Vehicle
    {
        public int Passenger
        {
            get;
            set;
        }
        public Car(string brand, string color, int passenger)
            : base(brand, color)
        {
            this.Passenger = passenger;
        }


        public void LaKe()
        {
            Console.WriteLine("我最多可以拉{0}个人",this.Passenger);
        }
    }


    public class Father
    {
        private string _lastName;
        public string LastName
        {
            get { return _lastName; }
            set { _lastName = value; }
        }

        private decimal _property;
        public decimal Property
        {
            get { return _property; }
            set { _property = value; }
        }

        private string _bloodType;
        public string BloodType
        {
            get { return _bloodType; }
            set { _bloodType = value; }
        }

        public Father(string lastName, decimal property, string bloodType)
        {
            this.LastName = lastName;
            this.Property = property;
            this.BloodType = bloodType;
        }

        public void SayHello()
        {
            Console.WriteLine("我叫{0},我有{1}元，我是{2}型血",this.LastName,this.Property,this.BloodType);
        }

    }

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

        public void PlayGame()
        {
            Console.WriteLine("儿子会玩游戏");
        }
    }

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

        public void Dance()
        {
            Console.WriteLine("女儿会跳舞");
        }
    }
}

07面向对象多态练习

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

namespace _07面向对象多态练习
{
    class Program
    {
        static void Main(string[] args)
        {
            //作业:员工类、部门经理类 程序猿类
            //（部门经理也是员工，所以要继承自员工类。员工有上班打卡的方法。用类来模拟。

            Employee emp = new Programmer();//new Manager();//new Employee();
            emp.DaKa();
            Console.ReadKey();
        }
    }
    public class Employee
    {
        public virtual void DaKa()
        {
            Console.WriteLine("员工九点打卡");
        }
    }

    public class Manager : Employee
    {
        public override void DaKa()
        {
            Console.WriteLine("经理十一点打卡");
        }
    }

    public class Programmer : Employee
    {
        public override void DaKa()
        {
            Console.WriteLine("程序猿不打卡");
        }
    }

}

08面向对象多态练习

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

namespace _08面向对象多态练习
{
    class Program
    {
        static void Main(string[] args)
        {
            //作业:动物Animal   都有吃Eat和叫Bark的方法，狗Dog和猫Cat叫的方法不一样.
            //父类中没有默认的实现所哟考虑用抽象方法。

            Animal a = new Dog();//new Cat();
            a.Bark();
            a.Eat();
            Console.ReadKey();
        }
    }

    public abstract class Animal
    {
        public abstract void Eat();
        public abstract void Bark();
    }

    public class Cat : Animal
    {
        public override void Eat()
        {
            Console.WriteLine("猫咪舔着吃");
        }

        public override void Bark()
        {
            Console.WriteLine("猫咪喵喵的叫");
        }
    }

    public class Dog : Animal
    {
        public override void Bark()
        {
            Console.WriteLine("狗狗旺旺的叫");
        }

        public override void Eat()
        {
            Console.WriteLine("狗狗咬着吃");
        }
    }

}

09面向对象接口练习

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

namespace _09面向对象接口练习
{
    class Program
    {
        static void Main(string[] args)
        {
            //作业:鸟-麻雀sparrow['spærəu] ，鸵鸟ostrich['ɔstritʃ] ，
            //企鹅penguin['pengwin] ，鹦鹉parrot['pærət]
            //鸟能飞,鸵鸟，企鹅不能。。。你怎么办

            IFlyable fly = new YingWu();// new QQ();//new YingWu();//new MaQue();
            fly.Fly();
            Console.ReadKey();
        }
    }

    public interface IFlyable
    {
        void Fly();
    }

    public class Bird
    {
        public double Wings
        {
            get;
            set;
        }

        public void SayHello()
        {
            Console.WriteLine("我是小鸟");
        }
    }

    public class MaQue : Bird, IFlyable
    {
        public void Fly()
        {
            Console.WriteLine("麻雀会飞");
        }
    }

    public class TuoNiao : Bird
    { 
        
    }

    public class QQ : Bird
    { 
        
    }

    public class YingWu : Bird, IFlyable
    {
        public void Fly()
        {
            Console.WriteLine("鹦鹉会飞");
        }
    }
}

10面向对象多态练习

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

namespace _10面向对象多态练习
{
    class Program
    {
        static void Main(string[] args)
        {
            //作业:橡皮rubber鸭子、木wood鸭子、真实的鸭子realduck。
            //三个鸭子都会游泳，而橡皮鸭子和真实的鸭子都会叫，
            //只是叫声不一样，橡皮鸭子“唧唧”叫，真实地鸭子“嘎嘎”叫，木鸭子不会叫.
            //IBark bark = new RealDuck();//new XPDuck();
            //bark.Bark();
            XPDuck xp = new XPDuck();
            MuDuck md = new MuDuck();
            RealDuck rd = new RealDuck();
            IBark bark = rd;
            Duck duck = rd;
            duck.Swim();
            bark.Bark();


            Console.ReadKey();

        }
    }

    public class Duck
    {
        public virtual void Swim()
        {
            Console.WriteLine("是鸭子就会游泳");
        }
    }

    public interface IBark
    {
        void Bark();
    }

    public class RealDuck : Duck, IBark
    {
        public void Bark()
        {
            Console.WriteLine("这的鸭子嘎嘎叫");
        }

        public override void Swim()
        {
            Console.WriteLine("真的鸭子会游泳");
        }
    }

    public class MuDuck:Duck
    {
        public override void Swim()
        {
            Console.WriteLine("木头鸭子也会游泳");
        }
    }

    public class XPDuck : Duck, IBark
    {
        public void Bark()
        {
            Console.WriteLine("橡皮鸭子唧唧叫");
        }

        public override void Swim()
        {
            Console.WriteLine("橡皮鸭子也会游泳");
        }
    }
}

11、抽象类练习

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

namespace _11_抽象类练习
{
    class Program
    {
        static void Main(string[] args)
        {
            //作业：计算形状Shape(圆Circle，矩形Square ，正方形Rectangle)的面积、周长
            Shape shape = new Square(5,7);//new Circle(5);
            double area = shape.GetArea();
            double perimeter = shape.GetPerimeter();
            Console.WriteLine(area);
            Console.WriteLine(perimeter);
            Console.ReadKey();
        }
    }

    public abstract class Shape
    {
        public abstract double GetArea();
        public abstract double GetPerimeter();
    }

    public class Square : Shape
    {
        public double Height
        { 
            get;
            set;
        }

        public double Width
        {
            get;
            set;
        }

        public Square(double height, double width)
        {
            this.Height = height;
            this.Width = width;
        }

        public override double GetArea()
        {
            return this.Height * this.Width;
        }

        public override double GetPerimeter()
        {
            return (this.Height + this.Width) * 2;
        }
    }


    public class Circle : Shape
    {
        public double R
        {
            get;
            set;
        }
        public Circle(double r)
        {
            this.R = r;
        }

        public override double GetArea()
        {
            return Math.PI * this.R * this.R;
        }

        public override double GetPerimeter()
        {
            return 2 * Math.PI * this.R;
        }
    }
}

12字符串

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

namespace _12字符串
{
    class Program
    {
        static void Main(string[] args)
        {
            //string s1 = "张三";//GC
            //s1 = null;
            //if (string.IsNullOrEmpty(s1))
            //{
            //    Console.WriteLine("是的");
            //}
            //else
            //{
            //    Console.WriteLine("不是");
            //}

            //string s = "abcdefg";
            //char[] chs = s.ToCharArray();
            //chs[0] = 'b';
            //s = new string(chs);
            //Console.WriteLine(s);
            ////s[0]='b';
            //Console.WriteLine(s[0]);
            //Console.ReadKey();

            //string s1 = "c#";
            //string s2="C#";
            //if (s1.Equals(s2,StringComparison.OrdinalIgnoreCase))
            //{
            //    Console.WriteLine("相同");
            //}
            //else
            //{
            //    Console.WriteLine("不相同");
            //}
            //Console.ReadKey();

            //string s = "abcdefg";
            //string sNew = s.Substring(3,1);
            //Console.WriteLine(sNew);
            //Console.ReadKey();

            //string str = "abcd , , fd, fdafd   [[  ---";
            //string[] strNew = str.Split(new char[] { ',', ' ', '[', '-' }, StringSplitOptions.RemoveEmptyEntries);


            //string[] names = { "张三", "李四", "王五", "赵六" };
            //string s = string.Join("|",'c',true,3.13,100,1000m,"张三");
            //Console.WriteLine(s);
            //Console.ReadKey();

            string str = "老赵伟大";
            str = str.Replace("老赵", "**");
            Console.WriteLine(str);
            Console.ReadKey();
        }
    }
}

13、字符串练习

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

namespace _13_字符串练习
{
    class Program
    {
        static void Main(string[] args)
        {
            //课上练习1：接收用户输入的字符串，将其中的字符以与输入相反的顺序输出。"abc"→"cba"

            //string str = "abcdefg";
            //char[] chs = new char[str.Length];

            //foreach (var item in chs)
            //{
            //    Console.WriteLine(item);
            //}
            //Console.ReadKey();

            //Console.WriteLine("请输入一个字符串");
            //string str = Console.ReadLine();
            //char[] chs = new char[str.Length];
            //int i = 0;
            //foreach (var item in str)
            //{
            //    chs[i] = item;
            //    i++;
            //}
            //foreach (var item in chs)
            //{
            //    Console.WriteLine(item);
            //}
            //Console.ReadKey();
            //char[] chs = str.ToCharArray();
            //for (int i = 0; i < chs.Length/2; i++)
            //{
            //    char temp = chs[i];
            //    chs[i] = chs[chs.Length - 1 - i];
            //    chs[chs.Length - 1 - i] = temp;
            //}

            //str = new string(chs);
            //Console.WriteLine(str);

            //Array.Reverse(chs);
            //str = new string(chs);
            //Console.WriteLine(str);

            ////课上练习2：接收用户输入的一句英文，将其中的单词以反序输出。      “I love you"→“i evol uoy"
            //string str = "I Love You";// I evoL uoY
            //string s2 = null;
            //string[] strNew = str.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            //for (int i = 0; i < strNew.Length; i++)
            //{
            //    string s = ProcessStr(strNew[i]);
            //    s2 += s+" ";

            //}
            //Console.WriteLine(s2);

            //Console.ReadKey();

            //课上练习3：”2012年12月21日”从日期字符串中把年月日分别取出来，打印到控制台
            //string date = "2012年12月21日";
            //string[] dateNew = date.Split(new char[] { '年', '月', '日' }, StringSplitOptions.RemoveEmptyEntries);
            //Console.WriteLine("{0}--{1}--{2}",dateNew[0],dateNew[1],dateNew[2]);
            //Console.ReadKey();




            //  练习5：123-456---789-----123-2把类似的字符串中重复符号去掉，
            //既得到123-456-789-123-2. split()、
            //string str = "123-456---789-----123-2";
            //string[] strNew = str.Split(new char[] { '-' }, StringSplitOptions.RemoveEmptyEntries);
            //str = string.Join("-", strNew);
            //Console.WriteLine(str);
            //Console.ReadKey();

            string[] str = File.ReadAllLines("员工工资.txt", Encoding.Default);
            int max = int.MinValue;
            int min = int.MaxValue;
            int sum = 0;
            for (int i = 0; i < str.Length; i++)
            {
                //张三,100
                string[] strNew = str[i].Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                if (int.Parse(strNew[1]) > max)
                {
                    max = int.Parse(strNew[1]);
                }
                if (int.Parse(strNew[1]) < min)
                {
                    min = int.Parse(strNew[1]);
                }
                sum += int.Parse(strNew[1]);
            }
            Console.WriteLine("工资最高是{0},最低是{1},平均薪资是{2}",max,min,sum/str.Length);
           

            Console.ReadKey();


        }


        public static string ProcessStr(string str)
        {
            char[] chs = str.ToCharArray();
            for (int i = 0; i < chs.Length / 2; i++)
            {
                char temp = chs[i];
                chs[i] = chs[chs.Length - 1 - i];
                chs[chs.Length - 1 - i] = temp;
            }
            return new string(chs);
        }
    }
}

14、高效的StringBuilder

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

namespace _14_高效的StringBuilder
{
    class Program
    {
        static void Main(string[] args)
        {
            StringBuilder sb = new StringBuilder();
            sb.Append("张三");
            sb.Append("李四");
            sb.Append("王五");
            sb.Insert(1, 123);
            sb.Replace("李四", "颜世伟");
            sb.Replace("颜世伟", "杀马特");
            Console.WriteLine(sb.ToString());
            Console.ReadKey();
        }
    }
}

15、使用StringBuilder来拼接网页

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 _15_使用StringBuilder来拼接网页
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {

            StringBuilder sb = new StringBuilder();
            sb.Append("<html>");
            sb.Append("<head>");
            sb.Append("</head>");
            sb.Append("<body>");
            sb.Append("<table border='1px' cellpadding='0px' cellspacing='0px'>");
            sb.Append("<tr>");
            sb.Append("<td>星期一</td>");
            sb.Append("<td>星期一</td>");
            sb.Append("<td>星期一</td>");
            sb.Append("<td>星期一</td>");
            sb.Append("</tr>");
            sb.Append("<tr>");
            sb.Append("<td>星期一</td>");
            sb.Append("<td>星期一</td>");
            sb.Append("<td>星期一</td>");
            sb.Append("<td>星期一</td>");
            sb.Append("</tr>");
            sb.Append("<tr>");
            sb.Append("<td>星期一</td>");
            sb.Append("<td>星期一</td>");
            sb.Append("<td>星期一</td>");
            sb.Append("<td>星期一</td>");
            sb.Append("</tr>");
            sb.Append("<tr>");
            sb.Append("<td>星期一</td>");
            sb.Append("<td>星期一</td>");
            sb.Append("<td>星期一</td>");
            sb.Append("<td>星期一</td>");
            sb.Append("</tr>");
            sb.Append("</table>");
            sb.Append("</body>");
            sb.Append("</html>");
            webBrowser1.DocumentText = sb.ToString();
           // webBrowser1.DocumentText
        }
    }
}

namespace _15_使用StringBuilder来拼接网页
{
    partial class Form1
    {
        /// <summary>
        /// 必需的设计器变量。
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// 清理所有正在使用的资源。
        /// </summary>
        /// <param name="disposing">如果应释放托管资源，为 true；否则为 false。</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows 窗体设计器生成的代码

        /// <summary>
        /// 设计器支持所需的方法 - 不要
        /// 使用代码编辑器修改此方法的内容。
        /// </summary>
        private void InitializeComponent()
        {
            this.webBrowser1 = new System.Windows.Forms.WebBrowser();
            this.button1 = new System.Windows.Forms.Button();
            this.SuspendLayout();
            // 
            // webBrowser1
            // 
            this.webBrowser1.Location = new System.Drawing.Point(68, 73);
            this.webBrowser1.MinimumSize = new System.Drawing.Size(20, 20);
            this.webBrowser1.Name = "webBrowser1";
            this.webBrowser1.Size = new System.Drawing.Size(439, 250);
            this.webBrowser1.TabIndex = 0;
            // 
            // button1
            // 
            this.button1.Location = new System.Drawing.Point(68, 23);
            this.button1.Name = "button1";
            this.button1.Size = new System.Drawing.Size(75, 23);
            this.button1.TabIndex = 1;
            this.button1.Text = "button1";
            this.button1.UseVisualStyleBackColor = true;
            this.button1.Click += new System.EventHandler(this.button1_Click);
            // 
            // Form1
            // 
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 12F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(676, 416);
            this.Controls.Add(this.button1);
            this.Controls.Add(this.webBrowser1);
            this.Name = "Form1";
            this.Text = "Form1";
            this.ResumeLayout(false);

        }

        #endregion

        private System.Windows.Forms.WebBrowser webBrowser1;
        private System.Windows.Forms.Button button1;
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace _15_使用StringBuilder来拼接网页
{
    static class Program
    {
        /// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());
        }
    }
}

16、集合复习

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

namespace _16_集合复习
{
    class Program
    {
        static void Main(string[] args)
        {
          //  ArrayList list = new ArrayList();
          ////  list.Add()
          //  Hashtable ht = new Hashtable();
          //  //ht.Add()

          //  List<int> list = new List<int>();
            //list.Add(); 添加单个元素
            //list.AddRange();添加集合
            //list.Insert();插入
            //list.InsertRange();插入集合
            //list.Remove();移除
            //list.RemoveAt();根据下标移除
            //list.RemoveRange();移除一定范围的元素
            //list.Contains();//判断是否包含

           // list.RemoveAll()

            //Dictionary<int, string> dic = new Dictionary<int, string>();
            //dic.Add(1,"张三");
            //dic.Add(2,"李四");
            //dic.Add(3, "颜世伟");
            //dic.Add(4, "杀马特");
            //dic[4] = "还是杀马特";

            //foreach (KeyValuePair<int,string> kv in dic)
            //{
            //    Console.WriteLine("{0}---{1}",kv.Key,kv.Value);
            //}
            //Console.ReadKey();

            //dic.ContainsKey();


        }
    }
}

17集合练习

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

namespace _17集合练习
{
    class Program
    {
        static void Main(string[] args)
        {
            #region 集合练习1
            //案例：把分拣奇偶数的程序用泛型实现。int[] nums={1,2,3,4,5,6,7,8,9};奇数在左边 偶数在右边
            //int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            //List<int> listJi = new List<int>();
            //List<int> listOu = new List<int>();
            //for (int i = 0; i < nums.Length; i++)
            //{
            //    if (nums[i] % 2 == 0)
            //    {
            //        listOu.Add(nums[i]);
            //    }
            //    else
            //    {
            //        listJi.Add(nums[i]);
            //    }
            //}

            //listJi.AddRange(listOu);
            //foreach (var item in listJi)
            //{
            //    Console.WriteLine(item);
            //}
            //Console.ReadKey(); 
            #endregion




            #region 集合练习2
            //练习1：将int数组中的奇数放到一个新的int数组中返回。
            //将数组中的奇数取出来放到一个集合中，最终将集合转换成数组 。
            //int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

            //List<int> listJi = new List<int>();

            //for (int i = 0; i < nums.Length; i++)
            //{
            //    if (nums[i] % 2 != 0)
            //    {
            //        listJi.Add(nums[i]);
            //    }
            //}
            ////集合转换成数组
            //int[] numsNew = listJi.ToArray();
            //foreach (var item in numsNew)
            //{
            //    Console.WriteLine(item);
            //}
            //Console.ReadKey();
            #endregion




            #region 集合练习3
            //练习2：从一个整数的List<int>中取出最大数（找最大值）。
            //集合初始化器
            //List<int> list = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            //int max = list[0];
            //for (int i = 0; i < list.Count; i++)
            //{
            //    if (list[i] > max)
            //    {
            //        max = list[i];
            //    }
            //}
            //Console.WriteLine(max);
            //Console.ReadKey();
            ////foreach (var item in list)
            ////{
            ////    Console.WriteLine(item);
            ////}
            //Console.ReadKey(); 
            //  list.AddRange(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 });
            //Person p = new Person("李四", 16, '女') { Name = "张三", Age = 19, Gender = '男' };
            //p.SayHello();
            //Console.ReadKey();
            #endregion




           
            #region 集合练习4
            //练习：把123转换为：壹贰叁。Dictionary<char,char>
            //"1一 2二 3三 4四 5五 6六 7七 8八 9九"
            //string str = "1一 2二 3三 4四 5五 6六 7七 8八 9九";
            ////123  一二三
            //Dictionary<char, char> dic = new Dictionary<char, char>();
            //string[] strNew = str.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);

            //for (int i = 0; i < strNew.Length; i++)
            //{
            //    //1一 strNew[i][0]  strNew[i][1]
            //    dic.Add(strNew[i][0], strNew[i][1]);
            //}

            //Console.WriteLine("请输入阿拉伯数字");
            //string input = Console.ReadLine();

            //for (int i = 0; i < input.Length; i++)
            //{
            //    if (dic.ContainsKey(input[i]))
            //    {
            //        Console.Write(dic[input[i]]);
            //    }
            //    else
            //    {
            //        Console.Write(input[i]);
            //    }
            //}
            //Console.ReadKey(); 
            #endregion



            #region 集合练习5
            ////练习：计算字符串中每种字符出现的次数（面试题）。 “Welcome to Chinaworld”，不区分大小写，打印“W2”“e 2”“o 3”…… 

            //string s = "Welcome to Chinaworld";

            //Dictionary<char, int> dic = new Dictionary<char, int>();
            ////遍历 s  
            //for (int i = 0; i < s.Length; i++)
            //{
            //    if (s[i] == ' ')
            //    {
            //        continue;
            //    }
            //    if (dic.ContainsKey(s[i]))
            //    {
            //        dic[s[i]]++;
            //    }
            //    else
            //    {
            //        dic[s[i]] = 1;
            //    }
            //}


            //foreach (KeyValuePair<char,int> kv in dic)
            //{
            //    Console.WriteLine("字母{0}出现了{1}次",kv.Key,kv.Value);
            //}
            //Console.ReadKey(); 
            #endregion


         
            #region 集合练习5
            //案例：两个（List）集合{ “a”,“b”,“c”,“d”,“e”}和{ “d”, “e”, “f”, “g”, “h” }，把这两个集合去除重复项合并成一个。
            //List<string> listOne = new List<string>() { "a", "b", "c", "d", "e" };
            //List<string> listTwo = new List<string>() { "d", "e", "f", "g", "h" };
            //for (int i = 0; i < listTwo.Count; i++)
            //{
            //    if (!listOne.Contains(listTwo[i]))
            //    {
            //        listOne.Add(listTwo[i]);
            //    }
            //}


            //foreach (var item in listOne)
            //{
            //    Console.WriteLine(item);
            //}
            //Console.ReadKey(); 
            #endregion

        }
    }

    public class Person
    {
        public Person(string name, int age, char gender)
        {
            this.Name = name;
            this.Age = age;
            this.Gender = gender;
        }

        public string Name
        {
            get;
            set;
        }
        public char Gender
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }

        public void SayHello()
        {
            Console.WriteLine("{0}---{1}---{2}", this.Name, this.Age, this.Gender);
        }
    }
}

18、静态和非静态的区别

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

namespace _18_静态和非静态的区别
{
    class Program
    {
        static void Main(string[] args)
        {
            Student.Test();
            Student.Test();
            Student.Test();
            Console.ReadKey();
        }
    }

    public class Person
    {
        private static string _name;
        private int _age;
        public void M1()
        { 
           
        }

        public static void M2()
        { 
            
        }


        public Person()
        {
            Console.WriteLine("非静态类构造函数");
        }

    }

    public static class Student
    {
         static Student()
        {
            Console.WriteLine("静态类构造函数");
        }

         public static void Test()
         {
             Console.WriteLine("我是静态类中的静态方法");
         }
      //  private string _name;
    }
}

19、结构和类的区别

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

namespace _19_结构和类的区别
{
    class Program
    {
        static void Main(string[] args)
        {
            //类型
            //结构：值类型 
            //类：引用类型

            //声明的语法：class  struct

            //在类中，构造函数里，既可以给字段赋值，也可以给属性赋值。构造函数是可以重载的
            //但是，在结构的构造函数当中，必须只能给字段赋值。
            //在结构的构造函数当中，我们需要给全部的字段赋值，而不能去选择的给字段赋值

            //调用：

            PersonClass pc = new PersonClass();


            //结构是否可以New？
            //在栈开辟空间  结构new  调用结构的构造函数
            PersonStruct ps = new PersonStruct();
            ps.M2();
            PersonStruct.M1();
            Console.ReadKey();
            //结构和类的构造函数：
            //相同点：不管是结构还是类，本身都会有一个默认的无参数的构造函数
            //不同点:当你在类中写了一个新的构造函数之后，那个默认的无参数的构造函数都被干掉了
            //但是，在结构当中，如果你写了一个新的构造函数，那么个默认的无参数的构造函数依然在。
            //
            //如果我们只是单纯的存储数据的话，我们推荐使用结构。

            //如果我们想要使用面向对象的思想来开发程序，我们推荐使用我们的Class

            //结构并不具备面向对象的特征


          //  int
        }
    }

    public class PersonClass
    { 
        //字段、属性、方法、构造函数
    }

    public struct PersonStruct
    {
        //字段、属性
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        private int _age;
        public int Age
        {
            get { return _age; }
            set { _age = value; }
        }

        private char _gender;
        public char Gender
        {
            get { return _gender; }
            set { _gender = value; }
        }

        public static void M1()
        {
            Console.WriteLine("我是结构中的静态方法");
        }
        public void M2()
        {
            Console.WriteLine("我是结构的非静态方法");
        }

        public PersonStruct(string name, int age, char gender)
        {
            //this.Name = name;
            //this.Age = age;
            //this.Gender = gender;

            this._name = name;
            this._age = age;
            this._gender = gender;
        }


        //public PersonStruct(string name)
        //{
        //    this._name = name;
        //}

    }
}