Note

开发分布式应用
distributed;
强类型机制 异常处理exception except

垃圾的自动收集
java对通过网络下载的类具有安全防范机制
通过网络下载的类有一个安全防范机制;
classLoader;
分配不同的名字空间以防替代本地的同名类,字节代码检查,并提供安全管理机制SecurityManager
在Java平台上被翻译为字节码格式 class后缀的文件;
java可移植
可移植性

类用于指定对象的形式 包含数据表示法和用于处理数据的方法,类中的数据和方法称为类的成员;
类用于指定对象的形式 包含了数据表示法和用于处理数据的方法 类中的数据和方法
类中的数据和方法称为类的成员
定义类本质定义一个数据类型 实际并没有定义任何数据 它定义了类的名称意味着什么
定义了类的对象包括了什么
类的成员函数是指那些把定义和原型写在类定义 内部的函数;、
类的成员函数
指那些把定义和原型写在类定义内部的函数
像类定义中的其他变量一样
类成员函数是类的成员
可以操作类的任意对象 ，可以访问对象中的所以成员;
使用成员函数访问类的成员，而不是直接访问类的成员

成员函数可以定义在类内部，或者单独使用
成员函数可以定义在类内部定义
成员函数可以定义在类定义内部,或者单独使用范围解析运算符::来定义
在类定义中定义的成员函数把函数
类定义中定义的成员函数把函数声明为内联 即便没有使用inline
类的外部使用范围解析运算符::定义函数;
类定义中定义的成员函数把函数声明为内联的
类的外部使用范围解析运算符::定义该函数
double Box::getVolume(void)
{
return length * breadth * height;
}

类的成员函数是指那些把定义和原型写在类定义内部的函数
像类定义中的其他变量
类成员可以被定义为public private protected;
Default private;
数据封装是面向对象编程的一个重要特点;
防止函数直接访问类类型的内部成员 类成员的访问限制是通过在类主体内部对各个区域标记public,private protected;
访问修饰符
每个标记区域在下一个标记区域开始之前或者在遇到类主体结束
成员和类的默认访问修饰符是private;

public protected public;
共有在程序中类的外部可以访问可以不使用任何成员函数来设置和获取公有变量的值
公有成员在程序中类的外部可以访问
可以不使用任何成员函数来设置和获取公有变量的值;

私有成员
私有成员变量或函数在类的外部是不可访问
私有成员变量或函数在类外部不可访问，甚至不可查看
只有类和友元函数可以访问私有成员
default 类的所有成员都是私有的 width private member;
类的成员将被假定为私有成员;
实际操作中 私有区域定义数据,在公有区域定义相关函数
在类的外部可以调用這个函数;
实际操作 私有区域定义数据,公有区域定义相关函数
只有类和友元函数
私有成员变量或函数在类的外部
保护成员protected
保护成员变量 函数 保护成员在派生类 -子类 可以访问
派生 子类;
private成员只能被本类成员(类内)和友元访问，不能被派生类访问
protected成员可以被派生类-子类访问;
数据封装 是面向对象编程的一个重要特点,防止函数直接访问类类型的内部成员
类成员的访问限制是通过在类主体内部对各个区域标记public private protected
关键字 称为访问修饰符
一个类可以有多个public protected private
public 公有成员在程序中类的外部是可访问的
公有成员在程序中类的外部是可以访问的,可以不使用任何成员函数来设置和获取公有变量的值
可以不使用任何成员函数来设置和获取公有变量的值

私有private成员
私有成员变量或函数在类的外部是不可访问的,甚至是不可查看
私有成员变量或函数在类的外部是不可访问的,只有类和友元函数可以访问私有成员;
很想知道 类是如何访问私有成员的
默认 类的所以成员都是私有的
class Box
{
double width;
public:
double length;
void setWidth(double wid);
double getWidth(void);
};私有区域定义数据,公有区域定义函数
私有成员
私有成员变量 或函数在类的外部是不可访问的,甚至是不可查看的,只有类和友元函数可以访问私有成员
默认情况下,类的所有成员都是私有的
在下面的类中,width是一个私有成员，如果你没有使用任何
保护成员
protected
类和友元中可以访问
类中访问就是把 类成员变量数据申明为私有,把设置类成员数据变量申明为公共
类 友元
派生 子类 保护成员变量或函数 保护成员在派生子类中可以访问;
派生和继承 父类中派生子类;
Box smallBox;

width成员可以被派生类smallBox的任何成员函数访问;
保护成员在派生类-子类中是可以访问的;
继承中的特点
public private protected成员修饰符,同样类有三种继承方式
改变了基类成员的访问属性
public继承:改变基类成员的访问属性
基类public protected private成员的访问属性在派生类中分别编程
public继承 基类public protected private 成员的访问属性在派生中分别变成public protected private;

protected继承 基类public protected privated成员的访问属性在派生类中分别为protected protected private

private继承 基类public protected privated;
private
无论那种继承方式,
private成员只能本类成员-类内和友元访问，不能被派生类访问;
private只能在本类和友元
protected成员可以被派生类访问;

类访问修饰符
构造函数析构函数;
constructor constructor structor constructor
destructor
constructor;
类的构造constructor函数是一种特殊的函数,在创建一个新的对象时调用,类的析构函数是一种特殊的函数,在删除所创建的对象调用;

构造函数 析构函数
构造函数特殊的函数 创建一个对象时调用 ，类的析构函数特殊的函数，删除所创建的对象调用;
c++类构造函数 析构函数
会在每次创建类的对象时执行
构造函数的名称与类的名称是完全相同，并且不会返回任何类型 也不会返回void 构造函数可用于为某些成员变量设置初始值
类的构造函数
类的一种特殊成员函数 会在每次创建类的新对象时执行
构造函数的名称与类的名称完全相同，并且不会返回任何类型，也不会返回void,构造函数可用于为某些成员变量设置初始值
构造constructor destructor functions;
类的构造函数是类的一种特殊的成员函数 会在每次创建类的新对象时执行
构造函数的名称与类的名称完全相同 并且不返回任何数据 也不返回void,构造函数可用于为某些成员变量设置初始值;

带参数的构造函数
默认的构造函数没有任何参数,如果需要,构造函数可以带参数
带参数的构造函数
默认的构造函数没有任何参数,如果需要，构造函数可以带参数，创建对象时 给对象赋予初始值
带参数的构造函数
默认构造函数没有任何参数,构造函数可以带参数,這样在创建对象时会给对象赋初始值
使用初始化列表来初始化字段
Line::Line(double len):length(len)
{

}

使用初始化列表来初始化字段

Line::Line(double len):length(len)
{
cout << "Object is being created,length = " << len << endl;
}

Line::Line(double len)
{
cout << "Object is being created,length = " << len << endl;

}

Line::Line(double len)
{
cout << "Object is being created,length = " << len << endl;
length = len;
}

类的析构函数
类的析构函数
每次删除所创建的对象时执行;
析构函数的名称与类的名称完全相同，只是在前面加了个波浪号(~)作为前缀~Line 不会返回值，也不能带任何参数;
析构函数 跳出程序-关闭文件，释放内存 前释放资源;

类的析构函数是类的一种特殊的成员函数，会在每次删除所创建的对象时执行
不返回 不带任何参数
析构函数有助于在跳出程序前释放资源 关闭文件，释放资源;
拷贝构造函数 创建对象时 使用同一类中之前创建的对象来初始化新创建的对象;
拷贝构造函数
c++拷贝构造函数,拷贝构造函数特殊的构造函数,创建对象时 使用同一类中
拷贝构造 创建对象时 使用同一类中之前创建的对象来初始化新创建的对象;
拷贝构造函数 创建对象时 使用同一类中之前创建 的 对象来初始化新创建的对象,拷贝构造函数
拷贝构造函数
创建对象时 使用同 一类中之前创建的对象来初始化新建对象,拷贝构造函数
使用另一个同类型的对象来初始化新建的对象，另一个同类型的对象来初始化新建的对象
复制对象作为参数传递给函数
复制对象，并从函数返回对象;
如果类中 类中带有指针变量,并动态内存分配 必须有拷贝构造函数
通过使用另一个同类型的对象来初始化新创建的对象;
复制对象把它作为参数传递给函数
复制对象,并从函数返回 這个对象;
拷贝构造函数
拷贝构造函数
特殊的构造函数,在创建对象,使用同一类中之前创建的对象来初始化新创建的对象 拷贝构造函数通常用于
通过使用另一个同一类型的对象来初始化创建对象;
复制对象把它作为参数传递给函数;
classname(const classname &obj)
obj是一个对象 对象用于初始化另一个对象
拷贝调用函数的调用时机
C++中 三种对象需要调用拷贝构造函数

A y = x;拷贝初始化,调用拷贝构造函数;
A x(2); //直接初始化,调用构造函数;
只包含类类型成员或内置类型成员的类
一个对象以值传递的方式传入函数体
一个对象以值传递的方式传入函数体

friend function;
类的友元函数定义在类外部,但有权访问类的所有私有成员和保护成员;

类的友元函数是定义在类外部，有权访问类的所有私有和保护成员
友元函数的原型有在类的定义中出现，但是友元可以是一个函数，friend function;
尽管友元函数的原型在类的定义中出现过,但是友元函数并不是成员函数
友元函数并不是成员函数,友元函数的原型在类的定义中出现过
友元函数并不是成员函数
友元函数的原型在类的定义
友元可以是一个函数,函数被称为友元函数,友元可以是一个类
申明函数为一个类的友元,需要在类定义中
在类定义中该函数原型前使用关键字friend; 友元

类的友元函数定义在类外部,有权访问类的所有私有,保护成员;

friend func
class Box
{
double width;
public:
double length;
friend void printWidth(Box box);
//参数是 类对象;
void setWidth(double wid);
};

内联函数,c++内联函数是通常与类一起使用,如果一个函数是内联的,那么在编译,编译器会把该函数的代码副本放置在每个调用函数的地方;
函数内联,编译器会把函数的代码副本放置在每个调用该函数的地方;
对内联函数进行任何修改,都需要重新编译函数的所有客户端
编译器需要重新更换一次所有代码,否则将会继续使用旧的函数
如果想把一个函数定义为内联的,需要在函数名前放置keyword inline 在调用函数之前需要对函数进行定义
如果已定义的函数多于一行,编译器会忽略
在类定义中定义的而不是声明的函数都是 内联函数，即使没有使用inline说明符;

c++内联函数
通常与类一起使用,如果一个函数是内联，在编译时,编译器会把该函数的代码副本放置在每个调用该函数的地方
在类定义中定义的函数都是内联函数,即使没有使用inline
C++内联函数通常与类一起使用,如果一个函数是内联的,那么在编译,编译器会把该函数的代码副本放置在每个调用该函数的地方;
对内联函数进行任何的修改,都需要重新进行编译,因为编译器需要重新更换一次所有的代码,否则将会继续使用旧 的函数

如果把一个函数定义为内联函数,则需要在函数面前放置关键字inline,在调用函数之前需要对函数进行定义
类定义中定义的函数都是 内联函数,即使没有inline说明符;

引入内联函数的解决程序中函数调用的效率问题,

程序在编译器编译时,编译器将程序中出现的内联函数的调用表达式用内联函数的函数体进行替换

编译器将程序中出现的内联函数的调用表达式用内联函数的函数体进行替换,而对于其他的函数,都是在运行时才被替换;
空间代价换时间，内联函数一般都是1-5行的小函数;

内联函数内不允许使用循环语句和开关语句;
内联函数的定义必须出现在内联函数第一次调用之前
函数申明为内联 编译器将内联展开,而不是按通常的函数调用机制进行调用
优点:当函数体比较小的时候
内联函数可以令目标代码更加高效,对于存取函数以及其它函数体比较短，性能关键的函数,鼓励使用内联
c++中,每一个对象都能通过this指针来访问自己的地址,this指针是所有成员函数的隐含参数
每一个对象都能通过this指针来访问自己的地址,this指针是所有成员函数的
每一个对象都能通过this指针来访问自己的 地址,this指针是所有成员函数的隐含参数
在成员函数内部可以用来指向调用对象
每一个对象都能 通过this指针来访问自己的地址,this指针是所有成员函数的隐含参数 在成员函数内部可以用来指向调用对象;
友元函数没有this指针 因为友元不是类的成员
只有成员函数才有this指针;
一个指向C++类的指针与指向结构的指针类似,访问指向类的指针的成员
使用指针之前，对指针进行初始化;

class static member;
C++类的静态成员
我们可以 static把类成员定义为静态的
申明类 的成员为静态时 意味着无论创建多少个类的对象 静态成员都只有ige副本
静态成员在类的所有对象中都是共享的 如果不存在其它的初始化语句，在创建第一个对象时 所有的静态数据都会被初始化为零;
静态成员在类的所有对象中是共享的 不能把静态成员的初始化放置在类的定义中
类的静态成员
static把类成员定义为静态
声明类的成员为静态时 无论创建多少个类的对象
静态成员都只有一个副本
静态成员在类的所有对象中都是共享的
如果不存在其他的初始化语句，在创建第一个对象时 所有的静态数据都会被初始化为零;
我们不能把静态成员的初始化放置在类的定义中 不能把静态成员的初始化放置在类的定义 可以在类的外部通过使用范围解析运算符::来重新声明静态变量从而对它进行初始化
在类的外部通过使用范围解析运算符::来重新声明静态变量从而对他进行初始化
静态函数成员
如果把函数成员声明为静态的
如果把函数申明为静态的可以把函数与类的任何特定对象独立开来
静态函数成员
如果把函数成员声明为静态的 就可以把函数与类的任何特定对象独立开来，静态成员函数
静态成员函数即使在类对象不存在的情况下也能被调用，静态函数只要使用类名加范围解析运算符::就可以
静态成员函数只能访问静态数据成员,不能访问其他静态成员函数和类外部的其他函数;

静态成员函数只能访问静态数据成员,不能访问其他静态成员函数和类外部的其他函数
静态成员变量在类中仅仅是声明，没有定义，所以要在类的外面定义
外面定义静态类成员数据变量 实际上是给类静态成员数据变量分配内存
declear define
初始化是赋予一个初始值,而定义是分配内存;
静态成员变量在类中仅仅是声明，没有定义，静态成员数据变量 需要在类外面进行定义
定义实际上是给变量分配内存空间;
初始化是赋予一个初始值 而定义是分配内存
access-specifier public protected private

C++重载 operator/function;
C++重载 overload operator function
允许在同一作用域的某个函数和运算符指定多个定义,分别称为函数和运算符重载
重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同的声明,但是他们的参数列表和定义不相同;
重载函数 函数 运算符
重载声明是指一个与之前已经在该作用域内声明的函数或方法具有相同名称的声明，但是他们的参数列表和定义不相同;
C++重载运算符和重载函数
允许在同一作用域中的某个函数和运算符指定多个定义,
重载声明是指一个与之前已经在该作用域内声明过 的函数和方法具有相同名称的声明，但是他们的参数列表和定义不相同
调用重载函数或重载运算符，编译器通过把你所使用的参数类型和定义中的参数类型进行比较，决定最合适的定义,选择最合适的重载函数和重载运算符的过程,重载决策;
operator overload;
使用自定义类型的运算符;
重载的运算符是带有特殊名称的函数,函数名是由关键字operator和其后要重载的运算符符号构成
C++中的 运算符operator overload重新定义和重载大部分C++内置的运算符使用自定义类型的运算符;
重载的运算符是带有特殊名称的函数, 函数是由关键字operator和其后
重载的运算符是带有特殊名称的函数
函数名称是由关键字operator和其后要重载的运算符符号构成,与其他函数一样 ，重载运算符有一个
运算符overload
重新定义或是重载大部分内置的运算符;
重载的operator 重载的运算符是带有特殊名称的函数
关系运算符重载
c++支持各种关系运算符 可用于比较C++内置的数据类型
比较C++内置的数据类型

C++关系运算符重载
C++语言支持各种关系运算符 可以比较C++内置的数据类型
可以重载任何一个关系运算符,重载后的关系运算符可用于比较类的对象;
使用私有标签定义的成员无法访问到使用类的代码,私有部分对使用类型的代码隐藏了实现细节
访问标签出现频率没有限制
每个访问标签指定了紧随 其后的成员定义的访问级别
如果只在类的私有部分定义数据成员,编写类的作者可以随意更改数据
如果实现发生改变,只需检查类的代码 看看改变会导致那些影响 数据公有 任何直接访问
所有定义在public标识符后边的变量或函数可以被程序中所有其他的函数访问;

把一个类定义为另一个类的友元类 从而降低了封装性

任何带有公有和私有成员的类都可以作为数据封装和数据抽象Instance;
C++接口-抽象类
abstract interface
接口描述了类的行为和功能,而不需要完成类的特定实现
接口描述了类的行为和功能，而不需要完成类的特定实现;

数据抽象是一个把实现细节与相关的数据分离开的概念
如果类中至少有一个函数被声明为纯虚函数

设计抽象类 Abstract()
为了给其他类提供一个可以继承的适当的基类
抽象类不能被用于实例化对象 只能作为接口使用 试图实例化一个抽象类的对象，导致编译错误
如果一个ABC的子类被实例化
具体类
数据抽象是一个把实现细节与相关的数据分离开的概念;
实现细节与相关的数据分离
类中至少有一个函数被声明为虚函数,则 這个类就是抽象类
类中至少有一个函数被申明为纯虚函数 ，类就是抽象类
纯虚函数就是通过在声明中使用"=0"来指定
抽象类
类中至少有一个函数被声明为纯虚函数,這个类就是抽象类

设计抽象类abc abstract abc 为了给其他类提供一个可以继承的适当的基类
设计抽象类的目的 是为了给其他类提供一个可以继承的适当的基类抽象类不能被用于实例化对象
只能作为接口使用
试图实例化一个抽象的对象
一个ABC的子类需要被实例化 则必须实现每个虚函数，意味着 C++支持使用ABC声明接口;
抽象类的子类需要被实例化，必须实现每个虚函数 意味着支持使用ABC声明接口
如果没有在派生类中重载纯虚函数，就尝试实例化类对象，会导致编译错误;
可用于实例化对象的类被称为具体类 抽象类
抽象类是为了给其他类提供一个可以继承的适当的基类 抽象类不能被实例化对象
从实例中 我们可以看到 一个抽象类是如何定义一个接口 两个派生类是如何通过不同的计算面积的算法来实现相同的函数

ofstream ifstream fstream;
std fstream;
OFstream 数据类型表示输出文件流创建文件并向文件写入信息

ifstream 数据 类型表示输入文件流 从文件读取
输出文件流，创建文件并向文件写入信息;
如果只需要打开文件进行读操作 ifstream对象;
ofstream fstream

design strategy:
面向对象的系统可能会使用一个抽象基类为所有的外部应用程序提供一个适当的，通用的 标准化的接口
派生类通过继承抽象基类 把所有类似的操作都继承
外部应用程序提供的功能-共有函数在抽象基类中是以纯虚函数的形式存在
cin cout分别用于从标准输入读取流 向标准输出写入流;
如何从文件读取流和向文件写入流

open()函数 的标准语法,open()函数fstream ifstream ofstream 对象 的一个成员;
void open(const char *filename,ios::openmode mode);
open()成员函数的第一个参数指定要打开的 文件的名称和位置，第二个参数定义文件被打开的模式
文件被打开的模式
void open(const char *filename,ios::openmode mode);
所有写入都追加到文件末尾
ios::app;
ios::ate 文件打开后定位到文件末尾
ios::in 打开文件用于读取
ios::out 打开文件用于写入
ios::trunc 如果文件已经存在，其内容将在打开之前被截断，即文件长度设为0
对象的方法
ofstream 用于写入文件
ifstrean
fstream

ios::in 读取
ios:out 打开文件写入;

ofstream outfile;//实例化类对象
//函数是对象的成员
outfile.open("file.dat",ios::out | ios::truc);//写入,或是如果文件 已经存在，其内容将被截断;把文件长度设为0;
打开文件读写
fstream afile;
afile.open("file.dat",ios::out | ios::in);//out 写入,in输出
程序终止时 自动关闭刷新所有流 释放所有分配的内存，关闭所有打开的文件
void close();