c# 面相对象2-之封装性

一、封装特性：

　　这是一种隐藏的特性。可以用一个公式来展示类的封装特性：

　　封装的类=数据  +  对此数据进行的操作（即算法）

　　通俗的说，封装就是：包起外界不必要知道的东西，只向外界展露可供展示的东西。

　　在面向对象理论中，封装这个概念拥有更为宽广的含义。小到一个简单的数据结构，大到一个完成的软件子系统，静态的如某个软件系统要收集数据信息项，动态的如某个工作处理的流程，都可以封装到一个类中。

　　具备这种封装的意识，是掌握面向对象分析与设计技巧的关键

二、类的成员：

成员变量：在类里面定义的变量
成员属性：在类里面定义的属性
成员函数：在类里面定义的函数
成员属性：定义变量，右键重构，封装字段，set赋值，get取值

类成员声明主要包括：常量（const）、字段（变量）、方法、属性、事件、索引器、运算符、构造函数、析构函数等。

类的数据成员包含字段、常量和事件。

1、字段：字段是与类相关的变量，相当于C++中的变量。

 

eg

 class Goods
 {
    public double height;             //实例字段
    public readonly double width = ;     //只读字段在声明时赋值
    public static int count = ;            //静态字段，
    public Goods( double h, double w )
    {
       height = h;
       width = w;     //只读字段在构造函数中赋值
       count++;
     }
     static void Main( string[ ] args )
     {
        Goods y = new Goods(,  );
        Console.WriteLine("height ={0}, width={1},count= {2}", y. height, y.width, Goods.count );
        Goods z = new Goods( ,  );
        Console.WriteLine("height ={0}, width={1},count= {2}", z. height, z.width, Goods.count );
        // z.width=700 ;则编译错误。只读字段不能在这里赋值
     } }

2、常量：用来定义与类相关的常量值。

 

3、事件：是类的成员，它可以让对象通知调用者某些特定的行为发生时间。

 

类的函数成员包括方法、属性、运算符、索引器、构造函数和析构函数。

 

4、方法：完成类中各种计算或功能的操作，类似函数。

 

a、方法的定义

【格式】：

方法修饰符 数据类型说明符 方法名（[形式参数说明列表]）

{

变量、数组的定义语句；

其他可执行部分

}

b、静态方法和非静态方法

C#中类定义可以包含两种方法：静态和非静态。定义静态时用static修饰，定义一个静态方法时，不能用virtual、abstract或override修饰符。

使用时需注意如下两点：

1）静态方法属于类所有，非静态方法属于类定义的对象所有 ，又称实例方法。

2）非静态方法可以访问类中包括静态成员在内的所有成员，而静态方法只能访问类中的静态成员。

eg

public void Eat()//成员函数（方法）
{
Console.Write("吃饭了！");
}

 

5、属性：定义类的特征，并对他们提供读、写操作。

eg

public double Weight//成员属性,定义上面的weight变量的

{
get { return weight; } //只读属性
set { weight = value; } //只写属性
}

 using System;

 class Account
 {
     private double balance = ;        //字段
     public double Balance            //属性
     {
         get { return balance; }
         set { balance = value;}
     }
     /*=============================================================
      * 我们可以通过修改get、set方法达到控制存取的目的。
      * 例如：
      *
      * 1)只读属性
      * public double Balance            //属性
      * {
      *    get { return balance; }
      *    set { }
      * }
      *
      * 2)读写控制
      * public double Balance
      * {
      *    get
      *    {
      *       if(Console.ReadLine()=="1234")
      *          return balance;
      *       else
      *          return -9999999;
      *    }
      *    set { }
      * }
      * =============================================================
      */

     public void Deposit(double n)
     { this.balance += n; }

     public void WithDraw(double n)
     { this.balance -= n; }
 }

 class Client
 {
     public static void Main()
     {
         Account a = new Account();
         a.Balance = ;    // 可以读写属性，因为属性Balance是public型的
         //a.balance = 1000;    //不可以读写字段，因为字段balance是private型的

         a.WithDraw();
         a.Deposit();
         Console.WriteLine(a.Balance);
     }
 }

6、构造函数在类被实例化时首先执行的函数，主要完成对象初始化操作。

作用：主要用来为对象分配存储空间，完成初始化操作（给类的成员变量赋值等）。

定义类的构造函数有如下规则：

1）构造函数的函数名和类的名称一样。

2）当某个类没有构造函数时，系统将自动为其创建构造函数，这种构造函数称为默认构造函数。

example1()

{

};

3）构造函数的访问修饰符总是public。如果是private，则表示这个类不能被实例化，这通常用于只含有静态成员的类中。

4）构造函数由于不需要显示调用，因而不用声明返回类型。

5）构造函数可以带参数也可以不带参数。

特点：

a.写法特殊：没有返回类型，函数名必须和类名一样。
b.执行时机特殊：在类实例化的时候执行，是最先执行的函数，可以用来初始化数据。

eg1

 class Employee
 {
     protected string ID,Name,Salary;
     public Employee()
     {
         ID="";
         Name="*****";
         Salary="";
         Console.WriteLine("{0}\t{1}\t{2}",ID,Name,Salary);
     }
     public Employee(string id)
     {
         ID=id;
         Name="空缺";
         Salary="空缺";
         Console.WriteLine("{0}\t{1}\t{2}",ID,Name,Salary);
     }
     public Employee(string id,string name)
     {
         ID=id;
         Name=name;
         Salary="空缺";
         Console.WriteLine("{0}\t{1}\t{2}",ID,Name,Salary);
     }
     public Employee(string id,string name,string salary)
     {
         ID=id;
         Name=name;
         Salary=salary;
         Console.WriteLine("{0}\t{1}\t{2}",ID,Name,Salary);
     }
 }

eg2

 sing System;

 public class Person
 {
     public string name = "";
     public int age = ;

     //默认构造函数
     public Person()
     {
     }

     //构造函数重载(1)
     public Person(int Age)
     {
         this.age = Age;
     }

     //构造函数重载(2)
     public Person(int Age, string Name)
     {
         this.age = Age;
         this.name = Name;
     }

     public void ShowInfo()
     {
         Console.WriteLine("The name is : " + name);
         Console.WriteLine("The age is:" + age);
     }
 }

 class Client
 {
     public static void Main()
     {
         Person p1 = new Person();
         p1.ShowInfo();

         Console.WriteLine("==========================");

         Person p2 = new Person();
         p2.ShowInfo();

         Console.WriteLine("==========================");
         Person p3 = new Person(, "Tom");
         p3.ShowInfo();
     }
 }

7、函数重载

条件:
a.函数名必须相同
b.函数需要的参数数量不同
c.函数需要的参数数量相同的情况下，类型不同

8、this关键字

 partial class Ren
     {
         private int year;
         private int month;
         private int day;

         public Ren(int y,int m)
         {
             year = y;
             month = m;
         }
         public Ren(int y,int m,int d):this(y,m)//this
         {
             day = d;
         }

         public void Showbirthday()
         {
             Console.WriteLine(name+"的生日是"+year+"年"+month+"月"+day+"日");
         }
         private string name;

         public string Name
         {
             get { return name; }
             set { name = value; }
         }

         public void Eat()
         {
             Console.WriteLine(name+"正在吃饭~");
         }

     }

8.static关键字

eg

 using System;
 class Example1
 {
     static public int a;//静态成员
     public int b;       //实例成员
     void Meth1()        //实例方法
     {
         a++;         //实例方法中可以访问本类的静态成员
         b++;         //实例方法中可以访问本类的实例成员
     }
     static void Meth2()
     {
         a++;         //静态方法能够访问本类的静态成员
         //b++;         //静态方法不能访问本类的实例成员
     }

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 + ;//静态成员只能通过类来访问
    E2.b = Example1.a + ;      //此语句正确，实例成员由对象来访问，静态成员由类来访问
      Console.WriteLine("a={0},b={1}", Example1.a, E2.b);
     }
 }