11类和对象

类和对象

1.基本概念

• 类、对象、成员变量、成员函数
• 面向对象三大概念
  封装、继承、多态
• 编程实践
  
  • 类的定义和对象的定义，对象的使用
  • 求圆形的面积
  • 定义Teacher类，打印Teacher的信息（把类的声明和类的实现分开）

2.类的封装

1.封装（Encapsulation）

• 封装，是面向对象程序设计最基本的特性。把数据（属性）和函数（操作）合成一个整体，这在计算机世界中是用类与对象实现的。

• 封装，把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

  备注：有2层含义（把属性和方法进行封装 对属性和方法进行访问控制）

• C++中类的封装
  * 成员变量，C++中用于表示类属性的变量
  * 成员函数，C++中用于表示类行为的函数

#include "iostream"

using namespace std;

//求圆形的面积
//封装有2层含义
//1 把属性和方法进行封装 
//2 对属性和方法进行访问控制

//3 类的内部和类的外部


//4 类的访问控制关键字
//public:  修饰的成员变量和函数 可以在类的内部和类的外部访问
//private:  修饰的成员变量和函数 只能在类的内部被访问,不能在类的外部访问
//protected:  修饰的成员变量和函数 只能在类的内部被访问,不能在类的外部访问, 用在继承里面


class MyCircle
{
public:
    double m_r; //属性 成员变量
    double m_s;

public:
    double getR()
    {
        return m_r;
    }
    void setR(double r) //成员函数
    {
        m_r = r;
    }

    double getS()
    {
        m_s = 3.14*m_r*m_r;
        return  m_s;
    }
protected:
private:
};

//类的封装的威力
//类封装的成员变量和成员函数  //可以调用类的成员函数
void printCircle01(MyCircle *pC)
{
    cout<<"r"<<pC->getR()<<endl;
    cout<<"s"<<pC->getS()<<endl;
}

void printCircle02(MyCircle &myc)
{
    cout<<myc.getS()<<endl;
}


void printCircle03(MyCircle myc)
{

}
void main_类的封装第一层含有()
{
    MyCircle c1, c2;
    c1.setR(10);
    cout<<"c1 s: "<<c1.getS()<<endl;

    c1.setR(11);
    printCircle01(&c1);


    c2.setR(20);
    printCircle01(&c2);


    //引用
    printCircle02(c2);

    cout<<"hello...."<<endl;
    system("pause");
}

2.类成员的访问控制

在C++中可以给成员变量和成员函数定义访问级别
Public修饰成员变量和成员函数可以在类的内部和类的外部被访问
Private修饰成员变量和成员函数只能在类的内部被访问

class MyAdvCircle
{
private:
    double m_r2; //没有权限修饰的成员变量 函数 是 默认是私有属性

private:
    double m_r; //属性 成员变量
    double m_s;  //相当于你的银行卡密码

public:
    double getR()  //你的名字
    {
        return m_r;
    }
    void setR(double r) //成员函数
    {
        m_r = r;
    }

    double getS()
    {
        m_s = 3.14*m_r*m_r;
        return  m_s;
    }
};

void main_02()
{
    MyAdvCircle c1, c2;
    //c1.m_r = 10; 
    c1.setR(10);

    system("pause");
}

3.struct和class关键字区别

• 在用struct定义类时，所有成员的默认属性为public
• 在用class定义类时，所有成员的默认属性为private

struct AAA
{
    int a;  //用struct关键字定义的类,不写,默认属性是public的.
            //class                                 private

public:
protected:
private:
};

void main()
{
    AAA a1;
    a1.a = 11;

    system("pause");
}

3.示例代码

案例1

• 设计立方体类(cube)，求出立方体的面积和体积
• 求两个立方体，是否相等（全局函数和成员函数）

#include <iostream>
using namespace std;

class myCube{
public:
    /*分别设置长、宽、高属性*/
    void setA(int tmp)
    {
        m_a = tmp;
    }
    void setB(int tmp)
    {
        m_b = tmp;
    }
    void setC(int tmp)
    {
        m_c = tmp;
    }
    void setABC(int a, int b, int c)//一次性设置三个属性
    {
        m_a = a;
        m_b = b;
        m_c = c;
    }


    /*获取长宽高的值*/
    int getA()
    {
        return m_a;
    }
    int getB()
    {
        return m_b;
    }
    int getC()
    {
        return m_c;
    }


    /*获取面积*/
    int getS()
    {
        m_s = 2 * (m_a*m_b + m_a*m_c + m_b*m_c);
        return m_s;
    }

    /*获取体积*/
    int getV()
    {
        m_v = m_a*m_b*m_c;
        return m_v;
    }


    /*成员函数判断两个立方体是否相等*/
    bool jugeCube(myCube &c2)
    {
        if ((m_a == c2.getA())
            && (m_b == c2.getB())
            && (m_c == c2.getC()))
        {
            cout << "Equal" << endl;
            return true;
        }
        else{
            cout << "Not Equal" << endl;
            return false;
        }
    }

private:
    int m_a;
    int m_b;
    int m_c;

    int m_s;
    int m_v;
protected:

};

/*全局函数判断两个立方体对象是否相等*/
bool jugeCube(myCube &c1, myCube &c2)
{
    if ((c1.getA() == c2.getA())
        && (c1.getB() == c2.getB())
        && (c1.getC() == c2.getC()))
    {
        cout << "Equal"<<endl;
        return true;
    }
    else{
        cout << "Not Equal" << endl;
        return false;
    }
}


int main(void)
{
    myCube v1, v2,v3;

    /*设置第一个立方体长宽高*/
    v1.setABC(1, 2, 3);
    cout << v1.getS() << endl;
    cout << v1.getV() << endl;

    /*设置第二个长方体属性*/
    v2.setABC(1, 2, 3);

    /*成员函数方式判断是否相等*/
    v1.jugeCube(v2);

    /*设置第三个立方体属性*/
    v3.setABC(2,3,4);

    /*全局函数方式判断是否相等*/
    jugeCube(v1, v3);


    system("pause");
    return 0;
}

案例2

• 设计一个圆形类（AdvCircle），和一个点类（Point），计点在圆内部还是圆外
• 即：求点和圆的关系（圆内和圆外）

1.点类的头文件

#pragma once

class MyPoint
{
public:
    void setX(int x);
    void setY(int y);
    void setPoint(int x, int y);

    int getX();
    int getY();

protected:
private:
    int m_x;
    int m_y;
};

2.点类的实现文件

#include "myPoint.h"


void MyPoint::setX(int x)
{
    m_x = x;
}
void MyPoint::setY(int y)
{
    m_y = y;
}
void MyPoint::setPoint(int x, int y)
{
    m_x = x;
    m_y = y;
}

int MyPoint::getX()
{
    return m_x;
}
int MyPoint::getY()
{
    return m_y;
}

3.圆类的头文件

#pragma once
#include "myPoint.h"
class MyCircle
{
public:
    void setCentral_X(int x);
    void setCentral_Y(int y);
    void setCentral_R(int r);
    void setCircle(int x,int y,int r);

    bool judge(MyPoint & point);

protected:
private:
    int m_r;
    int central_X;
    int central_Y;
};

4.圆类的实现文件

#include "myCircle.h"

void MyCircle::setCentral_X(int x)
{
    central_X = x;
}
void MyCircle::setCentral_Y(int y)
{
    central_Y = y;
}
void MyCircle::setCentral_R(int r)
{
    m_r = r;
}
void MyCircle::setCircle(int x, int y, int r)
{
    central_X = x;
    central_Y = y;
    m_r = r;
}

bool MyCircle::judge(MyPoint & point)
{
    int dist = 0;
    dist = (point.getX() - central_X)*(point.getX() - central_X) + (point.getY() - central_Y)*(point.getY() - central_Y);
    if (dist < m_r*m_r){
        return true;
    }
    else{
        return false;
    }
}

5.测试文件

#include <iostream>
#include "myPoint.h"
#include "myCircle.h"
using namespace std;



int main(void)
{

    MyCircle c1;
    MyPoint p1;

    c1.setCircle(2, 3, 3);
    p1.setPoint(2, 3);

    if (c1.judge(p1))
        cout << "inside the circle" << endl;
    else
        cout << "beyond the circle" << endl;

    system("pause");
    return 0;
}