c#封装继承多态抽象类静态类密封类

最新推荐文章于 2023-11-02 19:41:29 发布
最新推荐文章于 2023-11-02 19:41:29 发布
阅读量218 收藏 1
点赞数
分类专栏： c# 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuhongze98/article/details/119192231
版权 
using System;-------------封装继承多态--------------------

namespace aHomework
{
    class Equip
    {
        public string name;

        public Equip(string name)
        {
            this.name = name;
        }
    }

    class Weapon : Equip
    {
        public int level;
        public float attackPower;
        
        public Weapon(string name, float attackPower) : base(name)
        {
            this.attackPower = attackPower;
        }

        public virtual void Attack()
        {
            Console.WriteLine($"{name}攻击，攻击力{attackPower}");
        }
    }

    class Armor : Equip
    {
        //防御力
        public float armorPower;
        //耐久度
        public float durability;
        
        public Armor(string name, float armorPower) : base(name)
        {
            this.armorPower = armorPower;
        }
    }

    class MagicWeapon : Weapon
    {
        public MagicWeapon(string name, float attackPower) : base(name, attackPower)
        {
        }

        public override void Attack()
        {
            Console.Write("魔法武器");
            //父类中的Attack执行
            base.Attack();
        }
    }

    class BowAndArrow : Weapon
    {
        public BowAndArrow(string name, float attackPower) : base(name, attackPower)
        {
        }
        
        public override void Attack()
        {
            Console.Write("弓箭武器");
            base.Attack();
        }
    }

    class LongSword : Weapon
    {
        //防御力
        public float armorPower;
        
        public LongSword(string name, float attackPower, float armorPower) : base(name, attackPower)
        {
            this.armorPower = armorPower;
        }

        public override void Attack()
        {
            Console.Write("长剑武器");
            base.Attack();
        }
    }

    class Hero
    {
        /// <summary>
        /// 装备列表
        /// </summary>
        public Equip[] equipList;

        public Hero()
        {
            equipList = new Equip[6];
        }

        public void AddEquip(Equip equip)
        {
            for (int i = 0; i < equipList.Length; i++)
            {
                if (equipList[i] == null)
                {
                    //将新装备存储
                    equipList[i] = equip;
                    Console.WriteLine(equip.name + "添加到列表成功！");
                    return;
                }
            }

            Console.WriteLine("装备列表已满！");
        }

        public void RemoveEquip(Equip equip)
        {
            if (equip != null)
            {
                RemoveEquip(equip.name);
                return;
            }
            
            Console.WriteLine("装备为空！");
        }

        public void RemoveEquip(string equipName)
        {
            for (int i = 0; i < equipList.Length; i++)
            {
                if(equipList[i] == null)
                    continue;
                if (equipList[i].name == equipName)
                {
                    Console.WriteLine(equipName + "从列表删除成功！");
                    //删除该装备
                    equipList[i] = null;
                    return;
                }
            }

            Console.WriteLine($"列表中无{equipName}装备，删除失败！");
        }

        /// <summary>
        /// 找到一把弓箭并进行攻击
        /// </summary>
        public void FindBowAndArrowAndAttack()
        {
            for (int i = 0; i < equipList.Length; i++)
            {
                if(equipList[i] == null)
                    continue;
                if (equipList[i] is BowAndArrow)
                {
                    //攻击
                    (equipList[i] as Weapon).Attack();
                    return;
                }
            }

            Console.WriteLine("没有找到弓箭装备！");
        }

        
        /// <summary>
        /// 找到所有武器，并进行攻击
        /// </summary>
        public void FindAllWeaponAndAttack()
        {
            for (int i = 0; i < equipList.Length; i++)
            {
                if(equipList[i] == null)
                    return;
                if (equipList[i] is Weapon)
                {
                    //武器进行攻击
                    (equipList[i] as Weapon).Attack();
                }
            }
        }
    }
    
    
    class Program
    {
        static void Main(string[] args)
        {
            MagicWeapon wydb = new MagicWeapon("无用大棒",20);
            LongSword wjzr = new LongSword("无尽之刃",100,0);
            Equip bwg = new BowAndArrow("霸王弓",80);
            
            Equip ktkj = new Armor("狂徒铠甲",80);
            
            Hero angle = new Hero();
            angle.AddEquip(ktkj);
            angle.AddEquip(wydb);
            angle.AddEquip(wjzr);//Equip equip = wjzr;
            angle.AddEquip(bwg);
            
            angle.RemoveEquip(wjzr);
            angle.RemoveEquip("饮血剑");
            
            angle.FindBowAndArrowAndAttack();

            Console.WriteLine("---------");
            
            angle.AddEquip(wjzr);
            
            angle.FindAllWeaponAndAttack();
        }
    }
}
using System;--------抽象类*-------------------------------

namespace bAbstruct
{
    /// <summary>
    /// 运动员
    /// </summary>
    abstract class Sportsman
    {
        private string name;

        public Sportsman(string name)
        {
            this.name = name;
        }

        /// <summary>
        /// 训练
        /// </summary>
        public abstract void Train();
        /*
         * 抽象方法必须在抽象类中存在
         * 但是，抽象类中不一定要有抽象方法，一般在抽象类中都会有抽象方法
         * 但是，抽象类中也可以存在普通方法
         */

        public void Eat()
        {
            Console.WriteLine("吃饭");
        }
    }

    /// <summary>
    /// 足球运动员
    /// </summary>
    class FootBallSportsman : Sportsman
    {
        //问题2:训练方法可以重写，也可以不重写
        // public override void Train()
        // {
        //     Console.WriteLine("跑步、传球、射门");
        // }
        public override void Train()
        {
            Console.WriteLine("跑步、传球、射门");
        }

        public FootBallSportsman(string name) : base(name)
        {
        }
    }

    abstract class SwimSportsman : Sportsman
    {
        /*
         *     抽象方法在普通子类中，必须重写
         *     然而，在抽象子类中，可以选择重写或不重写
         */

        // public override void Train()
        // {
        // }
        protected SwimSportsman(string name) : base(name)
        {
        }
    }

    /// <summary>
    /// 自由泳
    /// </summary>
    class FreedomSwimSportsman : SwimSportsman
    {
        public override void Train()
        {
            Console.WriteLine("摆臂、蹬腿、憋气");
        }

        public FreedomSwimSportsman(string name) : base(name)
        {
        }
    }

    /// <summary>
    /// 蛙泳
    /// </summary>
    class Breaststroke : SwimSportsman
    {
        public override void Train()
        {
            Console.WriteLine("扩臂、蹬腿、憋气");
        }

        public Breaststroke(string name) : base(name)
        {
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            // Sportsman liuxiang = new Sportsman();
            // //问题1:方法体为空，不知道训练什么
            // liuxiang.Train();

            //抽象类允许声明对象
            Sportsman yaoming;
            //抽象类不能进行实例化对象
            //new Sportsman();
            
            Sportsman wulei = new FootBallSportsman("武磊");
            wulei.Train();
            
            Sportsman xiaoming = new FreedomSwimSportsman("xiaoming");
            Sportsman xiaohong = new Breaststroke("xiaohong");
            
            xiaoming.Train();
            xiaohong.Train();
        }
    }
}
using System;-------------------------------------------------------------

/// <summary>
/// 员工
/// </summary>
abstract class Emplyee
{
    private string name;
    private string id;

    public string Name
    {
        get { return name;}
        set { name = value; }
    }

    public string Id
    {
        get { return id;}
        set { id = value; }
    }

    // 抽象方法一定要是public 或 protected
    public abstract float CalculateSalary();

    public abstract void Work();
}

class Manager : Emplyee
{
    public float workScore;
    public float baseSalary = 10000;
    
    public override float CalculateSalary()
    {
        float salary = baseSalary + workScore * 100;
        
        Console.WriteLine($"{Name}正在结算薪资，薪资为{salary}");
        return salary;
    }

    public override void Work()
    {
        Console.WriteLine($"{Name}正在工作，获取到10点工作积分");
        workScore += 10;
    }
}

namespace cAbstructEx
{
    class Program
    {
        static void Main(string[] args)
        {
            Emplyee xiaohong = new Manager();
            xiaohong.Name = "小红";
            
            xiaohong.Work();
            xiaohong.Work();
            xiaohong.Work();

            float money = xiaohong.CalculateSalary();
        }
    }
}
using System;--------密封类-----
using System.Reflection.PortableExecutable;

namespace dSealed
{
    /// <summary>
    /// 添加Sealed关键词，该类就变成了密封类
    /// 功能：该类不能被继承
    ///        不能有派生类
    /// </summary>
    sealed class Time
    {
        public string date;
        public string time;
    }

    // class TestClass : Time
    // {
    // }

    abstract class Sportsman
    {
        public abstract void Train();

        public virtual void Match()
        {
        }
    }

    class RuningMan : Sportsman
    {
        ///当前方法不能再被子类重写        
        public sealed override void Train()
        {
            Console.WriteLine("力量练习");
        }
    }

    class LongTimeRunningman : RuningMan
    {
        //子类不能重写父类的密封方法了
        // public override void Train()
        // {
        //     Console.WriteLine("耐久度练习");
        // }
    }

    class Program
    {
        static void Main(string[] args)
        {
        }
    }

    class MyClass
    {
        private static MyClass instance;

        public static MyClass GetInstance()
        {
            if (instance==null)
            {
                instance = new MyClass();
            }

            return instance;
        }

        private MyClass()
        {
        
        }
    
    }

    class SingleTon
    {
        private static SingleTon instance;

        public static SingleTon GetInstance()
        {
            if (instance==null)
            {
                instance = new SingleTon();
            }

            return instance;
        }

        private SingleTon()
        {
            
        }
    }

    
    
}
using System;----------静态类--------------

namespace eStatic
{
    class Equip
    {
        
    }
    
    static class GameConst
    {
        //静态类中的常数定义的可以使用全大写or大驼峰
        public const float PLAYER_HEIGHT = 1.8f;
        public static float Player_MoveSpeed = 5;
        public static Equip[] Player_Equips;

        //静态构造函数
        //1、[前面不允许添加访问修饰符]
        //2、[不能有参数]
        //3、[执行的时间节点：第一次访问该类的静态字段、属性、方法]
        static GameConst()
        {
            Player_Equips = new Equip[5];
            Console.WriteLine("GameConst 静态构造");
        }
    }

    //在静态类中，只能有出现静态的东西，不能有成员的东西
    static class MathTool
    {
        //成员的字段、属性、方法，都不能存在
        // private string name;
        // public string Name
        // {
        //     get => name;
        //     set => name = value;
        // }
        // public void Demo()
        // {
        // }

        public static float[] Sort(float[] array)
        {
            return null;
        }
    }

    //普通的类中，也可以设置静态的字段、属性、方法
    class Person
    {
        public static float PLAYER_HEIGHT = 1.8f;
        
        //静态字段
        private static long population = 7000000000;
        public static int historyLength = 5000;

        //静态属性
        public static long Polulation
        {
            get { return population;}
            set { population = value; }
        }

        //静态方法
        public static long GetPopulation()
        {
            //静态方法里，不能出现成员的字段、属性、方法
            // Console.WriteLine(name);
            return Person.population;
        }

        static Person()
        {
            Console.WriteLine("Person 静态构造");
        }

        public void SayHello()
        {
            //成员方法里可以访问访问静态字段、方法
            Console.WriteLine(population);
            Console.WriteLine(historyLength);
            GetPopulation();
        }

        public string name;
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            //静态字段直接通过类名去访问
            // Console.WriteLine(Person.population);
            Console.WriteLine(Person.historyLength);
            
            Person xiaoming = new Person();
            // xiaoming.name
            Person xiaohong = new Person();
            // xiaohong.name


            Person.GetPopulation();
            Console.WriteLine(Person.historyLength);
            Console.WriteLine(Person.Polulation);

            //静态类不能进行实例化对象
            // new MathTool();
            //静态类的主要用途是，用于调用类中的静态字段、属性、方法
            MathTool.Sort(new float[] {2, 3, 5, 6, 3});
            
            //访问常数？常数一直保持不变，跟对象也毫无关系
            //访问方式，也是通过类名访问，类名.常数变量
            Console.WriteLine(GameConst.PLAYER_HEIGHT);
            Console.WriteLine(GameConst.Player_MoveSpeed);
            Console.WriteLine(GameConst.Player_MoveSpeed);
        }
    }
}
using System;-----------单例------------------

namespace fSingleton
{
    /// <summary>
    /// 单例类
    /// </summary>
    class Singleton
    {
        private static Singleton instance;
        public static Singleton GetInstance()
        {
            if (instance == null)
            {
                instance = new Singleton();
            }
            return instance;
        }

        private Singleton()
        {
        }
    }

    class AudioManager
    {
        private static AudioManager instance;

        public static AudioManager GetInstance()
        {
            if (instance == null)
            {
                instance = new AudioManager();
            }

            return instance;
        }

        private AudioManager()
        {
        }

        #region 单例成员

        public float maxVolume = 10;

        public void Play(string audioName)
        {
            Console.WriteLine($"正在播放{audioName}");
        }

        #endregion

    }

    class PlayerManager
    {
        private static PlayerManager instance;

        public static PlayerManager GetInstance()
        {
            if (instance == null)
            {
                instance = new PlayerManager();
            }

            return instance;
        }

        private PlayerManager()
        {
        }
    }
    
    
    class GameData
    {
        private GameData()
        {
        }

        #region ReadOnly方式

        //让某个静态字段只能读，不能写 readonly
        // public static readonly GameData instance = new GameData();

        #endregion

        #region 使用只读属性方式

        //可以用只读属性解决            
        // public static GameData Instance
        // {
        //     get { return instance;}
        // }

        #endregion

        #region 使用静态方法【懒加载】
        
        private static GameData instance;

        public static GameData GetInstance()
        {
            if (instance == null)
            {
                instance = new GameData();
            }
            return instance;
        }

        #endregion

        #region 使用单例

        public string gameTime;

        #endregion
    }
    
    
    class Program
    {
        static void Main(string[] args)
        {
            // new GameData()
            // GameData.Instance = null;
            // GameData.instance = null;

            GameData ins = GameData.GetInstance();
            ins.gameTime = "100";
            ins = null;
            Console.WriteLine(ins == GameData.GetInstance());
            Console.WriteLine(GameData.GetInstance() == null);
            
            AudioManager.GetInstance().maxVolume = 100;
            AudioManager.GetInstance().Play("主背景音乐");
        }
    }
}

Bug敲起来
关注
专栏目录
C#抽象类（abstract）
weixin_44022365的博客
06-19 3528
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 抽象类特征 1、抽象类不能实例化。 2、抽象类可以包含抽象方法和抽象访问器。 3、不能用 sealed 修饰符修改抽象类，这意味着该类不能被继承。 4、从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实实现。 在方法或属性声明中使用 abstract 修饰符以指示此方法或属性不包含实现。 抽象类关键字（abstract） ab
C# 封装-继承-多态
qq_39806817的博客
10-26 1351
一、封装 简单来说，封装就是利用访问修饰符，设置使用者的访问权限 1.用读写方法封装 public class Person { private string name; private int age; /// <summary> /// 写入名字 /// </summary> /// <param name="name"></param> public void SetName(string name
C#中的abstract 类和方法!!!
weixin_30709061的博客
09-20 141
C#中的abstract类不能被实例化，他只提供其他类的继承的接口using System;abstract class MyAbs{public void NonAbMethod(){Console.WriteLine("Non-Abstract Method");}}class MyClass : MyAbs{}class MyClient{public static void Main(){...
C#中抽象类和抽象方法以及密封类和密封方法的使用。
Liuxm
06-05 490
简介 抽象类和密封类的内容大致如下： 抽象类与抽象方法的使用 C#中使用“abstract”关键字来声明一个抽象类，并在该抽象类中声明一个抽象方法。 代码如下： public abstract class School { /* * 定义两个属性： * ID：学号 * NAME：姓名 */ private string id; private string name
C# 中 类和类中方法的继承关系abstract sealed virtual override 和 new
yxt99的博客
01-13 256
1、abstract修饰符可以和类、方法、属性、索引器及事件一起使用（待实现）。修饰类时表示抽象类，只能作为其他类的基类，不能被实例化，可以包括抽象方法和抽象访问器，从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实现； 2、sealed不能修饰抽象类，修饰非抽象类时表示该类不能被继承；sealed override可以一起修饰虚方法或虚属性，不可单独修饰虚方法或虚属性； ...
静态(static)方法的继承和重写
03-14
静态(static)方法的继承和重写
C# 抽象类、多态、接口
in_kim的博客
07-14 324
c#抽象类、多态、接口
2023/11/2——C#——封装、继承、多态；抽象类；重写和重载和覆盖；this，base
最新发布
m0_62178539的博客
11-02 581
三个特性主要目标:重用性(安全性)、灵活性和扩展性。封装 可以通过 以下 方式实现： * （方法不一定是属性 ； 属性一定是 方法！） 属性(Property):通过Get和Set方法实现对数据的读写操作， 并可以在进行数据读写时添加自定义的逻辑。 在C#中，属性可用于将实例变量封装到类中 访问修饰符:C#中有四种访问修饰符: public、private、protected和inter
封装 继承 多态理解
wan37的博客
10-14 990
一.封装 1.定义 封装：将类的某些信息隐藏在类内部(private)，不允许外部程序直接访问，而是通过该类提供的公共属性(public）来实现对隐藏信息的操作和访问 快捷键：prop+TABpropfull+TAB 2.封装的好处 1、隐藏类的实现细节 2、只能通过规定属性访问数据 3、方便加入控制语句 4、方便修改实现 二.继承 2.1 定义 继承：一个类具有另一个类的属性和方法，这个类叫子类（派生类），另一个类叫父类（基类、超类） 继承的关键符号 ：（冒号） ...
C#类与对象详解：封装、继承与多态
在C#中，类的定义使用`class`关键字，如`class Program`，它是一个静态类，意味着它的成员可以直接通过类名访问，无需实例化。`static void Main(string[] args)`是主函数，是程序的入口点。 理解和掌握C#类和对象...
静态方法和属性可以被继承吗？
weixin_42039825的博客
05-30 8188
package cn.qiaoh.inheritance; public class A { public static String staticStr = "A静态成员变量"; public String str = "A非静态成员变量"; public static void staticMethod() { System.out.println("A静态方法"); } public void method(){ Syst
C# 抽象类（abstract）
热门推荐
LiKe11807的博客
10-19 1万+
C#抽象类： C#抽象类是特殊的类，只是不能被实例化；除此以外，具有类的其他特性；重要的是抽象类可以包括抽象方法，这是普通类所不能的。抽象方法只能声明于抽象类中，且不包含任何实现，派生类必须覆盖它们。另外，抽象类可以派生自一个抽象类，可以覆盖基类的抽象方法也可以不覆盖，如果不覆盖，则其派生类必须覆盖它们。 abstract修饰符指示被修改内容的实现已丢失或不完整。 abstract 修饰符可用于类、方法、属性、索引和事件。 在类声明中使用abstract修饰符来指示某个类仅用作其他类的基类，而不用...
C#中将Object数组转换为String(或者其他类型)的数组(集合)
weixin_30532759的博客
09-23 2382
dataItem.EquipName = dataObject.EquipName.Select(o => o.ToString()).ToArray<string>(); 这里的dataItem.EquipName 是String[], dataObject.EquipName是Object[]，想要解决这个，就使用了Linq的扩展方法Select 将一个个对象转换成S...
C#封装、继承、多态
weixin_60826078的博客
03-11 545
面向对象就是一种编码的思想，简称(oop思想)，这种编程思想可以让你在编码的过程中，对于类的使用变得更加的方便快捷，在不同的场合使用不同的类和对象，会让你的程序维护起来更加方便，让你的程序结构更加清晰。封装就是把不需要展示出的或者私密的代码抽离封装成抽象的类，并且这个类可以把自己的数据和方法只让可信的类或者对象使用，对不可信的进行信息隐藏。可传递的特点，无需多写父类的属性，就可以直接调用父类的属性，代码可以多次使用，提高代码的复用性并且减少代码的冗余。（2）方法的重写(虚方法(virtual))
C#中的抽象类和静态类
syaguang2006的专栏
11-18 1643
c#中的抽象类的特征 抽象类具有以下特性： ·    抽象类不能实例化。 ·    抽象类可以包含抽象方法和抽象访问器。 ·    不能用 sealed 修饰符修饰抽象类，因为这两个修饰符的含义是相反的。采用 sealed 修饰符的类无法继承，而 abstract 修饰符要求对类进行继承。 ·    从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实际实现。[2] 
C#静态类的继承等疑惑解答
Heroin的博客
08-15 6411
文章本人原创，请勿随意粘贴转载 1.静态类可以从静态类中派生吗？ 静态类不允许从静态类中进行派生，也不允许从非静态类中派生，静态类必须从对象派生（个人觉得可能静态类不允许继承类），不允许有非静态的构造函数。下面代码会报错 public static class staFun { static staFun() { Consol...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值