.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