面向对象核心

最新推荐文章于 2024-08-30 19:03:32 发布
最新推荐文章于 2024-08-30 19:03:32 发布
阅读量98 收藏
点赞数
文章标签： c++ java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59342972/article/details/129148974
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

继承

作用：从基类（父类）基础上建立一1个新的类。继承一些方法，体现了代码复用的思想
已经存在的类称为父类或基类
从父类或基类基础上新建的类称为派生类或子类

#include <iostream>

using namespace std;

class Father{
public:
    string first_name="王";
};
class Son:public Father{
};

int main()
{
    Son s;
    cout<<s.first_name<<endl;
}

结果：
在这里插入图片描述

1.透传构造

概念：直接在派生类中的构造函数调用基类的构造函数

#include <iostream>
using namespace std;
class Father{
private:
    string first_name;
    int age;
public:
    Father(string name){
        this->first_name=name;
    }
    Father(string name,int age){
        this->first_name=name;
        this->age=age;
    }
    void show(){
        cout<<first_name<<" "<<age;
    }

};
class Son:public Father{
public:
    Son(string name):Father(name){}
    Son(string name,int age):Father(name,age){}

};

int main()
{
    Son s("张三",18);
    s.show();

}

2.委托构造

概念：某个类中的构造函数调用这个类中的重载的构造函数

#include <iostream>
using namespace std;
class Father{
private:
    string first_name;
    int age;
public:
    Father(string name){
        cout<<"Father一个参数构造函数"<<endl;
        this->first_name=name;
    }
    Father(string name,int age){
        cout<<"Father两个参数构造函数"<<endl;
        this->first_name=name;
        this->age=age;
    }
    void show(){
        cout<<first_name<<" "<<age<<endl;
    }

};
class Son:public Father{
public:
    Son(string name):Son(name,18){}
    Son(string name,int age):Father(name,age){}

};

int main()
{
    Son s("张",20);
    s.show();
    Son s2("李");
    s2.show();
}

3.多重继承

概念：一个派生类它有多个基类，会从多个基类中继承方法

#include <iostream>

using namespace std;
class Sofa{
public:
    void sit(){
        cout<<"可以坐着";
    }
};
class Bed{
public:
    void lay(){
        cout<<"可以躺着"<<endl;
    }
};
class SofaBed:public Sofa,public Bed{

};
int main()
{
    SofaBed s;
    s.sit();
    s.lay();
}

4.多重继承的二义性问题

概念：当多个基类中有同名的成员。此时就会产生二义性
可以通过类名：：方法来区分

#include <iostream>

using namespace std;
class Sofa{
public:
    void sit(){
        cout<<"可以坐着"<<endl;
    }
    void position(){
        cout<<"放在客厅";
    }

};
class Bed{
public:
    void lay(){
        cout<<"可以躺着"<<endl;
    }
    void position(){
        cout<<"放在卧室";
    }
};
class SofaBed:public Sofa,public Bed{

};

int main()
{
    SofaBed s;
    s.sit();
    s.lay();
    s.Sofa::position();
    s.Bed::position();
}

权限

private 本类中可以访问 在子类中不可以访问 全局中不‘’可以访问
protected 本类中可以访问 在子类中可以访问 全局中不可以访问
public 本类中可以访问 在子类中可以访问 全局中也可以访问

#include <iostream>
using namespace std;
class Father{
public:
    string  first_name="王";
protected:
    string  car="宝马";
private:
    string password="123789";

public:
    void show(){
        cout<<first_name<<endl;
        cout<<car<<endl;
        cout<<password<<endl;
    }
};
class Son:public Father{
public:
    void show2(){
        cout<<first_name<<endl;
        cout<<car<<endl;
        //cout<<password<<endl; //不能访问 父类的私有成员
    }
};
int main()
{
    Father f;
    cout<<f.first_name<<endl;
    //cout<<f.car<<endl; //不可以访问
    //cout<<f.password<<endl; //不可以访问
    Son s;
    s.show2();
}

1.public继承

public继承之后 成员在原来基类是什么权限，在派生类中还是什么权限

#include <iostream>
using namespace std;
class Father{
public:
    string str1="public";
protected:
    string str2="protected";
private:
    string str3="private";

};
class Son:public Father{
public:
    void show(){
        cout<<str1<<endl;
        cout<<str2<<endl;
        //cout<<str3<<endl;父类私有不能访问
    }

};
int main()
{
    Son s;
    s.show();
}

2.protect继承

protect继承之后。所有继承过来成员都会在Son中变成protected

#include <iostream>
using namespace std;
class Father{
public:
    string str1="public";
protected:
    string str2="protected";
private:
    string str3="private";

};
class Son:protected Father{
public:
    void show(){
        cout<<str1<<endl;
        cout<<str2<<endl;
        //cout<<str3<<endl;父类私有不能访问

    }

};
class GrandSon:public Son{
public:
    void show(){
        cout<<str1<<endl;
        cout<<str2<<endl;
        //cout<<str3<<endl;父类私有不能访问

    }


};
int main()
{
   Father f;
   cout<<f.str1<<endl;

   Son s;
   cout<<s.str1<<endl;  //在子类中变成了protected类型，在全局中不能访问
}

3.private继承

派生类私有继承之后 属性在派生中都变成私有.也就是下方的Son类中的属性都变成私有

#include <iostream>
using namespace std;
class Father{
public:
    string str1="public";
protected:
    string str2="protected";
private:
    string str3="private";

};
class Son:private Father{
public:
    void show(){
        cout<<str1<<endl;
        cout<<str2<<endl;
        //cout<<str3<<endl;父类私有不能访问
    }

};
class GrandSon:public Son{
public:
    void show(){
//        cout<<str1<<endl; //因为子类中变成私有 孙子类全访问不到
//        cout<<str2<<endl;
    }

};
int main()
{

   Son s;
   s.show();

   GrandSon gs;
   gs.show();

}

多态

函数重载是静态多态 编译的时候就已经确定
多态就是多种状态，可以一个接口实现多种状态。根据传入对象的不同，虽然调用同样接口，但 选择不同的代码实现。

多态需要三种条件：
1.pubic继承
2.派生类覆盖基类中的虚函数
3.接口参数为基类对象的指针或者基类引，指向派生对象

virtual关键字修饰的函数就是虚函数
1.当函数覆盖成功后，虚函数具有传递性。默认的函数都有virtual关键字
2.成员函数和析构函数可以定义为虚函数。静态函数和构造函数不可以
3.如果声明和定义分离时，virtual关键字只需要加在声明处。

1.多态的实现

#include <iostream>
using namespace std;
class Animal{
public:
    virtual void eat(){
        cout<<"吃东西"<<endl;
    }
};
class Dog:public Animal{
public:
    void eat(){
        cout<<"吃狗粮"<<endl;
    }
};
class Cat:public Animal{
public:
    void eat(){
        cout<<"吃鱼"<<endl;
    }
};
int main()
{
    Dog d;
    d.eat();  //吃狗粮
    Animal * a=&d;
    a->eat();  //吃东西
    Cat c;
    Animal * b=&c;
    b->eat(); //吃东西
}

2.多态应用

接口使用多态

#include <iostream>
using namespace std;
class Animal{
public:
    virtual void eat(){
        cout<<"吃东西"<<endl;
    }
};
class Dog:public Animal{
public:
    void eat(){
        cout<<"吃狗粮"<<endl;
    }
};
class Cat:public Animal{
public:
    void eat(){
        cout<<"吃鱼"<<endl;
    }
};
void test1(Animal * a){
    a->eat();
}
void test2( Animal &b){
    b.eat();
}
int main()
{
    //接口调用
    Cat c2;
    test2(c2);
    test1(&c2);
}

抽象类

抽象的概念。只有一些说明，没有具体实现，相当于一个框架的作用。抽象类中不具体的创建对象，不能作为参数类和和返回值类型
一个类中有纯虚函数，这个类就是抽象类；
如果一个类是抽象类，那么一定会有纯虚函数

如果继承了抽象类，需要实现全部实现，才能创建对象。否则它也会成为抽象类

#include <iostream>
using namespace std;
class Shape{
public:
    virtual void area()=0;
    virtual void perimeter()=0; //面积
};
class Rectangle:public Shape{
public:
    void area(){
        cout<<"长方形面积"<<endl;
    }
    void perimeter(){
        cout<<"长方形的周长"<<endl;
    }
};
int main()
{
    Rectangle r;
    r.area();
    r.perimeter();
}
壹玖揪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
面向对象核心概念
Meskjei的博客
05-21 1718
文章目录对象哲学中的对象面向对象中的对象面向对象与基于对象面向对象基于对象封装与信息隐藏封装信息隐藏信息隐藏内容实例化抽象数据类型（Abstract Data Type，ADT）性质类属性（attribute）操作消息传递泛化与多态泛化多态原型与基调覆盖（override）与重载（overload）动态链接 对象 哲学中的对象 与主体(subject)相对 客体（对象）是可感知到或想象到的任何...
面向对象的三大核心特性
xxhpx的博客
06-15 1754
面向对象开发模式更有利于人们开拓思维，在具体的开发过程中便于程序的划分，方便程序员分工合作，提高开发效率。面向对象程序设计有以下优点。 可重用性：代码重复使用，减少代码量，提高开发效率。下面介绍的面向对象的三大核心特性（继承、封装和多态）都围绕这个核心。 可扩展性：指新的功能可以很容易地加入到系统中来，便于软件的修改。 可管理性：能够将功能与数据结合，方便管理。 该开发模式之所以使程序设计更加完善和强大，主要是因为面向对象具有继承、封装和多态 3 个核心特性。 继承性 如同生活中的子女继承父母拥
java面向对象核心思想
snow_lyGirl
05-05 694
核心思想
面向对象的核心概念
a5868530的博客
05-22 2226
1.面向对象的核心概念 从理论上说，面向对象技术拥有四大基本特性。 （1）封装 这是一种隐藏信息的特征。封装这一特性不仅大大提高了代码的易用性，而且还使得类的开发者可以方便的更换新的算法，这种变化不会影响使用类的外部代码。可以用以下公式展示类的封装特性： 封装的类=数据+对此数据所进行的操作（即算法） 通俗的说，封装就是：包起外界不必需要知道的东西...
Java 面向对象编程核心概念
Jacks丶的博客
09-02 1328
Java 面向对象编程的核心概念。
Java面向对象核心知识点思维导图
08-28
Java面向对象核心知识点思维导图，综合整理Java面向对象核心知识点。
JavaScript面向对象核心知识与概念归纳整理
10-15
面向对象的核心概念包括三大特性：封装性、继承性和抽象性。封装性指的是将数据（属性）和功能（方法）结合起来，形成一个独立的单元——对象。继承性是指子对象可以继承父对象的属性和方法。抽象性涉及从具体事物中...
java面向对象核心知识点，独门大法
11-14
里面包含了java面向对象的核心知识点（封装+继承+多态+反射+jdbc..）还有一些其它的内容，都是很清晰的写出，对于新手小白的学习，是非常友好的，内容很丰富。每一个知识点的讲解，都会包含语法，语法个数如何定义，...
面向对象核心技术.pdf
09-02
面向对象编程（OOP）是目前软件开发中广泛使用的一种编程范式，它具有封装、继承和多态三个核心特性。在OOP中，类是创建对象的模板，继承则是实现类之间关系的一种机制。多态则提供了使用相同方法名调用不同方法的...
C语言如何快速求值
2301_81985098的博客
08-26 613
4、可得： m = (i + j) / 2， n = (i - j) / 2，i 和 j 要么都是偶数，要么都是奇数。3、设置： m + n = i，m - n = j，i * j =168，i 和 j 至少一个是偶数。一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？2、计算等式：m2 - n2 = (m + n)(m - n) = 168。1、则：x + 100 = n2, x + 100 + 168 = m2。6、由于 i * j = 168， j>=2，则。
c++命令模式
qq_71286244的博客
08-30 385
c++命令模式详细介绍
C语言破墙镐对称飞迷宫
qq_69383179的博客
08-22 2627
这里有我用C语言编译的破墙镐对称飞迷宫和与之相关的一些东西
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 5376
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
【C++ 面试 - 内存管理】每日 3 题（三）
Newin2020的博客
08-26 1037
栈就像我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。因为操作系统会在底层对栈提供支持，会分配专门的寄存器存放栈的地址，栈的入栈出栈操作也十分简单，并且有专门的指令执行，所以栈的效率比较高也比较快。栈顶和栈底是之前预设好的，栈是向栈底扩展，大小固定，可以通过 ulimit -a 查看，由 ulimit -s 修改。堆就像是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 1120
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
怎么解决 hash 碰撞，用 C++ 实现 hashMap？
zhanghaiou07657的博客
08-29 474
如果要自己实现一个简单的哈希映射，可以定义一个结构体来表示哈希表中的节点，包含键值对和指向下一个节点的指针（如果采用链地址法）。在插入操作时，计算键的哈希值，若该位置已被占用且键不相同，则根据选择的解决碰撞的方法（如链地址法）将新元素插入到链表中。在查找操作时，同样计算键的哈希值，然后遍历对应的链表（如果是链地址法）来查找目标键值对。“哈希碰撞是在哈希函数计算过程中可能出现的不同输入产生相同哈希值的情况。链地址法是将哈希值相同的元素存储在一个链表中，当进行查找等操作时，遍历对应的链表来找到目标元素。
Ascend C算子开发（入门）—— 算子开发初体验
Byyyi耀的博客
08-29 520
Ascend C算子开发（入门）—— 算子开发初体验
github源码指引：C++嵌入式WEB服务器
编程之道在明明德在亲民在止于至善
08-24 641
github源码指引：C++嵌入式WEB服务器
C++拷贝构造函数
最新发布
m0_75109289的博客
08-30 82
设计一个Per类，类中包含私有成员:姓名、年龄、指针成员身高、体重，再设计一个Stu类，类中包含私有成员:成绩、Per类对象p1，设计这两个类的构造函数、析构函数和拷贝构造函数。
C++面向对象核心：类、继承与多态
C++的面向对象核心语法提供了一种强大而灵活的编程方式，能够帮助开发者构建复杂的、易于维护的软件系统。通过理解并熟练掌握类、对象、继承、多态以及模板等概念，开发者可以更好地利用C++的强大功能，解决实际问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值