.net基础知识 .NET基础知识点

.NET基础知识点

 

.NET基础知识点

 

l  .Net平台  .Net FrameWork框架

 

l  .Net FrameWork框架提供了一个稳定的运行环境，；来保障咱们.Net平台正常的运转

 

l  两种交互模式

• C/S:要求客户的电脑上必需要安装一个客户端：qq、360、快播等.....
• B/S:要求客户的电脑上只须要安装一个浏览器

 

l  书写代码须要注意的地方：

n  代码中出现的全部标点都是英文半角 shift键快速切换中文半角和英文半角

n  shift+空格切换全角/半角

n  在c#代码中，每行代码的结束，咱们都以分号结束，注意：这个分号也是英文半角的分号。

n  Console.WriteLine("要打印的内容");

n  Console.ReadKey(); 暂停当前程序，等待用户按下任意键继续，按下的任意键将显示在咱们的控制台当中

 

l  注释符:

n  1)、注销

n  2)、解释

l  C#的3种注释符:

n  1)、单行注释 //

n  2)、多行注释 /*要注释的内容*/

n  3)、文档注释 /// 多用来解释类或者方法

 

l  常量

n  声明的常量的语法：

n  const 变量类型变量名=值;

 

l  变量:用来在计算机当中存储数据:

n  变量类型int double string char bool decimal

n  声明而且给变量赋值的简写形式：

u 变量类型变量名=值;

n  变量的使用规则:

u 若是你要是用变量的话，应该要先声明再赋值再使用。

n  给变量起名字的时候要知足两个命名规范：

u 1、Camel 骆驼命名规范。要求变量名首单词的首字母要小写，其他每一个单词的首字母要大写。

u 多用于给变量命名。

u 2、Pascal 命名规范：要求每一个单词的首字母都要大写，其他字母小写。多用于给类或者方法命名。

u HighSchoolStudent

u highSchoolStudent

n  变量的做用域：      

u 变量的做用域就是你可以使用到这个变量的范围。

u 变量的做用域通常从声明它的那个括号开始到那个括号所对应的结束的括号结束。

u 在这个范围内，咱们能够访问并使用变量。超出这个范围就访问不到了

 

l  数据类型:

n  1)、整数类型：int  只能存储整数，不能存储小数。

n  2)、小数类型：double 既能存储整数，也能存储小数，小数点后面的位数 15~16位。

n  3)、金钱类型：decimal：用来村粗金钱，值后面须要加上一个m.

n  4)、字符串类型:string,用来存储多个文本，也能够存储空，字符串类型的值须要被双引号引来，

n  这个双引号必须是英文半角状态下的双引号

n  5)、字符类型：char,用来存储单个字符，最多、最少只能有一个字符，不能存储空。

n  字符类型的值须要用单引号因起来。英文半角状态下的单引号。

 

l  波浪线

n  1)、若是你的代码中出现了红色的波浪线，意味着你的代码中出现了语法错误。

n  2)、若是你的代码中出现了绿色的波浪线，说明你的代码语法并无错误，

n  只不过提示你有可能会出现错误，可是不必定会出现错误。警告

 

l  命名规则：

n  ****首先要保证的就是这个变量的名字要有意义。

n  1 现阶段给变量起名字的时候都以字母开头

n  2 后面能够跟任意“字母”、数字、下划线.

n  注意:

u 1）你起的变量名不要与c#系统中的关键字重复.

u 2）在c#中,大小写是敏感的.  HTML

u 3)同一个变量名不容许重复定义(先这么认为,不严谨)

 

l  赋值运算符

n  =：表示赋值的意思，表示把等号右边的值，赋值给等号左边的变量。

n  由等号链接的表达式称之为赋值表达式。

n  注意:每一个表达式咱们均可以求解除一个定值，对于赋值表达式而言，等号左边的变量的值，

n  就是整个赋值表达式的值。

n  int number=10;

 

l  +号的做用

n  1)、链接：当+号两边有一边是字符串的时候，+号就起到链接的做用。

n  2)、相加：两边是数字的时候

 

l  占位符

n  使用方法：先挖个坑，再填个坑。

n  使用占位符须要注意的地方：

n  1、你挖了几个坑，就应该填几个坑，若是你多填了，没效果。

n                                   若是你少填了，抛异常。

n  2、输出顺序：按照挖坑的顺序输出。

 

l  异常

n  异常是指：语法上并无任何错误，只不过在程序运行的期间，因为某些缘由出现了问题，

n  使程序不能再正常的运行。  

 

l  转义符

n  转义符指的就是一个'\'+一个特殊的字符，组成了一个具备特殊意义的字符。

n  \n:表示换行

n  \":表示一个英文半角的双引号

n  \t:表示一个tab键的空格

n  \b:表示一个退格键，放到字符串的两边没有效果。

n  \r\n:windows操做系统不认识\n,只认识\r\n

n  \\:表示一个\

n   

n  @符号

n  1、取消\在字符串中的转义做用，使其单纯的表示为一个'\'

n  2、将字符串按照编辑的原格式输出

 

l  算数运算符

n  +

n  -

n  *

n  /

n  %

 

l  类型转换

n  隐式类型转换：

n  咱们要求等号两遍参与运算的操做数的类型必须一致，若是不一致，知足下列条件会发生

u 自动类型转换，或者称之为隐式类型转换。

u 两种类型兼容

u 例如：int 和 double 兼容(都是数字类型)

u 目标类型大于源类型

u 例如：double > int   小的转大的

n  显示类型转换：

u 1、两种类型相兼容  int--double

u 2、大的转成小的  double----int

n  语法：

u (待转换的类型)要转换的值;

n   

n  总结：

u 自动类型转换：int---->doublec   小的转大的

u 显示类型转换：double--->int     大的转小的

 

l  Convert进行类型转换：

n  类型若是相兼容的两个变量，可使用自动类型转换或者强制类型转换，可是，若是两个类型的变量不兼容，好比 string与int或者string 与double，这个时候咱们可使用一个叫作Convert的转换工厂进行转换。

n  注意：使用Convert进行类型转换，也须要知足一个条件：

u 面儿上必需要过的去。

 

l  算数运算符

n  ++：分为前++和后++，不论是前++仍是后++，最终的结果都是给这个变量加一。

n  区别表现表达式当中，若是是前++，则先给这个变量自身加一，而后带着这个加一后的值去参与运算。

n  若是是后++，则先拿原值参与运算，运算完成后，再讲这个变量自身加一。

n  --：同上。

 

l  对于向加加或者减减这样只须要一个操做数就能完成的运算，咱们称之为一元运算符。

l  + - * / % 对于这些须要两个或以上才能完成运算的操做符，咱们称之为二元运算符。

l  一元运算符的优先级要高于而元运算符。

l  若是在一个表达式当中，既有一元运算符，又有二元运算符，咱们首先计算一元运算符。

l   

l  int number=10;

l  int result=10 + ++number;

 

 

l  关系运算符

n  > 

n  < 

n  >=

n  <=

n  ==

n  !=

n  关系运算符是用来描述两个事物之间的关系

n  由关系运算符链接的表达式称之为关系表达式。

 

l  bool类型

n  在c#中咱们用bool类型来描述对或者错。

n  bool类型的值只有两个一个true  一个false

 

l  逻辑运算符

n  && 逻辑与

n  ||逻辑或

n  !逻辑非

n  又逻辑运算符链接的表达式叫作逻辑表达式

n  逻辑运算符两边放的通常都是关系表达式或者bool类型的值。

n   5>3 &&true

n   3>5||false

n   ！表达式

n   逻辑表达式的结果一样也是bool类型

 

l  复合赋值运算符

n  int number=10;

n  += :

n  number+=20;

n  number=number+20;

n  -=

n  number-=5;

n  number=number-5;

n  *=

n  number*=5;

n  number=number*5;

n  /=

n  %=

 

l  三元表达式

n  语法:

u 表达式1?表达式2:表达式3;

n  表达式1通常为一个关系表达式。

n  若是表达式1的值为true，那么表达式2的值就是整个三元表达式的值。

n  若是表达式1的值为false，那么表达式3的值就是整个三元表达式的值。

n  注意：表达式2的结果类型必须跟表达式3的结果类型一致，而且也要跟整个三元表达式的结果类型一致。

 

 

l  if语句：

n  语法：

u if(判断条件)

u {

u        要执行的代码;

u }

n  判断条件：通常为关系表达式或者bool类型的值。

n  执行过程：

u 程序运行到if处，首先判断if所带的小括号中的判断条件，

u 若是条件成立，也就是返回true，则执行if所带的大括号中的代码，

u 若是判断条件不成立，也就是返回一个false。则跳过if结构，继续向下执行。

n   

n  if结构的特色：先判断，再执行，有可能一行代码都不执行

n  用于一种状况的判断。

 

l  if-else

n  语法：

u if(判断条件)

u {

u        执行的代码;

u }

u else

u {

u        执行的代码

u }

n  执行过程：

u 程序执行到if处，首先判断if所带的小括号中的判断条件是否成立，

u 若是成立，也就是返回一个true，则执行if所带的大括号中的代码，

u 执行完成后，跳出if-else结构。

u 若是if所带的小括号中的判断条件不成立，也就是返回一个false，

u 则跳过if语句，执行else所带的大括号中的语句，执行完成后，跳出if-else结构。

n   

n  if-else特色：先判断，再执行，最少都要执行一条代码。

n  用于两种状况的判断

n  注意：else永远跟离它最近的那个if配对

 

l  if else-if

n  做用：用来处理多条件的区间性的判断。

n  语法：

u if(判断条件)

u {

u        要执行的代码;

u }

u else if(判断条件)

u {

u        要执行的代码;

u }

u else if(判断条件)

u {

u        要执行的代码;

u }

u else if(判断条件)

u {

u        要执行的代码;

u }

u ........

u else

u {

u        要执行的代码;

u }

n  执行过程；

u 程序首先判断第一个if所带的小括号中的判断条件，若是条件成立，也就是返回一个true，

u 则执行该if所带的大括号中的代码，执行完成后，当即跳出if else-if结构。

u 若是第一个if所带的判断条件不成立，也就是返回一个false，则继续向下进行判断，依次的判断每个if所带

u 的判断条件，若是成立，就执行该if所带的大括号中的代码，若是不成立，则继续向下判断，

u 若是每一个if所带的判断条件都不成立，就看当前这个if else-if结构中是否存在else。

u 若是有else的话，则执行else中所带的代码，若是没有else，则整个 if-else if神马都不作。

u else能够省略。

 

l  异常捕获

n  咱们在程序中常常会出现各类各样的异常，你若是想要你的程序变得坚强一些。

n  在你的代码中应该常常性的使用try-catch来进行异常捕获。

n   

n  哪行代码有可能出现异常，你就踹它一脚。

n  语法：

u try

u {

u        可能会出现异常的代码;

u        ....

u        ...

u        ...

u }

u //try和catch之间不能有其余的代码

u catch

u {

u        出现异常后要执行的代码;

u }

n   

n  执行过程:若是try中的代码没有出现异常，那么catch中的代码不会执行。

n  若是try中的代码出现了异常，那怕这行出现异常的代码后面还有一百行都不会执行了，

n  而是直接跳到catch中执行代码

 

l  switch-case

n  用来处理多条件的定值的判断。

n  语法：

u switch(变量或者表达式的值)

u {

u        case 值1:要执行的代码;

u        break;

u        case 值2:要执行的代码;

u        break;

u        case 值3:要执行的代码;

u        break;

u        ..........

u        default:要执行的代码;

u        break;

u }

n  执行过程：

u 程序执行到switch处，首先将括号中变量或者表达式的值计算出来，

u 而后拿着这个值依次跟每一个case后面所带的值进行匹配，一旦匹配成功，则执行

u 该case所带的代码，执行完成后，遇到break。跳出switch-case结构。

u 若是，跟每一个case所带的值都不匹配。就看当前这个switch-case结构中是否存在

u default，若是有default，则执行default中的语句，若是没有default，则该switch-case结构什么都不作。

 

l  循环结构

n  while循环：

u while(循环条件)

u {

u        循环体;

u }

n  执行过程：

u 程序运行到while处，首先判断while所带的小括号内的循环条件是否成立，

u 若是成立的话，也就是返回一个true，则执行循环体，执行完一遍循环体后，再次回到

u 循环条件进行判断，若是依然成立，则继续执行循环体，若是不成立，则跳出while循环。

u 在while循环当中，通常总会有那么一行代码，可以改变循环条件，使之终有一天再也不成立，

u 若是没有那么一行代码可以改变循环条件，也就是循环条件永远都成立，咱们称之这种循环叫作死循环。

u 最简单的最经常使用的死循环：

l  while(true)

l  {

l   

l  }

 

n  特色：先判断，再执行，有可能一遍循环都不执行。

 

l  do-while循环。

n  语法：

u do

u {

u        循环体;

u }while(循环条件);

n  执行过程:程序首先会执行do中的循环体，执行完成后，去判断do-while循环的循环条件，

n  若是成立，则继续执行do中的循环体，若是不成立，则跳出do-while循环。

n  特色：先循环，再判断，最少执行一遍循环体。

 

l  for循环

n  语法:

u for(表达式1;表达式2;表达式3)

u {

u        循环体;

u }

n  表达式1通常为声明循环变量，记录循环的次数(int i=0;)

n  表达式2通常为循环条件(i<10)

n  表达式3通常为改变循环条件的代码，使循环条件终有一天再也不成立(i++)。

n  执行过程：

u 程序首先执行表达式1，声明了一个循环变量用来记录循环的次数，

u 而后执行表达式2，判断循环条件是否成立，若是表达式2返回的结果为true，

u 则执行循环体。当执行完循环体后，执行表达式3，而后执行表达式2继续判断循环条件是否成立，

u 若是成立则继续执行循环体，若是不成立，则跳出for循环。

 

l  break

n  1)、能够跳出switch-case结构。

n  2)、能够跳出当前循环。

n  break通常不单独的使用，而是跟着if判断一块儿使用，表示，当知足某些条件的时候，就再也不循环了。

 

l  程序调试

n  1)、写完一段程序后，想看一下这段程序的执行过程。

n  2)、当你写完这段程序后，发现，程序并无按照你想象的样子去执行。

n   

n  调试方法：

u 1)、F11逐语句调试(单步调试)

u 2)、F10逐过程调试

u 3)、断点调试

 

l  int.TryParse int.parse 尝试着将一个字符串转换成int类型。

 

l  枚举

n  语法：

u 访问修饰符enum 枚举名

u {

u        值1,

u        值2,

u        值3,

u        ........

u }

n  enum：关键字，声明枚举的关键字

n  枚举名：要符合Pascal命名规范

n   

n  将枚举声明到命名空间的下面，类的外面，表示这个命名空间下，全部的类均可以使用这个枚举。

n   

n  枚举就是一个变量类型，int--double  string  decimal.

n  只是枚举声明、赋值、使用的方式跟那些普通的变量类型不同。

n  咱们能够将一个枚举类型的变量跟int类型和string类型互相转换。

n  枚举类型默认是跟int类型相互兼容的，因此能够经过强制类型转换的语法互相转换。

n  当转换一个枚举中没有的值的时候，不会抛异常，而是直接将数字显示出来。

n  枚举一样也能够跟string类型互相转换，若是将枚举类型转换成string类型，则直接调用ToString().

n  若是将字符串转换成枚举类型则须要下面这样一行代码：

n         (要转换的枚举类型)Enum.Parse(typeof(要转换的枚举类型),"要转换的字符串");

n  若是转换的字符串是数字，则就算枚举中没有，也会不会抛异常。

n  若是转换的字符串是文本，若是枚举中没有，则会抛出异常。

 

l  结构

n  能够帮助咱们一次性声明多个不一样类型的变量。

n  语法：

u [public] struct 结构名

u {

u        成员;//字段

u }

n  变量在程序运行期间只能存储一个值，而字段能够存储多个值。

 

l  数组

n  一次性存储多个相同类型的变量。

n  语法：

n  数组类型[] 数组名=new 数组类型[数组长度];

n   

n  ***数组的长度一旦固定了，就不能再被改变了

 

 

l  冒泡排序：就是将一个数组中的元素按照从大到小或者从小到大的顺序进行排列。

n  int[] nums={9,8,7,6,5,4,3,2,1,0}; 0 1 2 3 4 5 6 7 8 9

n  第一趟比较：8 7 6 5 4 3 2 1 0 9 交换了9次     i=0j=nums.Length-1-i

n  第二趟比较：7 6 5 4 3 2 1 0 8 9 交换了8次     i=1j=nums.Length-1-i

n  第三趟比较：6 5 4 3 2 1 0 7 8 9 交换了7次     i=2j=nums.Length-1-i

n  第四趟比较：5 4 3 2 1 0 6 7 8 9 交换了6次     i=3j=nums.Length-1-i

n  第五趟比较：4 3 2 1 0 5 6 7 8 9 交换了5次

n  第六趟比较：3 2 1 0 4 5 6 7 8 9 交换了4次

n  第七趟比较：2 1 0 3 4 5 6 7 8 9 交换了3次

n  第八趟比较：1 0 2 3 4 5 6 7 8 9 交换了2次

n  第九趟比较：0 1 2 3 4 5 6 7 8 9 交换了1次

n  for(int i=0;i<number.Length-1;i++)

n  {

n         for(int j=0;j<nums.Length-1-i;j++)

n         {

n                if(nums[j]>nums[j+1])

n                {

n                       int temp=nums[j];

n                       nums[j]=nums[j+1];

n                       nums[j+1]=temp;

n                }

n         }

n  }

 

l  方法

n  函数就是将一堆代码进行重用的一种机制。

n  函数的语法：

u [public] static 返回值类型方法名([参数列表])

u {

u        方法体；

u }

u public:访问修饰符，公开的，公共的，哪均可以访问。

u static：静态的

u 返回值类型：若是不须要写返回值，写void

u 方法名：Pascal 每一个单词的首字母都大些。其他字母小写

u 参数列表：完成这个方法所必需要提供给这个方法的条件。若是没有参数，小括号也不能省略。

u  

u 方法写好后，若是想要被执行，必需要在Main()函数中调用。

u 方法的调用语法：

u 类名.方法名([参数]);

u ***在某些状况下，类名是能够省略的，若是你写的方法跟Main()函数同在一个类中，这个时候，

u 类名能够省略。

n  方法的功能必定要单一。

u GetMax(int n1,int n2)

u 方法中最忌讳的就是出现提示用户输入的字眼。

 

l  return

n  1、在方法中返回要返回的值。

n  2、当即结束本次方法。

 

l  咱们在Main()函数中，调用Test()函数，

n  咱们管Main()函数称之为调用者，

n  管Test()函数称之为被调用者。

n  若是被调用者想要获得调用者的值：

u 1)、传递参数。

u 2)、使用静态字段来模拟全局变量。

n  若是调用者想要获得被调用者的值：

u 1)、返回值

 

l  不论是实参仍是形参，都是在内存中开辟了空间的。

 

l  out、ref、params

n  1)、out参数。

u 若是你在一个方法中，返回多个相同类型的值的时候，能够考虑返回一个数组。

u 可是，若是返回多个不一样类型的值的时候，返回数组就不行了，那么这个时候，

u 咱们能够考虑使用out参数。

u out参数就侧重于在一个方法中能够返回多个不一样类型的值。

n   

n  2)、ref参数

u 可以将一个变量带入一个方法中进行改变，改变完成后，再讲改变后的值带出方法。

u ref参数要求在方法外必须为其赋值，而方法内能够不赋值。

n   

n  3)、params可变参数

u 将实参列表中跟可变参数数组类型一致的元素都当作数组的元素去处理。

u params可变参数必须是形参列表中的最后一个元素。

 

l  方法的重载

n  概念：方法的重载指的就是方法的名称相同给，可是参数不一样。

n  参数不一样，分为两种状况

u 1)、若是参数的个数相同，那么参数的类型就不能相同。

u 2)、若是参数的类型相同，那么参数的个数就不能相同。

u ***方法的重载跟返回值没有关系。

 

l  方法的递归

n  方法本身调用本身。

n  找出一个文件夹中全部的文件。

 

 

l  面向过程-----> 面向对象

l   

l  面向过程：面向的是完成这件事儿的过程，强调的是完成这件事儿的动做。

 

l  类

n  语法：

u [public] class 类名

u {

u        字段;

u        属性;

u        方法;

u }

n  写好了一个类以后，咱们须要建立这个类的对象，

n  那么，咱们管建立这个类的对象过程称之为类的实例化。

n  使用关键字 new.

n   

n  this:表示当前这个类的对象。

n  类是不占内存的，而对象是占内存的。

 

l  属性

n  属性的做用就是保护字段、对字段的赋值和取值进行限定。

n  属性的本质就是两个方法，一个叫get()一个叫set()。

n  既有get()也有set()咱们诚之为可读可写属性。

n  只有get()没有set()咱们称之为只读属性

n  没有get()只有set()咱们称之为只写属性

n   

n  Field字段

n  Method方法

n  Property属性

n   

n  ****字段就是女人  属性才是男人。

 

l  访问修饰符：

访问修饰符	说明
public	公有访问。不受任何限制。
private	私有访问。只限于本类成员访问，子类，实例都不能访问。
protected	保护访问。只限于本类和子类访问，实例不能访问。
internal	内部访问。只限于本项目内访问，其余不能访问。
protected internal	内部保护访问。只限于本项目或是子类访问，其余不能访问

 

l  当咱们建立好一个类的对象后，须要给这个对象的每一个属性去赋值。咱们管这个过程称之为对象的初始化。

 

l  静态和非静态的区别

n  1)、在非静态类中，既能够有实例成员，也能够有静态成员。

n  2)、在调用实例成员的时候，须要使用对象名.实例成员;

n      在调用静态成员的时候，须要使用类名.静态成员名;

n  总结：静态成员必须使用类名去调用，而实例成员使用对象名调用。

n  静态函数中，只能访问静态成员，不容许访问实例成员。

n  实例函数中，既可使用静态成员，也可使用实例成员。

n  静态类中只容许有静态成员，不容许出现实例成员。

n   

n  使用：

n  1)、若是你想要你的类当作一个"工具类"去使用，这个时候能够考虑将类写成静态的。

n  2)、静态类在整个项目中资源共享。

n  只有在程序所有结束以后，静态类才会释放资源。

l   

l   

l  堆  栈  静态存储区域

l   

l  释放资源。GC Garbage Collection垃圾回收器

 

 

l  构造函数

n  做用：帮助咱们初始化对象(给对象的每一个属性依次的赋值)

n  构造函数是一个特殊的方法：

u 1)、构造函数没有返回值，连void也不能写。

u 2)、构造函数的名称必须跟类名同样。

n   

n  建立对象的时候会执行构造函数

n  构造函数是能够有重载的。

n  ***

n  类当中会有一个默认的无参数的构造函数，当你写一个新的构造函数以后，不论是有参数的仍是

n  无参数的，那个默认的无参数的构造函数都被干掉了。

 

l  new关键字

n  Person zsPerson=new Person();

n  new帮助咱们作了3件事儿：

u 1)、在内存中开辟一块空间

u 2)、在开辟的空间中建立对象

u 3)、调用对象的构造函数进行初始化对象

n  1)、建立对象

n  2)、隐藏从父类那里继承过来的同名成员。

n  隐藏的后果就是子类调用不到父类的成员。

 

l  this关键字

n  1)、表明当前类的对象

n  2)、在类当中显示的调用本类的构造函数  :this

 

l  命名空间

n  能够认为类是属于命名空间的。

n  若是在当前项目中没有这个类的命名空间，须要咱们手动的导入这个类所在的

n  命名空间。

u 1)、用鼠标去点

u 2)、alt+shift+F10

u 3)、记住命名空间，手动的去引用

 

l  值类型和引用类型

l  区别：

u 1、值类型和引用类型在内存上存储的地方不同。

u 2、在传递值类型和传递引用类型的时候，传递的方式不同。

u 值类型咱们称之为值传递，引用类型咱们称之为引用传递。

n  咱们学的值类型和引用类型：

u 值类型：int、double、bool、char、decimal、struct、enum

u 引用类型：string、自定义类、数组

n  存储：

u 值类型的值是存储在内存的栈当中。

u 引用类型的值是存储在内存的堆中。

n  值类型在复制的时候，传递的是这个值得自己。

n  引用类型在复制的时候，传递的是对这个对象的引用。

 

l  字符串

n  1)、字符串的不可变性

n  当你给一个字符串从新赋值以后，老值并无销毁，而是从新开辟一块空间存储新值。

n  当程序结束后，GC扫描整个内存，若是发现有的空间没有被指向，则当即把它销毁。

n  2)、咱们能够讲字符串看作是char类型的一个只读数组。

n  ToCharArray();将字符串转换为char数组

n  new string(char[] chs):可以将char数组转换为字符串

 

l  字符串提供的各类方法

n  1)、Length：得到当前字符串中字符的个数

n  2)、ToUpper():将字符转换成大写形式

n  3)、ToLower():将字符串转换成小写形式

n  4)、Equals(lessonTwo,StringComparison.OrdinalIgnoreCase):比较两个字符串，能够忽略大小写

n  5)、Split()：分割字符串，返回字符串类型的数组。

n  6)、Substring()：解决字符串。在截取的时候包含要截取的那个位置。

n  7)、IndexOf():判断某个字符串在字符串中第一次出现的位置，若是没有返回-1、值类型和引用类型在内存上存储的地方不同。

n  8)、LastIndexOf()：判断某个字符串在字符串中最后一次出现的位置，若是没有一样返回-1

n  9)、StartsWith():判断以....开始

n  10)、EndsWith():判断以...结束

n  11)、Replace():将字符串中某个字符串替换成一个新的字符串

n  12)、Contains():判断某个字符串是否包含指定的字符串

n  13)、Trim():去掉字符串中先后的空格

n  14)、TrimEnd()：去掉字符串中结尾的空格

n  15)、TrimStart()：去掉字符串中前面的空格

n  16)、string.IsNullOrEmpty():判断一个字符串是否为空或者为null

n  17)、string.Join()：将数组按照指定的字符串链接，返回一个字符串。

 

l  继承

n  咱们可能会在一些类中，写一些重复的成员，咱们能够将这些重复的成员，

n  单独的封装到一个类中，做为这些类的父类。

n  Student、Teacher、Driver  子类  派生类

n  Person                                 父类  基类

n  子类继承了父类，那么子类从父类那里继承过来了什么？

n  首先，子类继承了父类的属性和方法，可是子类并无继承父类的私有字段。

n  问题：子类有没有继承父类的构造函数？

u 答：子类并无继承父类的构造函数，可是。子类会默认的调用父类无参数的构造函数，

n  建立父类对象，让子类可使用父类中的成员。

n  因此，若是在父类中从新写了一个有参数的构造函数以后，那个无参数的就被干掉了，

n  子类就调用不到了，因此子类会报错。

n  解决办法：

u 1)、在父类中从新写一个无参数的构造函数。

u 2)、在子类中显示的调用父类的构造函数，使用关键字:base()

n  继承的特性

u 1、继承的单根性：一个子类只能有一个父类。

u 2、继承的传递性

 

l  里氏转换

n  1)、子类能够赋值给父类

n  2)、若是父类中装的是子类对象，那么能够讲这个父类强转为子类对象。

 

l  子类对象能够调用父类中的成员，可是父类对象永远都只能调用本身的成员。

 

l  IS & AS

n  is：表示类型转换，若是可以转换成功，则返回一个true，不然返回一个false

n  as：表示类型转换，若是可以转换则返回对应的对象，不然返回一个null

 

l  ArrayList集合的长度问题

n  每次集合中实际包含的元素个数(count)超过了能够包含的元素的个数(capcity)的时候，

n  集合就会向内存中申请多开辟一倍的空间，来保证集合的长度一直够用。

 

l  Hastable 键值对集合  字典  孙    sun---孙 

n  在键值对集合当中，咱们是根据键去找值的。

n  键值对对象[键]=值;

n  *****:键值对集合当中，键必须是惟一的，而值是能够重复的

 

l  编码格式

n  产生乱码的缘由就是由于你保存这个文件的编码格式跟你打开这个文件的编码格式不同

 

l  绝对路径和相对路径

n  绝对路径：经过给定的这个路径直接能在个人电脑中找到这个文件。

n  相对路径：文件相对于应用程序的路径。

n  结论：

n  咱们在开发中应该去尽可能的使用相对路径。

 

l  装箱、拆箱

n  装箱：就是将值类型转换为引用类型。

n  拆箱：将引用类型转换为值类型。

n  看两种类型是否发生了装箱或者拆箱，要看，这两种类型是否存在继承关系。

 

l  将建立文件流对象的过程写在using当中，会自动的帮助咱们释放流所占用的资源。

 

l  实现多态的手段

n  1)、虚方法

n  步骤：

u 将父类的方法标记为虚方法，使用关键字 virtual，这个函数能够被子类从新写一个遍

n  2)、抽象类

u 当父类中的方法不知道如何去实现的时候，能够考虑将父类写成抽象类，将方法写成抽象方法。

 

l  序列化 & 反序列化

n  序列化：就是将对象转换为二进制

n  反序列化：就是将二进制转换为对象

n   做用：传输数据。

n    序列化：

n         1)、将这个类标记为能够被序列化的。

 

l  接口

n  访问修饰符 interface I..able

n  {

n         成员;

n  }

 

l  sealed密封类不可以被其余类继承，可是能够继承于其余类。

 

 

 

 

Winform

 

1、winform应用程序是一种智能客户端技术，咱们可使用winform应用程序

帮助咱们得到信息或者传输信息等。

 

2、属性

Name：在后台要得到前台的控件对象，须要使用Name属性。

visible：指示一个控件是否可见。

Enabled：指示一个控件是否可用。

 

3、事件：发生一件事情。

注册事件：双击控件注册的都是控件默认被选中的那个事件。

触发事件:

 

4、

在Main函数当中建立的窗体对象，咱们称之为这个窗体应用程序的主窗体。

也就意味着，当你将主窗体关闭后，整个应用程序都关闭了。

 

5、TextBox控件

WordWrap:指示文本框是否换行。

PasswordChar：让文本框显示一个单一的字符

ScollBars：是否显示滚动条

事件：TextChanged 当文本框中的内容发生改变的时候触发这个事件。

 

6、跑马灯练习

abcde

bcdea

string str="abcde";

            str=str.Substring(1)+str.Substring(0,1);

 

 

cdeab

deabc

eabcd

abcde

 

 

7、Timer

在指定的时间间隔内作一件指定的事情。

 

 

8、简单记事儿本应用程序

1)、在程序加载的时候，取消文本框的自动换行，以及让两个按钮和文本框隐藏

2)、点击登录，判断是否登录成功

3)、自动换行功能

4)、保存文本到一个指定目录下。

 

 

9、单选和多选

checked：指示这个控件是否处于选中状态。

 

默认状况下，在一个窗体中，全部的单选按钮只容许选中一个，可使用groupbox进行分组。

 

10、MDI窗体的设计

1、首先肯定一个父窗体。将IsMdiContainer设置为true。

2、建立子窗体，而且设置他们的父窗体。

 

   1、Directory 操做文件夹

CreateDirectory 建立文件夹

Delete  删除文件夹

Move  剪切文件夹

Exist  判断是否存在

GetFiles 得到指定的目录下全部文件的全路径

GetDirectory 得到指定目录下全部文件夹的全路径

 

2、WebBrowser浏览器控件

 

3、ComboBox下拉框控件

DropDownStyle：控制下拉框的外观样式

名字：cbo+....

案例：日期选择器

 

4、点击更换图片

在程序加载的时候，将指定图片文件夹中全部的图片文件名读取到ListBox中

 

5、石头剪刀布

石头 1   剪刀 2 布  3

玩家赢了：  1 2=-1   2 3=-1  3  1=2

平手：   相减 =0

另一种状况：电脑赢了

 

6、对话框

 

7、进程

咱们能够把计算机中每个运行的应用程序都当作是一个进程。

而一个进程又是由多个线程组成的。

 

 

8、单线程给咱们带来的问题

 

9、在.Net下，是不容许跨线程的访问。

 

 

 

HTML & CSS

 

1、HTML

超文本标记语言

在HTML当中存在着大量的标签，咱们用HTML提供的标签，将要显示在网页中的内容包含起来。

就构成了咱们的网页。

 

CSS：控制网页内容显示的效果。

 

HTML+CSS=静态网页。

JS+Jquery

 

2、开始动手写HTML页面

1)、首先在桌面上随便的建一个文件。

2)、将建立的文件的名称改成.htm /.html

3)、开始写基本的框架标签

 

 

3、HTML中的标签

p标签:段落标签

&nbsp:空格

h#:标题标签

<!--要注释的内容-->：注释符

<img/>:图片标签，用来显示图片。

src:表示要显示的图片的路径

heigth:图片的高度 px

width：图片宽度  px

alt：当图片因为某些缘由显示失败的时候所显示的文本

title：当光标移动到图片上的时候显示的文本

<hr/>:分割线

<font></font>:字体标签  size =1 ~7 7最大  color:颜色 face：字体系列

a标签：超连接  href表示要链接到的地址  target：打开新网页的方式 _blank表示打开一个新网页进行跳转。

_self表示在当前页面进行跳转。

 

实现页面内部的跳转

实现页面间的跳转

发送邮件

 

4、Div+Span

可以熟练掌握css+div布局

 

 

1、注释符

单行注释 // 注释单行代码

多行注释  /*要注释内容*/

文档注释  /// 注释类和方法

HTML <!--要注释的内容-->

CSS /*要注释的内容*/

 

2、命名规范

Camel骆驼命名规范:要求首单词的首字母小写，其他单词首字母大写，变量、字段

int age  string name  char gender  string highSchool

int _chinese