【C++】核心编程——04类和对象【封装】

  C++面向对象编程的三大特征为：封装、继承、多态
  C++认为万事万物皆为对象，对象上有其属性和行为

1 封装

1.1 封装的意义

  封装是C++面向对象三大特性之一
  封装的意义：
  （1）将属性和行为作为一个整体，表现生活中的事物
  （2）将属性和行为加以权限控制
  封装意义一：
  在设计类的时候，属性和行为写在一起，表现事物
  语法：class 类名 {访问权限：属性 / 行为}

#include <iostream>
using namespace std;
const double PI = 3.14;

//设计一个圆类，求圆的周长
class Circle
{
public://访问权限

	//属性
	int r;
	//行为
	double calculateZC()
	{
		return 2 * PI * r;
	}
};

int main()
{
	//通过圆；类，创建具体的圆
	Circle c1;
	//给圆对象的属性赋值
	c1.r = 10;
	//调用圆的方法
	double result = c1.calculateZC();
	cout << "周长为：" << result;
}

  类中的属性和行为——统称为成员
  （1）属性——成员属性、成员变量
  （2）行为——成员函数、成员方法

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

//设计一个中学生类，属性有姓名和学好，可以给姓名和学好赋值，可以显示学生的姓名和学好
class Student
{
public://访问权限

	//属性
	string name;
	int id;
	//行为
	void show()
	{
		cout<<"姓名"<<name << "学号" << id <<endl;
	}
	void setName(string new_name)
	{
		name = new_name;
	}
};
int main()
{
	//通过学生类创建学生对象
	Student s1;
	//给学生对象的属性赋值
	s1.name = "张三";
	s1.id = 10086;
	//调用学生的方法
	s1.show();
	s1.setName("赵四");
	s1.show();
}

  封装意义二：
  类设计时，可以把属性和行为放在不同的权限下，加以控制
  访问权限分为3种：
  （1）public共有权限：成员——类内可以访问，类外可以访问
  （2）protected保护权限：类内可以访问，类外不可访问 子类也可以访问父类的保护成员
  （3）private私有权限：成员——类内可以访问，类外不可以访问 子类不可以访问父类的私有成员

#include <iostream>
#include <string>
using namespace std;
//访问权限
//公有权限public：成员——类内可以访问，类外可以访问
//保护权限protect:成员——类内可以访问，类外不可访问 子类也可以访问父类的保护成员
//私有权限private：成员——类内可以访问，类外不可以访问  子类不可以访问父类的私有成员
class Person
{
public:
	//公共权限
	string name;	
protected:
	//保护权限
	string car;
private:
	//私有权限
	int password;
public:
	//类内，三个种类型的成员都可访问
	void func()
	{
		name = "张三";
		car = "宝马";
		password = 10086;
	}
};
int main()
{
	//实例化对象
	Person p1;

	//
	p1.name = "李四";//公有权限，类外可以访问
	//p1.car = "奔驰";//保护权限，类外不可访问
	//p1.password=1002;//私有权限，类外不可以访问
}

1.2 struct和class的区别

  在C++中struct和class唯一的区别就在于默认的访问权限不同
  区别：
  （1）struct默认权限为公有
  （2）class默认权限为私有

#include <iostream>
#include <string>
using namespace std;
//struct默认权限是公有
//class默认权限是私有


class C1
{
	int m_A;//默认权限为私有
};

struct C2
{
	int m_A;//默认权限为公有
};
int main()
{
	//类
	C1 c1;
	//c1.m_A = 100;//私有权限在类外不可以访问

	//结构体
	C2 c2;
	c2.m_A = 100;//公有权限在类外可以访问
}

1.3 成员属性设置为私有

  优点：
  （1）将所有成员属性设置为私有，可以自己控制读写权限
  （2）对于写权限，我们可以检测数据的有效性

#include <iostream>
#include <string>
using namespace std;
//成员属性设置为私有
//1.自己控制读写权限
//2.对于写权限可以检测数据的有效性
class Person
{
private:
	string m_name;
	int m_age;
	string m_lover;
public:
	//姓名：设置可读可写
	void setName(string name)
	{
		m_name = name;
	}
	string getName()
	{
		return m_name;
	}

	//年龄:
	int getAge()
	{
		m_age = 0;//初始化年龄为0岁
		return m_age;
	}
	void setAge(int age)
	{
		if (age < 0 || age >150)
		{
			m_age = 0;//初始化年龄为0岁
			cout << "你输入的年龄有误" << endl;
			return;
		}
		m_age = age;
	}
	
	//情人：只写
	void setLover(string lover)
	{
		m_lover = lover;
	}
};

int main()
{
	//类实例化对象：该对象不能访问、操作私有权限的成员，但是可以利用公有的方法
	//操控私有权限的成员

	Person p1;

	//
	p1.setName("张三");
	cout << "姓名为：" << p1.getName() << endl;

	p1.setAge(1000);
	cout << "年龄为：" << p1.getAge() << endl;

	p1.setLover("小三");
}

1.4 封装案例

  案例1：设计立方体类，求出立方体的面积和体积，分别用全局函数和成员函数判断两个立方体是否相等

#include <iostream>
#include <string>
using namespace std;
//设计立方体类，求出立方体的面积和体积，
//分别用全局函数和成员函数判断两个立方体是否相等

class Cube
{
private:
	int m_L;
	int m_W;
	int m_H;
public:
	//设置高
	void setH(int h)
	{
		m_H = h;
	}
	//获取高
	int getH()
	{
		return m_H;
	}
	//设置宽
	void setW(int w)
	{
		m_W = w;
	}
	//获取宽
	int getW()
	{
		return m_W;
	}
	//设置长
	void setL(int l)
	{
		m_L = l;
	}
	//获取高
	int getL()
	{
		return m_L;
	}
	int square()//面积
	{
		return 2 * (m_L * m_W + m_H * m_W + m_L * m_H);
	}
	int volume()//体积
	{
		return m_H * m_L * m_W;
	}
	
	//利用成员函数判断两个立方体是否相等
	bool judge(Cube& c)
	{
		if (c.getH() == m_H && c.getL() == m_L && c.getW() == m_W) 
		{
			return true;
		}
		else
		{
			return false;
		}
	}
};

bool judge(Cube c1, Cube c2)//值传递，需要开辟内存空间，可以把参数改为 Cube &c1,Cube &c2这样不用开辟空间
{
	if ((c1.getH() == c2.getH()) && (c2.getL() == c2.getL()) && (c2.getW() == c2.getW()))
	{
		return true;
	}
	else
	{
		return false;
	}
}
int main()
{
	//1.实例化立方体
	Cube c1;
	c1.setL(20);//设置长宽高
	c1.setH(30);//设置长宽高
	c1.setW(10);//设置长宽高
	//2.立方体面积和体积
	cout << "立方体面积：" << c1.square() << endl;
	cout << "立方体体积：" << c1.volume() << endl;

	//3.分别用全局函数和成员函数判断两个立方体是否相等

	Cube c2;
	c2.setL(20);//设置长宽高
	c2.setH(30);//设置长宽高
	c2.setW(10);//设置长宽高
		//3.1 全局函数判断
	cout << "判断结果为：" << judge(c1, c2) << endl;
		//3.2 成员函数判断
	cout << "判断结果为：" << c2.judge(c1) << endl;

}

  案例2：点和圆的关系，设计一个圆类，和一个点类，计算点和圆的关系
  注意：圆的圆心是点

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

//点和圆的关系，设计一个圆类，和一个点类，计算点和圆的关系
class Point
{
private:
	int x;
	int y;
public:
	//设置x,获取x
	void setX(int new_x)
	{
		x = new_x;
	}
	int showX()
	{
		return x;
	}
	//设置y,获取y
	void setY(int new_y)
	{
		y = new_y;
	}
	int showY()
	{
		return y;
	}
};

class Circle
{
private:
	Point center;//圆心:类型为Point类
	int r;//半径
public:
	//设置半径，获取半径
	void setR(int new_R)
	{
		r = new_R;
	}
	int showR()
	{
		return r;
	}
	//设置圆心，获取圆心
	void setCenter(Point point)
	{
		center = point;
	}
	Point showCenter()
	{
		return center;
	}

};

//判断点和圆的关系
void judge(Point point, Circle circle)
{
	Point center = circle.showCenter();
	int x1 = center.showX();
	int y1 = center.showY();

	int x2 = point.showX();
	int y2 = point.showY();

	//1.计算两点之间的距离平方
	int distence = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
	//2.计算半径的平方
	int r_2 = circle.showR() * circle.showR();
	//3.两者之间的关系
	if (distence == r_2)
	{
		cout << "点在圆上" << endl;
	}
	else if(distence>r_2)
	{
		cout << "点在圆外" << endl;
	}
	else
	{
		cout << "点在圆内" << endl;
	}
}

int main()
{
	//1.圆
	Circle c1;
	c1.setR(5);
	Point p1;
	p1.setX(4);
	p1.setY(6);
	c1.setCenter(p1);

	//2.点
	Point p2;
	p2.setX(4);
	p2.setY(4);

	//3.判断两者关系
	judge(p2, c1);
}