C#学习的第十一天

于 2024-01-20 20:53:24 发布
阅读量384 收藏 10
点赞数 10
文章标签： 学习 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_53631431/article/details/135716420
版权
本文详细介绍了C#中的抽象类、多态、依赖注入以及几种设计模式（单例、简单工厂、泛型和接口）的应用实例，通过实例展示了如何使用这些概念实现代码复用和灵活扩展。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.抽象类实现多态

案例：动物会叫，猫会叫，狗会叫。
           如果父类方法中的实现，没有任何具体的意义，那我们使用抽象来实现多态
           abstract抽象----->抽象成员---->没意义，但是不能删---->给子类使用的

            1、被抽象修饰的方法，不允许有任何的实现，因为无意义
            2、类中的成员，如果被标记为抽象的，则整个类，也需要被标记为抽象的

 

namespace program3
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Animal animal = new Dog();//实现抽象类的继承
            animal.Bark();
            animal.Eat();
            animal.Drink();
            Console.ReadKey();
        }
    }
    //abstract抽象类实现父类的抽象方法供子类调用
    abstract class Animal
    {
        public Animal() { }

        public abstract void Bark();

        public abstract void Drink();

        public void Eat()
        {
            Console.WriteLine("Animal Eat~~~~");
        }

    }

    abstract class Cow : Animal
    {
        public abstract void EatGrass();
    }

    class CowSon : Cow
    {
        public override void Bark()
        {
            
        }

        public override void Drink()
        {
        }

        public override void EatGrass()
        {
        }
    }

    class Cat : Animal
    {
        //使用override关键字对父类的抽象方法进行重写
        public override void Bark()
        {
            Console.WriteLine("猫咪喵喵的叫");
        }

        public override void Drink()
        {
            Console.WriteLine("猫咪舔着水喝");
        }

    }

    class Dog : Animal
    {
        public override void Bark()
        {
            Console.WriteLine("狗汪汪的叫");
        }

        public override void Drink()
        {
            Console.WriteLine("狗狗端着水喝");
        }

        public Dog() { }
    }

}

运行结果如下图所示：实现了多态的功能

使用多态抽象类的一个练习：

   //计算 圆形、矩形、三角形的面积和周长，使用多态实现

namespace program4
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //计算 圆形、矩形、三角形的面积和周长，使用多态实现
            XingZhuang xz = new Circle(5);
            Console.WriteLine(xz.GetArea());
            Console.WriteLine(xz.GetZC());

            XingZhuang juxing = new JuXing(3, 4);
            Console.WriteLine(juxing.GetArea());
            Console.WriteLine(juxing.GetZC());

            Console.ReadKey();
        }
    }
    //抽象的父类实现方法，获取面积和周长
    abstract class XingZhuang
    {
        public abstract double GetArea();

        public abstract double GetZC();

    }
    //子类通过对父类方法的重写，来实现不同图形的面积和周长
    class Circle : XingZhuang
    {
        public double R { get; set; }

        public Circle(double r)
        {
            this.R = r;
        }
        public override double GetArea()
        {
            return Math.PI * this.R *this.R;
        }
        public override double GetZC()
        {
            return Math.PI * this.R * 2;
        }
    }
    class JuXing : XingZhuang
    {
        public double Height { get; set; }
        public double Width { get; set; }

        public JuXing(double height, double width)
        {
            this.Height = height;
            this.Width = width;
        }

        public override double GetZC()
        {
            return 2 * (this.Height + this.Width);
        }
        public override double GetArea()
        {
            return this.Height * this.Width;
        }
    }
}

依赖注入 

依赖注入有三种方式：

1.属性实现依赖注入。

2.构造函数实现依赖注入

3.通过方法传参实现依赖注入

 

namespace _07_抽象类练习
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Computer cpu = new Computer();
            Mobile mb = new UDisk();
            cpu.Read(mb);
            cpu.Write(mb);
            Console.ReadKey();

        }
    }

    abstract class Mobile
    {
        //提供两个抽象的方法，给子类重写使用
        public abstract void Read();

        public abstract void Write();
    }

    class MobileDisk : Mobile
    {
        public override void Write()
        {
            Console.WriteLine("移动硬盘写入数据");
        }

        public override void Read()
        {
            Console.WriteLine("移动硬盘读取数据");
        }

    }


    class UDisk : Mobile
    {
        public override void Read()
        {
            Console.WriteLine("U盘读取数据");
        }

        public override void Write()
        {
            Console.WriteLine("U盘写入数据");
        }
    }

    class MP3 : Mobile
    {
        public override void Read()
        {
            Console.WriteLine("MP3读取数据");
        }

        public override void Write()
        {
            Console.WriteLine("MP3写入数据");
        }

        public void PlayMusic()
        {
            Console.WriteLine("MP3可以播放音乐");
        }
    }

    class Computer
    {
        属性实现依赖注入
        //public Mobile MB { get; set; }
        //public void Read()
        //{
        //    this.MB.Read();
        //}

        //public void Write()
        //{
        //    this.MB.Write();
        //}

        //构造函数实现依赖注入
        //public Computer(Mobile mb)
        //{
        //    mb.Read();
        //    mb.Write();
        //}

        //通过方法传参，实现依赖注入
        public void Read(Mobile mb)
        {
            mb.Read();
        }

        public void Write(Mobile mb)
        {
            mb.Write();
        }

    }

 

2.设计模式

1.单例设计模式

目的：于一个软件系统中的某些特殊类来说，只有一个实例很重要。例如，一个系统只能有一个文件系统或者窗口管理器；一个系统只能有一个计时工具或者ID生成器等。所以要生成一个特殊的类，能保证只有一个实例对象。

做法：让类自身创建并保存他的唯一实例对象，并保证不能创建其他实例，他还需要提供一个访问该实例的方法。

1.懒汉式

2.饿汉式

1.1懒汉式
namespace program5
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //单例设计模式:保证内存中只有一个实例对象
            //懒汉式
            SinglePerson sp = SinglePerson.GetSinglePerson();
            //创建sp2后依旧返回只有一个实例对象，通过调试可以得知
            SinglePerson sp2= SinglePerson.GetSinglePerson();
            Console.ReadKey();

        }
    }
    class SinglePerson
    {
        private SinglePerson() { }
        //声明一个【静态】字段来存储全局的唯一单例对象
        //懒汉式
        private static SinglePerson _singlePerson = null;
        public static SinglePerson GetSinglePerson()
        {
            if(_singlePerson == null)
            {
                return _singlePerson = new SinglePerson();
            }
            return _singlePerson;
        }
    }
}
1.2饿汉式 
namespace program6
{
    internal class Program
    {
        static void Main(string[] args)
        {
            SinglePerson sp= SinglePerson.GetSinglePerson();
            SinglePerson sp2 = SinglePerson.GetSinglePerson();
        }
    }
    class SinglePerson
    {
        private SinglePerson() { }
        private static SinglePerson _singlePerson = new SinglePerson();//饿汉式
        public static SinglePerson GetSinglePerson() { return _singlePerson; }
    }
}
2.简单工厂设计模式

概述：简单来说就是创建一个工厂类，里面有各种实施不同职能的部门类，也就是父类与子类的关系，通过输入的参数创建对象赋值给基类，完成对想要的派生类的调用，从而达成目标，具体的操作均在子类中完成，工厂类只负责运算逻辑和给基类赋值。

 实例分析：

问题描述：

要实现在购买商品的过程中选择笔记本共有两种分别是：" 1.联想笔记本，2.宏碁笔记本"，利用工厂类完成对这五种操作的实现。

namespace program7
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("请输入您想要的笔记本品牌");
            string brand = Console.ReadLine();

            NoteBook nb = GetNoteBook(brand);
            if (nb == null)
            {
                Console.WriteLine("没有你要的品牌电脑");
            }
            else
            {
                nb.ShowBrand();//多态的调用
            }
            Console.ReadKey();
        }
        static NoteBook GetNoteBook(string brand)
        {
            NoteBook nb = null;
            //给父类，赋值子类对象
            switch (brand)
            {
                case "Lenovo":
                    nb = new Lenovo();
                    break;
                case "Acer":
                    nb = new Acer();
                    break;
            }
            return nb;
        }
    }
    abstract class NoteBook
    {
        public abstract void ShowBrand();
    }
    class Lenovo : NoteBook
    {
        public override void ShowBrand()
        {
            Console.WriteLine("我是联想笔记本");
        }
    }
    class Acer : NoteBook
    {
        public override void ShowBrand()
        {
            Console.WriteLine("我是宏碁笔记本");
        }
    }
}

 3.泛型和非泛型

  • 在C#编程语言中，集合结构有两种:泛型集合，非泛型集合。
  • 泛型集合:只能存储固定类型的对象的一种集合。
  • List泛型集合和ArrayList非泛型集合
  • List与ArrayList的区别
    ArrayList可以New一下添加任意类型元素；List对添加的元素具有类型约束；
    ArratList添加时装箱，读取时拆箱；List不需要装箱，拆箱操作；

List的操作方式： 

            List<int> list1 = new List<int>();
            List<string> list2 = new List<string>();
            List<double> list3 = new List<double>();
            List<Person> list4 = new List<Person>();

4.接口

接口只包含了成员的声明。
成员的定义是派生类的责任。
接口提供了派生类应遵循的标准结构。 

接口使用Interface关键字声明，它与类的声明类似。

实现接口：如下图所示：


namespace _08_接口
{  
    internal class Program
    {
        static void Main(string[] args)
        {
            //虚方法、抽象类、接口
            //接口：能力、规范

            //IFly fly = new Plane();//new MaBird();//new GeBird();
            //fly.Fly();


            IKouLan kl = new Teacher();//new CBAPlayer();// new NBAPlayer();//new Student();//new NBAPlayer();
            kl.KouLan();
            Console.ReadKey();

        }
    }
//实现接口的方式
    interface IKouLan
    {
        void KouLan();
        //void Test();
    }


    class Person
    {
        public void CHLSS()
        {
            Console.WriteLine("人类可以吃喝拉撒睡");
        }
    }

    class Student : Person
    {
        
    }
    //接口必须声明在类的后面
    class Teacher : Person,IKouLan
    {
        public void KouLan()
        {
            Console.WriteLine("老师也能扣篮啦");
        }
    }

    class NBAPlayer : Person,IKouLan
    {
        public void KouLan()
        {
            Console.WriteLine("NBA球员能扣篮");
        }
    }

    class CBAPlayer : Person,IKouLan
    {
        public void KouLan()
        {
            Console.WriteLine("CBA球员也能扣篮");
        }
    }
}

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值