C#面向对象编程

1、C# 泛型集合

List<T> 集合名=new List<T>(); //泛型类型参数"T",比如:string、int、dobule,泛型集合List<T>中只能有一个参数类型,"<T>"中T可以对集合中的元素进行类型约束

 

异同点

List<T>

ArrayList

不同点

增美成分时从严项目检查

可以增添其余类型

不需求装箱拆箱操作

须求装箱、拆箱操作

相同点

因而索引访问集合的因素

添加目的方法一致

透过索引删除成分

 

Dictionary<K,V> dt=new Dictionary<K,V>();
//Dictionary<K,V>声明中,其中"K"为占位符,具体定义用存储键"Key"的数据类型代替,"V",用元素的值"Value"的数据类型代替,这样在声明改集合时,声明了存储元素的键和值的数据类型,保证了数据类型的安全

 

类型

HashTable

Dictionary<K,V>

不同点

可添加装箱、读取时拆箱

对增进的要素具有类型约束

丰富衣服箱、读取时拆箱

不必要装箱、拆箱操作

相同点

由此键值访问集合的要素

丰富目的方法一致

由此键值删除集合的要素

 

会面的概念:

数组是一组具有同等名称和类其余变量集合,使用数组可以储存大批量多少,可以通过索引来检查数组中的成分,可是不可以数组开首化后不能再改吗其尺寸,在程序中无法促成动态拉长和删除数组成分,使数组的施用所有许多局限性,为了缓解那一个题材,.NET提供了各个集合对象如泛型集合:泛型集合Lsit<T>,Dictionary<K.V>。

System.Array类:

System.Array
类是所有数组的基类,位于System命名空间中,提供对数组中的值进行排序、反转数组、检索特定值等方法。

Array 类是一个浮泛的基类,不只怕被实例化。

Array
myarry=Array.CreateInstance(typeof(int),5);

那段代码创设了数组名为myarray,数据类型为int,长度为5的数组。typeof()用来拿到int型的目的,Array.CreateInstance()方法中有八个参数,一个是数据类型,另一个是数高管度。

例1:创造一个字符串数组,初步化数据,然后输出数据;把数组反转后输出数据;对数组排序后输出数据。

            //创建数组
            string[] doges = new string[4];
            //给数组元素赋值
            doges[0] = "哈士奇";
            doges[1] = "贵宾犬";
            doges[2] = "金毛犬";
            doges[3] = "巴哥犬";

            Console.WriteLine("数组的元素个数为:{0}",doges.Length);
            Console.WriteLine("数组的维数为:{0}",doges.Rank);

            Console.WriteLine("------------数组元素------------");
            //foreach遍历数组,获取元素数据
            foreach(string item in doges)
            {
                Console.WriteLine(item);
            }

            //反转数据元素
            Array.Reverse(doges);
            Console.WriteLine("------------反转后的数组元素------------");
            //用for循环遍历数组,获取元素数据
            for(int i=0;i<doges.Length;i++)
            {
                Console.WriteLine("第{0}个元素为{1}",i+1,doges[i]);
            }
            //对数组元素进行排序
            Array.Sort(doges);
            Console.WriteLine("------------排序后的数组元素------------");
            for(int i=0;i<doges.Length;i++)
            {
                Console.WriteLine("第{0}个元素为{1}", i + 1, doges[i]);
            }    

运行图:

图片 1

例2: 使用Array类的静态方法CreateInstance成立数组。

            //创建数组
            Array doges = Array.CreateInstance(typeof(string), 4);
            //给数组元素赋值
            doges.SetValue("哈士奇", 0);
            doges.SetValue("贵宾犬", 1);
            doges.SetValue("金毛犬", 2);
            doges.SetValue("巴哥犬", 3);

            Console.WriteLine("数组的元素个数为:{0}", doges.Length);
            Console.WriteLine("数组的维数为:{0}\n", doges.Rank);

            Console.WriteLine("------------数组元素------------");
            //foreach遍历数组,获取元素数据
            foreach (string str in doges)
            {
                Console.WriteLine(str);
            }

            //反转数据元素
            Array.Reverse(doges);
            Console.WriteLine("------------反转后的数组元素------------");
            //用for循环遍历数组,获取元素数据
            for (int i = 0; i < doges.Length; i++)
            {
                Console.WriteLine("第{0}个元素为{1}", i + 1, doges.GetValue(i));
            }
            //对数组元素进行排序
            Array.Sort(doges);
            Console.WriteLine("------------排序后的数组元素------------");
            for (int i = 0; i < doges.Length; i++)
            {
                Console.WriteLine("第{0}个元素为{1}", i + 1, doges.GetValue(i));
            }

运行图:

图片 2

非泛型集合的不足之处:

品质和体系安全。

泛型的亮点:

性能高:

动用泛型不要求开展类型转换,可以幸免装箱和拆箱操作,从而升高质量。

品种安全:

泛型集合对其存对象开展了项目约束,不是概念时声称的种类,是无力回天储存到泛型集合中的,保险了数量的种类安全。

代码重用:

运用泛型类型可以最大限度的录用代码,爱惜品种的安全以及提升质量。

例3:使用List<T>泛型集合完毕字符串数据动态的丰硕、修改、删除、检索操作。

 

            //创建List<string>泛型集合对象,保存字符串数据
            List<string> list = new List<string>();
            //向集合中添加数据
            list.Add("张雨琦");
            list.Add("赵丽颖");
            list.Add("杨幂");
            list.Add("周杰伦");
            list.Add("李易峰");

            Console.WriteLine("集合的元素个数为{0}\n",list.Count);

            Console.WriteLine("------集合元素------");
            //用foreach遍历集合中的元素
            foreach(string item in  list)
            {
                Console.WriteLine(item);
            }

            //修改集合元素
            list[2] = "大杨幂";
            Console.WriteLine("\n---修改之后的集合元素---");
            //用for遍历集合中的元素
            for(int i=0;i<list.Count;i++)
            {
                Console.WriteLine(list[i]);
            }

            //删除集合元素
            list.Remove("李易峰");//根据对象来删除元素
            list.RemoveAt(3);//根据索引删除元素
            Console.WriteLine("\n---删除之后的集合元素---");
            //用for遍历集合中的元素
            for(int i=0;i<list.Count;i++)
            {
                Console.WriteLine(list[i]);
            }
            Console.ReadLine();

运行图:

图片 3

 2、C#类的继承

持续的定义与风味:

面向对象语言有三大特点:封装、继承、多态,继承是面向对象编程的一个重点特征,任何类都可以从另一个类中继承,也等于说,那些类具有它继续的类的所有成员,在OOP
思想中,被持续的类称为父类(也叫做基类)。注意,C#中的对象仅能一贯派生于一个基类,当然基类也得以有投机的基类,类的继承一个第一功能是子类可选择父类的代码。那样就能够在一个地点集中维护一份代码,防止了重重的双重的代码。

简不难单的案例:

图片 4

声明:新建一个控制台项目,在里面添加了3个类,Daddy是父类,son1、son2是子类。

    public class Daddy_父类_
    {
        public string Name { get; set; }
        public string Sex { get; set; }
        public int Age { get; set; }

        public void hello()
        {
            Console.WriteLine("早上好!");
        }
    }

注脚:那是父类中的代码,有姓名、性别、年龄属性,和一个公告的方法。

    class son1_子类_
    {
        public void hello1()
        {
            Console.WriteLine("陈爸比");
        }
    }

    class son2_子类_
    {
        public void hello2()
        {
            Console.WriteLine("爹地");
        }
    }

诠释:这是三个子类中的代码,他们都各自所有属于本人具有本性的公告格局,那他们想继承类中的代码该如何做啊?

持续的语法格式:

class 子类的名字 : 父类的名字

{

}

接轨Daddy父类后的代码:

    class son1_子类_:Daddy_父类_
    {
        public void hello1()
        {
            Console.WriteLine("陈爸比");
        }
    }

    class son2_子类_:Daddy_父类_
    {
        public void hello2()
        {
            Console.WriteLine("陈爸比");
        }
    }

诠释:那是三番两遍父类之后的代码,这继承之后的界别在哪吧?又发生了如何变动?

            son1_子类_ so1 = new son1_子类_();
            so1.Name = "陈爸比1号";
            so1.Sex = "男";
            so1.Age = 19;
            so1.hello();
            Console.WriteLine();
            so1.hello1(); 

声明:继承之后,大家可以使用son1子类来调用父类中的属性跟打招呼的不二法门,有图有精神请看上边的图。

图片 5

图片 6

注明:我们用son1子类调用父类中的属性跟打招呼的点子,成功的创造了一个子类so1对象,并出口了父类中的打招呼形式的文书,且把温馨特殊的通报方式的文本输出了。

运行图:

图片 7

 sealed关键字:

C#提供了关键字sealed来预防发生屡次三番,就是由它修饰的类或形式将不或许被一而再或重写,假若大家将类标志为sealed,编译器将不会容许我们从这么些类派生。

    sealed class Daddy_父类_
    {
        public string Name { get; set; }
        public string Sex { get; set; }
        public int Age { get; set; }

        public void hello()
        {
            Console.WriteLine("早上好!");
        }

评释:我们用sealed修饰了Daddy父类,那背后会暴发哪些吧?

图片 8

诠释:系统那一个时候就会报错了。

Protected关键字:

公家项可以在其他地方平昔访问,而个人项除了定义它的类之外,不或者从此外对象举行走访,其他任何类都不可以访问;作为主流的面向对象语言,提供了其它一个概念成员可访问性的基本点字:protected.

base关键字调用父类成员:

C#中base关键字在后续中起到了相当首要的效果,base关键字表示父类,使用base关键字可以调用父类的构造方法、属性和章程。使用base关键字调用父类构造方法的语法如下:

子类构造方法:base(参考列表)

动用base关键字调用父类方法的语句如下:

base:父类方法();

案例:

    public class 父类
    {
        public 父类(string name,string sex)//构造方法
        {
            this.Name = name;
            this.Sex = sex;
        }
        public string Name { get; set; }
        public string Sex { get; set; } 

        public void hello()//父类方法
        {
            Console.WriteLine("姓名:{0},性别:{1}",this.Name,this.Sex);
        }
    }

    public class 子类:父类
    {
        public int Age { get; set; }
        public 子类(string name,string sex,int age):base(name,sex)//通过base调用父类构造方法
        {
            this.Age = age;
        }

        public void hh()
        {
            base.hello();
            Console.WriteLine("年龄:{0}",this.Age);
        }
    }

        static void Main(string[] args)
        {
            子类 cbb = new 子类("陈爸比","男",19);
            cbb.hh();
            Console.ReadLine();
        }

运行图:

图片 9

注释:

地点的代码中示范了什么使用base关键字调用父类构造方法,子类构造方法public
子类(string name,string sex,int
age)使用base关键字调用父类构造方法,base关键字括号内部是父类构造方法的参数列表,这里只写名称,不写参数类型。代码中还出现说法了怎么调用父类中的方法,base.hello()调用父类方法hello()。

this关键字调用本类成员:

C# this
关键字引用父类的日前实例。使用this关键字可以使代码编写更简短,不易于出错。在类的不二法门里输入
this
关键字,在后头输入“.”符号后,系统就会把本类所调用的非静态方法和变量都来得出来采纳,进步了编码成效。

窗体继承:

此起彼伏窗体就是按照现有窗体的构造创建一个不如一样的新窗体,那种从现有窗体继承的历程称为可视化继承,创造继承窗体有二种方法一种是编程格局,一种是运用持续拔取器成立继承窗体。

案例:

图片 10

诠释:先建多少个窗体(命名一定要正式,那是案例因而写的国语,以便精晓)

父窗体:

图片 11

子窗体:

图片 12

声明:子窗体里面内容是空的,若是子窗体的情节跟父窗体的故事情节大概,那我们可不得以把父窗体中的内容拷贝到子窗体中吗?对,的确可以将父窗体的情节复制到子窗体中,这除了复制还有没有其余方法吧?对,窗体继承!

步骤:

图片 13

讲明:打开子窗体界面,鼠标右键查看代码

图片 14

表明:子窗体中的代码

 图片 15

诠释:把From改成父,继承父窗体中的内容,然后大家点一下开行。

图片 16

诠释:这么些时候子窗体中早已有内容了,但假设大家想把登录按钮修改一下吧?

图片 17

注明:子界面中的始末多了一把锁,然后属性栏中的功效也是灰褐的,那个时候就表示无能为力编辑子窗体中的内容。

图片 18

表明:点一下签到按钮,大家发现了锁不见了,然后属性栏效率也苏醒正常了,那是干什么呢?

图片 19

图片 20

诠释:我们发现了,账号的TextBox的Modifiers的质量是:private,登录按钮的Modifiers的性质是:Protected。

结论:假如大家想一而再一个窗体,直接在该窗体中编辑代码,继承目的窗体,如若父窗体中的某个内容在子窗体中须求修改,那么要求修改内容的Modifiers的属性应该改成:Protected

走访修饰符设置访问权限:

访问修饰符 类内部 子类 其他类
Public 可以 可以 可以
private 可以 不可以 不可以
protected 可以 可以 不可以
Internal 可以 可以 可以

3、C#多态

图片 21

 注释:大家先建一个控制台应用程序,然后添加一个父类,几个子类,然后子类继承父类的艺术,假诺我们在子类中想修改一下继续过来的父类方法,那咱们应有怎样去修改父类中继续过来的方法呢?

图片 22

诠释:如若你想修改从父类中三番三次过来的措施,那么首先大家相应把父类中的方法写成虚方法,那样父类中的方法就同意大家去修改了,可是成立虚方法也是有语法格式的,在写父类方法的时候理应在造访修饰符前边添加 virtual 关键字。

图片 23

诠释:重写从父类中接二连三过来的章程时,应该在造访修饰符中添加重写的关键字:override  ,那样大家就修改成功了。

图片 24

诠释:成立一个基类数组,添加基类子类对象,子类1对象,然后把咱们输出会得到修改的结果。

图片 25诠释:大家发现父类那一个基类,大家一向不需求动用它创设的目的,它存在的含义就是供子类来三番五次,所以大家可以用抽象类来优化它,大家把父类改成抽象类,hello()方法改成肤浅方法,代码如下:

图片 26

诠释:抽象类父类内添加一个hello()抽象方法,没有方法体,也无法实例化,其他子类代码不变,子类也是用override关键字来写父类中架空方法,Main主函数中基类就不能创制对象了,代码稍微修改如下:

图片 27

运行图:

图片 28

诠释:总而言之,抽象类无法被实例化,我们挑选拔取虚方法已毕多态依然抽象类抽象方法完结多态,取决于我们是或不是要求接纳基类实例化的靶子。

4、C#接口

接口的概念:

接口是一种用来定义程序的合计,它讲述可属于其他类或结构的一组有关行为。接口可有方法、属性、事件和索引器或那多种成员的其余组合品种,但不能够包涵字段。

概念接口的语法格式:

 

接口存在的含义:

案例:

5、C#充裕处理

相关文章