C#类有关知识点的个人理解（陆续补充）

对象：

1. 定义：现实世界中的某个实体在计算机逻辑中的映射和体现。比如说一本书、一个人、一辆车，都是一个对象
2. 对象拥有属性和方法（可以理解为行为，功能）。比如说一辆车的颜色是属性，一辆车可以启动、鸣笛是它的方法。

类：

1. 定义：一组具有相同数据结构和相同操作的对象的集合

2. 类是对象模板，对象是类的具体化

3. 可以理解为自然界中的一类物品，比如说汽车是一个类，这个小轿车就是类的一个对象；鸟是一个类，麻雀就是鸟的一个对象。

4. public	公有类，表示外界可以不受限制访问
   private	私有类，只能被这个类的成员访问该类
   internal	内部类，仅有本程序能够访问该类
   protected	保护类，只能被这个类的成员或派生类成员访问
   abstract	抽象类，不能被实例化，只能做基类
   sealed	密封类，不能做基类

类成员：

1. 常量、方法、索引器、属性、事件、字段、运算符、构造函数、析构函数、静态析构函数

2. public	允许从类外部访问，限制最少
   private	不允许外界、派生类访问
   protected	不允许外界访问，但允许派生类访问
   internal	只允许同一个命名空间内的类访问
   readonly	只允许读

3. 如果缺省修饰符，则默认为private

静态成员：

1. 用static修饰
2. 属于类所有，通过 “类名.静态成员名” 使用

实例成员：

1. 没有用static修饰
2. 属于类的对象所有，通过 “对象名.成员名” 使用

静态方法：

1. 属于类所有，通过“类名.方法名”使用；不能通过“对象名.方法名”使用
2. 静态方法用static修饰
3. 静态方法一直在内存中，调用速度极快
4. 静态方法只能访问类中的静态成员

实例方法（非静态方法）：

1. 为类的对象所有，通过 “对象名.方法名” 使用
2. 没有static修饰的为实例方法
3. 可以访问类中的所有成员

    class Person
    {
    
    
        public string name; //公有成员名字
        public static int no;   //静态成员编号
        int age;        //私有成员年龄，缺省为private
        protected string sex;   //保护成员性别
        public static void A()
        {
    
    
            Console.WriteLine("这是一个静态方法");
            //name = "Tom"; //错误,不可以访问实例字段
            no = 9; //正确，可以访问静态字段
        }
        public void B()
        {
    
    
            name = "Tom";
            no = 10;//正确，可以访问静态字段
            Console.WriteLine("这是一个实例方法");
        }
    }
    class A
    {
    
          
        static void Main(string[] args)
        {
    
    
            Person Jack = new Person(); //实例化Person类，即创建“Jack”对象
            Person.A(); //使用类的静态方法
            Jack.B();   //使用类的实例方法
            //Jack.A(); 错误，对象无法访问类的静态方法
            Console.WriteLine(Person.no);
        }
    }

密封类：

1. 不允许其他类继承
2. 用sealed修饰
3. 通常是一些有固定作用，用来完成某种标准功能的类

密封方法：

1. 用sealed修饰
2. 密封方法防止在派生类中对该方法重写，即密封方法无法重写
3. 密封类和密封方法可以理解为一个模板或一个标准。

字段

1. 定义：直接在类中定义的变量

2. 声明格式：
   [字段修饰符] 字段类型 字段名列表；
   public string name;
   int age;
   protected string sex;
   public static int no;
   

3. 如同以上，加static修饰为静态字段，静态字段只能通过 **“类名.字段名”**访问

属性

1. 定义示例：
   class Person
   {
         
         
       private string name;	//私有字段name
       public string Name		//共有属性Name
       {
         
         
           get{
         
         return name;}
           set{
         
         name=value;}
       }
   }
   

2. get必须用return，set必须用value

3. 使用public属性可以从类的外部给类成员赋值

4. 属性与字段的区别

   • 属性可以只读或只写，字段不可以
   • get可以返回一些经过计算的或处理的数据

5. 何时使用属性？何时使用字段？

   • 在类的内部记录事物状态，用字段（对内字段）
   • 对外公布事物的状态，用属性（对外属性）

方法的继承、添加、重载、隐藏、重写

1. 继承：父类的方法自动被子类继承
2. 添加：子类添加新的方法
3. 重载：方法名与父类相同，但签名（参数）不同
4. 隐藏：方法名与父类相同，且前面（参数）也相同
5. 重写：如果父类的方法使用abstract或virtual修饰，那么子类定义与父类同名且签名也相同的方法，且子类方法前用override修饰

方法的隐藏

public class BaseClass{
    
    
    public void DoWork() {
    
    	Console.WriteLine("父类方法");	}
}
public class DerivedClass:BaseClass{
    
    
    public new void DoWork() {
    
    	Console.WriteLine("子类方法");	}
}
class Program{
    
    
    DerivedClass dc=new DerivedClass();
    dc.Dowork();	//调用子类的DoWork方法
}
//隐藏方法即在子类中创建同名方法，需要使用new 关键字
//那么是否还能调用父类的方法呢？当然能，需要使用base关键字
public class DerivedClass:BaseClass{
    
    
    public new void DoWork() {
    
    	Console.WriteLine("子类方法");	}
    public void A(){
    
    
        this.DoWork();//调用子类方法
   		base.Dowork();//调用父类方法
    }  
}

虚方法及其重写

class A {
    
    
    public virtual void VirtualMethod() {
    
     Console.WriteLine("基类虚方法"); }
}
class B : A {
    
    
    public override void VirtualMethod(){
    
     Console.WriteLine("子类重写基类虚方法"); }
}

抽象类：

1. C#中抽象类的作用是为它的派生类提供一个公共界面
2. 抽象类只能作为其他类的基类，不能创建对象
3. 抽象方法一定属于抽象类，抽象类中不一定有抽象方法
4. 如果一个类继承抽象类，那么该抽象类中的***所有抽象方法必须必须必须要在子类中重载实现！！！！！***

抽象方法：

1. 不提供具体的实现代码，只能定义在抽象类中，就定义了一下，里面啥都不要写
2. 要求子类（派生类）重写基类的抽象方法来实现具体功能，用override表示重写

abstract class Vehicle{
    
     //注意抽象类，抽象方法一定要在抽象类中！！！！
    public abstract void Whistle(); //声明抽象方法，只能这样写，大括号都不要写！！！
}
class Car : Vehicle{
    
    
    public override void Whistle(){
    
    	Console.WriteLine("抽象方法实现"); }
}