精华内容
下载资源
问答
  • 继承多态
    2022-07-31 11:18:31

    封装好理解,就是封装;

    像我之前做的播放器,里面的控件啊什么的都是私有的,你外面只能通过我提供的函数来操作控件,而不能直接修改我的控件
    封装就是合理利用权限修饰符,这个类外部的人只能通过我提供的接口来修改部分类成员变量,整个过程是可控的。

    继承就是派生类会获得父类所有公开权限的成员函数和成员变量,这样少去了重新定义的麻烦,另外派生类还可以增加其他的函数,扩展父类,以及重写父类函数,增加这个可拓展性,因为会遇到很多不同的情况,如果没有这种应变能力,就太死板了。

    多态:不同对象收到相同的的消息时(即调用相同的函数),产生不同的动作。直观的说,多态性是指用一个名字定义不同的函数(这里只要函数名相同就行),这些函数执行不同但又类似的操作,从而可以使用相同的方式来调用这些具有不同功能的同名函数。
    通过虚函数实现

    原因就是因为我们原先所写的程序,不容易维护,灵活性差,不容易扩展,更谈不上复用,因此面对需求变化,加班加点,对程序动大手术的那种无奈也就成了非常正常的事了。之后当我学习了面向对象的分析设计编程思想,开始考虑通过封装、继承、多态把程序的耦合度降低,传统印刷术的问题就在于所有的字都刻在同一版面上造成耦合度太高所致,开始用设计模式使得程序更加的灵活,容易修改,并且易于复用。体会到面向对象带来的好处,那种感觉应该就如同是一中国酒鬼第一次喝到了茅台,西洋酒鬼第一次喝到了XO一样,怎个爽字可形容呀。

    https://www.runoob.com/cplusplus/cpp-polymorphism.html

    更多相关内容
  • C++多继承多态的实现 如果一个类中存在虚函数,在声明类的对象时,编译器就会给该对象生成一个虚函数指针,该虚函数指针指向该类对应的虚函数表。 多态的实现是因为使用了一种动态绑定的机制,在编译期间不确定...
  • 详解java封装继承多态

    2020-08-26 04:46:57
    主要介绍了java封装继承多态,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • C++ 类的封装继承多态

    千次阅读 2022-04-28 22:16:16
    C++ 三大特性,封装继承多态。我们先实现一个Quote作为基类 class Quote { public: Quote() = default; Quote(const std::string &book, double sales_price) { price = sales_price; bookNo = book; } ...

    C++ 特性

    C++ 三大特性,封装继承多态。我们先实现一个Quote作为基类

    class Quote
    {
    public:
        Quote() = default;
        Quote(const std::string &book, double sales_price)
        {
            price = sales_price;
            bookNo = book;
        }
        std::string isbn() const
        {
            return bookNo;
        }
    
        virtual double net_price(std::size_t n) const
        {
            cout << "this is Quote net_price" << endl;
            return n * price;
        }
        static void PrintHello()
        {
            cout << "hello world" << endl;
        }
    
        Quote(const Quote &quote) : bookNo(quote.bookNo), price(quote.price) {}
    
        void printMem()
        {
            cout << "price is " << price << " bookNo is " << bookNo << endl;
        }
    
        virtual ~Quote()
        {
            cout << "this is Quote destruct" << endl;
        }
    
        // final 阻止其他继承Quote的类重写f3函数
        virtual void f3() final {}
    
    private:
        std::string bookNo;
    
    protected:
        double price = 0.0;
    };
    

    net_price是一个虚函数,实现了基类的计算规则。同时我们实现了一个虚函数f3,但是f3末尾用final标识了,表示继承Quote的子类不能重写f3函数。
    我们实现子类

    class BulkQuote : public Quote
    {
    public:
        BulkQuote() = default;
        BulkQuote(const std::string &book, double p, std::size_t qty, double disc) : Quote(book, p), min_qty(qty), discount(disc)
        {
        }
    
        // override 是C11提供的继承关系检测工具,检测函数类型是否匹配,是否为虚函数等。
        double net_price(std::size_t) const override;
        // void f3() {}
    
    private:
        //打折后最多买多少
        std::size_t min_qty = 0;
        //折扣额度
        double discount = 0.0;
    };
    

    子类无法重写f3所以注释了。子类BulkQuote重写了net_price,该函数后边用了overide关键字,C11规定写了override关键字的函数必须符合基类的规则,包括函数参数类型相同,返回值相同,函数名一致等。
    基类Quote有一个静态函数PrintHello,子类继承Quote也将PrintHello继承过来。
    可以通过如下方式调用

    void use_base_static()
    {
        Quote::PrintHello();
        BulkQuote::PrintHello();
    }
    

    可以将子类赋值给基类或者将子类对象传给基类的构造函数,这么做的结果是基类构造时只拷贝子类的基类部分。

    void use_derive_to_base()
    {
        BulkQuote bulkquote(string("Live"), 1.2, 100, 0.8);
        //子类传给基类构造函数,或者子类赋值给基类
        //就会调用基类构造函数,只构造基类部分。
        Quote quote(bulkquote);
        quote.printMem();
        quote = bulkquote;
        quote.printMem();
    }
    

    当我们将一个子类对象传递给一个基类引用,或者将一个子类对象的指针传递给一个基类指针,通过基类的指针或引用调用虚函数,会动态调用子类对象的虚函数版本,这种特性叫做多态。我们先实现一个全局函数

    void print_total(ostream &os, const Quote &quote, std::size_t n)
    {
        os << quote.net_price(n) << endl;
    }
    

    多态特性会让编译器根据动态类型绑定虚函数调用的版本,所谓动态类型就是运行时才确定的类型。

    void use_derive_param()
    {
        BulkQuote bulkquote(string("Live"), 1.2, 100, 0.8);
        Quote quote(string("Quote"), 1.2);
        print_total(cout, quote, 100);
        print_total(cout, bulkquote, 100);
    }
    

    上面的程序会根据传给print_total具体的实参类型调用各自的虚函数net_price。

    纯虚类

    如果一个类只包含纯虚函数,不包含成员变量,则该类为纯虚类。所谓纯虚函数就是只有声明,函数体为=0的形式。

    //纯虚类
    class VirtualBase
    {
    public:
        VirtualBase() = default;
        virtual void mem() = 0;
        virtual void test() = 0;
    };
    

    纯虚类类似于Go语言的interface,当我们继承纯虚类后一定要重写其所有的纯虚函数。

    class DeriveFromBase : public VirtualBase
    {
        virtual void mem()
        {
        }
        virtual void test() {}
    };
    

    封装性

    子类只可以访问基类的protected和public成员,不能访问private成员。子类的友元函数可以访问子类的私有变量,公有变量以及受保护的变量,当时不能访问基类的私有变量和protected变量。

    // protected
    class ProBase
    {
    public:
        ProBase() = default;
        ProBase(int n) : prot_mem(n) {}
        void mem_func()
        {
            cout << "this is ProBase mem_func" << endl;
        }
    
    protected:
        int prot_mem;
    
    private:
        int priv_mem;
    };
    

    ProBase包括一个私有变量priv_mem和一个受保护变量prot_mem。我们定义子类继承它

    class Sneaky : public ProBase
    {
    public:
        Sneaky() = default;
        Sneaky(int n) : ProBase(1024), prot_mem(n) {}
        //子类可以使用基类的public和protected成员
        void UsePro()
        {
            cout << prot_mem << endl;
        }
    
        //子类无法使用基类的private成员。
        // void UsePriv()
        // {
        //     cout << priv_mem << endl;
        // }
        friend void clobber(Sneaky &);
        friend void clobber(ProBase &);
    
        void GetMem()
        {
            cout << "this is ProBase prot_mem: " << ProBase::prot_mem << endl;
            cout << "this is Sneaky prot_mem: " << prot_mem << endl;
        }
    
        void mem_func(int n)
        {
            cout << "this is Sneaky mem_func" << endl;
        }
    
    private:
        int self_mem;
        int prot_mem;
    };
    

    通过继承Sneaky拥有了基类ProBase的私有变量priv_mem和受保护变量prot_mem。又定义了自己的私有变量self_mem和prot_mem。
    可以看到即使在Sneaky的类声明中UsePriv这个函数里也无权访问基类的私有变量priv_mem。我们在如下函数测试

    void use_probase()
    {
        Sneaky sk(11);
        // sk.prot_mem;
        sk.GetMem();
        //调用子类的mem_func(int n)
        sk.mem_func(100);
        ProBase pb;
        //调用基类的mem_func()
        pb.mem_func();
        //基类的mem_func()被覆盖了
        //sk.mem_func();
        //想使用基类的mem_func()需要添加基类作用域
        sk.ProBase::mem_func();
    }
    

    在类的声明之外,通过对象的方式无法直接使用sk的私有变量prot_mem。因为子类实现了mem_func(int n)版本,所以把基类的mem_func(void)覆盖了,想调用基类版本的mem_func()需要通过sk.ProBase::mem_func()显示调用基类版本。
    接下来我们实现Sneaky的两个友元函数

    void clobber(Sneaky &s)
    {
        s.prot_mem = 100;
        s.self_mem = 1000;
    }
    //子类友元无法访问基类受保护成员
    void clobber(ProBase &b)
    {
        // b.prot_mem = 10;
    }
    

    子类的友元函数无法访问基类的私有成员和保护成员。

    重写和隐藏

    子类继承基类,重新实现基类的虚函数就叫做重写,重写要求必须和基类的虚函数完全匹配,包括参数类型返回值等。
    对于基类的非虚函数,子类实现了同名的函数,只要名字相同,即使参数不同,也可以覆盖基类函数,叫做隐藏。

    class VBase
    {
    public:
        virtual int fcn()
        {
            cout << "this is VBase fcn()" << endl;
        }
    };
    
    class VD1 : public VBase
    {
    public:
        // VD1自己定义的fcn(int),因为和基类VBase的fcn参数不同
        //但是VD1也继承了VBase  fcn()这个版本
        //隐藏了基类的fcn()
        int fcn(int)
        {
            cout << "this is VD1 fcn(int)" << endl;
        }
    
        // VD1自己新定义的虚函数
        virtual void f2()
        {
            cout << "this is VD1 f2()" << endl;
        }
    };
    
    class VD2 : public VD1
    {
    public:
        //隐藏了VD1版本的fcn(int),因为VD1中fcn(int)不是虚函数
        int fcn(int)
        {
            cout << "this is VD2 fcn(int)" << endl;
        }
    
        //重写,因为VD1从VBase中继承了虚函数fcn()
        int fcn()
        {
            cout << "this is VD2 fcn()" << endl;
        }
    
        //重写了VD1的虚函数
    
        void f2()
        {
            cout << "this is VD2 f2()" << endl;
        }
    };
    

    如下函数展示了覆盖和重写等情况时调用规则

    void use_hiddenbase()
    {
        VD1 vd1;
        //调用基类VBase版本
        vd1.VBase::fcn();
        //调用VD1版本
        vd1.fcn(100);
    
        VD2 vd2;
        VBase *pvb = &vd1;
        //会调用基类的VBase::fcn()
        pvb->fcn();
        VBase *pvb2 = &vd2;
        //多态调用VD2::fcn()
        pvb2->fcn();
    
        VD1 *pvd1 = &vd2;
        //调用VD2版本的f2()
        pvd1->f2();
    }
    

    类的继承和多态总结

    1 派生类向基类转换只在指针或引用时才生效
    2 不存在默认的基类向子类转换,但是如果确认转换安全可以通过static_cast来转换。
    3 类不想被继承,可以在类名后添加final关键字
    4 如果子类无权访问基类构造函数,则无法实现子类对象向基类对象的转换。
    5 子类对象可以向基类对象转换,默认只将子类对象中基类的成员赋值给基类对象。
    6 多态就是将子类对象的指针赋值给基类对象的指针,通过调用基类的虚函数,实现动态绑定, 运行时调用了子类的虚函数。

    7 final 声明的虚函数会阻止继承该类的类重写该函数
    8 override 要求编译器检测重写的函数是否符合规则,是否为虚函数,是否为类型相同。
    9 继承纯虚类,一定要实现它的所有纯虚方法,否则该类无法使用。
    10 子类可以使用基类的public和protected成员,子类无法使用基类的private成员
    11 proteced 和private成员不可被对象的方式访问。
    12 子类的友元函数可以访问子类的私有变量和受保护变量,但是不能访问基类的受保护变量。
    13 子类的友元函数可以访问子类自己定义的私有变量,但是不能访问从基类继承而来的私有变量。
    14 子类和基类有相同名字的成员或者非虚函数非静态的成员函数,在使用的时候默认使用子类的,
    如果想使用基类的需要加上基类名字的作用域。
    15 如果子类实现的函数和基类的虚函数同名,但是参数类型不同,就不是重写而是隐藏,重写要求子类的函数和
    基类的虚函数类型,名称完全一致。
    16 针对一个普通的非虚函数的成员函数,子类实现了一个同名的函数,就是覆盖,会隐藏基类的同名函数
    17 重载是对于一个类来讲,实现了多个同名函数,他们的参数不同。

    展开全文
  • C++程序设计学习继承、封装、多态的例子。代码简单明了,清晰明确,用龙与人战斗的场景,通过控制台程序,展示了三大特征的最基本应用,循序渐进。适合初学者借鉴学习。
  • Python的继承多态

    2020-12-20 23:43:57
    Python的继承多态 文章目录Python的继承多态一、私有属性和私有方法01. 应用场景及定义方式02. 伪私有属性和私有方法二、单例01. 单例设计模式单例设计模式的应用场景02. `__new__` 方法03. Python 中的单例只执行一...
  • Java——封装继承多态

    2022-06-11 20:16:20
    子类可以继承父类的方法和属性Dog继承了Animal类中的方法和属性,所以就算Dog中没有定义move方法,也可以进行调用,此时调用的是父类的方法。多态 多态顾名思义就是多种形态,代码在运行时可以有多种形态。如果要...

    封装
    将方法和属性封装到一个对象中,对外提供方法用于改变该对象的属性值。

    public class Person {
    private String name;
    private Integer age;
    public String getName() {
    return name;
    }
    public void setName(String name) {
    this.name = name;
    }
    public Integer getAge() {
    return age;
    }
    public void setAge(Integer age) {
    this.age = age;
    }
    }

    该代码中定义了Person类,里面的属性定义为private,外部不能通过person.name=“zf" 进行修改,只能通过person.setName(“zf”)进行修改。

    继承
    子类可以继承父类的方法和属性

    public class Animal {
    public void move() {
    System.out.println(“animal move”);
    }
    public void eat() {
    System.out.println(“animal eat”);
    }
    }
    public class Dog extends Animal {
    public void eat() {
    System.out.println(“dog eat”);
    }
    }
    public static void main(String[] args) {
    Animal dog = new Dog();
    dog.eat();
    dog.move();
    }

    Dog继承了Animal类中的方法和属性,所以就算Dog中没有定义move方法,也可以进行调用,此时调用的是父类的方法。

    多态
    多态顾名思义就是多种形态,代码在运行时可以有多种形态。如果要满足多态,则有一些前置条件。就是必须有子类和父类的继承关系。比如一个动物类,下面有狗类、猫类。分别重写了动物类的eat方法,当调用一个动物的eat方法时,有可能会调用猫的eat方法,也有可能调用狗的eat方法。具体调用谁的eat方法,则需要在运行时判断该对象到底是猫还是狗。

    public static void main(String[] args) {
        Animal animal = new Dog();
        //Animal animal = new Cat();
        animal.eat();
        animal.move();
    }
    
    展开全文
  • 封装继承多态总结

    2013-12-06 09:29:22
    封装继承多态总结
  • 封装继承多态

    千次阅读 2022-03-23 16:46:51
    继承 子类可以继承父类的方法和属性 public class Animal { public void move() { System.out.println("animal move"); } public void eat() { System.out.println("animal eat"); } } public class Dog extends ...

    首页

    封装

    将方法和属性封装到一个对象中,对外提供方法用于改变该对象的属性值。

    public class Person {
        private String name;
        private Integer age;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    }
    
    

    该代码中定义了Person类,里面的属性定义为private,外部不能通过person.name=“zf" 进行修改,只能通过person.setName(“zf”)进行修改。

    继承

    子类可以继承父类的方法和属性

    public class Animal {
        public void move() {
            System.out.println("animal move");
        }
        public void eat() {
            System.out.println("animal eat");
        }
    }
    
    public class Dog extends Animal {
        public void eat() {
            System.out.println("dog eat");
        }
    }
    
        public static void main(String[] args) {
            Animal dog = new Dog();
            dog.eat();
            dog.move();
        }
    

    Dog继承了Animal类中的方法和属性,所以就算Dog中没有定义move方法,也可以进行调用,此时调用的是父类的方法。

    多态

    多态顾名思义就是多种形态,代码在运行时可以有多种形态。如果要满足多态,则有一些前置条件。就是必须有子类和父类的继承关系。比如一个动物类,下面有狗类、猫类。分别重写了动物类的eat方法,当调用一个动物的eat方法时,有可能会调用猫的eat方法,也有可能调用狗的eat方法。具体调用谁的eat方法,则需要在运行时判断该对象到底是猫还是狗。

        public static void main(String[] args) {
            Animal animal = new Dog();
            //Animal animal = new Cat();
            animal.eat();
            animal.move();
        }
    
    展开全文
  • python-封装继承多态

    千次阅读 2022-01-23 11:22:10
    多态的存在有2个必要条件:继承、方法重写. #多态 class Man: def eat(self): print("饿了吃饭") class Chinese(Man): def eat(self): print("中国人用筷子吃饭") class English(Man): def eat(self): print("英国人...
  • Java基础—封装继承多态(详细)

    千次阅读 2022-06-16 22:44:35
    面向对象三大特征 封装 继承 多态1.封装定义:就是把事物封装成类,将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问。
  • C++继承 多态

    2022-01-30 14:01:16
    C++继承 多态
  • C++封装继承多态理解

    千次阅读 2020-12-29 19:33:05
    面向对象的三个基本特征: 封装 、继承多态 简单概括三大特性作用: 封装是为了代码模块化和增加安全性 继承是为了重用和扩展现有的代码模块 多态是为了接口复用 封装: 保护数据成员,不让类以外的程序...
  • 一、什么是封装?请详细解释。主要封装哪些内容? ①每个对象都包含它能进行操作所需要的所有信息,这个特性称为封装,因此对象不必依赖其他对象来完成自己...1.继承定义了类如何相互关联,共享特性。 2.主要目的:为
  • C#封装继承多态

    2014-11-05 10:29:54
    这是关于C#封装继承多态的一个简单的例子,对于深入学习C#中封装继承多态将很有帮助!
  • 易语言的继承多态演示源码 ' 面向对象思想编程特点重用性,灵活性,扩展性 ' 继承:使得一个类A能直接使用另一类B的属性和方法的途径,类A可以有自己的属性和方法 ' 多态:引用同一个类型,使用不同实例而不同操作 ' 如下:...
  • 易语言的继承多态演示源码,的继承多态演示,说明,继承的方法,生产
  • 易语言的继承多态演示源码。' 面向对象思想编程特点重用性,灵活性,扩展性。' 继承:使得一个类A能直接使用另一类B的属性和方法的途径,类A可以有自己的属性和方法。' 多态:引用同一个类型,使用不同实例而不同操作。' ...
  • 应用多继承中虚拟基类的应用,掌握虚拟函数在多态性中的应用,掌握虚函数、纯虚函数、抽象类的概念,并能应用抽象类解决实际问题。
  • java继承多态

    2015-08-31 15:33:10
    理解继承如何增强软件的可重用性 超类(父类)和子类
  • 面向对象技术三大特性:封装,继承多态 封装 封装的概念体现在类抽象和对象实例化,封装就是将数据和对数据的操作封装在一个类中,用类对数据进行了抽象 继承 (1)如果两个类的关系存在一种所属关系,...
  • 安老师 的一个例子,c++ 的封装继承多态例子
  • C++:封装 继承 多态

    2021-10-17 17:12:29
    1. 封装 2. 继承 3. 多态
  • 一、继承多态. 1.疑问:Calendar是抽象类,怎么可以实例化对象呢? 2.解答:不是Calendar的实例化对象,在这里实现了继承多态。Calendar.getInstance();实际上是new Calendar抽象类的一个子类。等号左边为抽象类,...
  • 易语言源码易语言的继承多态演示源码.rar 易语言源码易语言的继承多态演示源码.rar 易语言源码易语言的继承多态演示源码.rar 易语言源码易语言的继承多态演示源码.rar 易语言源码易语言的继承多态演示源码.rar ...
  • java封装 继承 多态 的概念和作用

    千次阅读 2019-12-01 14:46:43
    一:概念 封装: 在java中,我们对类的封装,对方法的封装,在其他类中只需要调用这个类或者...只要子类继承父类,就可以调用父类中的方法(注:父类私有的方法子类无法调用)。 通俗点理解,我们家庭中,也是这种...
  • ATM取款机代码 C++ 用VC++6.0实现 类的多态性 继承
  • 精选文库 PAGE PAGE 2 实验报告 学生姓名 学 号 专业班级 实验类型 验证 综合 设计 创新 实验日期 实验成绩 一实验项目名称 抽象封装与类一 二实验目的 掌握抽象封装继承多态 熟练掌握如何自定义一个类 掌握类的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 311,081
精华内容 124,432
关键字:

继承多态