操作符(运算符)重载 或者叫 二元运算符 operator + 与 转换式操作符 implicit operator explicit operator

static void Main(string[] args)
        {
            rational r1 = new rational(5);
            rational r2 = new rational(51);
            rational r3 = r1 + r2;  // rational rational 回来 rational
            Console.WriteLine(r3.Value);
            Console.WriteLine(r1 - r2);  // rational rational 回来 int

            B bb = new B(52);
            rational rr = new rational(1);
            B bsbs = bb / rr;    // B rational 回来 B
            Console.WriteLine(bsbs);
        }

public class B
    {
        public B(int Nu)
        {
            Num = Nu;
        }
        public int Num { get; set; }
    }
    public sealed class rational
    {
        private int _value = 0;
        public int Value
        {
            get { return _value; }
            set { _value = value; }
        }
        public rational(int value)
        {
            this._value = value;
        }
        public rational()
        {

        }
        public static rational operator +(rational numl, rational numm2)
        {
            return new rational(numl.Value + numm2.Value);
        }
        public static int operator -(rational numl, rational numm2)
        {//1  public  2  static    3 方法 至少一个参数为 类的 类型rational
            return (numl.Value - numm2.Value);

        }
        public static B operator /(B b, rational r)
        {
            B b2 = new B(b.Num + r.Value);
            return b2;
        }
    }

　　

 

 

 

static void Main(string[] args)
        {
            rational ri = new rational(5);
            opop p = (opop)ri;  //过去 显式 
            Console.WriteLine(p.Name);
            p.Name = "12";

            rational r2 = p;   //回来 隐式
            Console.WriteLine(r2.Value);
            //int n = 10;
            //rational r1 = n;
            //double d = (double)r1;
        }

    public sealed class rational
    {
        private int _value = 0;
        public int Value
        {
            get { return _value; }
            set { _value = value; }
        }
        public rational(int value)
        {
            this._value = value;
        }
        public rational(double value)
        {
            this._value = (int)value;
        }
        public rational()
        {

        }
        public int ToInt()
        {
            return _value;
        }
        public double ToDouble()
        {
            return (double)_value;
        }
        public static rational operator +(rational num1, rational num2)
        {
            rational result = new rational(num1.Value + num2.Value);
            return result;
        }
        public static implicit operator rational(int value)
        {
            return new rational(value);
        }
        public static implicit operator rational(double value)
        {
            return new rational(value);
        }
        public static explicit operator int(rational value)
        {
            return value.ToInt();
        }
        public static explicit operator double(rational value)
        {
            return value.ToDouble();
        }


        //
        public static explicit operator opop(rational r1)
        {  //过去 显式
            opop o = new opop(r1.Value + "");
            return o;
        }

        public static implicit operator rational(opop op1)
        {  //回来 隐式  1 public  2 static  3 可理解为 方法名 是返回类型  参数为待转换的类型
            rational r1 = new rational(int.Parse(op1.Name));
            return r1;
        }

    }

    public class opop
    {
        public opop(string str)
        {
            Name = str;
        }
        public string Name { get; set; }

    }