C++面向对象——类与对象

已于 2024-04-22 18:47:36 修改
阅读量876 收藏
点赞数 1
分类专栏： C++ 文章标签： c++
于 2024-04-17 10:01:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44505194/article/details/137859482
版权

文章目录

类与对象

#include<iostream>
#include<string>
using namespace std;
/*
类与对象 
*/
class Person{
	public:
		string name;// 固有属性，成员变量 
		int age;
	public:
		void eat(){ // 成员函数，成员方法 
			cout<<"eat()"<<endl;
		}
		void show(){
			cout<<"[name:"<<name<<", age:"<<age<<"]"<<endl;
		} 
};
int main(){
	Person p1;  // 实例化对象 
	p1.name = "AAA";
	p1.age = 11;
	
	p1.eat();
	p1.show();
	return 0;
}

构造函数、析构函数

#include<iostream>
#include<string>
using namespace std;

/*
构造函数

类成员属性 
public属性的成员对外可见，对内可见。
private属性的成员对外不可见，对内可见。
protected属性的成员对外不可见，对内可见，且对派生类是可见的。
*/

class Person{
	public: // 公开，哪里都可以访问 
		string name;// 固有属性，成员变量 
		int age;
	public: // 公开，哪里都可以访问 
		Person(){// 无参构造 
			cout<<"构造函数：Person()"<<endl;
		} 
		Person(string _name,int _age){// 有参构造函数  
			name = _name;
			age = _age;
			cout<<"构造函数：Person(string _name,int _age)"<<endl;
		}
		Person(const Person& p){ // 复制构造函数 
			name = p.name;
			age = p.age;
			cout<<"构造函数：Person(const Person& p)"<<endl;
		}
		~Person(){ // 析构函数
		// 析构函数：无法重载，析构顺序与构造顺序相反 
			cout<<"~Person()"<<name<<endl; 
		}
		void show(){ // 成员函数，成员方法 
			cout<<"[name:"<<name<<", age:"<<age<<"]"<<endl;
		}
};
int main(){
	Person p1;  // 实例化对象，调用无参构造函数 
	p1.name = "AAA"; // error
	p1.age = 11;
	p1.show();

	Person p2("BBB", 12);// 实例化对象，调用有参构造函数 
	p2.show();
	
	Person p3(p1);
	p3.show(); 
	return 0;
}

get/set方法

#include<iostream>
#include<string>
using namespace std;

/*
get/set方法 
*/
class Person{
	private: // 私有，仅类内可以访问 
		string name;// 固有属性，成员变量 
		int age;
	public: // 公开，哪里都可以访问 
		Person(){// 无参构造 
			cout<<"构造函数：Person()"<<endl;
		} 
		Person(string _name,int _age){// 有参构造函数  
			name = _name;
			age = _age;
			cout<<"构造函数：Person(string _name,int _age)"<<endl;
		}
		Person(const Person& p){ // 复制构造函数 
			name = p.name;
			age = p.age;
			cout<<"构造函数：Person(const Person& p)"<<endl;
		}
		~Person(){ // 析构函数
		// 析构函数：无法重载，析构顺序与构造顺序相反 
			cout<<"~Person()"<<name<<endl; 
		}
		// 提供get/set方法 
		void setName(string _name){ name = _name; } 
		string getName(){ return name; }
		void setAge(int _age){ age = _age; }
		int getAge(){ return age; }

		void show(){ // 成员函数，成员方法 
			cout<<"[name:"<<name<<", age:"<<age<<"]"<<endl;
		}
};
int main(){
	Person p1;  // 实例化对象，调用无参构造函数 
//	p1.name = "AAA"; // error
//	p1.age = 11;
	p1.setName("AAA");
	p1.setAge(11);
	p1.show();

	Person p2("BBB", 12);// 实例化对象，调用有参构造函数 
	p2.show();
	
	Person p3(p1);
	p3.setName("CCC");
	p3.show(); 
	return 0;
}

函数：类内声明、类外定义

#include<iostream>
#include<string>
using namespace std;

/*
函数：类内声明、类外定义 
*/

class Person{
	private: // 私有，仅类内可以访问 
		string name;// 固有属性，成员变量 
		int age;
	public: // 公开，哪里都可以访问 
		Person(); // 无参构造函数的声明 
		Person(string _name,int _age);// 有参构造函数的声明  
		Person(const Person& p); // 复制构造函数的声明 
		~Person(); // 析构函数的声明 
		
		// 提供get/set方法 
		void setName(string _name){ name = _name; } 
		string getName(){ return name; }
		void setAge(int _age){ age = _age; }
		int getAge(){ return age; }
		void show(){ // 成员函数，成员方法 
			cout<<"[name:"<<name<<", age:"<<age<<"]"<<endl;
		}
};

// 构造函数的类外实现 
Person::Person(){// 无参构造 
	cout<<"构造函数：Person()"<<endl;
} 
Person::Person(string _name,int _age){// 有参构造函数  
	name = _name;
	age = _age;
	cout<<"构造函数：Person(string _name,int _age)"<<endl;
}
Person::Person(const Person& p){ // 复制构造函数 
	name = p.name;
	age = p.age;
	cout<<"构造函数：Person(const Person& p)"<<endl;
}
Person::~Person(){ // 析构函数
// 析构函数：无法重载，析构顺序与构造顺序相反 
	cout<<"析构函数：~Person()"<<name<<endl; 
}

int main(){
	Person p1; 
//	p1.name = "AAA"; // error
//	p1.age = 11;
	p1.setName("AAA");
	p1.setAge(11);
	p1.show();

	Person p2("BBB", 12);// 实例化对象，调用有参构造函数 
	p2.show();
	
	Person p3(p1);
	p3.setName("CCC");
	p3.show(); 
	return 0;
}

static

#include<iostream>
#include<string>
using namespace std;

/*
内联成员函数，使用inline关键字将函数定义为内联函数。
对于成员函数来说，如果其定义是在类体中，即使没有使用inline关键字，该成员函数也被认为是内联成员函数。

static 关键字： 静态成员属于类 
对于静态成员来说，不仅可以通过对象访问，还可以直接使用类名访问：
----------------临时分割线 
静态数据成员可以是当前类的类型，而其他数据成员只能是当前类的指针或引用类型
类的静态成员函数只能访问类的静态数据成员，而不能访问普通的数据成员。
静态成员函数不能定义为const成员函数，即静态成员函数末尾不能使用const关键字。
*/

class Person{
	private: // 私有，仅类内可以访问 
		string name;// 固有属性，成员变量 
		int age;
	public: // 公开，哪里都可以访问 
		static int cnt; 
		Person(); // 无参构造函数的声明 
		Person(string _name,int _age);// 有参构造函数的声明  
		Person(const Person& p); // 复制构造函数的声明 
		~Person(); // 析构函数的声明 
		
		// 提供get/set方法 
		void setName(string _name){ name = _name; } 
		string getName(){ return name; }
		void setAge(int _age){ age = _age; }
		int getAge(){ return age; }

		void show(){ // 成员函数，成员方法 
			cout<<"[name:"<<name<<", age:"<<age<<"]"<<endl;
		}
};
int Person::cnt = 0; // 初始cnt 

// 构造函数的类外实现 
Person::Person(){// 无参构造 
	cnt ++;
	cout<<"构造函数：Person()"<<endl;
} 
Person::Person(string _name,int _age){// 有参构造函数  
	cnt ++;
	name = _name;
	age = _age;
	cout<<"构造函数：Person(string _name,int _age)"<<endl;
}
Person::Person(const Person& p){ // 复制构造函数 
	cnt ++;
	name = p.name;
	age = p.age;
	cout<<"构造函数：Person(const Person& p)"<<endl;
}
Person::~Person(){ // 析构函数
	cnt --; 
// 析构函数：无法重载，析构顺序与构造顺序相反 
	cout<<"析构函数：~Person()"<<name<<endl; 
	cout<<Person::cnt<<endl;
}
int main(){
//	cout<<cnt<<end; // error
	cout<<Person::cnt<<endl; // 0
	
	Person p1; // 实例化对象，调用无参构造函数 
//	p1.name = "AAA"; // error
//	p1.age = 11;
	p1.setName("AAA");
	p1.setAge(11);
	p1.show();
	cout<<Person::cnt<<endl; // 1

	Person p2("BBB", 12);// 实例化对象，调用有参构造函数 
	p2.show();
	cout<<Person::cnt<<endl; // 2
	
	Person p3(p1);
	p3.setName("CCC");
	p3.show(); 
	cout<<Person::cnt<<endl; // 3
	cout<<p3.cnt<<endl; // 3 
	return 0;
}

this指针

同一类的各个对象创建后，都在类中产生自己成员的副本。
对象在副本中与成员函数建立关系是通过C++为成员函数提供的一个称为this的指针来进行的。

当创建一个对象时，this指针就初始化指向该对象。
当某一对象调用一个成员函数时，this指针将作为一个变元自动传给该函数。所以，不同的对象调用同一个成员函数时，编译器根据this指针来确定应该引用哪一个对象的数据成员。

this指针是由C++编译器自动产生且较常用的一个隐含对象指针，它不能被显式声明。
this指针是一个局部量，局部于某个对象。
this指针是一个常量，它不能作为赋值、递增、递减等运算的目标对象。
只有非静态类成员函数才拥有this指针，并通过该指针来处理对象。

友元

  1. 将普通函数声明为友元函数
#include <iostream>
using namespace std;  
// 将普通函数声明为友元函数的程序示例。
class Date {
   private:       // 数据成员
    int year;     // 年
    int month;    // 月
    int day;      // 日
   public:        // 公有成员
    Date(int y, int m, int d) : year(y), month(m), day(d) {}  // 构造函数
    friend void Show(const Date& dt);  // 输出日期,声明为友元
    void display(){
	    cout << year << "年" << month << "月" << day << "日" << endl;
	}
};
void Show(const Date& dt) {  // 输出日期
    cout << dt.year << "年" << dt.month << "月" << dt.day << "日" << endl;
}
int main() {
    Date dt(2009, 6, 18);  // 定义日期对象dt;
    Show(dt);              // 输出日期2009年6月18日
    dt.display();          // 通过成员函数访问 
    return 0;
}
  1. 将类Spouse声明为类Person的友元类
#include <cstring>
#include <iostream>
using namespace std;
// 将类Spouse声明为类Person的友元类
class Person;          // 对类Person的提前引用声明
class Spouse {         // 声明夫妻类
   private:            // 数据成员
    Person* pHusband;  // 丈夫
    Person* pWife;     // 妻子
   public:             // 公有成员
    Spouse(const Person& hus, const Person& wf);  // 构造函数
    ~Spouse() { delete pHusband; delete pWife; }  // 析构函数
    void Show() const;  // 输出信息
};

class Person {
   private:             // 数据成员
    char name[18];      // 姓名
    int age;            // 年龄
    char sex[3];        // 性别
   public:              // 公有成员
    Person(char* nm, int ag, char* sx) : age(ag) {  // 构造函数
        strcpy(name, nm), strcpy(sex, sx);
    }
    void Show() const { cout << name << " " << age << "岁 " << sex << endl; }
    friend class Spouse;  // 声明类Spouse为类Person的友元类
};

Spouse::Spouse(const Person& hus, const Person& wf) {
    pHusband = new Person(hus);  // 为丈夫对象分配存储空间
    pWife = new Person(wf);      // 为妻子对象分配存储空间
}

void Spouse::Show() const {  // 输出信息
    cout << "丈夫:" << pHusband->name << " " << pHusband->age << "岁" << endl;
    cout << "妻子:" << pWife->name << " " << pWife->age << "岁" << endl;
}

int main() {
    Person huf("张强", 32, "男");  // 定义丈夫对象
    Person wf("吴珊", 28, "女");   // 定义妻子对象
    Spouse sp(huf, wf);            // 定义夫妻对象
    huf.Show();                    // 输出丈夫信息
    wf.Show();                     // 输出妻子信息
    sp.Show();                     // 输出夫妻信息
    return 0;                      // 返回值0, 返回操作系统
}
  1. 将另一个类的成员函数声明为一个类的友元函数
#include <cstring>
#include <iostream>
using namespace std;
// 将另一个类的成员函数声明为一个类的友元函数
class Person;          // 对类Person的提前引用声明
class Spouse {         // 声明夫妻类
   private:            // 数据成员
    Person* pHusband;  // 丈夫
    Person* pWife;     // 妻子
   public:             // 公有成员
    Spouse(const Person& hus, const Person& wf);  // 构造函数
    ~Spouse() {
        delete pHusband;
        delete pWife;  // 析构函数
    }
    void Show() const;  // 输出信息
};
class Person {
   private:             // 数据成员
    char name[18];      // 姓名
    int age;            // 年龄
    char sex[3];        // 性别
   public:              // 公有成员
    Person(char* nm, int ag, char* sx) : age(ag) {  // 构造函数
        strcpy(name, nm), strcpy(sex, sx);
    }
    void Show() const {  // 输出信息
        cout << name << " " << age << " " << sex << endl;
    }
    // 声明类Spouse的成员函数Show()为类Person的友元函数
    friend void Spouse::Show() const;
};
Spouse::Spouse(const Person& hus, const Person& wf) {
    pHusband = new Person(hus);  // 为丈夫对象分配存储空间
    pWife = new Person(wf);      // 为妻子对象分配存储空间
}
void Spouse::Show() const {  // 输出信息
    cout << "husband:"<<pHusband->name<<" "<<pHusband->age<<" "<<endl;
    cout << "wife:" << pWife->name << " " << pWife->age << " " << endl;
}
int main() {                       // 主函数main()
    Person huf("张强", 32, "男");  // 定义丈夫对象
    Person wf("吴珊", 28, "女");   // 定义妻子对象
    Spouse sp(huf, wf);            // 定义夫妻对象
    huf.Show();                    // 输出丈夫信息
    wf.Show();                     // 输出妻子信息
    sp.Show();                     // 输出夫妻信息
    return 0;                      // 返回值0, 返回操作系统
}

名字空间

#include <iostream>
using namespace std;

namespace A {
    string a;
    void show() {
        cout << "A::show()" << endl;
    }
}

int main() {
    A::show();
    using namespace A;
    show();
    return 0;
}
  • 嵌套名字空间
#include <iostream>
using namespace std;

namespace A {
    string a;
    void show() {
       cout << "A::show()" << endl;
}
namespace B {
string b;
void show() {
  	    cout << "A::B::show()" << endl;
}
}
} 

int main() {
    A::show();
    A::B::show();

    using namespace A;
    show();
    B::show();
    return 0;
}
hello-hebin
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++面向对象程序设计教程——课件PPT
10-19
C++面向对象程序设计教程（第3版）——陈维兴、林小茶编著 清华大学出版社 这个是对应的PPT课件，文件为压缩包，里面每章一个PPT文件。
Visual C++ 面向对象编程教程——王育坚
01-20
学习MFC的不可多得的好教材，幻灯片形式，配合例题及讲解，试试看吧
C++面向对象——友元函数
x568059888的博客
03-13 873
1.友元可以是函数（友元函数），也可以是一个类（友元类）。 使用时在定义B时的public添加： [全局]friend void Func(); [友元类B的]friend class A; [A的成员函数]friend void A::Func(); 其中函数类又分为全局函数和成员函数 2.全局函数做友元时，全局函数的定义在类外部，它的声明有在类的定义中出现过，但并不是成员函数。 ...
面向对象——继承（c++）
weixin_48560325的博客
07-26 2100
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础，上进行扩展，增加功能。这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构。体现了由简单到复杂的认识过程。百度百科（继承）通过继承(inheritance)的机制可对类(class)分层，提供类型/子类型的关系。C++通过类派生(classderivation)的机制来支持继承。被继承的类称为基类(baseclass)或超类(superclass)，新产生的类为。......
C++入门——面向对象
beilizhang的博客
07-18 2189
面向对象 面向对象与面向过程，即对象 面向对象把数据即对数据的操作方法放在一起，作为一个相互依存的整体，即对象。对同类对象抽象出其共性，即类，类中的大多数数据都只能被本类的方法进行处理。类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信。抽象流程由用户在使用中决定 面向过程是一个以事件为中心的开发方法，就是自顶向下顺序执行，逐步求精，其程序结构是按功能划分为若干个基本模块，这些模块形成一个树状结构，各模块之间的关系也比较简单，在功能上相互独立，每一模块内部都是由顺序、选择和循环三
C++——类与对象
最新发布
Krisit的博客
07-12 684
本章主要讲解了类和对象的关系、类的定义与使用以及对象的概念和使用
C++面向对象总结——数据抽象与数据封装
明月清风@的博客
07-15 2020
引言 从抽象起就算是正式接触模块化编程了。 抽象的定义 抽象是指在程序中只向外界提供关键信息，而隐藏后台的实现细节，即只表现必要的信息而不呈现细节。 就 C++ 编程而言，C++ 类为数据抽象提供了可能。它们向外界提供了大量用于操作对象数据的公共方法，也就是说，外界实际上并不清楚类的内部实现。 在 C++ 中，我们使用类来定义我们自己的抽象数据类型(ADT)。简单的说，我们使用类iostream...
c++ 类和对象(上)
12-21
C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 在C++中对象的类型称为类（class）。类代表了某一批对象的共性和特征，总结一句话就是：类是对象的抽象，而对象是类的具体...
c++面向对象——模板
06-03
c++面向对象程序设计教程关于模板的教师ppt教程
DevC++的一些使用技巧
热门推荐
爱思考的小伙
12-03 1万+
文章目录1. 新建项目和源文件2. 编辑中的一些特点3. 搜索的使用4. 视图5. 运行(run)与调试（Debug）6. 配置界面语言7. 代码格式化8. 代码编辑时，光标变成黑方块或者下划线9. 字体格式和大小的修改10. 语法高亮提示11. 代码插入预定义模块12. 新建源文件自动插入代码模板13. dev运行时无法输出: Hello World 1. 新建项目和源文件 新建项目就不说了，直接快速使用新建源文件吧！ 为什么说要使用新建源文件呢？ 因为新建项目后，我们说过一个项目中只能由一个main函数
OI造数据以及Lemon评测教程
爱思考的小伙
07-01 2008
OI造数据以及Lemon评测教程 - hebin 前言 所谓数据，就是我们对解决某个问题的程序正确与否进行判断的依据。 不同的题目会考虑到时间和空间复杂度，所以需要对数据有严格要求，甚至部分数据只能人为创造。 本教程是基于C/C++和Python的造数据教程，如果不会，请先再继续向后看，再去学习对应的知识点即可。 并且在后文提供了软件Dev-C++ & Thonny(python集成ide) & Lemon的下载地址，Lemon教程在下载处就有。 A+B 最快入门的方式就是做一次题。所以这里
C++入门第一课：HelloWorld
爱思考的小伙
10-16 1455
文章目录1. devC++的下载安装2. C++输出 Hello World3. 数学符号：+ - * / %4. 注释5. 知识点 1. devC++的下载安装 这里我们也提供一个下载链接：devC++软件下载 也可以自己百度，打开浏览器，输入 ：dev，搜索，发现第一个就是官网，但是考虑到英文问题，我们不选择这里下载，继续向下翻页 然后我们看见了这样的链接，腾讯网页提供的dev下载链接 点进链接发现腾讯软件中心，向下翻，看见有安全下载和普通下载，选择普通下载，直接下载dev的安装包； 直接点击打
运算符，ASCII码表等常用编程资料
爱思考的小伙
10-27 1327
文章目录1. 常用的数据类型2. 运算符的优先级（从高到低）3. 常用字符与ASCII代码对照表 1. 常用的数据类型 数据类型 类型标识符 存储大小 数据范围 字符型 char 1B -2^8 ~ 2^8-1 短整型 short 2B -2^15 ~ 2^15-1 整型 int 4B -2^31 ~ 2^31-1 单精度浮点数 float 4B -3.4E+38 ~ 3.4E+38 双精度浮点数 double 8B -1.79E+308 ~ 1.79E+308 长整
C++造数据 和 对拍
爱思考的小伙
10-07 1063
C++造数据 和 对拍 0. 准备题目 吃早饭 同学们每天早上都会晨练，但是每次运动后都会很饿，于是他们回去吃早饭，信奥班的同学们当然很有素质，他们都遵守规矩排队。每个同学都面向窗口，一共有 N 个同学。现在你想知道每个同学能够看到的前面的同学的个数和是多少。 定义一个同学能够看到的人为在他前面且身高严格低于他的人，并且他的视线会被在他前面第一个身高大于等于他的人挡住。也就是说无论如何也无法看到再前面的人了。 输入：N+1 行 第一行一个正整数N表示同学的个数。 以下 N 行分别表示从后到前（窗口）同学的身
python造数据，并使用lemon评测，快速入门
爱思考的小伙
11-19 861
使用python造数据 最快入门的方式就是做一次题。 例：输入两个整数 a,b，输出它们的和，已知 0< a, b<1e+3 python代码 import random import os for i in range(1,11): # [1.11) with open ("%d.in" % i,"w") as fout: a = random.randint(1,1000) b = random.randint(1,1000) fou
C++入门第四课：三大结构
爱思考的小伙
11-01 728
文章目录1. 预习知识2. if3. for4. while 1. 预习知识 计算机编程三大结构： （1）顺序结构：从上至下，从左至右的执行程序 之前所学的程序都是顺序结构 （2）选择结构（分支结构）：按条件选择执行某段程序 需要使用 if(flag) { } 来判断 flag 的真假， 若为真，着执行接下来 {} 里面的语句，否则不执行。 （3）循环结构：循环执行某段程序 有以下三种方式： a. for(int i=0; i<length; i++){ } b. w
编程语言的介绍
爱思考的小伙
07-01 561
编程语言的介绍 所谓的编程语言其实就是一种人机交互的工具，类似于我们生活中的中文，英语，日语等，只是面向的对象由人与人之间变成了人与机器。 C语言 介绍：1972 年，为了移植与开发 UNIX 操作系统，丹尼斯·里奇在贝尔电话实验室设计开发了 C 语言。C语言是一门面向过程、抽象化的通用程序设计语言，广泛应用于底层开发。C语言能以简易的方式编译、处理低级存储器。C语言是仅产生少量的机器语言以及不需要任何运行环境支持便能运行的高效率程序设计语言。尽管C语言提供了许多低级处理的功能，但仍然保持着跨平台的特性，以
jmu-java-03面向对象基础-覆盖与equals
06-28
### 回答1： 覆盖和equals是面向对象编程中的两个重要概念。 覆盖指的是子类重写父类的方法，使得子类可以根据自己的需求来实现该方法。在覆盖时需要注意方法名、参数列表和返回值类型必须与父类方法一致，否则会编译错误。覆盖可以提高代码的复用性和可维护性。 equals是Object类中的一个方法，用于比较两个对象是否相等。默认情况下，equals方法比较的是两个对象的引用是否相等，即是否指向同一个内存地址。如果需要比较两个对象的内容是否相等，就需要在类中重写equals方法，并根据类的属性来比较对象的内容。在重写equals方法时，需要满足自反性、对称性、传递性和一致性等条件，否则可能会导致程序出错。 总之，覆盖和equals都是面向对象编程中非常重要的概念，掌握它们可以提高代码的质量和效率。 ### 回答2： 覆盖与equals是Java中面向对象编程的两个基础概念，它们的正确应用非常重要。 覆盖（Override）是指子类重写（覆盖）父类的方法。在Java中，子类可以重写其父类的方法，子类的方法名、参数类型和返回值类型必须与父类方法一致。通过覆盖，我们可以实现灵活的代码复用和更高效的代码运行。 在实际开发中，我们需要注意覆盖的一些规则：首先，被覆盖的方法必须有相同的方法名、参数列表和返回值类型；其次，覆盖的方法修饰符不能比被覆盖的方法更严格；最后，被覆盖的方法不能是final类型的。 equals是Java中的一个方法，它用于比较两个对象是否相等。在默认情况下，equals方法比较的是两个对象的引用地址，但是我们可以重写equals方法，来使其比较对象的内容是否相等。 当我们需要比较自定义的对象时，必须重写equals方法，因为默认的equals方法不能满足我们的需求。在自定义equals方法时，需要遵循几个规则：首先，比较对象时需要保证其一致性、反射性、对称性和传递性；其次，equals方法必须是自反的，并且不能与其他对象类型（如String类型）相等；最后，equals方法必须与hashCode方法一致。 总之，覆盖和equals方法是Java中面向对象编程的非常基础的概念，我们需要在实际开发中灵活应用，以实现更高效、更灵活和更安全的代码编写。 ### 回答3： 覆盖是指子类可以覆盖父类中的某些方法，使得子类在调用这些方法时，执行的是自己的实现而不是父类的实现。而equals()方法是用来比较两个对象是否相等的方法，它是Object类中的一个方法，在子类中也可以重写。 在覆盖中，子类通过重写父类中的某些方法，可以添加或修改方法中的行为。在Java中，子类中必须要实现父类中的抽象方法，否则子类就必须声明为抽象类。同时，子类通过super关键字可以调用父类中被覆盖的方法，从而实现在子类中添加新的行为。 在equals()方法中，如果不重写，则会默认调用Object类中的equals()方法，这种比较方式只比较两个对象的引用是否相等，而不是对象的值是否相等。因此，在比较两个对象的值时，需要在子类中重写equals()方法，并根据实际需求来实现比较两个对象的值是否相等。 在重写equals()方法时，需要遵循以下几点原则： 1. 自反性：对于任何非 null 的对象 x，x.equals(x) 必须返回 true。 2. 对称性：对于任何非 null 的对象 x 和 y，如果 x.equals(y) 返回 true，则 y.equals(x) 必须返回 true。 3. 传递性：对于任何非 null 的对象 x、y 和 z，如果 x.equals(y) 返回 true，y.equals(z) 返回 true，则 x.equals(z) 必须返回 true。 4. 一致性：对于任何非 null 的对象 x 和 y，只要对象的状态没有发生改变，则 x.equals(y) 多次调用时必须返回相同的结果。 5. 非空性：对于任何非 null 的对象 x，x.equals(null) 必须返回 false。 综上所述，覆盖和equals()方法都是非常重要的Java基础概念，对于Java程序员来说，熟练掌握这两个概念可以帮助我们更好地进行Java开发。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值