C#学习笔记---基础入门(二)

 class Program
    {
        //单例保证在程序运行期间，一个类最多同时存在一个唯一的对象，访问对象更加方便
        public class Player
        {
            //玩家角色属性
            public string name;
            public int level;
            public int hp;
            public int maxhp;
            //1.私有化构造方法，不让外界随意创建对象
            private Player()
            {

            }
            //2.需要在类的内部提供一个静态实例
            private static Player _instance;
            //3.提供获取实例的接口
            public static Player GetInstance()
            {
                if(null==_instance)
                {
                    _instance = new Player();
                }
                return _instance;
            }
           
        }
        public class Bag
        {
            public void UseHp()
            {
                Player p = Player.GetInstance();
                p.hp += 10;
            }
        }
        static void Main(string[] args)
        {
            Player p = Player.GetInstance();
            p.name = "aa";
            p.level = 2;
            p.hp = 30;
            p.maxhp = 100;

            Bag b = new Bag();
            b.UseHp();
            Console.WriteLine(p.hp );
            Console.ReadLine();
        }
      
    }

 public void A()
            {
                Console.WriteLine("这个方法是在Super中定义的A");
            }
            //虚方法，使用virtual关键字
            //只有方法与属性可以是虚，字段不能是虚
            //抽象方法与虚方法的不同：
            //1.抽象方法必须在抽象类中
            //2.抽象方法在父类中不能实现
            //3.抽象方法在非抽象子类中必须实现
            public virtual void B()
            {
                Console.WriteLine("这个方法是在Super中定义的B");
            }
        }
        public class sub:Super 
        {
            //方法替换，——使用new关键字进行在子类中重新实现父类中定义的方法
            public new void A()
            {
                Console.WriteLine("这个方法是在sub中定义的A");
            }
            public override void B()
            {
                Console.WriteLine("这个方法是在sub中定义的B");
            }
        }

        static void Main(string[] args)
        {
            //使用父类类型引用父类对象
            Super super = new Super();
            super.A();//调用了父类中定义的方法
            super.B();//调用了父类中定义的方法

            //使用子类类型引用子类对象
            sub sub = new sub();
            sub.A();//调用了子类中定义的方法
            sub.B();//调用了子类中定义的方法

            //使用父类类型引用子类对象
            Super c = new sub();
            c.A();//调用了父类中定义的方法
            c.B();//调用了子类中定义的方法
            //多态的概念就是--使用父类类型调用子类中实现的方法
            Console.ReadLine();

        }

 public class A
        {

        }
        //实物接口
        public interface Food
        {
            //在接口中定义方法
            //1.不能添加访问修饰符，默认都是public
            //2.在接口中的方法不能实现
            //3.接口中可以定义属性与方法，不能定义字段
            float Price { get; }//定义属性
            void Eat();
        }
        //Apple继承了A类，并实现了Food接口
        //一旦某个类实现了接口，就必须实现接口中定义的全部成员
        public class Apple :A, Food
        {
            public float Price
            {     
                get
                {
                  return 3.4f;
                }        
            }

            public void Eat()
            {
                Console.WriteLine("吃苹果Hp+10");
            }
        }
        static void Main(string[] args)
        {
            Apple a = new Apple();
            a.Eat();                    
            Console.WriteLine(a.Price);

            //多态-使用接口实现多态   使用多态（抽象，虚方法，以及接口)
            Food b = new Apple();
            b.Eat();          
            Console.WriteLine(b.Price);

            //不能直接实例化接口即Food b = new Food();
            Console.ReadLine();
        }