1、什么是面向对象程序语言
2、面向对象语言的特征
抽象、封装、继承、多态
3、什么是类、对象和成员
人类就是一个类,他包含很对对象,比如张三、李四等都是人类的一个对象,这些对象有共同的功能和数据,比如身高,体重等,或者是可以喝水,吃饭等等,这些东西可以看做人类共有的方法或者函数。
类是由若干变量和相关函数组成,而对象可以拥有这些变量和函数。
4、声明一个类
# include<iostream>
using namespace std;
class Human
{
public:
void GetStature;
void GetWeight;
private:
int stature;
int weight;
//private:表示他后面的成员都是私有的,不能被对象直接访问,必须通过公有的成员函数才能访问
};
void mian()
{
}
5、命名习惯
# include<iostream>
using namespace std;
class Human
//Human全部大写或者全部小写都可以。
{
public:
void GetStature();
void GetWeight();
//以上叫骆驼命名法,首字母大写;还有一个叫get_stature,下划线命名法。
private:
int stature;
int weight;
};
void main()
{
}
6、定义一个对象
# include<iostream>
using namespace std;
class Human
{
public:
void GetStature(){cout<<stature<<endl;}
void GetWeight();//只是声明了一个函数
void SetStature(int x){stature=x;}
void SetWeight(int);//声明也要有参数
private:
int stature;
int weight;
};
void Human::GetWeight()
{
cout<<weight<<endl;
}
void Human::SetWeight(int x)
{
weight=x;
}
void main()
{
Human Mike;
Mike.SetStature(160);
Mike.GetStature();
Mike.SetWeight(80);
Mike.GetWeight();
//Mike.stature=4;是错误的,私有成员不能直接访问。
//以上是定义一个对象的两种方式
}
运行结果:
7、定义类或者对象容易犯的错误
类是个抽象的名词,不是具体的个体,我们不能对其进行复制操作;比如,我们不能int=9;一样
# include <iostream>
using namespace std;
class Human
{
public:
int weight;
void walk(){cout<<"走路"<<endl;}
};
int main()
{
//Human.weight=8;我们不能给一个类的成员赋值,只能给一个对象的成员赋值 才行。
Human Tom;
Tom.weight=8;//这样才是正确的
Tom.walk();
//Tom.sleep();这样是错误的,对象不能调用类中没有的成员.
}
8、公有和私有
# include <iostream>
using namespace std;
class Human
{
public:
int weight;
};
int main()
{
Human Tom;
Tom.weight=80;
cout<<Tom.weight<<endl;
Human Mike;
Mike.weight=90;
cout<<Mike.weight<<endl;
//每个对象都可以访问或者修改共有成员的变量,去掉public就会报错。因为类的成员默认为私有成员。私有成员不能被对象直接访问,只能通过在类中设定的接口函数来访问。
}
# include <iostream>
using namespace std;
class Human
{
public:
int set(int x){weight=x;return weight;}
private:
int weight;
};
int main()
{
Human Tom;
cout<<"Tom的体重为:"<<Tom.set(180)<<endl;
Human Mike;
cout<<"Mike的体重为:"<<Mike.set(160)<<endl;
}
运行结果:
以上两个程序都能输出两个人的体重,为什么要用接口函数呢?
# include <iostream>
using namespace std;
class Human
{
public:
void set(int x)
{
if(x>0&&x<100)
{
weight=x;
}
else
{
cout<<"请输入一个大于零小于一百的数字,否则默认返回零!"<<endl;
weight=0;
}
}
int show(){return weight;}
private:
int weight;
};
int main()
{
Human Tom;
Tom.set(190);
cout<<"Tom的体重为:"<<Tom.show()<<endl;
Human Mike;
Mike.set(80);
cout<<"Mike的体重为:"<<Mike.show()<<endl;
}
运行结果:
9、成员函数的定义和声明
# include <iostream>
using namespace std;
class Human
{
public:
void set(int);
int show();
private:
int weight;
};
void Human::set(int x)
{
if(x>0&&x<100)
{
weight=x;
}
else
{
cout<<"请输入一个大于零小于一百的数字,否则默认返回零!"<<endl;
weight=0;
}
}
int Human::show()
{
return weight;
}
int main()
{
Human Tom;
Tom.set(190);
cout<<"Tom的体重为:"<<Tom.show()<<endl;
Human Mike;
Mike.set(80);
cout<<"Mike的体重为:"<<Mike.show()<<endl;
}
运行结果:
本例只是上例的声明和定义分开来写的!
10、内联函数
为什么声明和定义要分开来写?
我们可以用inline来解决,使用inline声明一个函数时,
# include<iostream>
using namespace std;
inline int set();
//声明了一个内联函数
int set(){return 18;}
int main()
{
cout<<set()<<endl;
//这就相当于把return 18拷贝到set()部分 就相当于直接输出 cout<<return 18<<endl;是一样的。
return 0;
}
运行结果:
# include<iostream>
using namespace std;
inline int func(int);
int func(int x){return x;}
//内联函数体的代码大的时候不建议这么做,本例只有一条语句,使用内联函数是相当划算的
int main()
{
int x;
cout<<"请输入一个数字:"<<endl;
cin>>x;
cout<<endl;
cout<<"输入的数字为:"<<func(x)<<endl;
//由于定义的是内敛函数,程序运行时,会自动把定义部分的return x放到func(x)来执行,节省了一次跳转
//正常情况下,遇到func(x)要跳转到程序的定义部分,然后执行函数,最后在跳转回来。
return 0;
}
运行结果:
成员函数的内联函数
# include<iostream>
using namespace std;
class A
{
public:
inline void func(int);
inline int get();
private:
int x;
};
void A::func(int a)
{
x=a;
}
int A::get()
{
return x;
}
int main()
{
A a;
int x;
cout<<"请输入一个数字:"<<endl;
cin>>x;
a.func(x);
cout<<endl;
cout<<"输入的数字为:"<<a.get()<<endl;
return 0;
}
运行结果:
11、头文件与源文件
我们一般把类的声明和定义放到一个文件里,该文件的后缀是.h
将程序的执行部分放到一个另一个文件里,该文件的后缀为.cpp
这样你就可以在.cpp文件的顶端写下如下代码,使.h的文件与.cpp的文件相关联:
# include"*.h"(中间的*号是.h文件的名字)
一个.h文件可以同时被多.cpp的文件调用
human.h
# include<iostream>
using namespace std;
class A
{
public:
void func(int i,int j){x=i;y=j;}
void print(){cout<<"两个数相乘的结果为:"<<x*y<<endl;}
private:
int x;
int y;
};
human.cpp
# include "human.h"
int main()
{
A a;
a.func(3,4);
a.print();
return 0;
}
如果你不想让某个成员函数修改成员变量的值,那么不妨将这个成员函数声明为const
# include<iostream>
using namespace std;
class A
{
public:
void func(int i,int j){x=i;y=j;}//本来就是要改变私有成员,不能加const
void print()const{cout<<"两个数相乘的结果为:"<<x*y<<endl;}
//由于本成员函数不会去修改私有成员的值,因此我们不妨将给函数写成const成员函数,这样就无法修改私有成员变量,修改会报错
//编程时一定多使用const,对不应改变对象的成员函数都应声明为const 这样改变的话系统就会报错
private:
int x;
int y;
};
int main()
{
A a;
a.func(3,4);
a.print();
return 0;
}
运行结果:
13、构造函数
构造函数是一种特殊的成员函数,它主要用于为对象分配存储空间,对数据成员进行初始化.构造函数具有一些特殊的性质:
(1)构造函数的名字必须与类同名;
(2)构造函数没有返回类型,它可以带参数,也可以不带参数。
(3)声明类对象时,系统自动调用构造函数,构造函数不能被显式调用;
(4)构造函数可以重载,从而提供初始化类对象的不同方法;
(5)若在声明时未定义构造函数,系统会自动生成默认的构造函数,此时构造函数的函数体为空.
# include<iostream>
using namespace std;
class rectangel
{
public:
rectangel(int i,int j){length=i;width=j;}
int area()const{return length*width;}
private:
int length;
int width;
};
int main()
{
rectangel a(4,5);
cout<<"长方形的面积为:"<<a.area()<<endl;
}
运行结果:
# include<iostream>
using namespace std;
class rectangel
{
public:
//rectangel(int i,int j){length=i;width=j;}
//本例这样写,编译是没有错误的。假如我们不提供一个构造函数,体统会自动给我们分配一个默认的构造函数,该函数什么也没有,也不执行任何操作,它的作用就是构造了一个对象。rectangel(){} 可写可不写。当我们创建了一个构造函数,默认构造函数就会被消除。
int area()const{return length*width;}
private:
int length;
int width;
};
int main()
{
rectangel a;
//rectangel a(4,5);
//cout<<"长方形的面积为:"<<a.area()<<endl;
}
我们可以同时创建一个带参数和不带参数的构造函数,系统会自动知道到各自的调用
# include<iostream>
using namespace std;
class rectangel
{
public:
rectangel(int i,int j){length=i;width=j;}
rectangel(){cout<<"构造函数在运行..."<<endl;}
int area()const{return length*width;}
private:
int length;
int width;
};
int main()
{
rectangel a(4,5);
cout<<"长方形的面积为:"<<a.area()<<endl;
rectangel b;
}
运行结果:
14、析构函数
析构函数和构造函数相反,构造函数用于构造一个对象,析构函数则是用于对象被销毁后清除他所占的内存空间,比如说可以清除由构造函数创建的内存。
析构函数和构造函数一样不能有返回值,也不能有参数,一个类只能有一个析构函数
# include<iostream>
using namespace std;
class A
{
public:
A(){cout<<"构造函数运行中\n";}
~A(){cout<<"析构函数运行中\n";}
//viod ~A(){} 是错误的
//~A(int i){} 是错误的
};
int main()
{
A a;
return 0;
}
运行结果:
分析:右大括号表示程序结束,对象a的生命周期也就结束了,这时系统会调用该类的析构函数,释放掉该对象所占的内存
先声明后定义
# include<iostream>
using namespace std;
class A
{
public:
A();
~A();
};
A::A(){cout<<"构造函数运行中\n";}
A::~A(){cout<<"析构函数运行中\n";}
int main()
{
A a;
return 0;
}
运行结果:
析构对象数组
# include<iostream>
using namespace std;
class A
{
public:
A();
~A();
};
A::A(){cout<<"构造函数运行中\n";}
A::~A(){cout<<"析构函数运行中\n";}
int main()
{
A a[2];
//定义了两个对象a[0]和a[1];
return 0;
}
运行结果:
注释:程序执行了两次构造函数,程序结束时,又执行了两次析构函数释放掉两个对象所占的内存。