c# 抽象类 和虚方法的区别 静态

一 抽象类（关键字：abstract）

抽象类的特点：

一：不能被实例化。
二：类中的抽象方法在继承的子类中必须重写。（需要用 override 重写）
三：类一旦有抽象方法出现，那这个类必须定义为抽象类。
四：如果一个抽象子类继承了一个抽象父类，则子类里面可以不用实现父类里面的抽象方法
也可以实现父类中的抽象方法。

抽象方法是一种特殊的虚方法，它只起声明作用，所以只加一个“;”号，一定不能带实现部分。例如：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace lesson抽象
{
    abstract class People
    {
        public abstract void Eat();
        //抽象类当中可以使用普通的方法，但是抽象类不能进行实例化
        public void Run()
        {
            Console.WriteLine("开始跑步");
        }
    }
    class Son : People
    {
        public override void Eat()
        {
            Console.WriteLine("吃饭了吗");
        }
    }
    abstract class Student:People 
    {
        //抽象子类不用重写抽象方法
        public static  string money;
        
    }
    class Program
    {
        static void Main(string[] args)
        {
            //抽象类可以通过非抽象子类来实例化
            People _people = new Son();
            _people.Run();
            Son _son = new Son();
            _son.Eat();
            Student.money = "100";
            Console.WriteLine(Student.money);
        }
    }
}

虚方法和抽象方法的区别：

虚方法和抽象方法的区别：
一：抽象方法是只有方法名称，没有方法体，即没有方法的具体实现，子类必须重写父类抽象方法才能实现具体功能；虚函数有方法名称也也有方法体，但是子类可以覆盖，也可不覆盖。
二：抽象方法是一种强制派生类覆盖的方法，否则派生类将不能被实例化。
三：抽象方法只能在抽象类中声明，虚方法不是。
四：派生类必须重写抽象类中的抽象方法，虚方法则不必要

抽象类	虚方法（virtual）
不允许有方法体	有方法体
用abstract修饰	用virtual修饰
必须被子类override	可以被子类override
必须在派生类中给出具体实现	除密封外都可以重写

虚方法：可以直接在main方法里边进行实例化
注意：字段不能是虚拟的，只有方法、属性才可以是虚拟的。

  class Car
    {
       public virtual void Funcion()
        {
            Console.WriteLine("1");
        }
    }
    class NewCar:Car 
    {
        public override void Funcion()
        {
            //base.Funcion();
            Console.WriteLine("2");
        }
    }

二 静态：

静态成员：用static修饰的成员称为静态成员。

静态成员 - 特点：
一： 如果在类成员前面加 static，表示该成员为静态成员。
二：静态成员，不能使用对象调用，只能使用类名调用，故 静态成员又称为 类成员。
三：成员前面没有加 static 表示该成员是对象成员，只能使用对象来调用，不创建对象就不能 调用。

class Beauty 
 { 
 //静态字段 
 public static string feature = "美女"; 
 //静态方法 
 public static void SpendMoney() 
 { 
 Console.WriteLine("买:衣服、包包、化妆品、鞋子。。。。"); 
 } 
 }

静态成员只能由类来调用

public static void Main(string[] args) 
{ 
 Beauty.SpendMoney(); 
 string name = Beauty.feature; 
}

静态类特点：

一：仅包含静态成员和const修饰的常量。
二：不能被实例化。
三：是密封的。（默认已经是sealed，不能再用sealed修饰）
四：有静态构造方法（函数），但静态构造方法必须是无参数的。
常量：
关键字：const
语法：const 成员类型 成员名 = 成员赋值；
作用：将成员修饰成常量
特点：const 修饰的成员必须在定义的时候就赋值，并且以后不能再其他的任何地方更改。
静态类不能实例化， 所以内部只允许有静态成员或const修饰的常量，如下

static class MyMath 
{ 
 //int length; // 不能包含非静态成员 
 static int length; 
 const int id = 10; 
 //void fun(){} // 不能包含非静态成员 
 static int Abs() 
 {
 return a > 0 ? a : -a; 
 } 
}

静态类的构造方法

public sealed class Time
 {
 public static float dealTime;
 static Time() //不能带访问修饰符，不能带参数，不能重载 
 {
 dealTime = 0.04f; //如果不写这句话，系统会为静态变量赋一个默认值
 Console.WriteLine ("static Time().");
 }
 }
class MainClass
 {
 public static void Main (string[] args)
 {
 Console.WriteLine ( Time.dealTime);
 //output:static Time(). 
 //output:0.04
 }
 }
}

单例模式：

public class Singleton
 {
 private static Singleton instance; //内建静态实例 
 private Singleton(){} //构造方法必须设为私有
 public static Singleton Instance
 {
 get{ 
 if (instance == null) {
 instance = new Singleton ();//为实例初始化
 }
 return instance;
 }
 }
 static Singleton(){
 Console.WriteLine (“Static Singleton");
 }
 public void SaySingleton(){
 Console.WriteLine ("Singleton");
 }
 }