静态类

1.静态类就是用Static 修饰的类
2.静态类只能包含静态成员
3.静态类不能实例化对象
4.静态类可以作为一个工具来使用，例如Console.Writeline()就是静态类，还可以使用在拓展方法

    //创建一个静态类，里面包括一个求绝对值的静态函数
    static class Test
    {
        public static int num;

        public static int Abs(int num)
        {
            if (num > 0)
                return num;
            else
                return num * -1;
        }
    }

    //使用静态类求绝对值
    int result = Test.Abs(-19);
    Console.WriteLine(result);

静态构造函数

1.静态构造函数 就是用static修饰的构造函数
2.静态类和普通类都可以使用 静态构造函数
3.静态构造函数 不能使用访问修饰函数（3p），不能有参数
4.静态构造函数 只能被自动调用一次
5.静态构造函数作用 用来初始化静态成员

    static class Test
    {
        public static int num;
        
        //静态构造函数
        static Test()
        {
            Console.WriteLine("被调用了");
            num = 100;
        }
        public static void Show()
        {
            Console.WriteLine("num值为{0}", num);
        }
    }

    //"被调用了" 只被执行了一次
    //"num值为100" 被执行了三次
    Test.Show();
    Test.Show();
    Test.Show();

拓展方法

1.概念：为现有的非静态的 变量类型 添加新方法
2.拓展方法可以提高程序的拓展性
3.拓展方法可以不需要在对象中重新写方法
4.拓展方法可以不需要继承来添加方法
5.拓展方法可以为别人已经封装的类添加额外的方法

基本语法

访问修饰符 stattic 返回值 函数名(this 要拓展的类名 参数名，参数类型 参数名，......)

为系统类创建拓展方法

    static class text
    {
        //拓展方法，可以为int 添加一个新方法
        public static void Int(this int value)
        {
            Console.WriteLine("我为int类型拓展了一个新方法");
            Console.WriteLine(value);
        }
    }

使用拓展方法

    //先实例化一个对象，再用对象调方法
    int a = 10;
    a.Int();

为自己写的类创建拓展方法

    class Tools
    {
        private int a;
        public void Show1()
        {
            Console.WriteLine("自带方法1");
        }
        public void Show2()
        {
            Console.WriteLine("自带方法2");
        }
    }
    static class text
    {
        public static void Show(this Tools str, string str1,string str2)
        {
            Console.WriteLine("{0} 为Tools类拓展了一个新方法{1}",str1,str2);
            Console.WriteLine(str);
        }
    }

使用拓展方法

     Tools t = new Tools();
     t.Show("张三", "666");

注意：

1.拓展方法 里面第一个参数值是实例化对象时赋的值
2.拓展方法 和 类 里面方法重名时 使用的是 类自身的方法
3.拓展方法 一定是写在静态类中
4.拓展方法 一定是一个静态函数
5.使用拓展方法 必须要先实例化对象，再用对象调方法
6.拓展方法 可以有返回值 和 n 个参数

运算符重载

1.作用：自定义类 或 结构体 能够使一个类和另一个类用运算符进行运算
2.使用关键字 operator
3.运算符重载一定是一个公共的静态方法
4.返回值写在operator前
5.逻辑处理可以自己定义

基本语法

public static 返回类型 operator 运算符(参数列表)

创建

    class Point
    {
        public int x;
        public int y;

        public static Point operator +(Point p1 , Point p2)
        {
            Point p = new Point();
            p.x = p1.x + p2.x;
            p.y = p1.y + p2.y;
            return p;
        }
    }

使用

    Point p1 = new Point();
    p1.x = 1;
    p1.y = 1;
    Point p2 = new Point();
    p2.x = 2;
    p2.y = 2;
    Point p = p1 + p2;

一个符号可以多个重载

    class Point
    {
        public int x;
        public int y;

        public static Point operator +(Point p1 , Point p2)
        {
            Point p = new Point();
            p.x = p1.x + p2.x;
            p.y = p1.y + p2.y;
            return p;
        }
        public static Point operator +(Point p1 , int a)
        {
            Point p = new Point();
            p.x = p1.x + a;
            p.y = p1.y + a;
            return p;
        }
    }

注意：

1.参数列表 里面 必须有一个参数得和类 类型一样
2.参数列表 里面的参数数量和 符号有关，（+） 就得两个参数 ， （!） 只有一个参数
3.参数列表 里面 不能有ref 和 out 关键字
4.有些条件运算符（<,>）,必须要成对重载
5.有些运算符不支持重载，例 （&&，||，[],()）等

内部类

1.概念：在一个类的内部再创建一个类，类似于套娃

创建

    //第一个类
    class Person3
    {
        public string naem;
        public int age;
        public Body body;
        //第二个类
        public class Body
        {
            Arm leftArm;
            Arm rightArm;
            //第三个类
            public class Arm
            {
            }
        }
    }

使用

    Person3 p = new Person3();
    Person3.Body b = new Person3.Body();
    Person3.Body.Arm a = new Person3.Body.Arm();

注意

1.内部类只有用public修饰才能被调用
2.调用方法 ： (第一个类).(第二个类).(...) 对象名 = new (第一个类).(第二个类).(...)();

分部类

1.概念：把一个类分成几部分来声明
2.分部类可以写在多个脚本文件中
3.分部类的访问修饰符要一致，且访问修饰符要写在partial前面
4.分别类中不能有重复的成员
5.分部类关键字：partial

创建

    partial class Student2
    {
        public string name;
        public int age;
    }
    partial class Student2
    {
        public int score; 
        public void Show()
        {
            Console.WriteLine(name);
            Console.WriteLine(age);
            Console.WriteLine(score);
        }
    }

使用

    Student2 s = new Student2();
    s.name = "张三";
    s.age = 19;
    s.score = 70;
    s.Show();

分部方法

1.概念：将方法的申明 和实现分离
2.分部方法 不能加访问修饰符 默认私有
3.分部方法 只能在分部类中申明
4.分部方法 返回值只能是void
5.分部方法 可以有参数但 不用 out 关键字
6.分部方法 前面要加 partial 关键字

创建

    partial class Student2
    {
        public string name;
        public int age;
        partial void Show();   //分部方法申明
    }
    partial class Student2
    {
        public int score;
        partial void Show()   //分部方法实现
        {
        }
    }