一、封装特性：
这是一种隐藏的特性。可以用一个公式来展示类的封装特性：
封装的类=数据 + 对此数据进行的操作（即算法）
通俗的说，封装就是：包起外界不必要知道的东西，只向外界展露可供展示的东西。
在面向对象理论中，封装这个概念拥有更为宽广的含义。小到一个简单的数据结构，大到一个完成的软件子系统，静态的如某个软件系统要收集数据信息项，动态的如某个工作处理的流程，都可以封装到一个类中。
具备这种封装的意识，是掌握面向对象分析与设计技巧的关键
二、类的成员：
成员变量：在类里面定义的变量
成员属性：在类里面定义的属性
成员函数：在类里面定义的函数
成员属性：定义变量，右键重构，封装字段，set赋值，get取值
类成员声明主要包括：常量（const）、字段（变量）、方法、属性、事件、索引器、运算符、构造函数、析构函数等。
类的数据成员包含字段、常量和事件。
1 class Goods 2 { 3 public double height; //实例字段 4 public readonly double width = 30; //只读字段在声明时赋值 5 public static int count = 0; //静态字段， 6 public Goods( double h, double w ) 7 { 8 height = h; 9 width = w; //只读字段在构造函数中赋值 10 count++; 11 } 12 static void Main( string[ ] args ) 13 { 14 Goods y = new Goods(100, 200 ); 15 Console.WriteLine("height ={0}, width={1},count= {2}", y. height, y.width, Goods.count ); 16 Goods z = new Goods( 300, 400 ); 17 Console.WriteLine("height ={0}, width={1},count= {2}", z. height, z.width, Goods.count ); 18 // z.width=700 ;则编译错误。只读字段不能在这里赋值 19 } }
【格式】：
方法修饰符 数据类型说明符 方法名（[形式参数说明列表]）
{
变量、数组的定义语句；
其他可执行部分
}
C#中类定义可以包含两种方法：静态和非静态。定义静态时用static修饰，定义一个静态方法时，不能用virtual、abstract或override修饰符。
使用时需注意如下两点：
1）静态方法属于类所有，非静态方法属于类定义的对象所有 ，又称实例方法。
2）非静态方法可以访问类中包括静态成员在内的所有成员，而静态方法只能访问类中的静态成员。
public void Eat()//成员函数（方法）
{
Console.Write("吃饭了！");
}
{
get { return weight; } //只读属性
set { weight = value; } //只写属性
}
1 using System; 2 3 class Account 4 { 5 private double balance = 0; //字段 6 public double Balance //属性 7 { 8 get { return balance; } 9 set { balance = value;} 10 } 11 /*============================================================= 12 * 我们可以通过修改get、set方法达到控制存取的目的。 13 * 例如： 14 * 15 * 1)只读属性 16 * public double Balance //属性 17 * { 18 * get { return balance; } 19 * set { } 20 * } 21 * 22 * 2)读写控制 23 * public double Balance 24 * { 25 * get 26 * { 27 * if(Console.ReadLine()=="1234") 28 * return balance; 29 * else 30 * return -9999999; 31 * } 32 * set { } 33 * } 34 * ============================================================= 35 */ 36 37 public void Deposit(double n) 38 { this.balance += n; } 39 40 public void WithDraw(double n) 41 { this.balance -= n; } 42 } 43 44 class Client 45 { 46 public static void Main() 47 { 48 Account a = new Account(); 49 a.Balance = 1000; // 可以读写属性，因为属性Balance是public型的 50 //a.balance = 1000; //不可以读写字段，因为字段balance是private型的 51 52 a.WithDraw(500); 53 a.Deposit(2000); 54 Console.WriteLine(a.Balance); 55 } 56 }
定义类的构造函数有如下规则：
1）构造函数的函数名和类的名称一样。
2）当某个类没有构造函数时，系统将自动为其创建构造函数，这种构造函数称为默认构造函数。
example1()
{
};
3）构造函数的访问修饰符总是public。如果是private，则表示这个类不能被实例化，这通常用于只含有静态成员的类中。
4）构造函数由于不需要显示调用，因而不用声明返回类型。
5）构造函数可以带参数也可以不带参数。
特点：
a.写法特殊：没有返回类型，函数名必须和类名一样。
b.执行时机特殊：在类实例化的时候执行，是最先执行的函数，可以用来初始化数据。
eg1
1 class Employee 2 { 3 protected string ID,Name,Salary; 4 public Employee() 5 { 6 ID="0000"; 7 Name="*****"; 8 Salary="0"; 9 Console.WriteLine("{0} {1} {2}",ID,Name,Salary); 10 } 11 public Employee(string id) 12 { 13 ID=id; 14 Name="空缺"; 15 Salary="空缺"; 16 Console.WriteLine("{0} {1} {2}",ID,Name,Salary); 17 } 18 public Employee(string id,string name) 19 { 20 ID=id; 21 Name=name; 22 Salary="空缺"; 23 Console.WriteLine("{0} {1} {2}",ID,Name,Salary); 24 } 25 public Employee(string id,string name,string salary) 26 { 27 ID=id; 28 Name=name; 29 Salary=salary; 30 Console.WriteLine("{0} {1} {2}",ID,Name,Salary); 31 } 32 }
eg2
1 sing System; 2 3 public class Person 4 { 5 public string name = ""; 6 public int age = 0; 7 8 //默认构造函数 9 public Person() 10 { 11 } 12 13 //构造函数重载(1) 14 public Person(int Age) 15 { 16 this.age = Age; 17 } 18 19 //构造函数重载(2) 20 public Person(int Age, string Name) 21 { 22 this.age = Age; 23 this.name = Name; 24 } 25 26 public void ShowInfo() 27 { 28 Console.WriteLine("The name is : " + name); 29 Console.WriteLine("The age is:" + age); 30 } 31 } 32 33 class Client 34 { 35 public static void Main() 36 { 37 Person p1 = new Person(); 38 p1.ShowInfo(); 39 40 Console.WriteLine("=========================="); 41 42 Person p2 = new Person(30); 43 p2.ShowInfo(); 44 45 Console.WriteLine("=========================="); 46 Person p3 = new Person(30, "Tom"); 47 p3.ShowInfo(); 48 } 49 }
7、函数重载
条件:
a.函数名必须相同
b.函数需要的参数数量不同
c.函数需要的参数数量相同的情况下，类型不同
8、this关键字
1 partial class Ren 2 { 3 private int year; 4 private int month; 5 private int day; 6 7 public Ren(int y,int m) 8 { 9 year = y; 10 month = m; 11 } 12 public Ren(int y,int m,int d):this(y,m)//this 13 { 14 day = d; 15 } 16 17 public void Showbirthday() 18 { 19 Console.WriteLine(name+"的生日是"+year+"年"+month+"月"+day+"日"); 20 } 21 private string name; 22 23 public string Name 24 { 25 get { return name; } 26 set { name = value; } 27 } 28 29 public void Eat() 30 { 31 Console.WriteLine(name+"正在吃饭~"); 32 } 33 34 }
8.static关键字
eg
1 using System; 2 class Example1 3 { 4 static public int a;//静态成员 5 public int b; //实例成员 6 void Meth1() //实例方法 7 { 8 a++; //实例方法中可以访问本类的静态成员 9 b++; //实例方法中可以访问本类的实例成员 10 } 11 static void Meth2() 12 { 13 a++; //静态方法能够访问本类的静态成员 14 //b++; //静态方法不能访问本类的实例成员 15 }
9.例题
//接8中的例子中的类 public static void Main() { Example1 E1 = new Example1();//产生类的实例E1 Example1 E2 = new Example1();//产生类的实例E2 E1.Meth1(); //调用非静态方法需使用类的实例 //E1.Meth2(); //此语句出现错误，因为静态方法只能由类来调用 Console.WriteLine("a={0},b={1}",Example1.a,E1.b); //E2.a=50; //此语句出现错误，因为静态方法只能由类来调用 Example1.a = Example1.a + 50;//静态成员只能通过类来访问 E2.b = Example1.a + 60; //此语句正确，实例成员由对象来访问，静态成员由类来访问 Console.WriteLine("a={0},b={1}", Example1.a, E2.b); } }