精华内容
下载资源
问答
  • C#多态的三种实现方式
    千次阅读
    2021-02-16 10:18:22

    C#实现多态主要有3种方法,虚方法,抽象类,接口

    1 虚方法

    ​ 在父类的方法前面加关键字virtual, 子类重写该方法时在方法名前面加上override关键字,例如下面的Person类的SayHello方法

    class Person
    {
        public Person(string name)
        {
            this.Name = name;
        }
    
        string _name;
    
        public string Name { get => _name; set => _name = value; }
    
        //父类方法加virtual,子类用override重写该方法,就实现了多态 
        public virtual void SayHello()   
        {
            Console.WriteLine("我是父类的方法");
        }
    }
    

    ​ 学生类和教师都继承于Person

    class Student : Person
    {
        public Student(string name) : base(name) { }
    
        public override void SayHello()
        {
            Console.WriteLine("我叫{0}, 我是学生", this.Name);
        }
    }
    
    class Teacher:Person
    {
        public Teacher(string name) : base(name) { }
    
        public override void SayHello()
        {
            Console.WriteLine("我叫{0}, 我是老师", this.Name);
        }
    }
    

    然后在Main函数中使用多态

    Student st = new Student("李雷");
    Teacher th = new Teacher("井边君");
    
    Person[] p = { st, th };  //子类对象赋给父类
    
    for(int i = 0; i < p.Length; i++)
    {
        p[i].SayHello();
    }
    
    Console.ReadKey();
    

    本例全部代码

    using System;
    
    namespace 多态之虚方法
    {
        class Program
        {
            static void Main(string[] args)
            {
                Student st = new Student("李雷");
                Teacher th = new Teacher("井边君");
    
                Person[] p = { st, th };  //子类对象赋给父类
    
                for(int i = 0; i < p.Length; i++)
                {
                    p[i].SayHello();
                }
    
                Console.ReadKey();
            }
        }
    
        class Person
        {
            public Person(string name)
            {
                this.Name = name;
            }
    
            string _name;
    
            public string Name { get => _name; set => _name = value; }
    
            //父类方法加virtual,子类用override重写该方法,就实现了多态 
            public virtual void SayHello()   
            {
                Console.WriteLine("我是父类的方法");
            }
        }
    
        class Student : Person
        {
            public Student(string name) : base(name) { }
    
            public override void SayHello()
            {
                Console.WriteLine("我叫{0}, 我是学生", this.Name);
            }
        }
    
        class Teacher:Person
        {
            public Teacher(string name) : base(name) { }
    
            public override void SayHello()
            {
                Console.WriteLine("我叫{0}, 我是老师", this.Name);
            }
        }
    }
    

    2 抽象类

    在类前面加关键字abstract,方法前面加abstract,抽象方法不能有函数体。

    抽象类的特点:

    (1)可以有字段

    (2)可以有非抽象方法

    抽象类实现多态的代码如下

    using System;
    using System.Collections.Generic;
    
    namespace 多态之抽象类
    {
        abstract class Person
        {
            //抽象方法不能有函数体
            public abstract void SayHello();
        }
    
        class Student : Person
        {
            public override void SayHello()
            {
                Console.WriteLine("我是子类Student重写的抽象方法"); ;
            }
        }
    
        class Teacher : Person
        {
            public override void SayHello()
            {
                Console.WriteLine("我是子类Teacher重写的抽象方法"); ;
            }
        }
    
        class Program
        {
            static void Main(string[] args)
            {
                List<Person> clist = new List<Person>();
    
                Student st = new Student();
                Teacher th = new Teacher();
                clist.Add(st);
                clist.Add(th);
    
                foreach(Person p in clist)
                {
                    p.SayHello();
                }
    
                Console.ReadKey();
            }
        }
    }
    

    3 接口实现多态

    代码如下

    using System;
    using System.Collections.Generic;
    
    namespace 多态之接口
    {
        public interface IWeapon
        {
            void Fire();
        }
    
        class Gun : IWeapon
        {
            public void Fire()
            {
                Console.WriteLine("我是枪");
            }
        }
    
        class Sword : IWeapon
        {
            public void Fire()
            {
                Console.WriteLine("我是剑");
            }
    
        }
    
        class Tank : IWeapon
        {
            public void Fire()
            {
                Console.WriteLine("我是坦克");
            }
        }
    
        class Program
        {
            static void Main(string[] args)
            {
                List<IWeapon> list = new List<IWeapon>();
    
                Gun gun = new Gun();
                Sword sw = new Sword();
                Tank ta = new Tank();
                list.Add(gun);
                list.Add(sw);
                list.Add(ta);
    
                foreach (IWeapon p in list)
                {
                    p.Fire();
                }
    
                Console.ReadKey();
            }
        }
    }
    

    接口的特点

    (1)接口里的方法不能有修饰符,默认是public

    (2)接口的方法不能有函数体

    (3)接口中不能包含示例字段,不能有构造函数

    (4)接口里的方法被继承的类重写时,不需要用override关键字,接口不能被实例化

    (5)接口之间可以继承,并且可以多继承;接口不能继承于类,但是类可以继承于接口

    (6)一个类可以同时继承一个类,并实现多个接口

    更多相关内容
  • c#初学者了解学习,大家对多态总是似懂非懂,没能好好的理解,做了一个关于多态的小案例
  • 深入理解c#多态

    2020-12-17 11:25:18
     多态:即一个接口,多个功能  同一种操作作用于不同的对象,可以有不同的解释,产生不同的执行结果  多态性可以是静态的或动态的。在静态多态性中,函数的响应是在编译时发生的。在动态多态性中,函数的响应是在...
  • C# 多态的理解

    2020-09-07 19:01:56
    主要介绍了对C# 多态的理解,帮助大家更好的理解和学习c#,感兴趣的朋友可以了解下
  • C#多态

    2020-12-20 23:56:32
    C#多态1:重写父类方法2:多态实现3:里氏转换原则4:Object类 1:重写父类方法 1:重写父类方法 父类方法:virtual 子类方法:override 示例: static void Main(string[] args) { Dog a1 = new Dog (); a1....
  • 精品专题课件(2021-2022年收藏)
  • C#多态详解

    2021-10-13 21:15:26
    定义 why? what? How? 实现多态的两个要素 案例 使用多态的好处 String类

     

     定义

    why?

     public class Master
        {
            public void Feed(Dog dog)
            {
                dog.eat();
            }
            public void Feed(Cat cat)
            {
                cat.eat();
            }
            /*
            public void Feed(XXX xxx)    //XXX代表父类
            {
                xxx.eat();
            }
            */
    
        }

          假设有一个主人类。喂食不同的动物。不同动物对象调用方法的时候,对重复的代码频繁的修改。代码的可展拓展性,可维护性差。

    所以我们可以用一个Animal类作为参数,让不同的动物继承这个动物类,这就是多态。

    what?

            多态是同一个行为具有多个不同表现形式或形态的能力。就比如说是给上面的动物喂食。不同的动物喂不同的食物。

            多人做一件事,结果不一样。就比如说老鹰会飞。杜鹃会飞。喜鹊会飞。他们都会飞。但是他们飞行的能力是不同的。有的飞的高飞有的飞的低

             

             多态性:

                    多态性可以是静态的或动态的。在静态多态性中,方法的响应是在编译时发生的。在动态多态性中,方法的响应是在运行时发生的。

               静态多态性在编译时,方法和对象的连接机制被称为早期绑定,也被称为静态绑定。C# 提供了两种技术来实现静态多态性。分别为:方法重载运算符重载

                    方法重载:在同一个类中。允许同名方法。他们的参数个数,或参数类型不同即可。

                    运算符重载:就是定义一个函数。在函数体内实现想要的功能。当用到该运算符时,编译器会自动调用这个函数。也就是说,运算符重载是通过函数实现的,它本质上是函数重载。

                   运算符重载_Simon的博客-CSDN博客

            动态多态性:是通过 抽象类 和 虚方法 实现的。

    实现多态的两个要素(How)

    1)子类重写父类方法

    2)使用父类的类型(子类转换为父类:向上转型)

    class Animal
    {
     	public virtual void call() {
            Console.WriteLine("无声的叫唤"); 
          }
    }
    class Dog : Animal
     {
            // new的作用是隐藏父类的同名方法
            //public new void call() { 
                //Console.WriteLine("叫声:汪~汪~汪~"); 
          //}  	
            public override  void call() { 
                Console.WriteLine("叫声:汪~汪~汪~"); 
            }
            public void smell() { 
                Console.WriteLine("嗅觉相当不错!");
            }
     }
    
     class Program
        {
            static void Main(string[] args)
            {         
                Animal animal = new Dog(); //向上转型 
                animal.call();
            }
        }
    
    /*输出: 叫声:汪~汪~汪~ */

     向上转型:将子类对象转为父类对象。此处父类对象可以是接口或抽象类

    转化后的父类对象具有父类所有方法,若方法被子类重写override,那么实际调用时,调用的是重写后的实现

    通过多层继承链,理解"父类型引用永远调用的是继承链中最新版本的重写函数"

    特别注意:使用new关键字后会破坏多态性!

    int a=(int)3.5;
    Dog dog = (Dog)animal;//向下转型
    dog.call();                 
    dog.smell(); 

     向下转型:把父类对象转为子类对象。

        转化后的子类对象,跟一般的继承子类对象一样。具有子类所有方法(包括重写方法)+父类所有方法(被重写的方法,按重写的算。)

    案例

            父类做参数

    
        class Animals
        {
            public virtual void Eat()
            {
                Console.WriteLine("吃");
            }
        }
    
         class Dog : Animals
        {
            public override void Eat()
            {
                Console.WriteLine("狗吃骨头");
            }
        }
        
        class Cat:Animals
        {
            public override void Eat()
            {
                Console.WriteLine("猫吃鱼");
            }
            
        }
        
        class Master
        {
            public void Feed(Animals a) //父类作为参数
            {
                a.Eat();
            }
        }
    
        
        class Program
        {
            static void Main(string[] args)
            {
                //匿名对象,调用一次方法
                Animals a = new Animals();
                Dog d = new Dog();
                Cat c = new Cat();
                
                a = b; //向上转型
                new Master().Feed(d);
    
            }
        }
           

    输出:狗吃骨头

    父类做返回值

     public Animals Feed(int i)  //父类作为参数
            {
                Animals a = null;    //默认赋空
                if (i==0)
                {
                    a = new Dog();
                }
                else if (i == 1)
                {
                    a = new Cat();
                }
                return a;
            } 
    
    
            static void Main(string[] args)
            {
                //匿名对象,调用一次方法
                Animals a = new Animals();
                Dog d = new Dog();
                Cat c = new Cat();
                
                a = d; //向上转型
                //new Master().Feed(d);
    
                a = new Master().Feed(1);
                a.Eat();    //调用方法
            }
    

    输出:猫吃鱼

    父类做参数优化

     public void Feed(Animals a) //父类作为参数
            {
                //a.Eat();    
                /*这样写不能直接判断传入的是猫还是狗?
                因此我们要对传进来的 a 进行判断。*/
                    
                if (a is Dog)   //使用 is 关键字
                {
                    a.Eat();
                }
                if (a is Cat)
                {
                    a.Eat();
                }
            }
    
    static void Main(string[] args)
            {
                //匿名对象,调用一次方法
                Animals a = new Animals();
                Dog d = new Dog();
                Cat c = new Cat();
                
                a = d; //向上转型
                new Master().Feed(d);
    
                //a = new Master().Feed(1);
                //a.Eat();

    输出:狗吃骨头

    使用多态的好处

    1. 应用程序不必为每一个派生类编写功能调用,只需要对抽象基类进行处理即可。大大提高程序的可复用性。//继承 

    2. 派生类的功能可以被基类的方法或引用变量所调用,这叫向后兼容,可以提高可扩充性和可维护性。 //多态的真正作用

    展开全文
  • C# 多态实例

    2021-08-27 17:10:38
    1、C#中的访问修饰符 public:公开的公共的。 private:私有的,只能在当前类的内部访问。 protected:受保护的,只能在当前类的内部以及该类的子类中访问。 internal:只能在当前项目中访问。在同一个项目中,internal...

    1、C#中的访问修饰符
    public:公开的公共的。
    private:私有的,只能在当前类的内部访问。
    protected:受保护的,只能在当前类的内部以及该类的子类中访问。
    internal:只能在当前项目中访问。在同一个项目中,internal和public的权限是一样的。
    protected internal:protected+internal
    1)、能够修饰类的访问修饰符只有两个:public、internal。
    2)、可访问性不一致
    子类的访问权限不能高于父类的访问权限,会暴露父类的成员。
    2、设计模式
    设计这个项目的一种方式。
    3、简单工厂设计模式。

    using System;
    
    namespace 简单工厂设计
    {
        class Program
        {
            static void Main(string[] args)
            {
                Console.WriteLine("请输入您想要得笔记本品牌");
                string brand = Console.ReadLine();
                NoteBook nb = GetNoteBook(brand);
                nb.SayHello();
                Console.ReadKey();
            }
    
            public static NoteBook GetNoteBook(string brand)
            {
                NoteBook nb = null;
                switch(brand)
                {
                    case "Lenovo":nb = new Lenovo();
                        break;
                    case "IBM":nb = new IBM();
                        break;
                    case "Acer":nb = new Acer();
                        break;
                    case "Dell":nb = new Dell();
                        break;
                }
                return nb;
            }
        }
    
        public abstract class NoteBook
        {
            public abstract void SayHello();
        }
    
        public class Lenovo:NoteBook
        {
            public override void SayHello()
            {
                Console.WriteLine("我是联想笔记本");
            }
        }
    
        public class Acer:NoteBook
        {
            public override void SayHello()
            {
                Console.WriteLine("我是鸿基笔记本");
            }
        }
        public class Dell:NoteBook
        {
            public override void SayHello()
            {
                Console.WriteLine("我是戴尔笔记本");
            }
        }
    
        public class IBM:NoteBook
        {
            public override void SayHello()
            {
                Console.WriteLine("我是IBM笔记本");
            }
        }
    }
    
    

    4、值类型在复制的时候,传递的是这个值得本身。
    引用类型在复制的时候,传递的是对这个对象的引用。
    5、系列化:就是将对象转化为二进制;
    反系列化:就是将二进制转换为对象;
    作用:传输数据。

    展开全文
  • 这是一个应用多态的范例,以规范的代码实现了“统一调用,多种实现”
  • c#多态的使用

    2021-10-14 11:41:58
    一,定义 多态: 1,多态是同一个行为具有多个不同...C# 提供了两种技术来实现静态多态性。分别为:方法重载、运算符重载 动态多态性是通过 抽象类 和 虚方法 实现的。 二,实现多态的两个要素 1)子类重...

    一,定义

    多态

              1,多态是同一个行为具有多个不同表现形式或形态的能力。

               2,多人做一件事情,结果不一样

    多态性可以是静态的或动态的。在静态多态性中,方法的响应是在编译时发生的。在动态多态性中,方法的响应是在运行时发生的。

    静态多态性:在编译时,方法和对象的连接机制被称为早期绑定,也被称为静态绑定。C# 提供了两种技术来实现静态多态性。分别为:方法重载运算符重载

    动态多态性是通过 抽象类 和 虚方法 实现的。

    二,实现多态的两个要素

    1)子类重写父类方法

    2)使用父类的类型(子类转换为父类:向上转型)

    public abstract class Shape

        {

            public abstract double GetArea();

            public abstract double GetPerimeter();

        }

        class Circle : Shape

        {

            private double r;

            public double R

            {

                get{return r;}          

                set{r = value;}

            }

            public Circle(double r)

            {

                this.r = r;

            }

            public override double GetArea()

            {

                return Math.PI * this.R * this.R;

            }

            public override double GetPerimeter()

            {

                return 2 * Math.PI * this.R;

            }

        }

    三,实现多态的好处

    1. 应用程序不必为每一个派生类编写功能调用,只需要对抽象基类进行处理即可。大大提高程序的

    可复用性。//继承 
    2. 派生类的功能可以被基类的方法或引用变量所调用,这叫向后兼容,可以提高可扩充性和可维护

    性。 //多态的真正作用

    展开全文
  • C# 多态与重载

    2021-08-19 21:18:14
    多态: 多态意味着多种形式,表现为一个接口多个功能,多态性分为静态、动态的 静态的:方法的重载、运算符重载 动态的:当一个定义的类需要在继承类中实现,通过抽象类和虚方法实现 定义虚方法: //访问修饰符...
  • C# 多态理解与用法

    2020-10-16 00:29:06
    C#多态的使用方法有两种,一种是方法隐藏,也就是在子类中通过new关键字来定义新的子类成员替换掉父类成员,另一种是方法重写。 方法隐藏: class MyClassOne { public void Num() { Console.WriteLine(100)...
  • C#多态测试C#多态测试C#多态测试C#多态测试C#多态测试
  • 详解c# 多态

    2020-12-17 09:25:32
    C# 中,每个类型都是多态的,因为包括用户定义类型在内的所有类型都继承自 Object。 多态就是同一个接口,使用不同的实例而执行不同操作,如图所示: 现实中,比如我们按下 F1 键这个动作: 如果当前在 Flash ...
  • C# 多态

    2021-04-28 10:57:43
    作用 让继承同一父类的子类们,调用相同的方法有不同的效果 关键字 virtual 修饰虚函数 override 重写虚函数 base 代表父类 使用父类装载子类后,不需要里氏转换就能使用子类方法 系统根据对象实例的类型来决定调用...
  • 参考: 1,C++ Primer Plus(第六版)中文版 2,... ... C++中多态: 若继承关系为Public时,基类的成员函数,在整个继承链中,可属于每个派生类;只不过成员函数中的...
  • C#多态示例讲解TXT

    2020-01-30 15:41:13
    详细讲解C#多态,完整概念+代码示例,亲自编写绝对正确,适合初学者,进阶人群谨慎下载!!!O(∩_∩)O哈哈~!!!
  • **C#中什么是多态多态的分类和实现多态的方式是什么?**一 : 多态的定义:二 :多态的类别:2.1 静态多态性2.2 动态多态性:三 :多态的几种实现方式: 多态性可以是静态的或动态的。在静态多态性中,函数的响应是在...
  • C# 多态概念

    2012-12-05 15:35:42
    C#多态概念,不同对象对于同一个方法实现不同的效果
  • C#多态实例详解.docx

    2020-02-28 14:13:22
    ----C#多态实例详解---- 多态是面向对象编程中三大机制之一,其原理建立在"从父类继承而来的子类可以转换为其 父类"这个规则之上,换句话说,能用父类的地方,就能用该类的子类.当从父类派生了很多子 类时,由于每个子类...
  • C# 多态的实现

    2020-06-19 17:50:38
    封装、继承、多态,面向对象的三大特性,前两项理解相对容易,但要理解多态,特别是深入的了解,对于初学者而言可能就会有一定困难了。我一直认为学习OO的最好方法就是结合实践,封装、继承在实际工作中的应用随处...
  • C#多态.pdfC#多态.pdf

    2021-03-10 20:30:20
    C#多态.pdfC#多态.pdfC#多态.pdf
  • public class Animal { public string name; public int age; } class Dog : Animal { public char gender; } class Hashiqi : Dog { public string kind; } class wolf : Animal { } class Tiger :...
  • C# 多态典型练习题

    千次阅读 2017-09-22 20:31:11
    多态典型练习题:例题:利用多态实现计算器Calc, 将加减乘除四则运算看作一种操作,请设计操作抽象类Operation, 该抽象类有一个Op的方法计算两个整数相应运算,并返回计算结果。 并派生出四则运算操作类。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,571
精华内容 13,828
关键字:

c#多态

c# 订阅
友情链接: demonwtuate__reflection.rar