面向对象 设计模式 委托

一、设计模式

1、工厂模式

public class JiSuan
    {
        private int a;

        public int A
        {
            get { return a; }
            set { a = value; }
        }
        private int b;

        public int B
        {
            get { return b; }
            set { b = value; }
        }


        public virtual int YunSuan()
        {
            return 0;
        }

    }

    //加法类
    public class Jia:JiSuan
    {
        public override int YunSuan()
        {
            return base.A + base.B;
        }
    }

    //减法类
    public class Jian : JiSuan
    {
        public override int YunSuan()
        {
            return base.A - base.B;
        }
    }


    //工厂类
    public class GongChang
    {
        public static JiSuan DuiXiang(string s)
        {
            switch(s)
            {
                case "+":
                    return new Jia();
                    break;
                case "-":
                    return new Jian();
                    break;
                case "*":
                    return new Cheng();
                    break;
                default:
                    return new Jia();
                    break;
                   
            }
        }
    }

2、单例模式

class DBDA
    {
        //建变量
        public string host;
        public string database;

        //静态成员，用来存储该类的对象
        public static DBDA db = null;

        //构造方法    让该类不能被实例化
        private DBDA()
        { 
        }

        //提供一个造对象的方法,控制只能造一个对象
        public static DBDA DuiXiang() //因为不能造对象所以用static
        {
            if (db == null)
            {
                db = new DBDA();
            }
            return db;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            DBDA db = DBDA.DuiXiang();
            db.host = "localhost";

            DBDA db1 = DBDA.DuiXiang();
            
            Console.WriteLine(db1.host);            
            Console.ReadLine();
        }

二、委托

也称为代理，事件也是一种委托，定义在类的最外面。

1、定义委托

关键字：delegate

函数签名：签名和函数保持一致 （函数签名指返回类型和参数列表：例上面程序2中的void和string s）

定义委托的时候要根据函数来定义

public delegate int First(int a,int b);

指向的方法的返回类型，需要参数必须一致！

2、定义委托变量，指向方法

委托不能被实例化，因为不是类

First f = new JiaFa().JiaFa; //新建委托变量，指向方法，注意！！方法不需要小括号！！

第二次可以使用+=

public int JiaFa(int a,int b)

{

        return a+b;

}

调用： f(5,3);

可以理解为函数的指针，委托指向哪个函数，则这个委托就代表哪个函数

可以让函数当做参数一样进行传递

//定义委托
    public delegate void SuiBian(string s);

    class Program
    {
        static void Main(string[] args)
        {
            //委托
            //把方法参数化
            SuiBian s = China;

            s += America; //+=是绑定方法，将两个委托的调用列表连接在一起  -=去掉一个方法    =是替换


            //调用语音方法
            Speak(s);

          
            Console.WriteLine();
            Console.ReadLine();

        }

        //语音功能的方法
        static void Speak(SuiBian yu)
        {
            yu("张三");
            //if (n == 0)
            //{
            //    America();
            //}
            //else if (n == 1)
            //{
            //    China();
            //}
            //else if (n == 2)
            //{
            //    HanYu();
            //}
            //America();
            //China();
        }

        //语音包
        public static void America(string s)
        {
            Console.WriteLine(s+"hello");
        }
        static void China(string s)
        {
            Console.WriteLine(s+"你好");
        }
        static void HanYu(string s)
        {
            Console.WriteLine(s+"bjdkaj");
        }  
    }

※事件

事件就是一种特殊的委托