C#面向对象与常用API的学习

一：C#中的集合ArrayList

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

namespace 集合
{
    class Program
    {
        static void Main(string[] args)
        {
            //1)创建一个集合对象
            ArrayList list = new ArrayList();
            list.Add(1);
            list.Add(true);
            list.Add('男');
            list.Add("陈如水");
            list.Add(1.2);
            list.Add(1.2m);
            list.Add(new string[] { "陈诗悦", "陈诗音" });
            list.AddRange(new int[] { 1, 2, 3, 4, 5, 6, 7, 8 });
            //删除指定的元素
            list.Remove('男');
            list.AddRange(list);

            list.Clear();

            //获取集合中实际的元素的个数。
            for (int i = 0; i < list.Count; i++)
            {
                //集合中的某一个元素
                Console.WriteLine(list[i]);
                //我们将一个对象输出到控制台，默认打印的是这个对象所在类的命名空间。
            }

            //集合练习题1：求集合中元素的和与平均值，最大值和最小值
            //创建一个集合
            ArrayList list1 = new ArrayList();
            //向集合中添加元素
            list1.AddRange(new int[] { 1, 3, 56, 78, 9, 0, 3, 4, 5, 7, 8, 9 });
            int sum = 0;
            int max = (int)list1[0];
            int min = (int)list1[0];
            //遍历集合
            for (int i = 0; i < list1.Count; i++)
            {

                //求集合里面的最大值
                if (max < (int)list1[i])
                {
                    max = (int)list1[i];
                }
                //求集合里面的最小值
                if (min > (int)list1[i])
                {
                    min = (int)list1[i];
                }

                //把每一个元素强转成int类型 因为Object类型是int类型的父类，所以可以强转
                sum += (int)list1[i];

            }
            //Console.WriteLine("这几个数的和是{0}，平均值是{1}，最大值是{2}，最小值是{3}", sum, sum / list1.Count, max, min);

            //集合练习题2：写一个长度为10的集合，要求里面的元素不重复
            ArrayList list2 = new ArrayList();
            //创建一个随机数类
            Random r = new Random();
            for (int i = 0; i < 10; i++)
            {
                int number = r.Next(0, 10);
                if (!list2.Contains(number))
                {
                    list2.Add(number);
                }
                else
                {
                    //一旦有重复的元素，当前的循环不算，重新来，当前减1即可
                    i--;
                }
            }
            for (int i = 0; i < list2.Count; i++)
            {
                Console.WriteLine(list2[i]);
            }

            Console.ReadKey();
        }
    }
}

Hashtable集合的使用(键值对集合)：

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

namespace 集合1
{
    class Program
    {
        static void Main(string[] args)
        {

            //第二个单词的首字母小写
            Hashtable ht = new Hashtable();
            ht.Add(1, "陈如水");
            ht.Add(2, "陈诗音");
            ht.Add(3, "陈诗悦");
            ht.Add(false, true);

            int a = 10;
            //获取变量的类型
            Type t = a.GetType();
            Console.WriteLine(t);
            //推断类型
            var b = 10;
            Type type = b.GetType();
            Console.WriteLine(type);

            //在键值对集合中是根据键寻找值的
            //for (int i = 0; i < ht.Count; i++)
            //{
            //    Console.WriteLine(ht[i]);
            //}
            //Console.ReadKey();


            foreach (var item in ht.Keys)
            {
                //var表示变量类型
                //item表示集合里面的每一项，表示一个键值对
                //collection表示待遍历的集合
                //ht.Keys 表示遍历集合中的键
                //ht.Values表示遍历集合中的值
                Console.WriteLine("遍历集合中的每一项,获取值{0}", ht[item]);
            }
            Console.ReadKey();
        }
    }
}

二：C#中的foreach使用以及Stopwatch类的使用

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

namespace 集合foreach循环
{
    class Program
    {
        static void Main(string[] args)
        {
            //for循环与foreach循环的效率问题：如果循环次数比较多，foreach循环的效率比较高。
            int[] sum = { 2, 34, 5, 7, 9, 5, 34, 2, 6, 7, 89, 9, 0, 5, 4, 3, 2, 2, 12 };
            //查看循环的耗时  //00:00:00.0062843
            Stopwatch sw = new Stopwatch();
            sw.Start();
            //for (int i = 0; i < sum.Length; i++)
            //{
            //    Console.WriteLine(sum[i]);
            //}
            //00:00:00.0053999
            foreach (var item in sum)
            {
                Console.WriteLine(item);
            }
            sw.Stop();
            Console.WriteLine(sw.Elapsed);

            //练习1：将用户输入的简体字转化成繁体字
            Console.WriteLine("请输入要转化的简体字：");
            string input = Console.ReadLine();
            Hashtable map = new Hashtable();
            //此时必须有把简体字作为键，把对应的繁体字最为值，这样才可以进行寻找到。
            for (int i = 0; i < map.Count; i++)
            {
                if (map.ContainsKey(input[i]))
                {
                    //打印键所对应的值
                    Console.WriteLine(map[input[i]]);
                }
                else
                {
                    //直接打印出用户的输入
                    Console.WriteLine(input[i]);
                }
            }
            Console.ReadKey();

        }
    }
}

三：C#中的path类的使用

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

namespace path练习
{
    class Program
    {
        static void Main(string[] args)
        {
            //Path类的练习：静态类，类中全部是是静态成员(其实是对字符串方法的封装)
            string path = @"C:\Users\Tuhuadmin\Desktop\面向对象初级\老赵.avi";
            //截取老赵.avi  取消转义
            int lastIndex = path.LastIndexOf("\\");
            string name = path.Substring(lastIndex + 1);
            Console.WriteLine(name);

            //1)获取文件的名字：
            string fileName = Path.GetFileName(path);
            Console.WriteLine(fileName);
            //2)获取文件的名字(忽略扩展名)：
            string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(path);
            Console.WriteLine(fileNameWithoutExtension);
            //3)获取文件扩展名：
            string extensionName = Path.GetExtension(path);
            Console.WriteLine(extensionName);
            //4)返回指定文件的目录信息：即当前文件位于哪个文件夹路径下
            string dirInfo = Path.GetDirectoryName(path);
            Console.WriteLine(dirInfo);
            //5)获取指定文件的全路径(包括文件名和扩展名)
            string fullPath= Path.GetFullPath(path);
            Console.WriteLine(fullPath);
            //6)连接两个字符串成为一个路径
            string str=Path.Combine(@"c:\a\","b.txt");
            Console.WriteLine(str);
            Console.ReadKey();
        }
    }
}

四：C#中的File类的使用

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

namespace file练习
{
    /// <summary>
    /// date: 20161018 
    /// author: crs
    /// describe: File类的练习:专门用来操作文件的类,静态类
    /// 对文件常见的操作：创建、删除、复制
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            //1)在指定的路径下创建文件(如果指定的路径下已经存在此文件，就不会继续创建)
            //File.Create(@"C:\Users\Tuhuadmin\Desktop\new.txt");
            //Console.WriteLine("创建成功！");

            //2)删除指定路径下的文件
            //File.Delete(@"C:\Users\Tuhuadmin\Desktop\new.txt");
            //Console.WriteLine("删除成功！");

            //3)复制一个文件到指定的路径
            File.Copy(@"C:\Users\Tuhuadmin\Desktop\new.txt", @"C:\Users\Tuhuadmin\new.txt");
            Console.WriteLine("复制成功!");
            Console.ReadKey();

        }
    }
}

五：C#中的编解码问题

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

namespace _3编码
{
    class Program
    {
        static void Main(string[] args)
        {
            //1)文本文件有不同的存储方式，将字符串以什么样的形式保存为二进制文件，这就是编码问题。
            //2)如果出现乱码现象，就是编码出现了问题。
            //3)什么是文本文件，用记事本能够打来的文件。.doc结尾的不算。
            //4)编解码为类Encoding
            //5)乱码产生的原因:你保存这个文件的编码格式与打开这个文件的编码格式不一致。

        }
    }
}

面相对象：(与面向过程相对应)

万物皆对象

创建一个对象帮你做事。

对象具备属性和方法，属性指对象具有的各种特征，每个对象的每个属性都拥有特定值。方法指对象的功能、作用、行为。

C#中类的基本语法 ：

访问修饰符 class 类名{

字段：字段前面必须添加下划线

属性：属性的作用是保护字段，对字段的取值和赋值进行限定.

属性的本质就是两个方法set和get.

自动生成属性的快捷键:Ctrl+R,Ctrl+E

输出属性值的时候，要调用get()方法

给属性赋值的时候，要调用set()方法,内部的实现和java一样

如何给当前项目添加一个类啊？选中项目----->右键单击----->添加----->类

类的实例化,用关键字new

 语法: 类  实例名 = new 类();

类的成员的访问:

    实例名.属性    实例名.方法名();

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

访问修饰符 :public private (internal protected)

当我们创建好一个类的对象后，要给这个对象的没个属性去赋值，这个过程称之为对象的初始化。

如果想要把一个类当做工具类，可以考虑将这个类写成静态的。

静态类为整个项目所共享，并且不占用内存。只有程序运行全部结束后，静态资源才会被释放。在定义的时候加关键字static。

this指代当前类的对象。

类的构造方法 (构造函数)：原理

1)构造方法用来创建对象，并且可以在构造函数中对对象进行初始化。

2)构造函数是用来创建对象的特殊方法，方法名和类名一样，没有返回值，连void都不用。

3)构造函数可以有参数，new对象的时候传递函数参数即可

4)如果不指定构造函数，则类有一个默认的无参构造函数。如果指定了构造函数，则不再有默认的无参构造函数，如果需要无参构造函数，则需要自己来写。

5)构造函数可以重载，也就是有多个参数不同的构造函数。

—————————————————————————————————————————————>

new关键字帮我们做了哪三件事 ？

1)在内存中帮我们开辟一块空间，

2)在开辟的空间中创建对象

3)对象的初始化工作。

——————————————————————————————————————————————>

命名空间 ：

1)namespace（命名空间），用于解决类重名问题，可以看做“类的文件夹”。

2)如果代码和被使用的类在一个namespace则不需要using。

3)在不同命名空间下的类调用有两种方法: 写全称 命名空间.类名;先using引用命名空间,再调用

4)如果使用集合，就需要导入命名空间，java中常说的导包。快捷键：Ctrl+.  类的左下角也可以导入命名空间；alt+shift+f10

比如两个项目之间引用其中的类，如何设置两个项目之间的引用。右键单击项目下的引用----->添加引用即可----->选择项目。

—————————————————————————————————————————————>

值类型和引用类型

值类型：存在于栈内存中，引用类型存在于堆内存中。

数组、枚举、结构是值类型。字符串属于引用类型。

————————————————————————————————————————————————————————————————————>

字符串 ：

1)string可以看做是char的只读数组。char c = s[1];。例子：遍历输出string中的每个元素。

2)C#中字符串有一个重要的特性：不可变性，字符串一旦声明就不再可以改变。所以只能通过索引来读取指定位置的char，不能对指定位置的char进行修改。

如果要对char进行修改，那么就必须创建一个新的字符串，用s. ToCharArray()方法得到字符串的char数组，对数组进行修改后，调用new string(char[])这个构造函数（暂时不用细研究）来创建char数组的字符串。一旦字符串被创建，那么char数组的修改也不会造成字符串的变化。例子：将字符串中的A替换为a。

不可变性：一句话解释，当你给字符串重新赋值后，就的值并没有被销毁，而是重新开辟新的空间去存储新的值。

字符串中方法的学习：

1)把字符串看做字符数组进行处理，直接可以通过下标获取某个字符；str[1];

2)ToCharArray()：获取一个字符数组char[ ];

3)创建一个新的字符串 new string(参数);

4)使用StringBuilder效率更高，一定要学会使用

5)StopWatch类用于统计程序的运行时间，sw.Start()、sw.Stop()、sw.Elapsed

6)Length：可以获取字符串的长度。

7)ToUpper()方法：将字符串转化成大写法；ToLower()方法，将字符串转换成小写

8)Equale()：比较字符串的方法，在比较的时候忽略了字符串的大小写。

9)Split(char[] separator, StringSplitOptions options):将字符串按照指定的字符，分割成字符串数组。 options 取RemoveEmptyEntries的时候移除结果中的空白字符串

10)Replace(string oldValue, string newValue) 字符串的替换方法：将字符串中的出现oldValue的地方替换为newValue；文字过滤，名字替换等

11)Substring(int startIndex)，取从位置startIndex开始一直到最后的子字符串；截取字符串

12)Substring(int startIndex, int length) 从位置startIndex开始长度为length的子字符串，如果子字符串的长度不足length则报错

13)bool Contains(string value)判断字符串中是否含有子串value

14)bool StartsWith(string value)判断字符串是否以子串value开始；

15)bool EndsWith (string value)判断字符串是否以子串value结束；

16)int IndexOf(string value)：取子串value第一次出现的位置。索引值

17)Int IndexOf(string value,int startIndex)

18)Int LastIndexOf() 字符最后一次出现的位置

19)Trim() 去掉字符串两端的空格

20)string.IsNullOrEmpty(name1); 判断字符串是否为null或者空字符串

21)string.json("",字符串数组) 主要用于把字符串数组转化成字符，中间以什么分割。

面向对象三大特征：继承、封装、多态

数组是引用类型，其他的按照常规就好了

继承:解决类中的代码冗余。

1)在c#中,所有的类都直接或间接的继承自了object类.(当我们定义一个类的时候,如果没有写:继承一个类,那么这个类就继承了object类)

2)继承的格式：父类

3)继承的特点:单根性和传递性

4)protected访问修饰符不允许其他非子类访问.子类可以访问。protected权限比private高。受保护的，由此修饰的成员，可以在当前类的内部以及在子类中进行访问。

类型转换:

1)Person p = new Teacher();  子类可以隐式的转换成父类.

2)Teacher t=(Teacher)p;

3)is和as  typeA is type B 仅判断,typeA as TypeB 先判断,再转换 

is把前面的转化成后面的，是否成功。

子类没有继承父类的私有字段，根本访问不到；公有字段是可以继承的。继承公有的属性和方法();

查看类图  查看类之间的继承关系：类之间的继承关系图。

子类没有继承父类的构造函数，但是在子类实例化的时候，会调用父类的构造函数。

子类会默认调用父类默认无参数的构造函数。

如果父类中写一个参数的构造函数，而子类中没有写对应的构造函数，就会报错：

解决方法:1)在子类中重新写一个无参数的构造函数2)在子类中显示的调用父类的构造函数，使用关键字:base() 只有独特的关键是才this接收。

new关键字的作用：隐藏从父类哪里继承过来的成员变量和成员方法。隐藏的后果就是子类调用不到父类的成员。

this  base

------------------------------------>

里式转换：主要用于实现多态。

1)子类可以赋值给父类

2)如果父类中装的是子类对象，那么父类可以强转成子类。

------------------------------------>

集合：关键是记忆api

特征:长度可变，类型多样。

Count：获取集合长度

Add() 添加单个元素

AddRange() 添加集合元素

list[i]遍历集合，获取集合中的某个元素

Clear():清空集合中的元素

Remove(Object obj):删除指定的元素

RemoveAt(int index):删除指定索引处的元素，索引从0开始。 

RemoveRange(0,3)：根据下标去移除一定范围内的元素

Reverse():元素翻转

Insert(int index,Object obj):在指定的索引处插入元素

InsertRange(int index,Object obj) 在指定的索引处插入一个集合。

Sort()：集合中的元素升序排列

Contains()判断集合是否包含某个元素，返回值为bool类型。合长度问题:

Count:实际包含的元素的个数

Capacity：可以包含的元素的个数

如果没有元素时，值都是0；

每次集合中实际包含的元素的葛素count超过了可以包含的元素的个数capacity的时候，

集合就会向内存申请多开辟一倍的控件，来保证集合的一直够用。

------------------------------------>

随机数类的使用

Random类 在某个范围内随机产生随机数。

Next(0,10)在0到10之间产生随机数，不包括10。

------------------------------------>

Hashtable集合：增加、删除、查询、判存；

1)数据是以键值对的方式存储，在键值对集合中，是通过键寻找值的。

2)键值对均是Objcet类型，

3)键用于查询数据，不允许重复

4)对值使用强制类型转换

Clear() ： 清空集合

Remove(Obkect key)：根据key移除指定的集合元素。

Add() ： 添加数据

ContainsKey() ： 是否包含指定的键  

根据索引去获取集合中的值

------------------------------------>

foreach循环的使用

foreach (var item in collection)

 {

 //var表示变量类型

 //item表示集合里面的每一项

 //collection表示待遍历的集合

 //ht.Keys 表示遍历集合中的键

 //ht.Values表示遍历集合中的值  

 }

C#是一种强类型的语言。在代码中，必须对每一个变量的类型有一个明确的定义。

var：能够根据值推断出数据类型。

在声明var变量的同时，必须给它赋值。

int a = 10;

//获取变量的类型

Type t = a.GetType();

Console.WriteLine(t);

//推断类型

var b = 10;

Type type = b.GetType();

Console.WriteLine(type); 

------------------------------------>

//Stopwatch:测量一个程序的运行时间。

Stopwatch sw =new Stopwatch();

sw.Start(); 

sw.Stop();

Console.WriteLine(sw.Elapsed); 

------------------------------------>

第十一天：总结：

里式转换：2条

两种集合：Arraylist与Hashtable，存储的数据类型任意，集合的遍历与数据的增删改查

Path类的使用 ： 操作路径的类

File类的使用：操作文件的类

导入命名空间的快捷键：

alt+shift+F10

------------------------------------>

————————————————————————————————————————>

要处理好着四个问题：

1)访问修饰符的限定作用

2)字段、属性、方法之间的关系，this关键字的使用

3)属性的作用

4)静态与非静态的调用方式

5)类的实例化与对象的初始化时不一样的