C#各种类

今日份主要内容：

虚方法，抽象方法
重写方法、重载方法、隐藏方法
抽象类、部分类、静态类、密封类

虚方法

    // 正常的方法，普通方法，官方称：实例方法，通过类的个体来调用。
    public void Method1() { }

    // 虚方法
    public virtual void Method2() 
    { 
   		 Console.WriteLine("这是基类的虚方法");
    }

虚方法使用virtual关键字，虚方法也是实例方法，但实例方法不叫虚方法。派生类可以重写（覆盖）基类的虚方法，在运行时根据实际对象的类型来调用相应的实现。

虚方法一开始定义的时候不知道具体的逻辑，子类可以改。也可以虚拟属性，但一般不这样。

虚方法在子类里可以一直修改，子类也只能修改虚方法。面向对象开发，一开始想的可能不周全，但是后面可以通过继承，一点点的进行完善。

抽象方法

抽象方法用abstract关键字修饰，它存在于抽象类中。

抽象方法只有方法声明，没有方法体。抽象类不能被实例化，它的主要作用是为派生类提供一个规范或模板，派生类必须实现抽象类中的抽象方法。

	abstract class AbstractBase
	{
        //抽象方法
    	public abstract void AbstractMethod();
        //抽象方法不能有方法体，它就是一个壳子。
	}

跟虚拟方法有啥关系？

抽象方法一定是一个虚方法，按照官方文档里的说法，它是一种隐式的虚方法。

抽象方法和虚方法的区别：虚方法必须实现（必须有方法体），可以重写也可以不重写；抽象方法不能实现，将来在子类中必须重写。

重写方法

重写方法是指在派生类中对基类中已有的方法进行重新定义，使用override关键字。继承过来的东西换掉不叫修改成员，叫做重写。从父类继承过来的虚方法，才能重写。

重写通过override和业务逻辑覆盖基类里的虚方法。重写是在派生类中提供一个与基类中虚方法或抽象方法同名的方法，从而改写基类中的实现。

重写方法本身也是一个虚方法。

隐藏方法

重新创建一个重名的，隐藏通常指的是通过派生类中的同名方法来隐藏基类的方法，丢掉继承过来的方法。可以使用new关键字来明确表示这种隐藏行为。

重写方法与隐藏方法有什么区别？

重写只能重写带virtual, abstract, override，即只能重写虚方法，抽象方法；
隐藏可以隐藏虚方法、普通方法，其他类型的方法。

重载方法

重载方法名必须保持不变，它和参数的类型、个数和顺序有关，与返回值没有关系。不一样的时候就是重载，可以打点列出来好几种方法，它们的参数类型，参数个数和顺序不一样。

重载和继承没有关系，在一个类内部定义了多个同名方法。

抽象类

抽象类是一种不能被直接实例化的类，它主要用于定义一些通用的属性和方法规范，让派生类去具体实现。

抽象类的抽象方法一开始就定义为虚的，方便后面进行更改。
当一个抽象类Calc，被多个类实现(继承)的时候，将来使用时，可以直接使用实现类。如:CalcImpl
Calc calcl=new CalcImpl(); //隐式转换
赋值给了同一个变量，变量名字都一样。

	
	abstract class Animal
	{    
		// 抽象方法，必须由派生类实现    
		public abstract void MakeSound();    
		// 非抽象方法，可以有具体实现    
		public void Sleep()   
 		{        
			Console.WriteLine("动物在睡觉");    
		}
    }

	class Dog : Animal
	{    
		public override void MakeSound()   
		{        
			Console.WriteLine("汪汪汪");    
		}
	}

	class Cat : Animal
	{    
		public override void MakeSound()    
		{        
			Console.WriteLine("喵喵喵");   
		}
	}

	class Program
	{    
		static void Main()    
		{        
		Dog dog = new Dog();      
		dog.MakeSound();        
		dog.Sleep();        
            
		Cat cat = new Cat();        
		cat.MakeSound();        
		cat.Sleep();    
		}
	}

部分类

部分类关键字partial，允许将一个类的定义拆分到多个代码文件中。在使用时类的各部分最终会合并一个完整的类。
优势：拆分类的成员，方便分工。


// File1.cs
partial class PartialExample
{    
    public void Method1()    
    {        
        Console.WriteLine("Method1 in File1");    
    }}

// File2.cs
partial class PartialExample{
    public void Method2()    
    {        
        Console.WriteLine("Method2 in File2");    
    }}


class Program
{    
    static void Main()    
    {        
        PartialExample example = new PartialExample();       
        example.Method1();        
        example.Method2();    
    }}

静态类

静态类是一种特殊的类，通过static关键字来定义。

静态类中只能有静态成员，不能有实例成员。
静态类有默认构造函数，也是静态的，不能公开。
使用静态类时，不能实例化，必须通过类本身去访问成员。也就是不能new，无法创建静态类的实例。
静态类一般用来封装一些工具，系统自带了一些静态类，如：Math，SQLHelper, Convert, Console。

static public class Calc
{
    // 静态类中的构造函数，不能有修饰符，必须是静态的。
    static Calc() { }
    static public int Add(int a, int b) { return a + b; }
    public static int Sub(int a, int b) { return a - b; }
    private static string name;
    public static string MyProperty { get; set; }
}

密封类

密封类使用sealed来定义，密封类不能被继承（不能扩展）。

public sealed class MySealed
{
    public MySealed()
    {

    }
    public int MyProperty { get; set; }
    private string name = "hello";

    public static void SayHello()
    {
        // 静态方法只能访问静态成员，不能访问实例成员
        Console.WriteLine("密封中可以有静态成员");
        //Console.WriteLine(name);  // 报错
    }
    
    public void SayHello1()
    {
        // 实例方法中，可以访问实例成员，也可以访问静态成员
        Console.WriteLine("密封中可以有实例成员"+ name);
        SayHello();
    }
    
     //public abstract void SayHello2();  // 不能有抽象成员

    /* public virtual void SayHello3()  // 不能有虚成员
     {
         Console.WriteLine("fdjslfjldj");
     }*/
}