黑马程序员--多态

最新推荐文章于 2024-05-24 20:27:52 发布
最新推荐文章于 2024-05-24 20:27:52 发布
阅读量477 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tobeabigcabbage/article/details/17261633
版权

--------------------- ASP.Net+Android+IOS开发.Net培训期待与您交流！ ----------------------

■子类可以有与父类方法名相同的方法

  ♢签名不同(重载)

  ♢签名相同(隐藏基类方法)

■子类可以重写父类方法

  ♢虚方法

  ♢重写方法

  ♢重写基类方法一样可以调用基类方法

■多态就是对象可以表现多个类型的能力.(一种表现形式,实现多种功能)

■几种建立多态的方式

  ♢用父类实现多态

  ♢用抽象类实现多态

  ♢用接口实现多态

■多态版本控制

  ♢需要保留基类方法使用new关键字

  ♢需要重写方法使用override关键字

1.隐藏基类方法

    class Program
    {
        static void Main(string[] args)
        {
            Base b = new Base();
            b.Func();//结果:我是一个父类
            Sub s = new Sub();
            s.Func();//结果:我是一个子类,此处隐藏了基类的方法
            Base b1 = s;
            b1.Func();//结果:我是一个父类
            Console.ReadKey();
        }
    }
    class Base
    {
        public void Func()
        {
            Console.WriteLine("我是一个父类");
        }
    }
    class Sub : Base
    {
        public new void Func()//此处可以直接写成 public void Func()省略掉new,我们姑且称为隐式隐藏
        {
            Console.WriteLine("我是一个子类");
        }
    }

通过上述例子,我们得知:隐藏基类方法时,我们访问到的方法是依据引用变量的,引用变量是基类访问到的就是基类的方法,引用变量是子类,访问到的是子类的方法

2.重写基类方法

class Program
    {
        static void Main(string[] args)
        {
           //重写基类方法:在基类方法前面加上virtual,在子类方法前加上override
            Base b = new Base();
            b.Func();//结果:我是一个父类
            Sub s = new Sub();
            s.Func();//结果:我是一个子类,重写
            Base b1 = s;
            b1.Func();//结果:我是一个子类,重写
            Console.ReadKey();
        }
    }
    class Base
    {
        public virtual void Func()
        {
            Console.WriteLine("我是一个父类");
        }
    }
    class Sub : Base
    {
        public override void Func()//此处可以直接写成 public void Func()省略掉new,我们姑且称为隐式隐藏
        {
            Console.WriteLine("我是一个子类");
        }
    }

从重写基类方法的例子,我们得知,对象决定我们访问到的方法,基类对象访问到基类方法,子类对象访问到子类方法.(因隐藏基类方法后,我们的父类引用访问不到子类对象,为了能访问到子类对象,所以就有了重写)

3.实现多态的例子:

(1)重写父类方法实现多太

 class Standard
    {
        public virtual void Usb()
        {
            Console.WriteLine("一系列标准条文");
        }
class Light : Standard
    {
        public override void Usb()
        {
            Console.WriteLine("我是个usb点灯,我亮了哈哈");
        }
    }
class Phone:Standard
    {
        public override void Usb()
        {
            Console.WriteLine("我是手机,我在充电");
        }
    }
class Upan : Standard
    {
        public override void Usb()
        {
            Console.WriteLine("我是upan,我存储东西");
        }
    }
class Wind:Standard
    {
        public override void Usb()
        {
            Console.WriteLine("我是个usb电风扇,我可以吹风哈哈");
        }
    }
 class Program
    {
        static void Main(string[] args)
        {
            while (true)
            {
                Console.Write("请问你要在usb接口上插上什么设备呢\n");
                Console.WriteLine("请输入你要的设备的序号 1.点灯2.手机3.u盘4.usb风扇");
                string choice = Console.ReadLine();
                Standard s;
                switch (choice)
                {
                    case "1": s = new Light(); break;
                    case "2": s = new Phone(); break;
                    case "3": s = new Upan(); break;
                    case "4": s = new Wind(); break;
                    default: s = new Standard(); break;
                }
                if (s!=null)
                {
                    s.Usb();//多态的实现,一种形式,实现多种功能,根据对象的不同,调用不同子类的方法
                }
                else
                {
                    Console.WriteLine("输入有误");
                }
                Console.ReadKey(true);
                Console.Clear();
            }    
        }
    }

 里氏转换中的例子改用多态实现的代码:

 public class Person//基类,或称为父类
    {
        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        private int age;
        public int Age
        {
            get { return age; }
            set { age = value; }
        }
        private char gender;
        public char Gender
        {
            get { return gender; }
            set { gender = value; }
        }
        public Person(string name, int age, char gender)
        {
            this.Name = name;
            this.Age = age;
            this.Gender = gender;
        }
        public virtual void SayHello()
        {
            Console.WriteLine("我是{0},我今年{1}岁了,我是{2}生", name, age, gender);
        }
    }
 public class Teacher:Person//继承类,或称子类
    {
        public string course;
        public string Cource
        {
            set{course=value;}
            get{return course;}
        }
        private int yearsOfService;
        public int YearsOfService
        {
            set { yearsOfService = value; }
            get { return yearsOfService; }
        }
    
        public override  void SayHello()
        {
            Console.WriteLine("你们好,我是{0},我今年{1}岁了,教书{2}年了,我是{3}老师", Name, Age, yearsOfService, course);
        }
        public Teacher(string name,int age,char gender,string course,int yearsOfService):base( name, age, gender)
            //此处若没写base(name,age,gender)构造方法,便是默认调用Person的无参构造方法即base()
        {
            this.course = course;
            this.yearsOfService = yearsOfService;
        }
    }
    public class Student : Person//继承类Student
    {
        private int classId;
        public int ClassId
        {
            set { classId = value; }
            get { return classId; }
        }
        private string hobby;
        public string Hobby
        {
            set { hobby = value; }
            get { return hobby; }
        }
        public override void SayHello()
        {
            Console.WriteLine("大家好,我是{0},我今年{1}岁了,我是{2}生,我是{3}班的,我喜欢{4}", Name, Age, Gender, classId, hobby);//包含基类的成员,加自己的成员,除了基类的私有成员外,其余成员都能访问到
        }
        public Student(string name,int age,char gender,int classId,string hobby):base(name,age,gender)
        {
            this.classId = classId;
            this.hobby = hobby;
        }

    }
 class Program
    {
        static void Main(string[] args)
        {
            Person[] ps = new Person[]{
                new Teacher("翟群",23,'女',"c#",0),
                new Student("何雄军",24,'男',2,"计算机"),
                new Person("呵呵",23,'女')};
            for (int i = 0; i < ps.Length;i++ )
            {
                ps[i].SayHello();
            }
            Console.ReadKey();
        }
    }

 

 

(2)抽象类抽象方法实现多太

■抽象类和抽象方法由abstract修饰

■abstract类的使用须注意:

　♢抽象方法没有抽象体

   ♢抽象成员只能存在于抽象类中

   ♢抽象类可以有非抽象成员

   ♢抽象类派生的非抽象类必须实现抽象方法

   ♢抽象类只能用于基类,无法实例化

 abstract class Standard
    {
        //public virtual void Usb()
        //{
        //    Console.WriteLine("一系列标准条文");
        //}虚方法是要有实现体的方法,如果不需要其实现,,或不知道怎么实现的时候,那么可以使用抽象方法
       public abstract void Usb();
       //抽象方法不允许有实现体,相当于定义的标准,用来让子类实现
       //抽象方法必须在抽象类中
    }
class Light : Standard
    {
        public override void Usb()
        {
            Console.WriteLine("我是个usb点灯,我亮了哈哈");
        }
    }
 class Phone:Standard
    {
        public override void Usb()
        {
            Console.WriteLine("我是手机,我在充电");
        }
    }
  class Upan : Standard
    {
        public override void Usb()
        {
            Console.WriteLine("我是upan,我存储东西");
        }
    }
class Wind:Standard
    {
        public override void Usb()
        {
            Console.WriteLine("我是个usb电风扇,我可以吹风哈哈");
        }
    }
 class Program
    {
        static void Main(string[] args)
        {
            while (true)
            {
                Console.Write("请问你要在usb接口上插上什么设备呢\n");
                Console.WriteLine("请输入你要的设备的序号 1.点灯2.手机3.u盘4.usb风扇");
                string choice = Console.ReadLine();
                Standard s;
                switch (choice)
                {
                    case "1": s = new Light(); break;
                    case "2": s = new Phone(); break;
                    case "3": s = new Upan(); break;
                    case "4": s = new Wind(); break;
                    default: s = null; break;
                }
                if (s != null)
                {
                    s.Usb();//多态的实现,一种形式,实现多种功能,根据对象的不同,调用不同子类的方法
                }
                else
                {
                    Console.WriteLine("输入有误");
                }
                Console.ReadKey(true);
                Console.Clear();
            }
        }
    }

 

(3)接口实现多态

■抽象的一种抽象的约定(接口是一组函数成员而不实现成员的引用类型)

■接口就是用来实现的

■语法

  ♢[访问修饰符]interface接口名

  {

  　　//接口成员定义,成员没有实现,实现被一个分号代替

  }

  ♢接口只有方法,属性,事件,索引的声明

  ♢接口是用来实现的,所有的成员默认为public

  interface IWalkable//定义一个走路的能力接口
    {
        void Walk();//返回类型 方法名(参数列表)
    }
  interface ISound//定义一个发出声音的接口
    {
        void Sound();
    }
 class Car:IWalkable
    {
        public void Walk()
        {
            Console.WriteLine("我是小汽车,我会跑的快");
        }
    }
class radio:ISound
    {
        public void Sound()
        {
            Console.WriteLine("我是小喇叭,我可以广播呵 啦啦啦");
        }
    }
abstract class Animal : IWalkable, ISound
    {
        public abstract void Walk();
        public abstract void Sound();
    }
class Cat:Animal
    {
        public override void Walk()
        {
            Console.WriteLine("我是猫猫,我会走猫步");
        }

        public override void Sound()
        {
            Console.WriteLine("我是猫猫,我会喵喵");
        }
    }
class Person:Animal
    {
        public override void Walk()
        {
            Console.WriteLine("我是人类,我会走路哟");
        }

        public override void Sound()
        {
            Console.WriteLine("我是人类,我可以发声哟");
        }
    }
class Program
    {
        static void Main(string[] args)
        {
            IWalkable[] walkObjects ={
                                       new Person(),
                                       new Cat(),
                                       new Car(),
                                   };
            for (int i = 0; i < walkObjects.Length;i++ )
            {
                walkObjects[i].Walk();
            }
            ISound[] soundObjects ={
                                       new Person(),
                                       new Cat(),
                                       new radio()
                                   };
            Console.WriteLine("\n=============\n");
            for (int i = 0; i < soundObjects.Length;i++ )
            {
                soundObjects[i].Sound();
            }
            Console.ReadKey(true);
        }
    }

 我们可以再为Person类派生一个子类Student,Student类继续重写Walk()和Sound()

class Student : Person
    {
        public override void Sound()
        {
            Console.WriteLine("我是一个重写Person父类sound()方法的子类方法");
        }
        public override void Walk()
        {
            base.Walk();//这样既可以调用Person的Walk()方法,又有自己的重写方法
            Console.WriteLine("我是重写Person父类的walk方法的子类方法");
        }
    }
Hizhaiqun
关注
多态的简单理解
Yanpr919的博客
06-09 1862
所谓多态（Polymorphism），按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作（摘自“Delphi4编程技术内幕”）。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数（Virtual Function） 实现.
做黑马程序员
12-19
免费视频教学 争做黑马程序员 月薪突破8K 有汗水必有财富。
今天在CSDN黑马程序员训练营的分享
mmdev
05-31 159
2012/5/30 时间有限，题目较大——移动互联网行业发展趋势——所以简单从两个方面进行了分享：机遇和挑战。 机遇： 第一，智能终端和移动宽带的发展造就移动互联网时代的机遇。 第二，开放平台和生态系统给开发者带来机会。 第三，开放源码和开放教育给予开发者不断提升自身的可能性。 挑战： 第一，全球经济衰退，裁员。 第二，IT技术变革速度快，生命周期短。 第三，就业市场、资本市...
黑马程序员_集合
adent4heima的专栏
08-05 187
  ------- android培训、java培训、期待与您交流！---------
什么是多态？如何实现？只看这一篇就够了
热门推荐
海盗船长y的博客
04-12 11万+
1. 多态的概念 1.1 概念 多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。 2. 多态的定义及实现 2.1多态的构成条件 多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。 那么在继承中要构成多态还有两个条件： 必须通过基类的指针或者引用调用虚函数 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写 2.2 ...
C++多态详解
liuty0125的博客
05-24 1231
在继承中构成多态有两个条件：1.必须通过基类的指针和引用调用虚函数 2.被调用的函数必须是虚函数 ，且派生类必须对基类的虚函数进行重写 多态调用时在运行时在虚函数表找函数的地址，进行调用，所以指向父类调的是父类的虚函数，指向子类调用的是子类的虚函数而普通调用时是在编译时，通过调用者类型确定函数地址
黑马程序员----泛型学习注意点
04-04
黑马程序员提供的这篇关于泛型的学习注意点，结合了源码分析和工具应用，旨在帮助开发者深入理解并有效运用泛型。下面将详细阐述泛型的主要知识点： 1. 泛型的基本概念： 泛型是Java SE 5.0引入的新特性，主要用于...
黑马程序员 - Java基础教学 - 08 - 面向对象（4）-多态.doc
04-21
Java基础教学 - 面向对象（4）- 多态 在本文中，我们将讨论Java语言中的一种重要概念 —— 多态（Polymorphism）。多态是面向对象编程（OOP）中的一个核心概念，它允许我们编写更加灵活和可扩展的代码。 一、多态...
黑马程序员匠心之作 C++教程_第4阶段实战-基于多态的企业职工系统讲义.rar
03-19
《C++教程_第4阶段实战-基于多态的企业职工系统讲义》是黑马程序员精心制作的一份教学资源，特别适合C++初学者。这份讲义深入浅出地讲解了C++编程语言中的多态性，并通过实战项目——企业职工系统，让学习者能够将...
C++黑马程序员学习资料
最新发布
08-05
C++黑马程序员学习资料，附赠《InterviewGuide第四版By阿秀》、《LeetCode刷题手册》、《背包问题九讲》、《算法图解》pdf版本，三个基础课程文档手册及三个实验项目，由简到繁分别为《通讯录管理系统》、《职工管理...
黑马程序员C++从0到1笔记教程-pdf带目录
05-07
有七个阶段：第1阶段C++ 匠心之作 从0到1入门，第2阶段实战-通讯录管理，第3阶段-C++核心编程 资料，第4阶段实战-基于多态的企业职工系统，第5阶段-C++提高编程资料，第6阶段实战-基于STL泛化编程的演讲比赛资料，第...
【封装·继承·多态】个人通俗理解
亚特兰蒂斯
07-28 4754
记得从前面试，老是记不住这三个概念，容易混淆，这里特意记一下。 1.封装所谓封装，就是将某些共同的东西提取出来成为一个抽象基类。例如：男人和女人都属于人类，他们共同的行为都有吃、喝、住、行，所以我们将这些共同行为封装在一个Human的基类，让它拥有吃、喝、住、行的方法。public abstract class Human{ public abstract void eat(); pub
多态的理解
tck66的博客
08-19 1915
编程就是一个将具体事务抽象化的过程，多态就是抽象化的一种体现，把一系列具体事务的共同点抽象出来，再通过这个抽象的事物，与不同的具体事物进行对话。多态的概念：多态的概念：简单来讲，多态的意思就是多种形态，或者说，去完成某个行为，当不同的对象去完成时会产生出不同的状态。2. 派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩展性和可维护性。//多态~ switch。多态是面向对象的重要特性，简单说：“一个接口，多种实现”，就是同一种事物表现出的多种形态。//父类指针或引用指向子类对象。
通俗聊聊什么是多态
大黄奔跑
02-01 526
微信公众号：大黄奔跑 关注我，可了解更多有趣的面试相关问题。 写在之前 Java中的多态是三大特性中的一个比较重要的特性，之前有很多经典书籍对该概念做了一些阐述，本人尝试从一个菜鸡的角度谈一谈自己的理解，如有不妥，还望再次交流。 《Java编程思想》中用了一个极度简单的话形容多态。 多态通过分离做什么和怎么做来达到灵活编程的目的。 初学者难免觉得晦涩难懂，但是却极为经典。本文会尝试从是什么，怎么玩，通过举例子来分析多态。 ###为什么存在多态问题 多态存在是有一定条件的，主要有三个核心条件： 类之.
多态的好处
koala_swnu的专栏
09-05 1165
假设有一个类 叫 鸟类，它拥有属性翅膀，拥有方法鸣叫，如下 public class Bird{ private Wing wing; public void moo(){ System.out.println("鸟叫声"); } } 鸟类封装了 翅膀类和moo方法；另外有两个类都继承鸟类并重写了moo方法，分别是鹦鹉和麻雀如下： 鹦鹉类： public cl
Java 特性 -- 多态的通俗理解(详细案例)
潘小蓝的博客
09-17 1588
Java 的三大特性是我们在刚接触 Java 的时候就一直在叨叨,那到底什么是 封装、继承 、多态呢？封装和继承相对来说好理解一些,这篇文章主要来说一下 多态。 文章目录1、多态娱乐初始版:2、多态娱乐改进版: 1、多态娱乐初始版: 在介绍多态之前先来看一下之前不用多态多出现的问题,通过代码来详细看一下(不要慌,代码很好懂): 代码搞起来: Application.java package com.pxl.form.versionOne; import com.pxl.form.ver.
谈谈你对多态的理解
qiumei1101381170的博客
09-27 4134
现象：一个调用语句出现多种形态。 实现多态的三个条件：1）要有继承；2）要有虚函数重写；3）要有父类指针（引用）指向子类对象。 多态的原理：动态连编，根据实际对象的类型还判断重写函数的调用。
黑马程序员基于多态的冲突
09-05
在黑马程序员的教学中，关于基于多态的冲突一般会涉及到两种情况： 1. 方法重载冲突：方法重载是指在同一个类中存在多个同名方法，但它们的参数类型和/或个数不同。当我们调用这个方法时，编译器会根据参数类型选择...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值