第一章：c#基礎
一、程序設計語言的發展及歷史
1、程序設計語言
通俗也叫編程語言，實現人與機器交互的工具
2、歷史
1）機器語言：0,1
2）匯編語言：包含一些機器語言，同時增加了一些指令，便於理解
3）C語言：和我們的自然語言非常像
4）C++：在C語言的基礎上進行發展,增加了面向對象的特性
5）Java：SUN公司開發，被Oracle公司收購
6）C#：面向對象的程序設計語言
7）易語言：源代碼是使用中文來編寫的
...
注：不同的編程語言，應用場景是不一樣的
java、C#是面向企業級的應用開發
機器語言（0,1） 匯編語言（Add 1,2） 高級語言（1+2）
void main() {
printf("我愛你的錢！") ;
}
3、編譯器(翻譯者)
把源代碼編譯（翻譯）成計算機能讀懂的代碼(0、1)
二、.NET框架（.NET Framework）
1、概述
是所有.NET程序運行的平台
C#、C++、F#……
2、組成
通用語言運行庫(CLR)：運行程序的環境
類庫：.NET程序的工具集合
3、C#
"面向對象"的程序設計語言
微軟公司研發的
與Java語言競爭
4、Visual Studio(VS) : 開發軟件的"集成"工具
5、第一個C#程序
第一：新建一個以.cs為后綴的文件
第二：編寫源代碼
using System ;
namespace Xxxx
{
class Yyyy
{
static void Main()
{
//在此編寫程序，實現功能
}
}
}
第三：把源代碼編譯成二進制的代碼（機器代碼、目標代碼）
csc Xxxxx.cs -> Xxxxx.exe
第四：運行程序
Xxxxx
注：Xxxxx表示CS文件名
6、.NET程序的編譯機制(執行過程)
.NET源代碼 -> MSIL -> 機器代碼
兩次編譯
三、算法、指令、程序、軟件的關系
算法：解決問題的步驟/過程
指令：編寫每一條代碼
程序：指令的集合
軟件：程序+數據的集合
四、C#語言的基本結構及其含意（重要）
using System;
namespace ch01
{
class HelloWorld
{
static void Main(string[] args)
{
Console.WriteLine("hello,world") ;
}
}
}
說明：
1）C#程序必須以cs為后綴
2）C#程序嚴格區分大小寫
3）標識符 : 是一個符號，用於命名。標識符的命名規則為：
一般由字母、數字、下划線組成
首字符必須使用字母或下划線
命名有意義
name、age、aGE123、a123b、_123A、123_C
4）using System; : 使用命名空間
命名空間：文件夾，用於組織和管理類
5）namespace Ch01 : 自定義命名空間，語法如下：
namespace 命名空間名稱
{
...
}
6）class Programe ：自定類(類別)，語法如下：
class 類名稱
{
...
}
注：類名要首字母要大寫
7）static void Main(string[] args) ：主函數，是程序的入口
注：一個C#程序，至少要有一個Main方法
static：靜態
void： 空的
string[] args：傳入參數
8）Console.WriteLine("我愛你C#!") ;
Console：
是系統中的一個類，表示控制台
此類在System這個命名空間
因此，使用此類，必須using System ;
或者：
System.Console.WriteLine(".".") ;
WriteLine("打印輸出的內容")
是一個輸出函數,把雙引號的內容，
打印輸出到屏幕
雙引號必須是英文狀態下輸入
9）每一個語句必須以分號結束
10）轉義字符 -> 把特殊字符轉換為對應意義的字符
轉義字符都是以\開始
\ -> \
\" -> "
\' -> '
\t -> 一個制表位(8個空格)
\n -> 換行
11）注釋 : 注釋的代碼不會被執行，便於程序員閱讀或理解代碼
//單行注釋
/*
多行注釋
*/
注：養成注釋的習慣
五、輸出函數（重要）
1、Console.Write("內容")：輸出內容后，不換行
2、Console.WriteLine("內容")：輸出內容后，換行
3、占位符輸出:
{N}，N從0開始，有多少個占位符，就有多少個數據
Console.Write("姓名：張三,年齡：18") ;
Console.Write("姓名：{0},年齡：{1}","張三",18) ;
六、.Net程序的類型
1、控制台程序
2、窗體程序
3、ASP.NET應用程序 -> web應用
七、程序的錯誤類型
1、語法錯誤（編譯時錯誤）
2、運行時錯誤
3、邏輯錯誤
第二章：數據類型
一、計算機的組成
CPU、硬盤、主板、顯示器、內存、鍵盤、鼠標、打印機
顯卡、網卡、電源、光驅....
輸入設備：輸入數據
輸出設備：輸出數據
運算器：加工處理數據
控制器：控制各部件有條不紊的工作
存儲器：存儲數據
外存(輔存) -> 硬盤、U盤、移動硬盤、光驅 ->容量大、速度慢、成本低、永久存放數據
內存(主存)-> 容量小、速度快、成本高、斷電后數據丟失
CPU當前處理的數據存儲在內存中
二、計算機的執行過程
編寫C#語言程序的目的為了"處理數據"
C#語言中處理的數據都是從主存(內存)中獲取
三、變量、常量
內存中開辟的某個空間,用於存儲程序即將處理的數據（變量）
1、概念：
變量：可以改變的量
常量：一旦賦值，就不能改變
變量名/常量名：用於指定內存空間的名稱，方便操作內存空間中的數據
2、標識符
是一個符號，用於命名（變量、命名空間、類、方法...）
在C#語言中，標識符具有以下命名規則：
1）由字母、數字、下划線組成，且第一個字符必須是字母或下划線
2）嚴格區分大小寫
3）不能使用關鍵字(關鍵字[保留字]:已經具體特殊意義且被程序設計語言占用)
4）取名要有意義
命名規范
規則一：Pascal規則（帕斯卡命名）：每個單詞開頭的字母大寫（如：TestCounter）
命名空間、類、方法名
規則二：Camel規則(大駝峰和小駝峰命名)：除了第一個單詞外的其他單詞的開頭字母大寫， 如testCounterHello
變量名
規則三：Upper規則：僅用於一兩個字符長的常量的縮寫命名，超過三個字符長度應該應用Pascal規則
常量，PI -> 圓周率
3、變量的定義
1）語法如下
[訪問修飾符] 數據類型 變量名 ;
注：訪問修飾符->控制訪問變量的權限
2）賦值 -> 給變量對應的內存空間存放數據
變量名 = 值 ;
3）其它用法
[訪問修飾符] 數據類型 變量名1,...,變量名n ;
int a,b,c,d;
在定義變量的同時，給變量賦值
[訪問修飾符] 數據類型 變量名 ＝ 值 ;
可以通過輸入方法給變量賦值
string 變量 = Console.ReadLine() ;
注：
變量在同一個范圍中，只能定義一個
在使用局部變量之前，必須給變量賦值
4.常量的定義(基本同變量)
[訪問修飾符] const 數據類型 常量名 = 值 ;
注：
使用const關鍵字聲明常量
在定義常量的時候，必須賦值
四、數據類型
具體數據的分類（歸類），指定內存空間存放數據的種類
1、好處
增加安全性
規范化數據
2、數據類型的種類
1）整型（整數）
默認是int
A、sbyte,byte 字節
B、short,ushort
C、int,unit
D、long,ulong
2）浮點數型（實型、小數）
A、單精度浮點型 -> float -> F
B、雙精度浮點型 -> double -> 默認
C、財務專用類型 -> decimal -> M
注：(數值型)整數和浮點數都能表示某個范圍的數據
溢出：超出類型所示的范圍
3.14
3.14F
3.14M
sbyte age = 130 ; //報錯,溢出
3）布爾類型（邏輯）
bool
true
false
4）字符型
char
注：
字符型數據必須使用單引號；
同時，字符型數據和整型數據可以相互轉換（ASCII表）
'a' -> 97
'A' -> 65
'張'（2個字符）
5）字符串型
string
0個或多個字符的序列
注：
字符串型數據必須使用雙引號;
string name ;
name = "張三" ;
string cls ;
cls = "s1s148" ;
五、輸入數據
Console.ReadLine()：返回輸入的字符串
注：+號運算符有兩種運算法則
1、+號左右兩邊的數據如果有一邊是字符串，則進行字符串連接運算
"Abc" + 100 = "Abc100"
3.14 + "AAA" = "3.14AAA"
"555" + "AAA" = "555AAA"
2、+號左右兩邊的數據都是數值型數據，則進行算術運算
100 + 200 = 300
100 + 3.14 = 103.14
六、類型轉換
1、為什么需要類型轉換
1）數據進行運算時，得不到我們想要的結果
"1" + "2" = "12" ;
2）相同類型的數據，才可以進行正常的運算
1 + 3.14 = 4.14 ;
2、隱式轉換（小 -> 大）
也叫自動轉換,遵循的原則是：
小的數據類型自動的向大的數據轉換
1 + 3.14 = 4.14 ;
int + double = double ;
3 + 3.14F = 6.14F ;
int + float = float ;
3.顯式轉換（大 -> 小）
也叫強制類型轉換，語法如下：
數據類型 變量 = (數據類型)數據 ;
或
數據類型 變量 = (數據類型)(表達式) ;
int a = (int)3.14 ;
注：強制類型轉換可能會丟失精度
int a = (int)3.14 + 2.5 ; //錯誤
int a = (int)3.94 + (int)2.5 ; //5
int a = (int)(3.914+2.5) ;//6
注：強制類型轉換一般用於數值型數據
4.特殊方法轉換
1）數據類型.Parse(string): 把字符串類型轉化為其他類型
string s1 = "100" ;
int a = int.Parse(s1) ;
double d = double.Parse(s1) ;
2）Convert.ToXxx():其中Xxx是你要轉換的數據
3）ToString()：將其它類型的數據轉換為字符串
C#字符串的大小寫轉換
using System;
namespace g
{
class g
{
static void Main()
{
string c="H";
string d="e";
d=d.ToUpper();//把小寫的a轉換成大寫的A，再賦值給str1,這時候str1就是大寫的A了。
c=c. ToLower();//把大寫的B轉換成小寫的b，再賦值給str2,這時候str2就是小寫的b了。
Console.WriteLine("c={0},d={1}",c,d);
}
}
}
第三章：選擇（if和swich）
加工處理
1、C#程序的基本結構
using System ;
namespace Xxx
{
class Yyy
{
static void Main()
{
//在此處編寫代碼，實現具體的功能
}
}
2、輸入/輸出
Console.ReadLine() ;
Console.Write() ;
Console.WriteLine() ;
Console是一個類
使用Console類必須引用Console類所在的命名空間（System）
命名空間是組織和管理類的地方
在使用某個類之前，必須using相關的命名空間
3、變量、數據類型
數據類型 : 指定內存空間存放數據的種類
int,unit
short,ushort
long,ulong
sbyte,byte
float,double,decimal
bool
char,string
變量 : 變量是內存中開辟空間
4.類型轉換
1）隱式轉換，自動轉換 : 小 -> 大
2）顯式轉換，強制轉換 : 大 -> 小
數據類型 變量名 = (數據類型)變量/數據/表達式 ;
3）特殊方法
數據類型.Parse() ;
Convert.ToXxxx() ;
數據.ToString() ;
一、表達式
由數據和運算符號組成的式子
1、概念
1 + 1
a + 2
"100" + c + 3.14
10 * 10 - 20
2、作用
加工處理數據
計算表達式要遵循兩個法則:
1）優先級
算術運算符 > 關系運算符 > 邏輯運算符
2）結合方向
a * b * c/2
3、運算符
運算的符號,它結合表達式，用於對數據進行加工處理
+-*/...
二、運算符
加工處理
1、運算符的分類
1）單目運算符：只有一個操作數
2）雙目運算符：有兩個操作數
3）三目運算符：有三個操作數
1 + 1
a++ ;
a ? "aa" : "bb"
2、賦值運算符
給變量賦值
分類：
=、+=、-=、*=、/=、%=
要點：
1）把右邊的數據，賦值給左邊的變量
2）左邊必須是變量
3）左邊變量的數據類型必須大於或等於右邊數據的類型
int a ;
a = 100 ;//正確,類型相同
float a ;
a = 100 ;//正確,類型大於
float a ;
a = 3.14 ;//錯誤,類型小於
100 = 100 ;//錯誤,左邊不是變量
int a = 1 ;
a += 100 ; ==> a = a + 100 ;
a *= 100 ; ==> a = a * 100 ;
3、算術運算符
1）+ - * / % ++ --
注：/ : 表示除，如果兩個操作數都為整數，
則進行整除運算，小數點部分直接舍棄
5 / 2 = 2
如果要計算正常的小數，則需要其中一個操作數變成浮點數
++ : 自增1
-- : 自減1
有兩種形式：
前綴++ -> ++ 變量 ；前綴++，先運算后取值
后綴++ -> 變量 ++ ；后綴++，先取值后運算
前綴-- -> -- 變量 ；
后綴-- -> 變量-- ；
1++ ? ==> 1 = 1 + 1 ;//錯誤
int a = 1 ;
a ++ ; //2 ==> a = a + 1 ;
int a = 1 ;
++a ; //2 ==> a = a + 1 ;
int a = 1 ;
int b = a++ + 1 ;//b=2,a=2
Console.Write(a) ;
Console.Write(b) ;
int a = 1 ;
int b = ++a + 1 ;//b=3,a=2
Console.Write(a) ;
Console.Write(b) ;
int a = 1 ;
int b = a-- + 1 ; //b=2,a=0
Console.Write(a) ;
Console.Write(b) ;
int a = 1 ;
int b = --a + 1 ;//b=1,a=0
Console.Write(a) ;
Console.Write(b) ;
4、關系（比較）運算符
用於比較兩個數
分類：> 、 < 、 >= 、<= 、 != 、==
運算結果：要么真(成立)->true，要么假(不成立)->false
1 > 1 = false
100 > 2 = true
100 == 100 = true
100 != 100 = false
注意：
int a == 100 ; //錯誤，賦值運算符是=
5、邏輯運算符
運算結果：
邏輯運算符和關系運算符運算的結果一樣。
要么真(成立)->true,要么假(不成立)->false
分類：
1）邏輯與：&&
true && true = true ;
false && true = false ;
true && false = false ;
false && false = false ;
總結：
兩個操作數同時為真，結果為真。否則，為假
例子：
100>2 && 20>2 ==> true
100>2 && 20<2 ==> false
2）邏輯或：||
true || true = true ;
true || false = true ;
false || true = true ;
false || false = false ;
總結：
兩個操作數同時為假，結果為假。否則，為真。
例子：
100<2 || 20<2 ==> false
100>2 || 20<2 ==> true
3）邏輯非：!
真的為假，假的為真
!true = false ;
!false = true ;
例子：
100<2 || !(20<2) ==> true
100>2 || 20<2 ==> true
補充：邏輯運算符 -> 短路運算
100 < 0 && 1 > 0 ==> false
int a = 10 ;
(a=3)<=10 && (a=2)<=2 ==> false
a = 3
總結：
短路運算：進行邏輯與運算時，如果左邊操作數為假，結果為假。
而右邊的操作數據不需要運算。
int a = 10 ;
(a=3)<=10 || (a=2)<=2 ==> true
a = 3
int a = 10 ;
(a=3)>=10 || (a=2)<=2 ==> true
a = 2
總結：
進行邏輯或運算時，如果左邊操作數為真，結果為真。
而右邊的操作數據不需要運算。
6、逗號運算符 , -> 分隔，減少篇幅
int a = 10 , b = 20 ;
int a = 10 ;
int b = 20 ;
7、三目運算符 -> ? : （x>y?1:2） x>y為真輸出1，反之為2
三、程序控制語句
控制程序語句執行的順序（流程）
1、概念
去銀行辦卡
第一：拿身份證，打扮一下
第二：坐603
第三：吉大站下車
第四：走到銀行
第五：按號、辦卡
第六：回家
第一：拿身份證，打扮一下
第二：坐603
如果603被打劫了，並且被搶傷了
去醫院
第三：吉大站下車
第四：走到銀行
第五：按號、辦卡
第六：回家
2、分類
1）順序語句：程序代碼，從上往下，一行代碼一行的執行
2）條件語句：根據滿足某個條件，執行相關的代碼
3）循環語句：重復的執行相關代碼
四、條件語句
1、if ... else
2、三目運算符 : 功能同if...else...
條件?表達式1:表達式2 ;
3、switch語句
switch(表達式/變量)
{
case 常量表達式1：語句1 ;
case 常量表達式2：語句2 ;
case 常量表達式3：語句3 ;
case 常量表達式n：語句n ;
default:語句n+1
}
注：
1）break表示退出switch語句，一般在各個case后面都加break
2）default語句可以放在switch語句的任意位置，但一般放在最后面，且不需要加break語句
3）常量表達式必須是一個常量值，數據類型必須和switch后面的表達式一致
4）case后面的常量表達式的值必須不一樣， 不允許重復
5）多個case語句可以共用一組執行語句(不寫break語句)
6）case后面的語句可以是多條，可不用{}括起來。
第四章：循環（for和while）
一、作用
重復做某些操作->循環
舉例在生活中，重復做的事情?
人活的每一天
追女孩
吃飯、睡覺
二、循環的四個要素
1、循環變量(i,j,k)
1）控制循環的次數
2）表示要處理的數據
2、循環條件
控制是否要重復做某些操作
3、遞增/遞減循環變量
控制循環能正常的結束
避免死循環
使循環變量發生改變,進而使用循環條件為假,
從而結束循環
4、循環體
重復要做的事情
三、循環的三種寫法
1、while
語法如下：
while(條件)
{
語句塊 ;
}
注：
1>條件一般是關系運算或邏輯運算或兩個的混合
2>語法有點類似if語句if
if(條件)
{
語句塊 ;
}
3>執行過程
當條件為真的時候，執行大括號的語句塊
語句塊執行完后，回到條件繼續判斷
如果為真，則繼續執行大括號中的語句塊
直到條件為假時，while語句結束
2、do...while
語法如下：
do
{
循環體 ;
}
while(條件) ;
區別：
1）語法格式不相同
2）執行過程不相同
當循環條件為假時，while循環的循環體一次都不執行
當循環條件為假時，do...while循環中的循環體會被執行一次
執行過程：
先執行循環體，然后判斷條件
如果條件為假，則循環結束，循環體被執行了一次
如果條件為真，則繼續的執行循環體
循環體執行完后，繼續判斷循環條件，...
直到循環條件為假時，整個循環結束
注：
do...while語句后面的分號不能省略
而while語句后面不要加分號
3、for
語法如下：
for(表達式1;表達式2;表達式3)
{
循環體 ;
}
執行過程：
首先，執行表達式1(定義循環變量，給循環變量賦值),表達式只執行一次
然后，執行表達式2，表達式2是循環條件,判斷是否為真
如果為假，循環結束
如果為真，則執行循環體
循環體執行后，則執行表達式3(遞增/遞減循環變量)
接着，執行表達式3后，則執行的判斷循環條件(表達式2)
...
注：
1）表達式1：定義循環變量，並給循環變量賦初值,且只執行一次
表達式2：循環條件，就是while后面的條件
表達式3：遞增/遞減循環變量
2）表達式1可以省略，則一般在for語句之前編寫
3）表達式3也可以省略，則一般在for語句之內編寫
4）當表達式1和表達式3省略，則等同於以下內容：
for(;i<=3;)
{
printf("你好\n") ;
i++ ;
}
5）表達式2也可以省略，則此for語句就成了死循環
for(表達式1;;表達式3)
{
}
for(;;)
{
}
四、特殊語句（break&continue）
1、break：只能使用在switch語句或循環語句內（跳出）
1）switch：表示退出switch語句
2）循環：表達終止（退出）循環
2、continue：只能在循環語句內容使用（跳過）
表示跳過本次循環，繼續下一次循環
注：break和continue語句，不能獨立存在
五、死循環
循環條件永遠為真
在開發中，要避免死循環
在開發過程中，我們有時候也要使用死循環，常用的形式有：
while(true)
{
//1.生成密碼
//2.匹配
}
for( ; ; )
{
}
do
{
}while(true) ;
六、嵌套循環（難點）
1、定義 : 在循環內部，嵌套地使用循環
2、分類：根據嵌套的層數，分為雙重循環、三重循環、四、五...
3、雙重語法
for(;;)
{
for(;;)
{
}
}
for(;;)
{
while()
{
}
}
for(;;)
{
do
{
}
while() ;
}
4、三重循環
//注：以下是雙重循環
for(;;)
{
for(;;)
{
}
for(;;)
{
}
}
for(;;)
{
for(;;)
{
for(;;)
{
}
}
}
5、雙重循環的執行過程
注：
雙重循環，可以實現二維表格的效果
外循環用於控制行
內循環用於控制列，且在內循環下要換行
從外循環到內循環進行執行，
當外循環執行結束后，雙重循環才結束
金字塔代碼：
using System;
namespace jzt
{
class f
{
static void Main()
{
int n=4;//表示有多少層
for(int i=1;i<=n;i++)
{
//找出規律
//1->3 2->2 3->1 4->0找出空格
for(int k=1;k<=n-i;k++)
{
Console.Write(" ");
}
//打印*
//1->1 2->3 3->5 4->7找出星的規律
for(int j=1;j<=(i-1)*2+1;j++)
{
Console.Write("*");
}
Console.WriteLine();//換行
}
}
}
第五章：數組
一、回顧數據類型
1、作用：指定內存空間存放數據的種類
2、分類
1）基本數據類型
整型
sbyte,byte
short,ushort
int(默認),uint
long,ulong
浮點型
float
double(默認)
decimal
布爾型
bool
字符型
char
字符串型
string
2）構造數據類型（對象類型）
依賴基本類型，根據實際需求，用戶構造的特殊的數據類型（數組）
二、概念
數組：數據的集合,數據類型相同,有序的
double[] cj = new double[3] ;
多個相同數據類型的有序集合
數組是一個特殊的數據類型，由用戶根據需求構造出來的新的數據類型
數組依賴基本數據類型
三、為什么要使用數組
方便開發者對數據進行操作、管理
四、數組定義的語法
數據類型[] 數組名 ;
注：
1）數據類型可以為任意的基本數據類型或構造類型
2）數組名的命名必須嚴格符合標識符的命名規范
五、數組的操作步驟
1、定義（聲明）數組
數據類型[] 數組名 ;
double[] cj ;
數據類型 變量名 ;
int age ;
注：聲明數組，且聲明數組中各元素的數據類型
2、創建數組：在內存中，開辟連續的空間
數組名 = new 數據類型[長度] ;
注：一般在開發中，第一步和第二步可以合並一起
也就是說，在聲明數組的同時創建數組，語法如下:
數據類型[] 數組名 = new 數組類型[長度] ;
3.初始化數組(給數組賦值)
語法如下：
數組名[下標索引] = 值 ;
例如：
數組名[0] = 值1 ;
...
數組名[n] = 值n ;
或：在聲明數組的同時，給數組賦值
數據類型[] 數組名 = {值1,...,值n} ;
4.使用
數組名[下標]
注：
1）引用數組時，下標從0開始，最大值為長度-1
2）Length屬性：返回數組的長度大小
3）數組中的數據，稱之為元素
4）遍歷數組：循環
foreach循環是針對數組和集合的遍歷操作
foreach(元素類型 迭代變量名 in 數組名稱或集合名稱)
{
...
}
六、算法實現
1、最大值、最小值
2、求和、平均值
3、搜索數據
4、排序(難點)
升序:小->大
降序:大->小
實現排序的算法有：
1）冒泡排序
數據的個數：5
比較的輪數：1 2 3 4
每輪比較的次數：4 3 2 1
誰跟誰比：相鄰的兩個數進行比較
2）選擇排序
3）插入排序
七、多維數組
最大值，最小值，總和，平均舉例：
using System;
namespace f
{
class g
{
static void Main()
{
float[] num=new float[10];
float sum=0;
float avg=0;
for(int i=0;i<num.Length;i++)
{
Console.Write("請輸入第{0}個數：",i+1);
num[i]=float.Parse(Console.ReadLine());
if(num[i]>=0&&num[i]<=100)
{
sum+=num[i];
continue;
}
else
{
Console.Write("輸入不合法，請重新輸入第{0}個數：",i+1);
num[i]=int.Parse(Console.ReadLine());
}
}
Array.Sort(num);
foreach(int m in num)
Console.WriteLine(m+"\t");
avg=sum/10;
float max=num[0];
for(int i=1;i<num.Length;i++)
{
if(max<num[i])
{
max=num[i];
}
float min=num[0];
for(int i=1;i<num.Length;i++)
{
if(min>num[i])
min=num[i];
}
Console.WriteLine("最高分為：{0}，最低分為：{1}，總分為：{2}，平均分為：{3}",max,min,sum,avg);
}
}
}
冒泡舉例：
using System ;
namespace Test01
{
class Programe
{
static void Main()
{
int[] arr = {23,90,9,25,16,1,8,7,6,5} ;
int t ;
Console.WriteLine("排序前") ;
foreach(int a in arr)
{
Console.Write("{0}\t",a) ;
}
for(int i=0;i<arr.Length-1;i++) //輪數
{
for(int j=0;j<arr.Length-1-i;j++) //每輪的次數
{
if(arr[j]<arr[j+1])
{
t = arr[j] ;
arr[j] = arr[j+1] ;
arr[j+1] = t ;
}
}
}
Console.WriteLine("排序后") ;
foreach(int a in arr)
{
Console.Write("{0}\t",a) ;
}
Console.ReadKey();
}
}
第六章：類與對象
一、編程思想
編寫程序的指導思想（方法、思路、模式）
面向過程 VS 面向對象
面向過程：把各種操作步驟，封裝為相應的方法(函數)（C語言）
取號
排隊
填表
辦理
回去
面向對象：通過描述某個對象的屬性和行為進行各種各樣的操作（c#與java）
張三
1、屬性（描述對象的特征）
心情
姓名
身份證
手機號碼
2、行為（描述對象的動作、功能、業務）
取號
排隊
填表
辦理
回去
與現實要符合
更容易理解、維護、擴展
二、類與對象（重點、難點）
1、類是對象的抽象（抽取、概括、歸納）->抽取有用的、本質的、共同的信息 -> 形成的一個類別（概念）
類是模糊的、不具體的、抽象的
類中包含三個部分內容：
1）屬性 : 描述對象的特征
2）行為 : 描述對象的功能、技能、動作
3）事件
類是對象的模板，對象是這個模板的實例
2、對象是具體的類，是類的實例（實際的例子）
對象是具體的，實際存在的、清晰的
世界萬物都是對象
三、面向對象的實現
第一：定義類
[訪問修飾符] class 類名 {
1、字段 -> 表示具體的數據，訪問修飾符一般是private
[訪問修飾符] 數據類型 字段名稱 ;
2、屬性 -> 封裝字段，設置和訪問數據（字段） ，訪問修飾符一般使用public
[訪問修飾符] 數據類型 屬性名稱
{
get{return 字段名稱;}
set{字段名稱=value;}
}
說明：
set : 設置數據，並可以對數據進行驗證處理
get : 獲取數據
set、get根據情況可以省略不寫
屬性的訪問修飾符一般是public
如果字段沒有初始化，那么字段會有相應的默認值
屬性名稱和字段名稱一般相同，但要使用帕斯卡命名規則
3、構造方法 -> 對象的初始化,在創建對象的同時，初始化對象;在構造方法中，可以對數據進行合法性判斷
[訪問修飾符] 構造方法名([參數列表])
{
構造方法體 ;
}
4、方法 -> 描述對象的動作、功能（操作） -> 成員方法(四種形式)
[訪問修飾符] 數據類型 方法名([參數列表]) {
方法體 ;
[return 數據;]
}
說明：
1）訪問修飾符：控制修飾內容的訪問權限，分類有：
public：公有訪問，不受任何訪問限制，公開的
protected：保護訪問，只能在本類或子類中訪問
private：私有訪問，只能在本類內訪問
internal：內部訪問，只能在本項目內訪問
對於類來說，默認的訪問修飾符是internal，但一般使用public
對於類成員來說，默認的訪問修飾符是private
2）命名
類名、屬性名使用帕斯卡命名法
字段名使用駝峰命名法
3）自動屬性 -> .Net Framework2.0之后新的特性，方便簡單
public class 類名
{
public 數據類型 屬性名1{get;set;}
...
public 數據類型 屬性名N{get;set;}
}
說明：
不需要定義屬性對象的字段
get,set簡寫了，但必須同時存在get,set
無法對數據進行驗證
4）構造方法 -> 在創建對象的同時，初始化對象
訪問修飾符一般使用public
構造方法名稱必須與類名相同
參數列表表示要給對象初始化的數據，可以省略，在構造方法內指定具體的數據
語法：數據類型 參數名1,...,數據類型 參數名n
this表示當前對象
在創建對象(new)的時候，構造方法會被自動的調用
在類的內部，如果用戶沒有自定義構造方法，則類的內部會默認定義一個無參構造方法,形式如下：
public 構造方法名()
{
}
字段如果沒有被初始化，則不同類型的字段會有相應的默認值
數值型默認為0
布爾型默認為False
字符串默認為""
字符型默認為''
第二：創建對象（實例化對象）
類名 對象名 = new 類名([參數]) ;
注：
new后面的是"構造方法",而參數就是初始化的具體數據
第三：初始化對象
方法一：
對象名.屬性 = 值
方法二：
... = new 類名(值1,...,值n) ;
第四：操作(方法)
訪問屬性：
[數據類型 變量名 = ]對象名.屬性名 ;
訪問方法：
[數據類型 變量名 = ]對象名.方法名稱([實參列表]) ;
四、編寫程序的四個基本步驟
第一：定義變量 -> 開辟內存空間
第二：初始化，給變量賦值 -> 把數據添加到變量對應的內存空間
第三：加工處理(核心)
第四：打印輸出
例子一：變量+數據類型的使用 -> 一個空間一個空間地開辟
int age ;
age = 100 ;
age = age + 1 ;
Console.WriteLine("年齡：{0}",age) ;
例子二：數組+數據類型的使用 -> 可以一次開辟多個空間(數據類型一樣)
數組是一個構造類型,依賴基本類型構造的新的類型
float[] score = new float[100] ;
score[0] = 120 ;
..
score[99] = 135 ;
score[0] = score[0] + 20 ;
Console.WriteLine("分數1：{0}",score[0]) ;
...
Console.WriteLine("分數N：{0}",score[99]) ;
例子三：類+數據類型的使用
類和數組一樣，也是構造類型->可以開辟多個空間，且數據類型可以不一樣
第一：定義類 -> 創建新的數據類型
class Student
{
//1.字段
private string name ;
int age ;
float weight ;
....
public string Name
{
set{name = value;}
get{return name ;}
}
}
第二：創建對象 -> 本質上就是定義變量
Student stu = new Student（） ;
第三：初始化對象
對象名.屬性 = 值 ;
stu.Name = "aaa" ;
第四：加工處理/操作
第五：打印輸出
第七章：方法
一、方法
對象能做什么、實現具體的功能、業務 -> 提高代碼重用性、維護性
1、語法：
[訪問修飾符] 數據類型 方法名([參數列表])
{
方法體 -> 此方法具體功能的實現
[return 返回值;]
}
注：
數據類型表示返回值的數據類型（注：數據類型要大於或等於返回值的類型）
數據類型使用void表示方法沒有返回值
2、兩個角色
主調方法 : 調用被調方法所在方法（地方） - Main
被調方法 : 被調用的方法 - kai
3、方法四要素
1）參數：主調方法向被調方法傳遞的數據,參數的個數：0個或多個
2）返回值：被調方法向主調方法返回的數據，返回值的個數：0個或1個 (注：返回多個 -> 數組或集合)
3）方法體-功能（業務）的實現->變量、表達式、程序控制語句
4）方法名
4、參數
1）語法：
數據類型 參數名1,...,數據類型 參數名n
2）分類：
形參（形式參數）：[定義時]形式意義的表示（代表） -> int du, string where
實參（實際參數）：[調用時]實際傳遞的數據 -> 18,"后面"
5、方法調用
數據類型 變量 = 方法名([參數列表]);
注：必須通過對象(實例)來調用的方法，叫實例方法
6、方法的分類
根據參數、返回值，方法分為以下四類
1）無參無返
[訪問修飾符] void 方法名()
{
方法體 -> 此方法具體功能的實現
}
注：無返回值方法，數據類型使用void聲明
2）無參有返
[訪問修飾符] 返回值的數據類型 方法名()
{
方法體 -> 此方法具體功能的實現
return 返回值 ;
}
注：有返的方法，一般在方法內直接把結果返回，不會做過多的處理
在調用有返的方法時，一般需要定義變量，接收返回值
3）有參無返
[訪問修飾符] void 方法名(數據類型 參數名1,...,數據類型 參數名n)
{
方法體 -> 此方法具體功能的實現
}
4）有參有返
[訪問修飾符] 返回值的數據類型 方法名(數據類型 參數名1,...,數據類型 參數名n)
{
方法體 -> 此方法具體功能的實現
return 返回值 ;
}
根據方法的調用，分為以下兩類
1）實例方法 : 必須通過對象（實例）調用的方法
類名 對象名 = new 類名([...]) ;
對象名.方法([參數列表]) ;
2）靜態方法 : 不需要通過對象調用，而直接通過類名調用的方法
定義 -> 使用static聲明的方法，就是靜態方法
[訪問修飾符] static 數據類型 方法名([參數列表])
{
方法體 -> 此方法具體功能的實現
[return 返回值;]
}
調用 -> 直接通過類名調用
類名.方法名([參數列表])
3）特殊方法
構造方法 -> 創建對象 + 初始化對象
A）方法名與類名相同
B）構造方法沒有返回值
重載方法
方法名相同 && (方法參數的個數不同 || 方法參數的數據類型不同)
public int sum(int a,int b)
{
return a + b;
}
public int sum(int a,int b,int c)
{
return a + b + c;
}
public double sum(double a,double b)
{
return a + b;
}
public double sum(int a,double b)
{
return a + b;
}
public double sum(double a,int b)
{
return a + b;
}
//出錯
public double sum(int b,int a)
{
return a + b;
}
//出錯
public double sum(int a,int b)
{
return a + b;
}
public static int sum(int a,int b)
{
return a + b;
}
public static int sum(int a,int b,int c)
{
return a + b + c;
}
注：靜態方法也可以重載
class Animal
{
...
public Animal(){}
public Animal(string name)
{
this.name = name ;
}
public Animal(string name,int age)
{
this.name = name ;
this.age = age ;
}
public Animal(int age)
{
this.age = age ;
}
...
}
注：構造方法也可以重載
如何調用重載方法呢？
方法名
方法參數的個數
方法參數的數據類型
4）根據方法的定義，分為以下兩類
用戶自定義方法
系統方法
Console.WriteLine() ;