枚舉
枚舉是被命名的整型常數的集合；枚舉類型的變量只有賦值后才能使用；不同枚舉中的枚舉值可以重名；可以自定義枚舉值。
enum Playstates {
跑, 跳,下滑,左轉,右轉
}枚舉值的使用：Playstates.跑；
結構體
結構體相當於一個復合型的容器，其是由一系列不同類型的數據構成的集合；結構體中的成員不能在定義中賦初始值。
struct Person{
//public 類型 變量名
public string name;
public int age;
}//在main函數之前定義結構體的使用：Person p；//先聲明一個person類型變量
p.name="老王"；
訪問修飾符
public 公共，訪問不受限制
private 私有，只能在當前的類或者結構體中使用
protected 受保護的 只有在其所在類或者子類中可以訪問，不能在結構體中使用
internal 內部的，同一程序集中的任何代碼都可以訪問該類型或成員，但在其他程序集中不可以訪問
權限：1沒有嵌套在其他類或者結構中的類型，只能是public或者internal，默認是internal
2 類成員可以是任意的訪問權限，不加修飾符默認是private
類與對象
類是抽象的類型，對象是具體的實現
訪問修飾符 class 類名{
類成員...
}
public class Person{public string name;public int age;}
Person p=new Person();//使用new關鍵字聲明一個新的對象，對象也叫做類的實例。
字段
我們用字段描述類的特征 ，在類中可以直接給字段設置初始值；
訪問字段：p.name="老王";
方法
我們用方法描述類的行為，方法就是在類中定義的多條語句的代碼塊
語法 ：訪問修飾符 返回值類型 方法名（參數列表）{語句；..;return 返回值；}
調用方法：對象.方法名（參數）；
對於私有成員變量既不能獲取也不能更改，為了獲得，可以設置get，set方法
public class Car { private string name="老王";//私有變量不能被外界訪問 public string GetName() { return name; } public void SetName(string newname) { name = newname; } }
屬性
屬性自動幫我們給字段添加set get方法，屬性本質上也是set get方法，只是形式不同
語法： 訪問修飾符 屬性類型 屬性名 {set{}；get{}}
public class Car { private string name="老王"; public string Name//屬性 { //get訪問器 get { return name; } //set訪問器 set { //value關鍵字只能在屬性的set方法中有意義，表示外界客觀傳遞過來的值 name = value; } } }
使用：Car C=new Car();
C.Name="hello";//更改名稱，注意使用屬性名Name
屬性的訪問權限：僅當屬性同時具有Set與Get方法時，才能使用訪問器修飾符，並且只能夠對其中一個訪問器使用修飾符
值類型和引用類型
值類型在棧中分配空間，由系統自動分配
引用類型在堆中分配空間，由我們用new分配
string是特殊的引用類型
方法參數
形參：定義方法時，在參數列表中定義的參數叫做形參
實參：調用方法時，在參數列表中傳遞的參數叫做實參
值類型在方法內對形參做改變，不會影響到外界的實參，而引用類型可以在方法內對外界值做改變。
值類型的參數想要達到引用類型參數的效果，需要用到引用修飾符ref
public void Swap(ref int x, ref int y){
int temp=x;
x=y;
y=temp;
}
int i=5;
int j=12;
Swap(ref int i,ref int j);//可實現兩數互換值。
輸出參數：如果想讓一個方法返回多個值，在參數前加out修飾符
public void Sum(int i,int j,out int sum){
sum=0;//必須先在方法中賦初始值
sum=i+j;
}
int r;
Sum(5,13,out r);
可變參數：如果在定義方法時不能確定有多少個參數，可以使用可變參數params
public int Sum(params int[] nums){
int s=0;
foreach(int n in nums){ s+=n;}
return s;
}
int m= Sum(1,2,3,4,5);
字符串
string字符串是引用類型，因為它本質上是一個char類型的數組。因此可以使用下標索引字符串中的字符元素
方法：Contains();//判斷是否包含子字符串
IndexOf();//獲取指定字符或者字符串中的下標
Remove();//刪除子字符串
Replace();//替換子字符串
Split();//分割子串
Substring();//獲取字串
string str = "lanou/jiaoyu/hello/haha 123"; string[] a = str.Split(new char[] { '/' ,' '}, 5); foreach(string tem in a) { Console.WriteLine(tem); } Console.ReadLine();//輸出5個子字符串
方法重載
即多個不同的方法采用同樣的名字——方法名相同，參數列表不同（參數類型不同或者參數個數不同）
這樣可以使得方法調用更為方便。
在方法重載中與返回值類型無關
遞歸
遞歸---在方法體內，再次調用方法本身，遞歸必須有出口
例如數學公式計算從1加到100的和
f(n)=f(n-1)+n ; //當n>1
f(n)=1;//當n=1
轉化為遞歸表達為
public class AB { public int F(int n) { if (n > 1){ return F(n - 1) + n; } else{ return 1; } } } static void Main(string[] args){ AB a = new AB(); Console.WriteLine(a.F(5)); Console.ReadLine(); }
遞歸方法的使用適合那些復雜的大問題可以拆分為與原問題相同的小問題來解決，並且小問題更為簡單。
構造與析構
public class Person { public string name; public int age; //構造方法負責初始化對象 //構造方法的方法名必須與類名一致 //構造方法沒有返回值，不需要寫Void //構造方法可以帶有參數，因此可以重載構造方法 //如果沒有給類手動添加構造方法，系統會默認添加構造方法 //構造方法可以設為私有，此時不能使用構造創建實例 public Person() { //初始化成員變量 name = "老王"; age = 20; } public Person (string name,int age) { this.name = name;//this指向類中的字段 this.age = age; }
//析構方法--在對象銷毀時調用，用於釋放內存
//1.每個類中只有一個析構方法
//2.析構函數不能有返回值
//3.析構函數不能有訪問權限修飾符
//4.析構函數不能帶有參數，更不能重載
//5.析構函數由系統自動調用，不能手動調用
~Person(){
} } static void Main(string[] args) { //使用new關鍵字創建對象的時候就已經調用了構造方法 Person p = new Person(); Console.WriteLine(p.name); }
面向對象
封裝與繼承
封裝——封裝是實現面向對象程序設計的第一步，封裝就是將數據/方法等集合在一個個單元中，稱之為類，封裝的意義在於保護代碼/數據，屏蔽復雜性
繼承——一個類可以繼承於另外一個類，被繼承的類叫做父類，或者基類，繼承的類叫做子類，或者派生類。
（C#只支持單繼承，也就是一個子類只能有一個父類。繼承具有傳遞性）
public class Student:Person{//student繼承於Person類，則擁有了person的屬性，方法等，同時可以進行功能擴展
}
抽象類
父類中添加抽象方法需要添加abstract關鍵字
例如 public abstract void Eat()；//在父類中定義的抽象方法不能夠實現//抽象方法只能出現在抽象類中，則類前也需要加abstract
子類中實現父類的抽象方法時，需要添加override關鍵字
抽象類不能夠直接實例化，即不能通過抽象類直接創建對象
抽象類中可以包含普通的方法
抽象方法不能使用private訪問權限修飾符
靜態類
用static修飾的成員是靜態成員
靜態成員只能由類來調用，不能使用對象或者實例調用
用static修飾的類是靜態類
靜態類不能實例化，只能包含靜態成員和const常量
在內存中一共存有五個區域
1.堆區：需要程序員手動開辟並管理內存
2.棧區：由系統自動完成內存管理
3.靜態區（全局區）：程序運行過程中內存中的數據一直存在
4.常量區：用於存放常量
5.代碼區：存放程序運行所需的代碼
靜態構造方法
構造方法也可以設置為靜態
靜態構造不能有參數和訪問修飾符
不管是不是靜態類，都可以有靜態構造
靜態構造會在第一次實例化或調用靜態成員時調用
單例
單例是一種設計模式，確保一個類最多同時只存在一個實例，並易於訪問
class Program { //單例保證在程序運行期間，一個類最多同時存在一個唯一的對象，訪問對象更加方便 public class Player { //玩家角色屬性 public string name; public int level; public int hp; public int maxhp; //1.私有化構造方法，不讓外界隨意創建對象 private Player() { } //2.需要在類的內部提供一個靜態實例 private static Player _instance; //3.提供獲取實例的接口 public static Player GetInstance() { if(null==_instance) { _instance = new Player(); } return _instance; } } public class Bag { public void UseHp() { Player p = Player.GetInstance(); p.hp += 10; } } static void Main(string[] args) { Player p = Player.GetInstance(); p.name = "aa"; p.level = 2; p.hp = 30; p.maxhp = 100; Bag b = new Bag(); b.UseHp(); Console.WriteLine(p.hp ); Console.ReadLine(); } }
虛方法
public void A() { Console.WriteLine("這個方法是在Super中定義的A"); } //虛方法，使用virtual關鍵字 //只有方法與屬性可以是虛，字段不能是虛 //抽象方法與虛方法的不同： //1.抽象方法必須在抽象類中 //2.抽象方法在父類中不能實現 //3.抽象方法在非抽象子類中必須實現 public virtual void B() { Console.WriteLine("這個方法是在Super中定義的B"); } } public class sub:Super { //方法替換，——使用new關鍵字進行在子類中重新實現父類中定義的方法 public new void A() { Console.WriteLine("這個方法是在sub中定義的A"); } public override void B() { Console.WriteLine("這個方法是在sub中定義的B"); } } static void Main(string[] args) { //使用父類類型引用父類對象 Super super = new Super(); super.A();//調用了父類中定義的方法 super.B();//調用了父類中定義的方法 //使用子類類型引用子類對象 sub sub = new sub(); sub.A();//調用了子類中定義的方法 sub.B();//調用了子類中定義的方法 //使用父類類型引用子類對象 Super c = new sub(); c.A();//調用了父類中定義的方法 c.B();//調用了子類中定義的方法 //多態的概念就是--使用父類類型調用子類中實現的方法 Console.ReadLine(); }
接口
interface
public class A { } //實物接口 public interface Food { //在接口中定義方法 //1.不能添加訪問修飾符，默認都是public //2.在接口中的方法不能實現 //3.接口中可以定義屬性與方法，不能定義字段 float Price { get; }//定義屬性 void Eat(); } //Apple繼承了A類，並實現了Food接口 //一旦某個類實現了接口，就必須實現接口中定義的全部成員 public class Apple :A, Food { public float Price { get { return 3.4f; } } public void Eat() { Console.WriteLine("吃蘋果Hp+10"); } } static void Main(string[] args) { Apple a = new Apple(); a.Eat(); Console.WriteLine(a.Price); //多態-使用接口實現多態 使用多態（抽象，虛方法，以及接口) Food b = new Apple(); b.Eat(); Console.WriteLine(b.Price); //不能直接實例化接口即Food b = new Food(); Console.ReadLine(); }