c#学习 委托、面向对象

一、委托

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

namespace Project2
{   //定义一个委托跟函数差不多，区别在于
    //1.定义一个委托需要加上delegate关键字
    //2.委托的定义不需要函数体
    //3.委托：指向一个函数
    public delegate double MyDelegate(double param1, double param2);
    class 委托{
        static double Multiply(double param1,double param2)
        {
            return param1 * param2;
        }
        static double Divide(double param1,double param2)
        {
            return param1 / param2;
        }
        static void Main()
        {
            MyDelegate de;//利用我们定义的委托类型声明了一个新变量
            de = Multiply;//当我们给一个委托的变量类型赋值的时候，返回值跟参数列表必须一样，否则无法赋值
            Console.WriteLine(de(2.0,34.1));
            de = Divide;
            Console.WriteLine(de(2.0,34.1));
            Console.Read();
        }
    }
}

二、面向对象

有五个类：分别是Boss、Enemy、Program、Type1Enemy、Type2Enemy

Boss:

namespace _054_函数的递归调用
{
    class Boss:Enemy
    {
        //public override void Move()//重写，原来的方法不在了
        //{
        //    Console.WriteLine("这是Boss的移动方法");
        //}

        public new void Move()//当子类里面有一个签名于父类相同的方法的时候，就会把父类中的方法隐藏
        {//隐藏只是把父类中的方法隐藏看不到，实际还存在
            Console.WriteLine("这是Boss的移动方法");
        }

        public void Attack()
        {
            AI();
            Move();
            HP = 100;//父类里面公有的数据和函数成员蔡可以在子类里面访问
            Console.WriteLine("Boss正在进行攻击");
        }
    }
}

Enemy:

namespace _054_函数的递归调用
{
    class Enemy
    {
        private float hp;
        private float speed;
        public float HP
        {
            get { return hp; }
            set { hp = value; }
        }

        public float Speed
        {
            get { return speed; }
            set { speed = value; }
        }

        public void AI()
        {
            //Move();
            Console.WriteLine("这里是Enemy1的公有AI方法");
        }
        //public virtual void Move()
        //{
        //    Console.WriteLine("这里是Enemy1的公有Move方法");
        //}
        
        public void Move()
        {
            Console.WriteLine("这里是Enemy1的公有Move方法");
        }
    }
}

Program:

namespace _054_函数的递归调用
{
    class Program
    {
        static void Main()
        {
            //Boss boss = new Boss();
            //boss.AI();//继承：父类里面所有的数据成员和函数成员都会继承到子类里面
            //boss.Attack();
            //Enemy enemy;
            //enemy=new Boss();//父类声明的对象，可以由子类去构造 子类声明的对象不可以用父类去构造
            //enemy虽然使用弗雷进行了声明，但是使用了子类构造，所以本质上是一个子类类型，我们可以强制类型转换
            //Boss boss = (Boss)enemy;
            //boss.Attack();

            // Enemy enemy = new Enemy();
            //Boss boss = (Boss)enemy;//一个对象是什么类型的 主要看它是通过声明构造的 这里enemy使用了父类的构造函数，所以只有父类的字段可以强制转换

            //Boss boss = new Boss();
            //boss.Attack();
            //boss.AI();//重写虚函数后，不管在哪里调用，都调用的是重写后的函数

            //Enemy enemy = new Enemy();
            //enemy.AI();

            Enemy  boss = new Boss();
            boss.Move();//隐藏方法：如果使用子类声明的对象，调用隐藏方法会调用子类的如果使用父类声明，就会调用父类的

            Console.Read();
        }
    }
}

Type1Enemy

namespace _054_函数的递归调用
{
    class Type1Enemy:Enemy
    {
    }
}

Type2Enemy

namespace _054_函数的递归调用
{
    class Type2Enemy:Enemy
    {
    }
}