委托的学习-一切皆地址

委托 是函数指针的“升级版”

实例：c/c++的函数指针

一切皆地址
变量（数据）是以某个地址为起点的一段内存中所存储的值
函数（算法）是以某个地址为起点的一段内存中所存储的一组机器语言指令

直接调用和间接调用

直接调用：通过函数名来调用函数，CPU通过函数名直接获得函数所再地址并开始执行->返回
间接调用：通过函数指针来调用函数，CPU通过读取函数指针存储的值获得函数所在地址并开始执行->返回

java 中没有与委托相对应的功能实体

委托的简单使用
系统自带的两个委托
Action
Func

自定义委托 delegate
委托是一种类（class），类是数据类型，所以委托也是一种数据类型
它的声明方式与一般类不同，主要是为了照顾可读性和c/c++传统
注意声明委托的位置-避免写错地方，结果声明称嵌套类型
委托与所封装的方法必须“类型兼容”

//委托的声明，是一种类，要和类处在一个级别
    //要与所指向的方法-类型兼容
    public delegate double Calc(double x, double y);
    class Program
    {
        static void Main(string[] args)
        {

            Calculator calculator = new Calculator();
            Calc calc1 = new Calc(calculator.Add);
            Calc calc2 = new Calc(calculator.Sub);
            Calc calc3= new Calc(calculator.Mul);
            Calc calc4 = new Calc(calculator.Div);

            double x = 100;
            double y = 200;
            double z = 0;

            z = calc1(x,y);
            Console.WriteLine(z);
            z = calc2(x, y);
            Console.WriteLine(z); 
            z = calc3(x, y);
            Console.WriteLine(z);
            z = calc4(x, y);
            Console.WriteLine(z);
            z = calc1.Invoke(x,y);
            Console.WriteLine(z);
        }
    }
    class Calculator
    {
        public double Add(double x, double y)
        {
            return x + y;
        }
        public double Sub(double x, double y)
        {
            return x - y;
        }
        public double Mul(double x, double y)
        {
            return x * y;
        }
        public double Div(double x, double y)
        {
            return x / y;
        }
    }

委托的一般使用

实例：把方法当作参数传给另一个方法

正确的使用1：模板方法， 借用指定的外部方法来产生结果
相当于填空题
常常位于代码中部
委托有返回值
示例：

    class Program
    {
        static void Main(string[] args)
        {
            //实例化一个工厂
            ProductFactory productFactory = new ProductFactory();
            //实例化一个包装工厂
            WrapFactory wrapFactory = new WrapFactory();
            //委托的实例，参数列表为空，返回值类型为product 所以是匹配的
            Func<Product> func1 = new Func<Product>(productFactory.MakePizza);
            //委托的实例2，参数列表为空，返回值类型为product
            Func<Product> func2 = new Func<Product>(productFactory.MakeToyCar);
            //不通过直接调用方法来生产pizza等，而是通过委托来调用 委托给了func1 和 func2
            Box box1 = wrapFactory.WrapProduct(func1);
            Box box2 = wrapFactory.WrapProduct(func2);

            Console.WriteLine(box1.Product.Name);
            Console.WriteLine(box2.Product.Name);

        }
    }

    class Product
    {
        public string Name { get; set; }
    }
    class Box
    {
        public Product Product { get; set; }
    }

    class WrapFactory
    {
        public Box WrapProduct(Func<Product>getProduct)
        {
            Box box = new Box();
            //委托一个返回product 的方法,这个看上去好理解
            Product product = getProduct();
            //Product product = getProduct.Invoke();这个不好理解啊
            box.Product = product;
            return box;
        }
    }

    class ProductFactory
    {
        public Product MakePizza()
        {
            Product product = new Product();
            product.Name = "Pizza";
            return product;
        }

        public Product MakeToyCar()
        {
            Product product = new Product();
            product.Name = "ToyCar";
            return product;
        }
    }