C++学习:类,对象,封装
C++学习:类,对象,封装
- 类
- 对象
封装
C++是一门集面向过程,面向对象以及泛型编程于一体的强大的编程语言,在这里面最重要的要属面向对象了吧???什么是面向对象?面向对象的思想是什么???总结下来就一句话:万物皆对象.在面向对象的世界里,一切都是可以用对象来解释的.这也是面向对象思想的精髓部分.
万物皆对象
1:类
举个例子:在超时里面进行商品购物的时候,它所有的商品都是按类目来划分的.生活用品,食品等.这就是按类别来分.而在自然界中也是.如:动物昆虫等.这就是类.将一类相似的的东西抽象成一类东西.
结构化程序设计
程序 = 算法 +数据结构
面向对象设计OOP
OBJECT ORIENRED PROGRAMING
Object oritened programing
程序 = 对象 +对象 +....
关键:让每个对象都负责执行一组相关的任务
面向对象开发范式的特性：
万物皆是对象
程序是一组对象彼此之间在发送消息
每个对象都有自己的内存占用，可以组装成更大的对象
每个对象都有类型,特定类型的对象都可以接收相同的消息
概念：
类：类是创建对象的模板和蓝图，类是一组相似对象的共同抽象定义
对象：对象是类的实例化结果，对象是实实在在的存在，代表现实世界的某一事物
对象的三大特性：
行为：对象能干什么
状态：对象的属性，行为的结果
标识：对象的唯一身份；
类和对象的区别：
类是静态定义
对象是动态实例
建立模型得到的是类而非对象
联系：
类是对象的定义
对象的产生离不开类这个模板
类存在的摸底是实例化得到对象
世界是由对象组成的
定义一个类的步骤:
1:定义类名
2:编写类的数据成员代表属性
3:编写类的方法代表行为
类的建模是一个抽象和封装的过程：
抽象：去掉不关注的，次要的信息而保留重要的信息
封装：信息打包
具体一点：将数据和行为结合在一个包中，对对象的使用者隐藏数据的具体实现方式
实现封装的关键：不能让类中的方法直接访问其他类的内部数据，只能通过公开行为方法间接访问：
例子:
class ClassName{
field1;
field2;
.....;
constructor;
.....
method1;
method2;
}
对象的两种类的形式：
1:结构体形式：
struct Saving{
unsigned accountNumber;
float balance;
};
缺点:安全性不好,任何人都是可以进行访问的
2:class形式：
class Savings{
public:
float deposit(float amount){
balance +=amount;
return balance;
}
private:
unsigned accountNumber;
float balance;
};
优点:类不仅可以保护数据,而且可以提供成员函数来操作
C++用类来定义抽象数据类型
C++早期的版本被成为带类的C
class 类名称{
public:
//共有函数
protected：
//保护成员
private:
//私有函数
//私有成员
int val;
};
类中定义成员函数：
class Tdate{
public:
void set(int m = 1,int d = 2,int y = 3){
month = m;
day = d;
year = y;
}
bool isLeepYear(){
return (year%4 ==0 &&year%100!=0) || (year %400==0);
}
void print(){
cout<在类中定义成员函数：
类中定义的成员函数一般都为内联函数，即使没有明确用inline标示
在C++中，类定义通常在头文件中，因此这些成员函数定义也伴随这进入头文件
在类之后定义成员函数：
C++允许在其他地方定义成员函数；
将类定义和其成员函数定义分开，是目前开发程序的通常做法
我们把类定义看成是类的外部接口，类的成员函数定义看成是类的内部实现
看一个最简单的实例:在main.cpp中去定义一个类.并且在此类中直接实现成员函数.(也可以通过Car.h和Car.cpp的形式去实现)
/*
* ===========================================================================
*
* Filename: main.cpp
* Description:
* Version: 1.0
* Created: 2017年05月26日 22时24分05秒
* Revision: none
* Compiler: gcc
* Author: (),
* Company:
*
* ===========================================================================
*/
#includevoid shut(){
cout<<"car shutdown"<void setProperty(int price,int carNum){
this->mPrice = price;
this->mCarNum = carNum;
}
private:
int mPrice;
int mCarNum;
};
int main(int argc,char *argv[]){
Car mCar;
/* *类的成员函数是不会占用内存的 */
cout <<"sizeof Car" <<sizeof(mCar)<cout << &mCar <10000,1000000);
mCar.run();
mCar.shut();
return 0;
} 通过Car.cpp及Car.h来实现一个简单类的封装
/*
* ===========================================================================
*
* Filename: Car.h
* Description:
* Version: 1.0
* Created: 2017年05月26日 22时43分53秒
* Revision: none
* Compiler: gcc
* Author: (),
* Company:
*
* ===========================================================================
*/
#ifndef __CAR_H__
#define __CAR_H__
#ifdef __cplusplus
extern "C"{
#endif
/* *
* 在头文件中去定义一个Car类型
* */
class Car{
private:
int mCarPrice;
int mCarNum;
int mCarType;
public:
void run();
void shut();
void setProperty(int price,int carNum,int carType);
void print();
};
#ifdef __cplusplus
}
#endif
#endif/*
* ===========================================================================
*
* Filename: Car.cpp
*
* Version: 1.0
* Created: 2017年05月26日 22时48分41秒
* Revision: none
* Compiler: gcc
* Author: (),
* Company:
*
* ===========================================================================
*/
#includeelse if(mCarType == 2){
cout << "car type is two" <else if(mCarType == 3){
cout << "car type is three" <void Car::print(){
cout <<"price:"<"\n";
cout <<"carnum:"<"\n";
cout <<"carType"< /*
* ===========================================================================
*
* Filename: CarTest.cpp
* Description:
* Version: 1.0
* Created: 2017年05月26日 23时18分01秒
* Revision: none
* Compiler: gcc
* Author: (),
* Company:
*
* ===========================================================================
*/
#includesetProperty(20000,20002,3);
mCar ->run();
mCar ->shut();
mCar ->print();
}
/* *
*使用引用的形式来调用成员函数,与对象的调用一致
* */
void userReference(Car &mCar){
cout << "==============="<10000,100001,2);
mCar.run();
mCar.shut();
mCar.print();
}
int main(int argc,char *argv[]){
Car mCar;
cout << "address:"<< &mCar <cout <<"size of mCar"<< sizeof(mCar) <80001,88888,1);
mCar.run();
mCar.shut();
usePoint(&mCar);
userReference(mCar);
return 0;
} 以上是简单的关于类和对象以及一个简单的封装的国政
在成员函数中访问成员：
成员函数必须用对象来调用
Car mCar;
mCar.run();
在成员函数内部，访问数据成员或成员函数无需如此
void setProperty(int price,int carNum){
this->mPrice = price;
this->mCarNum = carNum;
}
this指针代表当前对象占用内存空间的地址:
void Tdate::set(int m ,int d,int y){
this->month = m;
this->day = d;
this->year = y;
}
通过指针来调用成员函数：
例子:
#include"tdate.h"
#include
void func(Tdate *pDate){
pDate->print();
if(pDate->isLeepYear()){
cout<<"leepyear"< 通过引用来调用成员函数:
#include"tdate.h"
#include
void func(Tdate &pDate){
pDate.print();
if(pDate.isLeepYear()){
cout<<"leepyear"< 类的成员函数的重载：
类的成员函数可以像普通函数一样进行重载
但是不同的类即使有相同的函数名也不算重载
类的成员函数可以默认设置成员参数：
在类之外去定义这样一个类的行为
OOP三大特性(面向对象的三个特性)：
继承(inheritance)：
多态(polymorphism):
封装(encapsulation)：类背后隐藏的思想是数据抽象和封装
信息隐藏，隐藏对象的实现细节，不让外部直接访问
将数据成员和成员函数一起包装到 一个单元中 ，单元以类的形式实现
将数据成员和成员函数包装进类中，加上具体实现的隐藏，共同被称作封装，其结果是一个同时带有特征和行为的数据类型
封装类:定义类，定义其成员函数的过程称为封装类
细节:
除非必须公开底层的实现细节,否则应该将所有字段指定为private
使数据成员私有,控制数据访问限制.增强了类的可维护性
隐藏方法的具体实现.向外部提供公开的接口.以供安全调用
信息隐藏是OOP最重要的特性之一,也是可以使用访问修饰符的原因
访问修饰符号：
public
protected
private
信息隐藏的原因:
对模块的任何实现细节所做的更改不会影响使用该模块的代码
防止用户意外的修改数据
使模块易于使用和维护