C#笔记（02）

1 day1

2.  0526程序工具   4

 

数据库语言和系统：

SQL语言

SQL SEVER

Oracle

程序开发平台和语言：

C 语言，VB，C++

ASP，HTML/javaScript（标志符语言）

预备课程

计算机基础

程序设计基础：

课程安排

.NET入门  C#理论

.

 

 

 

 

 

 

 

.net发展：微软在2000年6月发布.net战略  2002年底一个版本visual studio.net2002

       发行版本VS.net2002   VS.net2005          Vs.net2008[2007          Vs.net2010[2009]测试版

.net简介：

.NET程序执行

.net产生的原因：1.互联网的发展  2.用户需要个人空间  3.企业需要资源利用最优化企业利润最大化想整合新旧系统

                           异构（是硬件不兼容）是阻碍互联网发展的因素

                     4.程序员需要高效强大的工作

。NET怎样创建WEB服务？

1.        创建WEB服务项目

2.        加一个Web服务到项目中取名 编写一个Funvtion  通过[ebMethod]把Funtion变为Web服务器

3.        编译连接

.net是一种思想

.net是一种思想一种理念让任何人在任何时候任何地方做

.net是微软一起系统的总称  .net企业服务具有.net开发

C#  VB.NET  C++  .NET

公共语言规范CLS（common Language Specification）： ASP.NET  Windiows窗体  ADO.NET   XML

.net框架类库

CLR 公共语言运行库（Common Languages）

WINFOWS COM+服务

.NET执行：两次编译

第一次编译：源代码编译产生的是中间语言（慢）

第二次编译：中间语言（immediate language 是一种介于高级语言和基于汇编语言的伪汇编语言，由一种特定指令组成独立CPU的指令集，平台无关，跨平台，实现语言互操作性[跨语言]）转换成可编译语言（快）

.NET特点：

1.       统一的编程接口

传统的编程模式

不同的语言[VB，VC，Delphin]采用不用的编程模式和编程接口

Web编程和windows编程采用不同的编程模式

2.       .net编程模式

3.       .NET的核心技术基础：以.XML和Internet协议为基础

基于开放的标准

4.       高效而功能强大的集成开发环境（IDE：integrated Developing Environment）

Visual studio.NET

典型C#构成：

l         C#和.net的关系：C#是专门为.NET设计的面向Internet和企业应用的新一代编程语言，

l         程序：一系列有序指令的集合

l         C#程序的本质：C#的程序是类的集合

l         C#程序的构成单元

编译：注解说明

  单行编译 //说明

多行编译 /*   */不能嵌套

//hello C#程序注释

//System.Console.Writelne(“hello,word”)方法：将指定的数据输出

Namespace 定义命名空间

  Using System;    // System命名空间

namespace MyNamespce

{

              class class1

{

      static void Main()   //必须有Main方法且必须放在类中且静态（static）的返回类型void或int有返回值return(); Main(string[]) 参数可有可无

{

       //System.Console.Writelne(“hello,word”)

Console.Writelne(“hello,word”)；

Console.ReadLine();//停止

 

}

}     //输出hello,word

}

课后回顾问题：

1.       .NET是编程语言吗？

不是语言是平台

2.       .NET平台支持那种语言？举例  

VB.NET  C#  C++.NET  Delphin  J#.NET

3.       所有的.NET应用程序都经过几次编译？第一次编译结果是什么？

2次   中间语言

4.       基于.NET平台的软件是如何执行的

经过2次编译

5.       IL指的是什么？

      immediate language 在任何时间任何地点访问任何

6.       .NET平台理念是什么？

7.       .NET平台的核心技术基础核心组件是什么？

8.       描述一下.NET Framework 体系结构？

9.       CLS的含义？

公共语言规范

10.     .NET 的特点？

作业

 图片从左向右运动   ftp  用户名：MSD0905 密码：tarena_0905

0526

//格式规范

/1块{}

//块内部有其他块内部块要回退一个Tab（4个空格）键

//支持半角符号

程序工具

1.       文本编辑器(效率低 但也要回用)

1记事本输入代码

2改扩展名 .cs

3DOS下执行如：csc.exe hello.cs

csc  在msdn上查帮助

2.       VS.NET

1)      VS.net 特点介绍：是高效而强大的集成开发环境   是一整套的开放工具很多模版

2)      生成的项目类型：控制台应用程序  windows应用程序 Asp.NET web应用程序 智能设备应用程序（移动应用程序）

3)      编程特性

4)      环境：让代码显示行号（工具-选项-文本编辑器）  代码中的字体（工具-选项-环境） 常用窗口（在试图里找）： 1资源管理器        窗口-重置布局

5)      控制台应用程序项目模板等价文本+编译器 常用模版：windows应用程序控制台应用程序  ASP.NET网站  添加项目模板（选中项目点右键）重要：类（用于语法学习）主要是实现功能逻辑功能。常用：windows窗体：主要输入输出。web窗体：UI输入输出  文本文件可以转换任意文件

6)      解决方案和项目：解决方案中会包含多个项目（工具-选项-解决方案）  解决方案多启动

C#应用程序是类的集合（另一个角度文件的集合：可以包含多个文件）

 1.类和文件的关系：

1）一个文件里可以包含多个类，一个类可以拆分到不同文件中。作为一种编程规范：最好一个文件中放一个类。没什么关系！

2）文件名和类名：可以相同也可以不同，写代码用的是类名  编码规范：最好 文件名和类名保持一致；

控制台应用程序 模板多种类型文件—作用  

 

 

1.         *.lsn 解决方案文件：管理项目 a包含几个项目 b打开所有项目

2.         *.suo 解决方案用户设置文件

3.         *.csproj 管理文件  a..包含了多少文件 b.打开当前文件注意不能直接点击一个.cs文件，没办法调试

框架文件犹如建筑物

4.         *.csproj.user 项目用户设置文件

5.         所有以.cs结尾的文件dou不能删除  主要是代码

6.         文件的层次不能修改   properties  见后

7.         bin 文件：输出文件夹，程序编译后的结果    

a.       ConsoleApplication1.exe文件是最终编译结果

b.       ConsoleApplication1.pdb 程序调试数据库文件，供编译器使用

c.       ConsoleApplication1.vshost.exe  提高调试性能

obj 文件：目标文件，中间的结果

运用帮助

1.          索引  本地资源

2.          搜索  本地互联网

3.          目录  没事系统罗列

4.         快捷帮助     F1  ok

 

会简单的调试和单步执行

1.         F5 运行 回车退出

2.         单步执行  F11  黄色消失说明执行焦点转移等待输入

VS.NET创建控制台的步骤

1.        新建项目合适的语言合适的

标志符：程序中用来区别某个元素的名字

1.       预定义保留标志符（关键字）

2.       自定义的标志符（表字符）

3.       类库中的命名空间  pascal 命名

C#中标志符的规则：

l         不能包含任何特殊字符但可以是_

l         .可以包含数字  但不可以数字开头

l         区分大小写不可以重复

l         C# 中系统标志符不可以再用

l         C# 保留字（系统）不能在程序中做标志符  @前缀

关键字：是对编译器具有特殊意义的预定义保留标志符

作业：关键字：中的语句预习 msdn 运算符：整除取余

附加题：运算 z=x+y*(x*y)

 

                

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

0527（day3）

运算符：执行计算，为变量赋值进行相等或不相等的测试以及执行其他运算

表达式：罗列而成的式子

赋值运算符：语法：变量=表达式；x=90；p41；

算数运算符：1.连接（字符串）2.加法；p40

1.         操作数一致

2.         类型一样类型兼容系统会自动把一种类型转换车功能另一种类型

逻辑运算符：与（&&）或（||）非（!）

数据库结构.成员 

优先级别

循环 int re=Math.Pow(2,8);

内置数据类型（1.内置结构类型 2.枚举）

基本内置结构类型：整型浮点 char

  选择：合适够用不浪费

Unicode字符：是用于字符和文本的通用字符编码方案 

包括基本ASCII字符集，各种其他字母。重音符，货币符号，小数，音调符号以及数学支持和技术符号。

Unicode的前128个码位（0~127）对应于标准美国键盘上的字母和符号

ASCII字符代表

字符串：是Unicode字符发有序集合 

格式：string  s=“ ”;

      String s1=”abcde”;

         Char x=s1[0]; 从第一个开

String：

1.          空   string s =” ”;

2.         数字字符串由 0~9字符组成的   string s=”123”;

3.         日期格式字符串

4.         混合字符串     12a

5.         string  默认为null

6.         string  x=null；内存中不存在不被引用

string  s=” ”;  内存中以开辟了s为空的空间

数据类型的分类：

1.        CTS的含义：（common  type system公共类型系统）

2.        CTS是.NET平台利用了不同语言的共性抽象出来的

3.        CTS主要包含标准.NET数据类型和准则集

l         CTS中的每一个类型都是继承自一个基类—system.object（）

值     栈执行效率高   空间利用率低   特点算法 系统管理  先进后出（轻量级）

引用   堆  数据需寻址  效率低 空间利用率高（重量级）

 

 

0530（day4）

加法程序：

1.         //总体提示

  Console.writeLine(“进行加法运算”);

2.         //获得输入一个或多个

String a=Console.ReadLine();

String b=Console.ReadLine();

3.         //处理

//初步处理

int x=convert.int32(a);

int x=convert.int32(a);

//核心处理

String re=x+y;

4.         //输出

Console.WriteLine(re);

数据类型转换：

l         隐式（自动）类型转换（Implicit Data Tupe Conversion） 例如： int x=5; double y=x;

l         显示（强制）类型转换（Explicit Data Type Conversion）语法：类型名变量或数值

例如 int x=5;double b=(double)x;

类型转换：

1.       值《》值（值到值的转换）：表示范围小的类型值转换为表示范围大的类型的值

Short – int – long – float – double

把范围大的转换为范围小的类型的值

l          大转小要显示

l          不一定会成功

2.       值《》引用：

1）值转换为引用：装箱（Boxing）

l         可以用2种方式可以隐也可以显示方式

l         一定成功

2）引用转换为值：拆箱（UnBoxing）

       只可以显示拆箱

3.       引用《》引用

类型转换方法：

源（8）转换为目标（”8”）

n         Convert 类 : 语法：Convert.To目标（源） string re=Convert.ToString(8);

命名空间：System 程序集：mcorlib

n         （）:     结果 (目标)源  string re=(string)8;

n         Parse: 发放源是字符串  re=目标.parse (源)

int re=int.parse(“8”);

 

                                         源                               目标

1.       Convert 类 : 常用的基本数据类型   引用类型之间的转换

值，引用：string object日期datetime

l         字符串：数值字符串》值

l         值》字符串： string re=a.tostring();或 string re=convert.tostring(a);

l         字符串：日期格式字符串》日期

  日期：DateTime d=new DateTime(2008,8,9,12,25,30);显示：”2008-8-9,12:25:30”

   DateTime d=DateTime.now;    datetime re=d.tostring();

         日期格式的转换： 

 string s1 = "2008-8-8";

            string s2 = "2008/8/8";

            string s3 = "2008-08-08";

            string s4 = "2008/08/08";

            DateTime d1 = Convert.ToDateTime(s1);

            DateTime d2 = Convert.ToDateTime(s2);

            DateTime d3= Convert.ToDateTime(s3);

            DateTime d4 = Convert.ToDateTime(s4);

       

2.       （）:                     装箱和拆箱       引用类型之间的转换

3.       Parse:    数字字符串                                     基本类型

 

1.     Console.WriteLine(re); //输出换行

2.     Console.Write(re);//输出不换行

3.     Console.ReadLine(); 例如 String a=Console.ReadLine();

4.     Console.Read(); 例如  int a=Console.Read ();

1）只读取 一个字符 2）把字符转换成相应的   ASCII值。

格式化输出

Console.WriteLine(“格式化字符串”,参数);

占位符（标识符）：”{数字}”,参数列表

 

 

 

 

 

 

 

 

 

 

0601

1.         分析问题   一个任务分成多个小任务  类似性

      确定此问题需要循环

2.         选择循环语句

记住语法

3.         套语法

l         确定循环条件  循环表达式

a 固定次数  b设定

l         确定循环体 循环语句的语句块

While循环：

1.       循环语句初始化

修改循环条件否则死循环模板：  

int i = 0;

        while(i<5)

      {

        i++;

      }

do … while 循环：

l         do… while 先执行后判断 所以条件为假 至少执行一次

int i = 0;

            do

            {

                i++;

  } while (i < 5);

l         while循环 先判断后执行 所以条件为假不执行

int i = 0;

           while (i < 5)

            {

                i++;

  }

for循环

    for(表达式1(赋初值);表达式2（限制循环条件）;表达式3（修改循环变量的值）)

{

    语法；

}

Foreach循环

        用于遍历整个集合或数组（循环访问集合）以获取所需要信息

        语法：foreach(数据类型 变量名in 集合的名)

               {

               }

        例子：int[] numbers = new int[5];

 

             foreach(int iin numbers)

             {

                Console.WriteLine(i);

             }

 

 

            string s = "abcde";

            foreach(char iin s )

            {

                Console.WriteLine(i);

 }

 

 

循环次数不固定 do和 while

 

Goto 将执行路径直接传递给标记语句  使代码的阅读和维护更加困难

 

0602

1.         枚举

2.         数组：是可以在内存中连续存储多个相同数据类型的数据结构类型的元素结构 system Array是抽象的基类   数组的5种写法

数组的规则：

l         声明 [ ]不能写任何数据  表示数组的维数

     [ , ] 一维数组

     [ ,  , ] 二维数组

l         = 右边的 [ ] 表示数组的长度绝对不能为空 常量  变量

     固定数组：一旦创建 大小（长度）就不能再修改了

l         创建初始化成非默认值  可以用循环  值类似：“zhang1”“zhang2”

For 循环放值

l         不可以循环一个一个的放

 

数组：

1.       创建：

//1 了解

            Array names = Array.CreateInstance(typeof(string), 3);

            //2 ok!

            string[] names2;

            names2 = new string[3];

            //3 ok

            string[] names3 = new string[3];

            /*

             * 1 声明【】，表示的是数组，以及数组的维数

             *        【】空一维

             *        【】，二维

             *        【】，，三维

             *        【】千万写数据

             * 2 =右边的【】，表示数组的长度，绝对不能为空

             *                 常量，变量

             *   固定数组：一旦创建，大小【长度】就不能再修改了

             *             不能插入，移除        

             */

 

            //4 ok

            string[] names4 = new string[3] { "a","b","c"};

            //5 ok

            string[] names5 ={"aa","bb","cc" };

            // || no!!

            //string[] names55 ;

            //names55={ "aa", "bb", "cc" };

            //6 ok

            int x = 3;

            string[] names6 = new string[x];

2.           放值:  数组的名字【X】=要放的值；类型一致

        //创建的写法,元素默认值 string【】》null

        //                        int[] >0

        //目标：放值》初始化成非默认值

        //注意：1>names.Length

        //      2>数组的名字【X】：表示的下标为x的元素

        //      names[0]        ：x>=0;x<names.Length

        static void Main66()

        {

            //创建

            string[] names = new string[30];

            //初始化成非默认值

            //1)可以用循环》值类似：“张三1”“张三2”

            // for>放值

            //for (int i = 0; i < 30; i++)

            for (int i = 0; i < names.Length; i++)//ok!

            {

                names[i] = "张三" + i.ToString();

 

            }

 

            //2)不可以用循环:一个一个赋值

            //names[0] = "张三";

            //names[2] = "李四";

            .....

            //names[29] = "标";

            //names[30] = "爱爱" ;//no!!

            Console.ReadLine();

 

 

 

 

 

 

 

 

 

 

 

DAY7 0603

方法变量

1．方法是在类或结构中声明的包含流程控制语句的代码块

在C# 中每个执行指令都是在方法的上下文中执行的

2．  大部分方法可以处理传入的数据并返回处理的结果

3．  方法尽可能小，以便完成

4．  方法减少代码的重复

5．  方法的语法：

[修饰符 ]返回类型 <方法名>( [参数的数据类型参数名称] ,……)

{

 

}

1. 方法的声明，定义

       a.位置 类，结构中，不能嵌套

       b.一般语句放在方法中 尤其：方法的调用必须放在方法中  一般用 A方法调用B方法

       c.传入值  --方法体    传出值  ——调用端

2. 方法的调用

语法：方法名（[参数列表]）；

           条件必须位于一个类中

1) 返回类型   2大类  a..没有返回值 返回类型  void  可以没有return   如果函数返回类型是void 调用端酒不能用=接收  return ;不能在return 后面加任何表达式[常量，变量等]表示立即返回[到调用端]

特点：利用跳出函数条件语句中运用

 b. 有返回值       返回类型除了void之外的 c#数据类型  必须有return

语法: return表达式 ;   这个表达式类型必须和返回类型兼容[一样，]

调用方法：a。不用=          b。用=

注意：每个可能的路径都有 return表达式

3. 参数：

1）  两大类

a. 形式参数（形参）：声明[定义]方法时，（）中声明的参数是

 形参

l         语法：数据类型名称1，数据类型，名称2，……

l         注意：必须有数据类型相当于变量 类似变量的声明不能初始化

l         作用：变量的作用

b. 实际参数（实参）：调用方法时，（）中声明的参数是

       注意：调用方法的时候要对用一致

定义时没有参数调用也不能用

如果定义时有调用时对应一致

对应一致：定义时有几个，调用时就几个

但是实参不能有数据类型说明符且类型匹配

个数一样  类型一致

实参：常量变量

方法的写法：

2）  语法

3）  分层 模块化

 第一步：用原始方法作出来 一个方法 Main

 第二步：Main代码两类 一类 UI [ userinterface：出入输出]

第三步： 编写方法：把核心处理 写成方法

            注意：确定返回值和参数

                    不要出现ui元素输入输出语句

 

 

 

变量：

    局部变量：声明在方法中的变量 一般标识符 已经声明了就不能再声明了

    成员变量：直接声明在类中的变量

       全局变量：c#中没有   

              区别：1）局部变量必须程序员初始化才能用

                             成员变量程序员不初始化就可以用

                       2）变量的作用域 作用范围不同

                                  局部变量：当前语句块初始化开始到  } 结束范围内

                                  成员变量：当前类块

       重名问题：

l         同一函数中局部变量和局部变量不能同名

l         同一类中成员变量和成员变量不能同名

l         成员变量和局部变量重名的时候遵循就近原则 如要使用成员变量类名.成员变量 或 this.成员变量（没有static）

 

参数的传递：

值传递：调用端不受被调用函数的影响

引用传递：调用端受被调用函数的影响 ref  c#中的引用传递 让函数返回值

引用传递实现方法：

参数传递：

1.        值以值得方式传递   参数默认类型，默认

2.        值以引用的方式传递 参数是值类型，ref，out

3.        引用以值的方式传递 参数是引用类型，默认

4.        引用以引用的方式传递不用

Void f（ref string s）例外

重点：值以引用的方式传递 ref，out

Ref返回值输入输出  当需要一个函数返回多个类型值的时候可以考虑用引用传递即

ref参 在调用端初始化（面试题）

out参数：传出  先使用后初始化 一定在方法中初始化

params：定义参数时使用参数是可变的

注意：在方法中声明的params关键字之后不允许任何其他参数，并且不允许只有一个params参数

              是形参表最后一个且只能由一个   只可以是一维数组8

 

 

 

 

 

 

 

0604 day8

方法重载

 

 

方法重载：定义在

1.         同一个类中

2.         名字相同

3.         参数不同

l         参数类型不同

l         参数个数不同

l         参数类型和个数都不相同

4.         多个方法

注意：与参数名称无关 与函数返回值无关

何时用方法重载：一个类有多个功能 其中有2个以上功

能类似就可以对相似的功能用重载

方法重载优缺点：

              优点：代码重用

                      提高开发效率

                      方便（使用者）调用

              缺点：用的不合适将使代码难以维护〉度合时

微软类库重载标志：如：Console.WriteLine();

              技巧：方法后先输入（暂停

XML文档注释（只能放在类的上边，类中成员的上边）

///自动感应声成注释和生成文档的作用

 单行 多行

C# 中的类是一种数据类型，用来定义对象的类型的类

是对象的模板，对象是类的实例[对象基于类的实例]

C#的对象是用于在程序中模拟现实生活的事物对象是具体的实体

C# 中的类是使用class关键字创建的

       语法：[访问修饰符] class<类名>

                     {

                           类的主体——成员变量；

                           类的成员——（成员）方法；

}

成员变量语法：[访问修饰符]数据类型成员变量；

方法的语法：[访问修饰符]返回值<方法名>）（[]）

创建类对象的方法;

       类名称对象名称=new类名称（）；

调用类成员的语法：对象名变量名；

类的成员是非静态的，跨类调用

静态： static对象方法方法

非静态：没有static类方法

 

 

 

 

调用类的静态方法：

       类名.静态变量；目的取值赋值

       类名.静态方法名（[]）

静态方法是专门为了访问静态变量的 不能访问非静态

方法发调用  同一个项目跨类调用

       看被调用的函数是不是public[internal]不是不调用

       看被调用的函数有没有static如果有调用的语法：

              类名.成员

       没有调用的语法：对象名.成员名；

 

 

 

 

 

 

 

 

 

 

 

0605 day9

构造函数和析构函数结构和继承

 

构造函数

1. c#中的构造函数是类中的特殊类型的方法；与类同名；不

返回值  

语法：[访问修饰符 public]类名（）

              { 构造主体 }

     class 车

    {

   int ID;

        string name;

        public 车(int ID,string name)

        {

            this.ID = ID;

            this.name = name;

        }

   }

 

n         可以重载

n         用途：初始化

n         初始化类的成员变量的使之初始化为非默认值

n         非静态构造函数 初始化非静态变量的，使之初     始化为非默认值

n         静态构造函数 初始化静态成员变量，使之初始化为非默认值

2. 成员变量1）系统完成初始化，没有编写构造函数        2）程序员编写构造函数 初始化成默认值或非默认值

 

3. 类中多个构造函数的关系：

       1）非静态构造函数：

a.       默认构造函数（无参构造函数）

b.       有参（非默认）构造函数

由谁调用：系统[隐式的]

何时：new 创建对象时调用

2）静态构造函数：以static开头

l         没有访问修饰符

l         不能有任何参数

l         可以和类非静态构造函数共存

l         不允许出现访问修饰符

l         不能重载

l         只被执行一次

l         只有一个

l         初始化类的静态成员的

由谁调用：系统[隐式的]

何时：类的第一个实例创建前执行

5.         类中构造函数：如果编写了一个有参的构造函数应该再加一个没有参数的构造函数。

4. 调用多个：语法：在构造函数的（）：this（实际参数）

C#析构函数：是类中特殊类型的方法 ~不能有修饰符

  可以有但不用

创建和使用自定义结构类型：

结构类型（struct，随同ructure的缩写）

l         以struct定义的值类型

l         可以有方法

l         可以拥有带参数的构造函数

l         结构属于值类型不能实现继承

定义：structstudent

        {

            public int id;

            public string name;

            public void show_details()

            { 显示学生信息 }

        }

5. 结构：1. 这个样子  属性，索引器：是c#语法中一种结构2.用struct关键字创建的一种数据类型[值类型]

狭义结构：用struct关键字创建的一种数据类型[值类型]

        面试题：结构和类比较

C#中的结构和类相似，结构是有很多制约条件的一种类型

相同点：他们都可以有成员变量和方法，构造函数

           都是用来模拟现实生活事物的

轻量级，不想被继承 〉结构；

轻量级，           〉类

重量级 ，          〉类

重量级 ，不想被继承〉封闭类（存在堆上）

不同：结构是值类型  类是引用类型，一般可以被继承

结构：

l         可以有Main函数

l         成员变量不能直接初始化（区别于类 1.）

l         静态成员变量可以直接初始化

l         方法（一般非静态）可以直接初始化

l         静态 可以直接初始化

l         默认（无参数）不能包含无参数构造函数（区别    于类 2.）

l         有参数（非静态）初始化所有非静态成员有参数（区别于类 3.）

l         可以有析构函数 不能包含（区别于类 4.）

如何使用：  

差别结构没有new初始化所有成员变量可以调用它的变量否则不能

结论：new后调用如同类一样

 

 

 

OOP的基本特征：OOP（object oriented programming）面向对象的编成

定义：是一种思想也是一种方法，以分类和抽象的方法解决问题的技术

特征：继承，多态，封装

优点：可以实现代码的重用，提高开发效率，提高可维护性

缺点：度，过度，性能降低

学习重点：贯穿整个项目

OOA：（object orientedAnalysis）面向对象的

OOD：（object oriented design）面向对象的设计 

   

继承：在声明类时，在类名称后放置一个冒号，然后指定要继承的类（实现了继承）

public class Father : Son{ }

Father是派生类 Son是基类

如果没有冒号系统认为是基类object的派生类

Father和Son兼容。继承关系会自动转换为 Son对象〉Father

优点：代码重用；派生类将获取基类的所有非私有数据和行为以及新类为自己定义的所有其他数据或行为。因此，派生类具有两个有效类型：

继承的类型：c#只支持单继承

单继承：继承自一个基类

多继承：继承2个或以上基类

 

Father son=new Son();//只调父类

 Son son=new Son();//可以调父类和自己

继承关系相同调用不同

何时用：

 

0608 day10

多态性

1.         多态性：通过继承，一个类可以用多种类型可以作用他自己的类型、任何基类型或者在实现接口时作用任何接口类型。

l         C#中的每个类型都是多态的类型可用作他们自己的类型或作用object实例，因为任何类型都自动将object当作基类型。

2.        多态性的实现：

l         当派生来从基类继承时，它获取得基类的所有方法、字段、属性和事件。

l         若要更改基类的数据和行为，您有两种选择：可以使用新的派生成员替换基成员，或者可以重写虚拟的基成员。即多态性主要靠重写和隐藏来实现

l         方法隐藏:隐藏基类成员（派生类用和基类相同的名字隐藏基类）

3.         隐藏基类中现有方法的步骤：

1. 在继承类中声明同名的新方法
2. 在该方法名前附加new关键字

方法重写:重写基类成员

4.         重写基类中现有方法的步骤：

1. 在基类中定义虚方法，方法加virtual关键字
2. 在继承类中声明同名的新方法
3. 在该方法名前附加override关键字

隐藏调用的是父类方法

重写调用的是子类方法

5.         方法：                  静态                    非静态

l         一般             可以                     可以

l         构造方法      可以                     可以

l         析构方法      可以                     不可以

l         虚方法：virtual   可以                     不可以   

l         隐藏方法：new    可以                   可以

l         重写方法：override     可以              不可以

l         重载方法：一般 看参数    可以      可以

l         抽象方法：abstract      可以           不可以  继承类必须实现 override

性质：

静态

              非静态

类：

特性                                实例化          继承

1.一般 1）一般                 可以              可以

2.特殊 2）封闭类 sealed    可以

          3）抽象类 abstract                     可以

          4）接口 interface                        可以

抽象类：在类定义中将关键字abstract置于 class 的前面创建的类

抽象类的特点：可被继承不能被实例化

抽象类可以包含抽象方法也可以不包含抽象方法

抽象方法：是只包含方法的定义,不包含方法的实现，方法定义后面是分号，而不是常规的方法块。

 分类：1.放在抽象类中的  有标志abstract

 特点：派生类必须实现 不同于虚方法（没有实现）

虚方法放在抽象类中的  抽象方法的区别：

虚方法：有实现继承类可以重写也可以不重写如果重写 virtual〉 override

抽象方法：没有实现继承类必须重写

abstract 〉 override

抽象类的派生类必须实现所有抽象方法。

抽象类中定义抽象方法，将关键字 abstract添加到方法的返回类型的前面，而且关键字 abstract 修饰符的抽象方法，只能存在于抽象类中

abstract class A

      {

          public virtual string Name() { ... }

          public abstract int Length();

      }

      class B : A

      {

          public override string Name() { ... }

          public override int Length() { ... }

      }

纯抽象类：抽象类中包含抽象方法语法不同 abstract class

接口：本身就是抽象方法

接口实现：类继承接口，必须实现借口列出的成员

接口继承 ：接口继承

显示实现不能加 public

密封类：在类定义中将关键字sealed 置于 class的前面。

密封类的特点：可被实例化不能被继承

 

封装：包含和控制对一系列相关信息的访问能力

n         把一系列相关的信息包含在一个单元中

n         控制访问性

封装的目的：

l         隐藏内部细节从而实现保护具有安全稳定性

l         便于使用

面向对象：规范定义类中成员变量不公开 private protected特征：间接手段获得

属性，方法，构造函数

最好的选择：属性 赋值  取值[读写]使用简单

                    方法  赋值 取值[读写] 不简单

                    构造函数赋值

属性：属性是c#中的一种语法结构

private int_age;

        public int age

        {

           set     //读

            {

               if(value>0)

               {

                   _age=value;

               }

            }

            get     //写

            {

                return _age;

            }

        }

  为何使用属性：属性是实现封装的一种方式起到保护类成员变量的作用调用简洁方便通过属性可以访问私有成员变量

   属性与字段的比较：属性是公有字段的扩展，与字段不同，属性不直接应对存储位置

属性与方法的比较：属性与方法不同，属性不使用（）（属性的本质相当于2个方法）

索引器：是c#中的一种结构

[访问修饰符]  数据类型this[数据类型标识符]

        {

            get { };//get访问器

            set { };//set访问器

      }

为何时用：索引器

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

0609 day11

委托和事件

委托：是c#中的一种引用类型类似于c/c++中的函数指针

委托的用途：主要用于.NET Framework中的事件

委托是一种安全的封装方法的类型委托包含对方法的引用

委托可以封装方法[那些方法可以分配给该委托]

与委托的签名[由返回类型和参数组成]匹配的任何方法

一旦为委托分配方法，委托将与该方法具有完全相同的行为

委托使用步骤：

方法只做委托的参数

EventArgs 是包含事件数据的类的基类

Public Class EventArgs

事件：是类在发生其关注的事情时用来提供通知的一种方式

使用事件，对象A可以将关于事件或已发生变化的信息通知其他对象B

l         引发事件的对象成为发送生方 或事件源

l         捕获事件并对其作出相应的对象叫做事件接收方

在事件中，发送方不知道哪个对象或方法将接手[处理]它引发的事件。故需要在发送方和接受方之间一个媒介

计算机通讯方式：

1.       查询式

2.       通知式事件

优缺点：

1.       查询式  工业监控系统

信息发生频率高，密集，周期性 信息丢失，资源浪费

2.       通知式信息频率不高，不密集。随机性

事件通知

事件必须定义在类中

定义事件发布方

预定事件：能否给对象预定事件取决于事件是否存在

如果事件存在

 

 

 

 

 

 

 

 

 

 

 

 

 

 

0610  day12

 

集合是一种通用的数据类型集合帮助我们集中的存储和操作数据

System.Collections 简介

System.Collections.ArrayList类

ArrayList类：

数组 Array int[] string[]普通固定

ArrayList     可变数组列表  链表

ArrayList用法：

属性：Capacity（容量） .Count（数量）

方法：add insert remove removeat

1.  ArrayList List =newArrayList();

      int x = List.Count;

      int y = List.Capacity;  // Capacity 自动(可以手动修改) 0     4   8   16  32

             List.Capacity = 1;

 2.//set不能用下标 只能add

             //List[0] = "ok";

             List.Add("1");       // Add  0   1   5   9   17 

数组1）可以设置数组的下界2）只可以一维

Hashtable ：哈希表存储键值对

 放置：

  Hashtable hash = new Hashtable();

             hash.Add(1, "zs");

             hash.Add(2, "zs");

                hash[3]="ok";

                hash["3"] = "ok";

get 用途：key > value  2)!key values

string re = hash[1].ToString;

 

 

 

泛型：

定义：是c#语言2.0和通用语言运行时（CLR）的一个新特性。

参数类型（type parameters）是泛型为.NET框架引入的概念

    类型参数使得设计类和方法时，不必确定一个或多个具体参数，其具体参数可延迟到客户代码中声明实现。例如：

l         使用泛型的类型参数T 写一个类  Person<T>

l         客户代码可以这样调用：

Person<int> p1=new Person<int>

泛型就时用类型参数定义的语法结构

分类 ： 1.泛型类型 :泛型类  泛型结构   泛型接口

2.泛型方法

含义：高度抽象  任何类型 可变   VB variant k;k=8;k=”ok”;k=’5’;  c++:模板

一个泛型类相当于多个类

class l

    {

        static void Main()

        {

            pet<int> dog1 =new pet<int>();

            pet<string > cat1 =new pet<string>();

        }

    }

class pet<t>{    }

泛型类型参数约束：在编写泛型类型时，对类型参数T一般来说是不能适应所有类型

对类型参数 T的约束

约束的方式：是一种基类约束，指定T的祖先即继承的接口

目的：是为了改善c#版本  应用于集合类型  为了改善集合类型性能低 安全性差

缺点：可维护性差，过于复杂，乱

建议：适应类库中的泛型   集合的范畴

缺陷：

    使用集合类型的规范：总是放相同类型的元素

引入泛型的原因：为了改善早期c#语言的局限  主要集合类型的缺陷

泛型优点：复用性、类型安全和高效于一身

用途：广泛用于容器（collections或集合）  集合 对集合操作的方法中

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

611                    day13

命名空间

命名空间：对类和其他命名空间的一个逻辑划分

嵌套命名空间：在一个命名空间内声明令一个命名空间

命名空间的作用：

n         专用于组织代码

n         用于避免命名冲突

n         使代码简介、有条理、有结构

语法：namespace  NameSpaceName   {此处列出命名空间的全部类 }

嵌套：namespace Sony

{

`  namespace TV

         {

             class T1

             {

                   class T2

                  { }

              }

       

         }

}

使用命名空间：

n         非限定命名：classi name     省略   简写

    A B 在同一命名空间

n         限定名：namespace。Class name  不省略 完整路径

A B 在不同命名空间

Using用法：

1.     命名空间指令用法  引用所有类

2.      别名指令    为某个命名空间里的某个类起别名

Using 别名名称 = 到命名空间或类的完全限定路径

Using int=System.int32；

基类库：是预先编写好的编码集合，可以合并到应用

异常处理

异常：是中断应用程序正常执行的非正常、特殊、意外情况。

    异常是出现错误时由运行库产生的

异常是一个对象，该对象的类是从System。Exception派生的

异常处理：.net 框架提供了大量的异常处理，这些类型存储了有关异常的信息提供了相关飞帮助。当出现一个错误信息的异常

               异常一旦产生 就会由应用程序或默认的异常处理程序进行处理，但需要有特殊结构。

语句：try ……cahtch……finally

    1. try

    {}

    catch(exception )

    {}

 

2.    try

            { }

            catch (exception e1)

            { }

            catch (System.IO )

            { }

          

3.    try

            { }

            catch (exception e1)

            { }

finally

            { }

4.           try

            { }

            catch (exception e1)

            { }

            catch (System.IO )

            { }

finally

            { }

 

 

目的：恢复正常运行  用异常处理技术

          了解出错原因

          从中断中恢复

怎么用：用在哪 何时用

IO    ADO.NET    受客观环境制约的代码 容易出错

Try    放置受客观环境制约的代码 容易出错

Catch   捕获错误信息 获得出错信息 错误处理

Finally  无论是否产生异常，都会执行finally块中的代码  释放资源（使用内存的对象）的代码 保证执行成功调用 close，dispose方法

多个catch块是允许 为了提高捕获异常的性能 但不能一样 如果是继承 基类放在前面

Throw ：使用throw自定义异常

Checked:用来对算数运算进行溢出检查

Unchecked:用于取消整形算数运算和转换的溢出检查

资源管理：

对象的生命周期：new关键字从堆中分配一些处于自然状态的内存。

          New关键字还必须初始化这个现象。可以通过构造函数来控制这个阶段

          当对象不再使用的时候最好将其设置为null

对象的铲除阶段与创建阶段对应也有两个阶段

          必须做一些整理工作；这可以通过析构函数完成。

          将内存归还给堆；对象所在内存必须释放。

堆铲除和归还内存给堆的过程 称为垃圾回收（garbage 简称 GC）

自己负责对象的铲除的问题：如果忘记看对象的铲除，很容易使内存不足

          你也许多次尝试铲除同一个对象

垃圾回收器可以保证：

          每个对象都会被铲除，其析构函数都会别调用

          每个对象都被精确的铲除

          每个对象只在不被引用的时候

程序元可以通过程序调用System.GC.Collect()启动垃圾回收器

释放资源

有时依赖垃圾回收器自动释放资源是失策的

稀有资源需要被释放而且要尽可能快

如果一个类有dispose或close方法可以显示调用因此可以控制资源的释放

如：System.IO命名空间中的TextReaser类close方法

使用using释放资源：using用于定义一个范围，在此范围的末尾将释放对象

 语法：  using (Font font1=new Font (“Arial”,10.0f ) )

    using (Font f =new Font("宋体", 20), f2 =new Font("宋体", 20) )用，连接两个

            {

 

                byte b = f.GdiCharSet;

            }

 

 

 

0612   day14

运算符重载：c#允许用户定义的类型通过operator关键字定义静态成员函数来实现运算符重载

                     (C#中使用operator关键字来扩展或改变运算符的功能)

可以重载的运算符：+ - * /！ & | >> << >= <= !=

如何实现运算符重载：public static

预处理器指令：标志 #开头

l         #region 与 #endregion  代码分区

#region 块必须以#endregion 指令终止。

#region 块不能与#if 块重叠。但是，可以将 #region 块嵌套在 #if 块内，或将 #if 块嵌套在 #region 块内。

l         #define

l         #if指令开始的条件指令必须用 #endif指令显式终止。

定义：不被翻译为可以执行代码中的命令，但会影响编译过程的各个方面      

预处理器指令必须是行上唯一指令，预处理器指令仍由编译器处理

特性：Attribute使得我们可以为程序的各种元素   如：类接口结构方法等提供额外的描述性信息，

l         指定一类需要的安全设置

l         指定要拒绝的安全设置减少安全风险

l         声明能力，比如支持序列化

l         描述程序集，比如提供标题，描述，版权，商标信息

特性以两种形式存在

l         在公共语言运行库的基类库中定义的特性

l         自定义特性，可以向代码中添加附加信息

Attribute类是自定义特性的基类

Attribute类将预定义的系统信息或用户定义的自定义信息

特性提供的信息也称为元数据：描述元素的元素叫元数据

所有特性类型都直接或间接的从Attribute类派生来的

特性实例话