面向对象程序设计之继承(C++)

1.继承的定义

1.1继承的概念

继承(inheritance)机制是⾯向对象程序设计使代码可以复⽤的最重要的⼿段，它允许我们在保持原有类特性的基础上进⾏扩展，增加⽅法(成员函数)和属性(成员变量)，这样产⽣新的类，称派⽣类。继承 呈现了⾯向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的函数层次的复⽤，继承是类设计层次的复⽤ 

#include<iostream>using namespace std;
//基类
class Person
{
public:// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证 void identity(){cout << "void identity()" << _name << endl;}
protected:string _name = "张三"; // 姓名 string _address; // 地址 string _tel; // 电话 int _age = 18; // 年龄 
};
//派生类
class Student : public Person
{
public:// 学习 void study(){// ...}
protected:int _stuid; // 学号 
};
class Teacher : public Person
{
public:// 授课 void teaching(){//...}
protected:string title; // 职称 
};int main()
{Student s;Teacher t;//继承基类的公有函数与保护成员s.identity();t.identity();return 0;
}

1.2 继承定义格式

下⾯我们看到Person是基类，也称作⽗类。Student是派⽣类，也称作⼦类。(因为翻译的原因，所以 既叫基类/派⽣类，也叫⽗类/⼦类)

1.3继承基类成员访问⽅式的变化

注意：继承后的派生类继承了基类中的所有成员，不过有特定的成员因为权限不可被访问

1. 基类private成员在派⽣类中⽆论以什么⽅式继承都是不可⻅的。这⾥的不可⻅是指基类的私有成员还是被继承到了派⽣类对象中，但是语法上限制派⽣类对象不管在类⾥⾯还是类外⾯都不能去访问它

2. 基类private成员在派⽣类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派⽣类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。

3. 实际上⾯的表格我们进⾏⼀下总结会发现，基类的私有成员在派⽣类都是不可⻅。基类的其他成员在派⽣类的访问⽅式==Min(成员在基类的访问限定符，继承⽅式)，public >protected> private

4. 使⽤关键字class时默认的继承⽅式是private，使⽤struct时默认的继承⽅式是public，不过最好显示的写出继承⽅式。

5. 在实际运⽤中⼀般使⽤都是public继承，⼏乎很少使⽤protetced/private继承，也不提倡使⽤ protetced/private继承，因为protetced/private继承下来的成员都只能在派⽣类的类⾥⾯使⽤，实际中扩展维护性不强

派生类不可以访问基类中的私有成员，但是可以使用基类的公有成员函数调用访问私有成员 

class Parent
{
public:void GetNum(){cout << num << endl;}
private:int num = 1;
};class Child : public Parent
{
public:void GetRet(){cout << ret << endl;}
private:int ret = 2;
};int main()
{Parent p;Child c;p.GetNum();c.GetNum();return 0;
}

1.4类模版的继承

使用类模版模拟实现一个栈，可以使用vector/list/deque来当做底层容器，核心就是类模版的继承 

template<class T>
class Stack : public std::vector<T>
//class Stack : public std::list<T>
//class Stack : public std::deque<T>
{
public:// 基类是类模板时，需要指定⼀下类域， // 否则编译报错:error C3861: “push_back”: 找不到标识符 // 因为stack<int>实例化时，也实例化vector<int>了 // 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到 void push(const T& x){vector<T>::push_back(x);}void pop(){vector<T>::pop_back();}const T& top(){return vector<T>::back();}bool empty(){return vector<T>::empty();}
};int main()
{Stack<int> st;st.push(1);st.push(2);st.push(3);st.push(4);while (!st.empty()){cout << st.top() << " ";st.pop();}cout << endl;return 0;
}

2.基类与派生类的转换

1.public继承的派⽣类对象可以赋值给基类的指针、基类的引⽤。这⾥有个形象的说法叫切⽚或者切割。寓意把派⽣类中基类那部分切出来，基类指针或引⽤指向的是派⽣类中切出来的基类那部分

2.基类对象不能赋值给派⽣类对象

3.基类的指针或者引⽤可以通过强制类型转换赋值给派⽣类的指针或者引⽤。但是必须是基类的指针是指向派⽣类对象时才是安全的。这⾥基类如果是多态类型，可以使⽤RTTI(Run-Time-Type-Information)的dynamic_cast)来进⾏识别后进⾏安全转换

3.作用域

基类与派生类都具有不同的作用域，所以不存在重载，因为重载需要在相同的作用域

1. 在继承体系中基类和派⽣类都有独⽴的作⽤域
2. 派⽣类和基类中有同名成员，派⽣类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏(在派⽣类成员函数中，可以使⽤基类::基类成员显示访问)
3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏，不论参数相同与否
4. 注意在实际中在继承体系⾥⾯最好不要定义同名的成员

 通过子类调用继承父类的同名函数，如果父类的函数被隐藏则会报错，需要显示指定作用域

class Parent
{
public:void fun(){cout << "fun()" << endl;}
};class Child : public Parent
{
public:void fun(int i){cout << "fun(i)" << endl;}
};int main()
{Parent p;Child c;//报错,因为子类中没有参数为空的fun函数，而继承父类中的fun函数被隐藏，所以会报错,指定作用域即可//c.fun();c.Parent::fun();return 0;
}

4.派生类的默认成员函数

6个默认成员函数，默认的意思就是指我们不写编译器会变我们⾃动⽣成⼀个，那么在派⽣类中，这⼏个成员函数是如何⽣成的呢

扩展：初始化的顺序与初始化列表顺序无关，与声明顺序有关 

首先回顾一下默认构造完成的操作：

1.对内置类型:不确定

2.对自定义类型:调用默认构造

3.对从基类继承的类型: 将继承而来的成员看做一个整体，调用基类的默认构造

1.派⽣类的构造函数必须调⽤基类的构造函数初始化基类的那⼀部分成员。如果基类没有默认的构造函数，则必须在派⽣类构造函数的初始化列表阶段显示调⽤

class Parent
{
public://Parent(const char* name = "zhangsan")//基类没有默认构造函数Parent(const char* name):_name(name){cout << "Parent(const char* name)" << endl;}Parent(const Parent& p):_name(p._name){cout << "Parent(const Parent& p)" << endl;}Parent& operator=(const Parent& p){cout << "Parent& operator=(const Parent& p)" << endl;if (this != &p){_name = p._name;}return *this;}~Parent(){cout << "~Parent()" << endl;}
private:string _name;
};class Child : public Parent
{
public:Child(const char* name,int num):Parent(name)//显示初始化,_num(num){cout << "Child(const char* name,int num)" << endl;}private:int _num;
};

2.派⽣类的拷⻉构造函数必须调⽤基类的拷⻉构造完成基类的拷⻉初始化

对于内置类型：值拷贝

对于自定义类型：默认拷贝构造

对于继承而来的父类成员：调用父类的拷贝构造

所以一般来说子类使用默认拷贝构造函数即可，除非开辟了新的空间需要自定义拷贝构造

class Parent
{
public://Parent(const char* name = "zhangsan")//基类没有默认构造函数Parent(const char* name):_name(name){cout << "Parent(const char* name)" << endl;}Parent(const Parent& p):_name(p._name){cout << "Parent(const Parent& p)" << endl;}Parent& operator=(const Parent& p){cout << "Parent& operator=(const Parent& p)" << endl;if (this != &p){_name = p._name;}return *this;}~Parent(){cout << "~Parent()" << endl;}
private:string _name;
};class Child : public Parent
{
public:Child(const char* name,int num):Parent(name),_num(num){cout << "Child(const char* name,int num)" << endl;}Child(const Child& c):Parent(c),_num(c._num){cout << "Child(const Child& c)" << endl;}private:int _num;
};

3.派⽣类的operator=必须要调⽤基类的operator=完成基类的复制。需要注意的是派⽣类的 operator=隐藏了基类的operator=，所以显示调⽤基类的operator=，需要指定基类作⽤域

class Parent
{
public://Parent(const char* name = "zhangsan")//基类没有默认构造函数Parent(const char* name):_name(name){cout << "Parent(const char* name)" << endl;}Parent(const Parent& p):_name(p._name){cout << "Parent(const Parent& p)" << endl;}Parent& operator=(const Parent& p){cout << "Parent& operator=(const Parent& p)" << endl;if (this != &p){_name = p._name;}return *this;}~Parent(){cout << "~Parent()" << endl;}
private:string _name;
};class Child : public Parent
{
public:Child(const char* name,int num):Parent(name),_num(num){cout << "Child(const char* name,int num)" << endl;}Child(const Child& c):Parent(c),_num(c._num){cout << "Child(const Child& c)" << endl;}Child& operator=(const Child& c){cout << "Child& operator=(const Child& c)" << endl;if (this != &c){//子类和父类的operator=构成隐藏关系Parent::operator=(c);_num = c._num;}return *this;}private:int _num;
};

4.派⽣类的析构函数会在被调⽤完成后⾃动调⽤基类的析构函数清理基类成员。因为这样才能保证派⽣类对象先清理派⽣类成员再清理基类成员的顺序

5.派⽣类对象初始化先调⽤基类构造再调派⽣类构造

6.派⽣类对象析构清理先调⽤派⽣类析构再调基类的析构

class Parent
{
public://Parent(const char* name = "zhangsan")//基类没有默认构造函数Parent(const char* name):_name(name){cout << "Parent(const char* name)" << endl;}Parent(const Parent& p):_name(p._name){cout << "Parent(const Parent& p)" << endl;}Parent& operator=(const Parent& p){cout << "Parent& operator=(const Parent& p)" << endl;if (this != &p){_name = p._name;}return *this;}~Parent(){cout << "~Parent()" << endl;}
private:string _name;
};class Child : public Parent
{
public:Child(const char* name,int num):Parent(name),_num(num){cout << "Child(const char* name,int num)" << endl;}Child(const Child& c):Parent(c),_num(c._num){cout << "Child(const Child& c)" << endl;}Child& operator=(const Child& c){cout << "Child& operator=(const Child& c)" << endl;if (this != &c){Parent::operator=(c);_num = c._num;}return *this;}~Child(){ //子类与父类的析构构成隐藏关系，不需要显式调用//Parent::~Parent();cout << "~Child()" << endl;}
private:int _num;
};

7.因为多态中⼀些场景析构函数需要构成重写，重写的条件之⼀是函数名相同。那么编译器会对析构函数名进⾏特殊处理，处理成destructor()，所以基类析构函数不加virtual的情况下，派⽣类析构函数和基类析构函数构成隐藏关系 

5.不可被继承的基类 

方法一：将父类的构造函数私有化，这样子类就无法实例化对象

//方法一：将基类的构造函数私有化，这样派生类就无法实例化对象
class Parent
{
private:Parent(){cout << "Parent()" << endl;}
};class Child :public Parent
{
public:Child(){cout << "Child()" << endl;}
};

方法二：C++11新增了final关键字，使得基类不可以被继承 

//方法二：C++11新增了final关键字，使得基类不可被继承
class Parent final
{
public:Parent(){}
};class Child :public Parent
{
public:Child(){}
};int main()
{Child c;return 0;
}

 6.继承与友元

友元不能被继承，也就是说父类的友元不可以访问子类的私有和保护成员，除非是子类与父类共同的友元

//友元不可被继承，父类的友元不能访问子类的保护与私有成员//前置声明
class Child;class Parent
{void friend Display(const Parent& p, const Child& c);
protected:int _parent;
};class Child :public Parent
{
protected:int _child;
};void Display(const Parent& p, const Child& c)
{cout << p._parent << endl;cout << c._child << endl;
}

7.继承与静态成员

基类定义了一个静态成员，那么无论有多少子类都只有一个静态变量成员，即一个static实例

//继承与静态成员
//父类中定义一个静态成员，无论派生出多少子类都只有一个static实例
class Parent
{
public:static int _parent;
};int Parent::_parent = 0;class Child :public Parent
{
public:int _child;
};int main()
{Parent p;Child c;cout << &p._parent << endl;cout << &c._parent << endl;cout << &c._child << endl;return 0;
}

8.多继承及菱形继承 

8.1继承模型 

1.单继承：⼀个派⽣类只有⼀个直接基类时称这个继承关系为单继承

2.多继承：⼀个派⽣类有两个或以上直接基类时称这个继承关系为多继承，多继承对象在内存中的模型是，先继承的基类在前⾯，后⾯继承的基类在后⾯，派⽣类成员在放到最后⾯。

3.菱形继承：菱形继承是多继承的⼀种特殊情况。菱形继承有数据冗余和⼆义性的问题，⽀持多继承就 ⼀定会有菱形继承，像Java就直接不⽀持多继承，规避掉了这⾥的问题，所以实践中我们也是不建议设计出菱形继承这样的模型的 

//菱形继承
class Base
{
public:int _base;
};class Mother :public Base
{
public:int _mother;
};class Father :public Base
{
public:int _father;
};class Child :public Father, public Mother
{
public:int _child;
};int main()
{Child c;cout << c._base << endl;return 0;
}

这里由于菱形继承所以无法确定访问的_base是哪个类里的成员变量 

8.2虚继承 

使用virtual关键字来完成虚继承，确保一个变量只存在一个定义，避免二义性，一般地如果有多个子类连续菱形继承，只对继承父类的第一批子类进行virtual关键字修饰，即对产生数据冗余的类进行虚继承即可

//2.虚继承
class Base
{
public:int _base;
};class Mother : virtual public Base
{
public:int _mother;
};class Father : virtual public Base
{
public:int _father;
};class Child :public Father, public Mother
{
public:int _child;
};int main()
{Child c;Base b;Father f;Mother m;cout << &c._base << endl;cout << &b._base << endl;cout << &f._base << endl;cout << &m._base << endl;return 0;
}

 8.3继承后的指针偏移问题

根据下图我们知道Derive继承了Base1与Base2，其中p3自然指向的是Base1，p1由于是Base1继承而来，就与p3指向同一个位置，而p2则是由于切片后指向的是p1与p3的下一个位置，所以三者的内存地址是:p1==p3!=p2 

//继承中的指针偏移问题
class Base1
{
public:int _b1;
};class Base2
{
public:int _b2;
};class Derive : public Base1, public Base2
{int _d;
};int main()
{Derive d;Base1* p1 = &d;Base2* p2 = &d;Derive* p3 = &d;cout << &p1 << endl;cout << &p2 << endl;cout << &p3 << endl;return 0;
}

 9.继承与组合

public继承是⼀种is-a的关系。也就是说每个派⽣类对象都是⼀个基类对象
• 组合是⼀种has-a的关系。假设B组合了A，每个B对象中都有⼀个A对象
• 继承允许你根据基类的实现来定义派⽣类的实现。这种通过⽣成派⽣类的复⽤通常被称为⽩箱复⽤ (white-box-reuse)。术语“⽩箱”是相对可视性⽽⾔：在继承⽅式中，基类的内部细节对派⽣类可⻅。继承⼀定程度破坏了基类的封装，基类的改变，对派⽣类有很⼤的影响。派⽣类和基类间的依赖关系很强，耦合度⾼
• 对象组合是类继承之外的另⼀种复⽤选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接⼝。这种复⽤⻛格被称为⿊箱复⽤(black-box-reuse)，因为对象的内部细节是不可⻅的。对象只以“⿊箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使⽤对象组合有助于你保持每个类被封装。 
• 优先使⽤组合，⽽不是继承。实际尽量多去⽤组合，组合的耦合度低，代码维护性好。不过也不太那么绝对，类之间的关系就适合继承(is-a)那就⽤继承，另外要实现多态，也必须要继承。类之间的关系既适合⽤继承(is-a)也适合组合(has-a)，就⽤组合。

template<class T>class vector{};// stack和vector的关系，既符合is-a，也符合has-a template<class T>class stack : public vector<T>
{};template<class T>class stack{public:vector<T> _v;
};int main()
{return 0;
}

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.xdnf.cn/news/1536747.html

如若内容造成侵权/违法违规/事实不符，请联系一条长河网进行投诉反馈，一经查实，立即删除！

相关文章

给虚拟机linux系统安装交叉编译工具链

给虚拟机linux系统安装交叉编译工具链

我们在电脑上写的代码编译生成的是X86架构的二进制文件&#xff0c;只能在X86平台上运行&#xff0c;而开发板是ARM架构因此需要安装交叉编译链工具&#xff0c;这样在电脑上写的代码交叉编译之后生成的是ARM架构的二进制文件。 绿色的字眼是与本文无关的只是这样有助于我们的…
阅读更多...
推荐5款AI论文大纲生成器，一键极速生成！

推荐5款AI论文大纲生成器，一键极速生成！

在当今学术研究和写作领域&#xff0c;AI论文大纲生成器的出现极大地提高了写作效率和质量。以下是五款功能强大且全面的AI论文大纲生成器推荐&#xff1a; 一、千笔-AIPassPaper 千笔-AIPassPaper是一款基于深度学习和自然语言处理技术的AI写作助手&#xff0c;旨在帮助用户…
阅读更多...
【探索数据结构与算法】希尔排序原理、实现与分析（图文详解）

【探索数据结构与算法】希尔排序原理、实现与分析（图文详解）

目录 一、 引言 二、算法思想 三、算法步骤 四、代码实现 五、复杂度 &#x1f493; 博客主页&#xff1a;C-SDN花园GGbond ⏩ 文章专栏&#xff1a;探索数据结构与算法 一、 引言 希尔排序&#xff08;Shell Sort&#xff09;是插入排序的一种更高效的改进版本&#x…
阅读更多...
【Kubernetes笔记】为什么DNS解析会超时？

【Kubernetes笔记】为什么DNS解析会超时？

【Kubernetes笔记】为什么DNS解析会超时&#xff1f; 目录 1 问题背景2 产生后续的问题3 DNS 负缓存工作原理&#xff1a;4 如何解决和缓解 DNS 负缓存 4.1 减小负缓存 TTL4.2 重试机制4.3 减少 Pod 的频繁重启或调度4.4 使用 Headless Service4.5 手动刷新 DNS 缓存 5 总结 …
阅读更多...
【电脑组装】✈️从配置拼装到安装系统组装自己的台式电脑

【电脑组装】✈️从配置拼装到安装系统组装自己的台式电脑

目录 &#x1f378;前言 &#x1f37b;一、台式电脑基本组成 &#x1f37a;二、组装 &#x1f379;三、安装系统 &#x1f44b;四、系统设置 &#x1f440;五、章末 &#x1f378;前言 小伙伴们大家好&#xff0c;上篇文章分享了在平时开发的时候遇到的一种项目整合情况&…
阅读更多...
15. 三数之和（实际是双指针类型的题目）

15. 三数之和（实际是双指针类型的题目）

15. 三数之和 15. 三数之和 给你一个整数数组 nums &#xff0c;判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i ! j、i ! k 且 j ! k &#xff0c;同时还满足 nums[i] nums[j] nums[k] 0 。请你返回所有和为 0 且不重复的三元组。 注意&#xff1a;答案中不可以…
阅读更多...
支持升降压型、升压、降压、60V的1.2MHz频率LED恒流驱动器LGS63040、LGS63042

支持升降压型、升压、降压、60V的1.2MHz频率LED恒流驱动器LGS63040、LGS63042

前言&#xff1a; 一款支持升降压的LED驱动器。适合单节锂电池使用。当然不仅于此。SOT23-5封装的外形和丝印 特性 宽输入电压、宽输出电压范围&#xff1a;3.0V-60V 支持 PWM 调光及模拟调光 内置 60V/350mΩ低侧金属氧化物半导体场效应晶体管 1.2MHz固定工作频率 逐周期峰值…
阅读更多...
面试官问：你在团队中的角色是什么？

面试官问：你在团队中的角色是什么？

面试官问你在团队中的角色是什么&#xff0c;其目的是了解你如何在团队环境中工作&#xff0c;以及你如何看待自己在团队中的定位。他们希望听到你如何与他人协作、你的领导能力或团队合作精神&#xff0c;以及你是否能适应不同的团队角色。 回答这类问题时&#xff0c;你可以…
阅读更多...
（南京观海微电子）——GH7006+Boe_6.8_AV068WVU-N10原理介绍

（南京观海微电子）——GH7006+Boe_6.8_AV068WVU-N10原理介绍

​​​​​​​​​​​​​​​​​​​​​​​​​​​​
阅读更多...
07_Python数据类型_集合

07_Python数据类型_集合

Python的基础数据类型 数值类型&#xff1a;整数、浮点数、复数、布尔字符串容器类型&#xff1a;列表、元祖、字典、集合 集合 集合&#xff08;set&#xff09;是Python中一个非常强大的数据类型&#xff0c;它存储的是一组无序且不重复的元素&#xff0c;集合中的元素必须…
阅读更多...
Python 课程12-Python 自动化应用

Python 课程12-Python 自动化应用

前言 Python 自动化应用 可以帮助开发者节省时间和精力&#xff0c;将重复性、手动操作变为自动化脚本。例如&#xff0c;Python 可以用于自动化处理文件、邮件、生成报表&#xff0c;甚至可以控制浏览器执行复杂的网页操作任务。借助 Python 的强大库和工具&#xff0c;可以轻…
阅读更多...
Linux 开发工具（vim、gcc/g++、make/Makefile）+【小程序：进度条】-- 详解

Linux 开发工具（vim、gcc/g++、make/Makefile）+【小程序：进度条】-- 详解

目录 一、Linux软件包管理器 - yum&#xff08;ubuntu用apt代替yum&#xff09;1、Linux下安装软件的方式2、认识 yum3、查找软件包4、安装软件5、如何实现本地机器和云服务器之间的文件互传 二、Linux编辑器 - vim1、vim 的基本概念2、vim 下各模式的切换3、vim 命令模式各命令…
阅读更多...
开题报告的流程

开题报告的流程

开题报告是学术研究或工程项目开始前的一个重要环节&#xff0c;它标志着项目正式启动。开题报告的流程通常包括以下几个步骤&#xff1a; 1. **选题与立项**&#xff1a; - 确定研究或项目的主题。 - 进行初步的文献调研和市场调查。 - 提出研究或项目的意义、目标和…
阅读更多...
Mysql连接不上的问题？

Mysql连接不上的问题？

Mysql服务器本地能访问&#xff0c;但是外部连接报错如下&#xff1a;显然我也知道这就是一个权限问题&#xff0c;但是在网上百度的方法要么就是不生效&#xff0c;要么就是执行命令报错&#xff0c;很抓狂&#xff5e;这里提供精准的解决方案&#xff1a;SELECT User, Host F…
阅读更多...
OJ在线评测系统 后端项目初始化 Springboot项目通用模版讲解

OJ在线评测系统 后端项目初始化 Springboot项目通用模版讲解

后端项目初始化 重要 先把通用的后端框架跑起来 准备好文件 用idea打开 先去把项目名替换了 全局替换 第二步是改包名 包名也改一下 查看配置文件 启动 访问端口 接口文档 就是一个加强版的postman 创建数据库 执行 创建 进行测试 使用接口文档 后端初始化模版讲解 讲…
阅读更多...
【JAVA干货店】带你玩转数组与递归

【JAVA干货店】带你玩转数组与递归

&#x1f308;个人主页: Aileen_0v0 &#x1f525;热门专栏: 华为鸿蒙系统学习|计算机网络|数据结构与算法 ​&#x1f4ab;个人格言:“没有罗马,那就自己创造罗马~” 文章目录 递归利用递归求斐波那契数列数组入门 递归 自己调用自己 StackOverflowError:栈溢出错误,出现的原…
阅读更多...
AR技术在电商行业中有哪些应用场景？有何优势？

AR技术在电商行业中有哪些应用场景？有何优势？

AR&#xff08;增强现实&#xff09;技术在电商行业中的应用场景广泛且多样&#xff0c;为消费者带来了全新的购物体验&#xff0c;同时也为商家提供了诸多优势。51建模网为电商行业AR技术应用提供解决方案&#xff0c;以下是AR技术在电商行业中的主要应用场景及其优势&#xf…
阅读更多...
PhotoZoom Pro / Classic 9.0.2激活版安装激活图文教程

PhotoZoom Pro / Classic 9.0.2激活版安装激活图文教程

图像格式中&#xff0c;位图格式的图像是由点阵像素组成的数据文件&#xff0c;所以呢在把位图图像放大的时候&#xff0c;就会发现看到它是由于许多点构成&#xff0c;这就是为什么数码照片在使用普通的工具放大时会失真的原因。不过呢由于一些日常需求&#xff0c;我们经常需…
阅读更多...
TalkSphere项目介绍

TalkSphere项目介绍

TalkSphere项目介绍 文章目录 TalkSphere项目介绍一、前言二、技术栈及开发环境三、主要功能&#xff08;一&#xff09;用户登录与注册&#xff08;二&#xff09;用户历史消息展示&#xff08;三&#xff09;在线用户实时聊天 四、结语 一、前言 在线聊天室作为一个虚拟社交…
阅读更多...
关于安卓App自动化的一些想法

关于安卓App自动化的一些想法

安卓App自动化一般使用PythonAppium。页面元素通常是使用AndroidStudio中的UI Automator Viewer工具来进行页面元素的追踪。但是这里涉及到一个问题就是&#xff0c;安卓apk在每次打包的时候&#xff0c;会进行页面的混淆以及加固&#xff0c;所以导致每次apk打包之后会出现页面…
阅读更多...
最新文章

Copyright @ 2022~2023