多态继承

继承:

访问修饰符  class  类名 :类名            只能继承让你继承的

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 继承_多态
{
    class Ren
    {
        private string _Name;

        public string Name
        {
            get { return _Name; }
            set { _Name = value; }
        }
        private string _Sex;

        public string Sex
        {
            get { return _Sex; }
            set { _Sex = value; }
        }
        private DateTime _Birthday;

        public DateTime Birthday
        {
            get { return _Birthday; }
            set { _Birthday = value; }
        }

        private string _Nation;

        public string Nation
        {
            get { return _Nation; }
            set { _Nation = value; }
        }

    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 继承_多态
{
    class XueSheng : Ren
    {

    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 继承_多态
{
    class Program
    {
        static void Main(string[] args)
        {
           ren r = new ren();
           xuesheng xs = new ren();
           xs.//可以搜出在class ren中写的name  sex  birthday

            Console.ReadLine();
        }
    }
}

一个类只能有一个父类(亲爹)

父类  某个类继承自某个类

子类  派生类   超类

多态:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 继承_多态
{
    class Fly
    {
        public virtual string Flying()//不加virtual其他class不能用flying
        {
            return "我会飞!!!";
        }

    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 继承_多态
{
    class Bird : Fly
    {
        public override string Flying()//需要加override才能用
        {
            return "拍拍翅膀我就能飞!!!";
        }

    }
}

类的多种形态

父类存在虚方法   virtual 子类重写         override

访问修饰符:

public      公共的,只要引用了命名空间就能用    访问级别最高

private                     私有的,只能在类的内部进行访问    访问级别最低

internal                   默认的,同一个命名空间下可以访问    访问级别次最高

protected                    被保护的,类的内部及它的子类中才可以访问    访问级别次最低

时间: 2024-11-07 22:05:06

多态继承的相关文章

Java多态-继承与清理

通过组合和继承方法来创建新类时,永远不必担心对象的清理问题,子对象通常会留给垃圾回收器进行处理.如果确是遇到清理问题,那必须用心为新的类创建dispose()方法(在这里我们选用此名).并且由于继承的缘故,如果我们有其他作为垃圾回收一部分的特殊清理动作,就必须在导出类中覆盖被继承的dispose()方法.当覆盖被继承的diopose()方法时,务必记住调用基类版本dispose()方法:否则,基类的清理动作就不会发生.下例便是一个证明: package polymorphism; class C

课堂笔记--初识继承和多态 继承

第六章 初始继承和多态 继承:一个类可以使用另一个类的属性和方法(成为该类的成员) 子类继承父类使用的符号是冒号 子类不能继承父类的构造方法 子类不能访问父类的私有字段和方法 在调用子类构造的时候,没有使用base关键字调用父类的指定构造,那么默认调用父类的无参构造. 定义一个Person类 class Person { public string Name { get; set; } public Gender Sex { get; set; } public void SayHello()

C++基础学习教程(七)----类编写及类的两个特性解析--->多态&继承

类引入 到目前为止我们所写的自定义类型都是关键字struct,从现在起我们将采用class方式定义类,这种方式对于学习过其他高级语言包括脚本(Such as Python)的人来说再熟悉不过了. 但是在写之前我们还是需要比较一下用struct和class之间有什么区别. 首先对于struct,在C兼容性方面很重要,尽管C++是有别于C的另一门语言,但许多程序还是必须与C交互,C++有两个重要功能,可以方便的与C交互.其中之一的就是POD,即是Plain Old Data(简单旧式数据)的缩写.

封装,多态,继承. super的方法,类的约束,

1.python的三大特性:python的三大特性,封装,多态,继承封装:函数 模块 类 对象多态 : python中默认支持多态继承: python中的子类继承父类属性和方法 鸭子类型: 看着像鸭子,它就是鸭子python中处处都是鸭子 # 两者之间没有任何关系,但是都遵循着一个隐形的标准两个类中的鸭子类型:# 优点:1,统一标准,减少了词汇量# 2,两者之间没有任何耦合性,但是可以产生关系,其中一个的对象可以调用另一个类的方法# 其他例子 :index pop clear 2. super的

封装 多态 继承

封装  /**  * 所谓封装,就是将对象具有的成员变量和成员函数包装和隐藏起来,让外界无法直接使用,  * 被封装的成员只能通过某些特定的方式才能访问.   * 实现封装有两个步骤:  *   1.将不能暴露的成员隐藏起来,我们就不能让其在类的外部被直接访问或赋值.  *    实现方法是将该成员定义为私有的,在成员定义前加上private访问权限修饰符.  *   2.用公共方法来暴露对该隐藏成员的访问,可以给成员加上public修饰符,将该成员定义为公共的 public class tes

网易云课堂_C++程序设计入门(上)_第6单元:丹枫虽老犹多态–继承与多态

第01节:继承 回顾 面向对象的4个特点: A(抽象) P(多态)I(继承)E(封装) 前两个单元:AE 本单元: PI 第02节:构造函数和析构函数 派生类继承的成员 派生类继承 ctor 和 dtor 吗? 派生类不继承的特殊函数 构造函数 (C++11已允许继承) 析构函数 作为特权地位的友元函数 赋值运算符函数 #include <iostream> struct A { A(int i) { } A(double d, int i) { } // ... }; struct B :

C++多态,继承,重载,隐藏,覆盖的关系

override->重写(=覆盖).overload->重载.polymorphism -> 多态 override是重写(覆盖)了一个方法,以实现不同的功能.一般是用于子类在继承父类时,重写(重新实现)父类中的方法.成员函数的重载(overload).覆盖(override)与隐藏很容易混淆,C++程序员必须要搞清楚概念,否则错误将防不胜防. 1   重载与覆盖 成员函数被重载的特征: (1)相同的范围(在同一个类中: (2)函数名字相同: (3)参数不同: (4)virtual  

(一)Python入门-6面向对象编程:07面向对象三大特征(封装、继承、多态)-继承

一:面向对象三大特征介绍 Python是面向对象的语言,也支持面向对象编程的三大特性:继承.封装(隐藏).多态. 封装(隐藏) 隐藏对象的属性和实现细节,只对外提供必要的方法.相当于将“细节封装起来”,只 对外暴露“相关调用方法”. 通过前面学习的“私有属性.私有方法”的方式,实现“封装”.Python 追求简洁的语法,没有严格的语法级别的“访问控制符”,更多的是依靠程序员自觉实现. 继承 继承可以让子类具有父类的特性,提高了代码的重用性. 从设计上是一种增量进化,原有父类设计不变的情况下,可以

多态 继承

多态(一个接口,多种实现)允许将子类类型的指针复制给父类类型的指针 向上转换:派生类转换为基类,总是合法和自动的 向下转换:基类转换为派生类,不会自动 C++中,只有一个参数的构造函数,可以将类型与该参数相同的值转换为类 例:构造函数 Stonewt(double lbs); 则可以有:Stonewt myCat=19.6; 程序使用构造函数Stonewt(double)来创建一个临时的Stonewt对象,将将19.6作为初始值.随后,采用逐成员赋值的方法将该临时对象的内容复制到myCat中,这