学习笔记之Java和C++的区别

C++中的任意一个对象都应当具有这两个要素，即属性(attribute)和行为(behavior)，它能根据外界给的信息进行相应的操作。一个对象往往是由一组属性和一组行为构成的。一般来说，凡是具备属性和行为这两种要素的，都可以作为对象。每个对象都是由数据和函数(即操作代码)这两部分组成的，数据体现了前面提到的属性，调用对象中的函数就是向该对象传送一个消息，要求该对象实现某一行为(功能)。

Java表现了一种更加纯粹的面向对象程序设计方式，把一切事物都当成对象这是Java的另一种思维模式。对象呗视为奇特的变量，它可以存储数据，除此之外你还可以要求他在自身上执行操作。Java程序就是众多对象的集合，他们之间通过发送消息来告知彼此所要做的（想要请求一个对象就必须对该对象发送一条消息，实际上这个步骤跟C++类似就是调用该对象的方法或者函数）。对象具有状态、行为和标识，即任何对象都可以拥有内部数据（他们给出了该对象的状态）和方法（他们产生行为）。并且每一个对象都可以唯一的与其他对象区分开来，即每一个对象在内存中都有一个唯一的地址。

综上所述，C++中认为具有属性和行为两个要素的都可以被的称为对象，而Java更加纯粹扩大了范围认为万物都可以当成一个对象。

C++中类其实是从结构体中引申过来的，因此C++中的类其实就是一种数据类型，只不过这种复合型的数据类型中是一组不同类型的数据集合和若干个函数体。因为有了这些成员变量（属性），还有成员函数（行为）,这样就被称为了对象。

Java中所有的类都是直接或者间接的继承了java.lang.Object类，它是所有类的父类，是Java类层中的最高层类。当创建一个类时，总是在继承。Java中的类中可以定义若干变量和若干方法，不止符合了万物都是类，还符合了C++中定义的属性和行为。

1.1 对象的声明

无论是C++还是Java，都通过类(class)来表示对象的数据类型。C++中有几种基本类型数据(int/long/short/char)，还有结构体联合体枚举等数据类型，从结构体类型延伸出了class类型。Java中除了基本数据类型之外还有引用数据类型（类，接口，注解等），个人认为引用数据类型的本质其实还是跟指针地址等概念有些类似。

1.1.1 C++声明对象

class CCPObject           
{
public:                  //公有访问权限
    CCPObject();         //构造函数   如果没有声明构造函数编译器会默认生成一个空实现的构造函数
    CCPObject(int par1,char par2,float par3);
    CCPObject(int par1,char par2,float par3):var1(par1),var2(par2),var3(par3);
    ~CCPObject();        //析构函数   如果没有声明析构函数编译器会默认生成一个空实现的析构函数
    int var1;            //数据成员的声明
    int function1();     //成员函数的声明
private:                 //私有访问权限
    char var2;
    void function2();
protected:               //保护访问权限
    float var3;   
    void function3(int x);
}
//默认构造函数的实现
CCPObject::CCPObject(){ 
}
//析构函数的实现
CCPObject::~CCPObject(){ 
}
//带参数构造函数实现
CCPObject(int par1,char par2,float par3){
    var1 = par1;
    var2 = par2;
    var3 = par3;
}
//带参数和初始化列表构造函数 等价于上面带参数构造函数
CCPObject(int par1,char par2,float par3):var1(par1),var2(par2),var3(par3){
}
//类外成员函数的实现
int CCPObject::function1(){
}
void CCPObject::function2(){
}
void CCPObject::function3(int x){
}

1.1.2 Java声明对象

public class JavaObject{        //权限修饰符 class 类名标识符
    private int var1;           //私有成员变量
    public char var2;           //公有成员变量
    protected String var3;      //保护成员变量 子类和自己可以方法
    public JavaObject(){        //构造方法 如果没有定义编译器默认生产一个空实现的构造方法
    }
    public JavaObject(int par1,char par2,String par3){
        var1 = par1;
        var2 = par2;
        var3 = par3;
    }
    private void method1(){     //私有方法声明和实现
    }
    public int method2(int x){  //公有方法声明和实现
    }
}

1.1.3 Java对象的理解

在Java中有一句比较流行的话，叫做“万物皆对象”，这是Java语言设计之初的理念之一。要理解什么是对象，需要跟类一起结合起来理解。下面这段话引自《Java编程思想》中的一段原话：

　　“按照通俗的说法，每个对象都是某个类（class）的一个实例（instance），这里，‘类’就是‘类型’的同义词。”

　　从这一句话就可以理解到对象的本质，简而言之，它就是类的实例，比如所有的人统称为“人类”，这里的“人类”就是一个类（物种的一种类型），而具体到每个人，比如张三这个人，它就是对象，就是“人类”的实例。

何谓对象引用？

我们先看一段话：

　　“每种编程语言都有自己的数据处理方式。有些时候，程序员必须注意将要处理的数据是什么类型。你是直接操纵元素，还是用某种基于特殊语法的间接表示（例如C/C++里的指针）来操作对象。所有这些在 Java 里都得到了简化，一切都被视为对象。因此，我们可采用一种统一的语法。尽管将一切都“看作”对象，但操纵的标识符实际是指向一个对象的“引用”（reference）。”

　　这段话来自于《Java编程思想》，很显然，从这段话可以看出对象和对象引用不是一回事，是两个完全不同的概念。举个例子，我们通常会用下面这一行代码来创建一个对象：

Person person = new Person("张三");

　　有人会说，这里的person是一个对象，是Person类的一个实例。

　　也有人会说，这里的person并不是真正的对象，而是指向所创建的对象的引用。

　　到底哪种说法是对的？我们先不急着纠结哪种说法是对的，再看两行代码：

Person person;
person = new Person("张三");

　　这两行代码实现的功能和上面的一行代码是完全一样的。大家都知道，在Java中new是用来在堆上创建对象用的，如果person是一个对象的话，那么第二行为何还要通过new来创建对象呢？由此可见，person并不是所创建的对象，是什么？上面的一段话说的很清楚，“操纵的标识符实际是指向一个对象的引用”，也就是说person是一个引用，是指向一个可以指向Person类的对象的引用。真正创建对象的语句是右边的new Person("张三");

　　再看一个例子：

Person person;
person = new Person("张三");
person = new Person("李四");

　　这里让person先指向了“张三”这个对象，然后又指向了“李四”这个对象。也就是说，Person person，这句话只是声明了一个Person类的引用，它可以指向任何Person类的实例。这个道理就和下面这段代码一样：

int a;
a=2;
a=3;

　　这里先声明了一个int类型的变量a，先对a赋值为2，后面又赋值为3.也就是说int类型的变量a，可以让它的值为2，也可以为3，只要是合法的int类型的数值即可。

　　也就是说，一个引用可以指向多个对象，而一个对象可不可以被多个引用所指呢？答案当然是可以的。比如：

Person person1 = new Person("张三");
Person person2 = person1;

　　person1和person2都指向了“张三”这个对象。

1.1.4 总结

右上可以发现，C++和Java都可以通过权限访问符来对成员变量和成员函数（方法）进行修饰权限，唯一不同的就是C++可以在类外进行成员函数的实现，而Java觉得这样太复杂，因此简化了流程禁止类外实现成员方法。

除此之外，C++提供了构造函数和析构函数，其中构造函数还可以通过初始化列表对成员变量进行初始化，而Java并没有提供析构函数（Java中对象可以被GC自动回收，析构函数的事情GC自动已经做了，因此不需要手动去实现析构函数）和构造函数的初始化列表。因此如果你想要某个类清理一些东西，就必须显式的编写一个特殊方法来做这件事，并确保客户端程序员知道必须调用这一方法。

1.2 对象的存储

用类去定义对象时，系统会为每一个对象分配存储空间。如果一个类包括了数据和函数，要分别为数据和函数的代码分配存储空间。能否只用一段空间来存放这个共同的函数代码段，在调用各对象的函数时，都去调用这个公用的函数代码。显然，这样做会大大节约存储空间。C++编译系统正是这样做的，因此每个对象所占用的存储空间只是该对象的数据部分所占用的存储空间，而不包括函数代码所占用的存储空间。Java中类的方法存在一个专门的区叫方法区,事实上类刚装载的时候就被装载好了（不过它们在"睡眠"，只是这些方法必须当有对象产生的时候才会"苏醒"）。所以方法在装载的时候就有了只有实例对象调用方法的时候才可用。

1.2.1 C/C++存储机制

C++中的全局变量（包括基础数据类型和对象数据类型），其生命周期从程序启动开始到程序结束为止。全局数据（包括对象和基本数据类型）和静态局部数据（包括对象和基本数据类型）存放在全局存储区（静态存储区），初始化的全局对象和静态局部对象在一块区域，未初始化的全局对象和未初始化的静态局部对象在相邻的另一块区域，程序结束后由系统释放。

C++中的局部变量（包括基础数据和对象数据类型），其生命在作用域结束时结束，它的析构函数会自动被调用，即对象自动被清理。很显然局部数据（包括对象和基础数据）存放在栈中。

C++中的动态对象，其生命在new的时候开始，它被 delete 时候结束。动态对象存放在堆中，而用于创建动态对象的指针存放在栈中。程序中的指针 d 就是用来创建动态对象的，在 new 的时候被构造，而在 delete 的时候被析构。new 的对象，必须使用 delete 去显式的调用析构函数，否则程序不会去调用其析构函数，从而造成内存泄露。

1.2.2 Java内存机制

Java 把内存划分成两种：一种是栈内存，另一种是堆内存。

在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配，当在一段代码块定义一个变量（局部变量）时，Java 就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java 会自动释放掉为该变量分配的内存空间，该内存空间可以立即被另作它用。

堆内存用来存放由 new 创建的对象和数组，在堆中分配的内存，由 Java 虚拟机的自动垃圾回收器来管理。在堆中产生了一个数组或者对象之后，还可以在栈中定义一个特殊的变量，让栈中的这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或者对象，引用变量就相当于是为数组或者对象起的一个名称。引用变量是普通的变量，定义时在栈中分配，引用变量在程序运行到其作用域之外后被释放。而数组和对象本身在堆中分配，即使程序运行到使用 new 产生数组或者对象的语句所在的代码块之外，数组和对象本身占据的内存不会被释放，数组和对象在没有引用变量指向它的时候，才变为垃圾，不能在被使用，但仍然占据内存空间不放，在随后的一个不确定的时间被垃圾回收器收走（释放掉）。这也是 Java 比较占内存的原因，实际上，栈中的变量指向堆内存中的变量，这就是 Java 中的指针！

1.2.3 C++引用变量

上文中提到了引用的概念，这里不得不分别来解析一下C++引用变量与Java引用类型。

C++中的引用变量其实是一种隐式指针，通过操作符&来实现。它通常用于函数的参数表中和函数的返回值，但也可以独立使用。当引用被创建时，它必须被初始化，一旦被初始化为指向一个对象，它就不能被改变为对另一个对象的引用。这些规则都显示引用( & )像一个自动能被编译器逆向引用的常量型指针，只不过我们在使用过程中完全可以把它当成一个变量的别名（即普通变量）来处理，因为编译器自动给我做了隐式转换。正因为如此，引用不是一种数据类型而指针是一种数据类型。

C++中的引用变量在定义的同时必须进行初始化且不可更改，引用变量一旦被初始化后就是目标变量的别名，因此对引用变量的任何操作其实就是对目标变量的操作，C++编译器必须保证对引用变量的操作与对其目标变量操作完全一样，例如对引用变量使用取地址符运算，C++编译器必须解析成取出来的结果是目标变量的地址（详情参考）。如下：

#include <stdio.h>
int main(){
    int a=1;
    //初始化引用变量b，其目标变量是a
    //引用变量b其实是一个常量指针，将变量a的地址赋值给这个常量指针
    int &b = a;
    //对普通变量a取地址：取的是变量a的地址
    int *p = &a;
    //对引用变量b取地址：取的是引用变量b的值
    int *q = &b;
    printf("p=0x%x\n", p); //输出：p=0xcbe8a67c
    printf("q=0x%x\n", q); //输出：q=0xcbe8a67c
    printf("*p=%d\n",*p); //输出：1
    printf("*q=%d\n",*q); //输出：1
    return 0;
}

除此之外，C++编程规范通常建议使用引用变量来代替指针作为函数参数传递，在多重函数传递过程中，C++编译器始终保持着引用变量作为目标变量的别名来使用，即在任何情况下，对引用变量的操作等价于对目标变量的操作，如下：

#include <stdio.h>
void setX(int &x){
    x = 10;
}
void setY(int &y){
    y = 20;
}
//引用变量xy作为参数传递，注意千万不要认为这里是取xy的地址
void setXY(int &xy){
    setX(xy);
    setY(xy)
}
int main(){
    int a=5;
    setXY(a);
    printf("a=%d\n",a); // 输出：a=20
    return 0;
}

C++的引用变量除了能够作为函数参数进行传递还能声明为函数的返回值，即声明函数返回值为引用变量，那么在函数执行return的时候就会将return后面的变量的地址取出来并返回。如下：

#include <stdio.h>
//定义全局变量
int x = 10;
//返回值为引用变量的函数
int& getRefX(){
    return x; // return的时候返回的是全局变量x的地址
}
int& getRefQ(){
    int q = 30;
    return q; // return的时候返回的是局部变量q的地址
}
int& getRefC(){
    return 10; // 编译报错，引用函数的return必须是变量
}
int main(){
    printf("x = %d\n", x); //输出：x = 10
    //使用普通变量来接收引用函数
    int a = getRefX();     //等价：int a = x;
    a = 20;
    printf("x = %d\n", x); //输出：x = 10
    //使用引用变量来接收引用函数
    int &b = getRefX();    //等价：int &b = x;
    b = 30;
    printf("x = %d\n", x); //输出：x = 30
    //引用函数返回被销毁的变量
    int &q = getRefQ();
    printf("q = %d\n", q); //程序崩溃：因为q为局部变量的别名，且该局部变量已经被销毁了
    return 0;
}

1.2.4 Java引用类型

Java中有两种数据类型，分别是基本数据类型和引用数据类型（包括类、接口类型、数组类型、枚举类型、注解类型、字符串型）。引用数据类型在被创建时，首先要在栈上给其引用（句柄）分配一块内存，而对象的具体信息都存储在堆内存上，然后由栈上面的引用指向堆中对象的地址。由此可见，Java的引用类型其实采用了C++指针的原理，只不过这些转换都被虚拟机做了，因此Java虽然去掉了指针的概念，但是指针的思想无处不在。

1.2.5 总结

C++的数据类型包括基本数据类型（int这样的），复合型数据类型（数组、枚举、联合体、结构体）和指针以及对象
C++对象创建方式有两种：静态创建（显示或隐式调用，类名标识符对象名）方式在栈空间或者静态区或者全局区域分配空间；动态创建（通过new实例化）方式在堆空间分配空间
Java的数据类型包括基本数据类型（int这样的，多了布尔类型），引用数据类型（类、接口类型、数组类型、枚举类型、注解类型，字符串型）
Java的基本数据类型创建跟C++一样，通过（类名标识符对象名）方式分配空间，引用数据类型只能通过new的方式动态申请分配，这里虚拟机做了改进，不支持引用数据类型像C++那样静态创建
C++的全局变量（包括基本数据类型，复合型，和类），在全局区进行空间分配
C++的局部变量（包括基本数据类型，复合型，和类），在栈区进行空间分配
Java的全局变量（基本数据类型和引用数据类型的句柄），在全局区进行空间分配
Java的局部变量（基本数据类型，不包括引用数据类型），在栈区进行空间分配
C++的动态对象和Java的引用数据类型都通过new的方式动态创建一个对象，这些对象实例都是在堆中进行分配。C++可以通过一个指针变量来指向这个对象地址，Java内部通过独有的引用方式来访问这个对象地址。如果是在作用域内进行动态方式创建，那么C++的这个指针变量还是Java的这个引用变量都是存放在栈空间中，在作用域结束的时候C++需要通过delete手动进行对象的释放，而Java通过虚拟机自动进行释放。

1.3 对象的差异

1.3.1 对象的创建

C++可以静态方式和动态方式进行对象的创建，如下：

class CppObject {
public:
    //注意如果写了带参的构造函数没有参数的构造函数则时候编译器是不会自动创建无参构造函数（java也是这样子的）
    CppObject(int a,int b):x1(a),x2(b){}
    void show(){
        LOGE("x1=%d",x1);
        LOGE("x2=%d",this->x2);
    };
private:
    int x1;
    int x2;
};
void main(){
    //静态创建
    CppObject obj1(3,5);
    obj1.show();
    //动态创建
    CppObject *obj2 = new CppObject (3,8); //动态创建的时候只能用指针去赋值，因为可以理解new的返回值是一个地址
    obj2->show();
}

Java只能进行动态创建，如下：

class JavaObject {
    private int x1;
    private int x2;
    //注意如果写了带参的构造函数没有参数的构造函数则时候编译器是不会自动创建无参构造函数（C++也是这样子的）
    JavaObject(int a,int b){
        x1 = a;
        x2 = b;
    }
    void show(){
    };
};
void main(){
    //Java完全抛弃了指针，但是不表示没有了地址的概念
    //Java所有的类型数据变量都属于引用变量，即他是一个对象的句柄（实际上就是C++指针地址的意思）
    //Java虚拟机隐式的做了地址之间转换的事情，因此程序员操作引用类型变量就跟C++里面的静态创建的类似，但是他们有本质的不同
    //对于从C++转换到Java或者Java转换到C++的程序员如果不理解这一点，很容易出现世界观被颠覆的感觉，因为我以前就是
    //其实只要把Java中操作对象的方式看成C++中操作指针的方式一样来理解就豁然开朗了
    JavaObject obj = new JavaObject(3,9);
    obj.show();
}

1.3.2 this

对于类的非静态成员，每一个对象都有自己的一份数据拷贝，即拥有不同的地址空间（C++可能在堆也可能在栈或者全局区上，Java全部在堆中）。但是他们的成员函数或者方法却是每个对象共享的（代码区），那么调用共享的成员函数或方法是如何找到自己的数据成员的呢，其实就是通过类中隐藏的this指针。当不同的对象调用同一个成员函数或方法的时候，隐式的将this指针作为参数传递了进去，该成员函数或方法在引用成员变量的时候，隐式的做了些转换，当然这些对于我来说都是编译器或者虚拟机自己完成的，我们不用太过于关心。

当然我们也可以显示的使用this。在C++中this就是一个指针，因此在调用的时候需要this->xxx的方式使用；在Java中this其实是自己的引用（指向自己的句柄），在调用的使用需要this.xxx的方式使用。

1.3.3 对象的赋值

C++中如果对一个类定义了两个或多个对象，则这些同类的对象之间可以互相赋值，或者说，一个对象的值可以赋给另一个同类的对象。这里所指的对象的值是指对象中所有数据成员的值。对象之间的赋值也是通过赋值运算符“=”进行的。本来赋值运算符"="只能用来对单个的变量赋值，现在被扩展为两个同类对象之间的赋值，这是通过对赋值运算符的重载实现的。实际这个过程是通过成员复制来完成的，即将一个对象的成员值一一复制给另一对象的对应成员。

Java中也可以通过操作符"="取右边的值复制给左边，右边可以是任何常数变量或者表达式（只要它能生成一个值就行），但是左边必须是一个明确的已经命名的变量。对基本数据类型的赋值很简单，直接将一个地方的内容复制到了另一个地方。但是在为引用数据类型变量进行赋值的时候情况却发生了变化，在对一个对象进行操作时，我们真正操作的是对"对象"的引用，即将“引用”从一个地方复制到另一个地方，由以前的分析可以知道Java的引用内部其实也是通过地址来实现的，因此这就更加的像C++中的指针值传递了。（注意Java的引用本质上还是值传递，只不过引用句柄等价于地址而已）。

综上所述，C++中通过“=”给对象进行赋值，他们只是把对象里面的内容进行复制了一遍，这两个对象位于不同地址空间的变量。而Java中通过“=”给对象进行赋值，是把对象的引用复制了一遍，被赋值后的变量引用指向了新的堆空间，而以前的对象则与该变量断开了联系，最终被垃圾回收器释放（没有任何引用）。

1.3.4 Java的四种引用方式

强引用：是指创建一个对象并把这个对象赋给一个引用变量。强引用有引用变量指向时永远不会被垃圾回收，JVM宁愿抛出OutOfMemory错误也不会回收这种对象。如果想中断强引用和某个对象之间的关联，可以显示地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。

//强引用 通过=操作运算符可以实现将一个对象强引用给一个引用类型变量
Object object = new Object();
String str = "hello";
//如果想中断强引用和某个对象之间的关联，可以显示地将引用赋值为null
object = null;    
str = null;

软引用：如果一个对象具有软引用，内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存,比如网页缓存、图片缓存等。使用软引用能防止内存泄露，增强程序的健壮性。

//可以通过SoftReference来实现对“对象”的软引用
MyObject aRef = new  MyObject();  
SoftReference aSoftRef=new SoftReference(aRef);  
//此时对于MyObject对象，有两个引用路径：来自SoftReference的软引用，来自引用变量aRef的强引用
aRef = null;//断开aRef的强引用后，MyObject就只有一个软引用，随时都可能会被系统干掉

弱引用：弱引用也是用来描述非必需对象的，当JVM进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象。GC并不是只在内存不足的时候才会触发，在软引用跟弱引用的区别就是：只要GC触发弱引用都将被回收，而软引用可能不会被回收，只有在内存不足的时候才会被回收。

//弱引用跟软引用用法类似，通过WeakReference来实现，只要触发GC都会被回收
WeakReference<People>reference=new WeakReference<People>(new People("zhouqian",20));

虚引用：虚引用和前面的软引用、弱引用不同，它并不影响对象的生命周期。如果一个对象与虚引用关联，则跟没有引用与之关联一样，在任何时候都可能被垃圾回收器回收。

ReferenceQueue<String> queue = new ReferenceQueue<String>();
//虚引用通过PhantomReference实现，就跟没有引用一样，随时都会被回收，弱引用是在GC触发的时候发生
PhantomReference<String> pr = new PhantomReference<String>(new String("hello"), queue);

2、继承

继承在面向对象开发思想中是一个非常重要的概念，它使整个程序架构具有一定的弹性，在程序中复用一些已经定义完善的类不仅可以减少软件开发周期，还可以提高软件的可维护性和可扩展性。所谓继承就是在一个已存在的类的基础上建立一个新的类。一个新类从已有的类那里获得其已有特性，这种现象称为类的继承。通过继承，一个新建子类从已有的父类那里获得父类的特性。从另一角度说，从已有的类(父类)产生一个新的子类，称为类的派生。

2.1 子类的声明

构造一个派生类包括以下3部分工作：A 派生类把基类全部的成员(成员变量和成员函数方法，但不包括构造函数和析构函数)接收过来，不能选择接收其中一部分成员，而舍弃另一部分成员；B 接收基类成员是程序人员不能选择的，但是程序人员可以通过权限访问来对这些成员的访问作一些控制；C 在声明派生类时增加的新的成员。

在声明子类时，一般还应当自己定义子类的构造函数和析构函数（Java不需要），因为构造函数和析构函数是不能从基类继承的。子类是基类定义的延续。可以先声明一个基类，在此基类中只提供某些最基本的功能，而另外有些功能并未实现，然后在声明派生类时加入某些具体的功能，形成适用于某一特定应用的派生类。通过对基类声明的延续，将一个抽象的基类转化成具体的派生类。因此，派生类是抽象基类（不是Java的抽象基类，这里指的是一种封装思想，就是把相关的类的公共部分抽离出来封装成基类，通过不同的子类完善他们的不点）的具体实现。

C++子类的声明方式如下：

//继承方式包括: public (公用的),private (私有的)和protected(受保护的)
//此项是可选的，如果不写此项，则默认为private(私有的)
class 派生类名：［继承方式］ 基类名 {
    派生类新增加的成员变量
    派生类新增加的成员函数
};

Java子类的声明方式如下：

class 子类名 extends 父类名 {
    子类新增加的属性
    子类新增加的方法
}

很明显Java子类的声明方式远远比C++简单的多。C++提供了三种继承方式（public、private、protected）区别如下：

公用继承：基类的公用成员和保护成员在派生类中保持原有访问属性，其私有成员仍为基类私有
私有继承：基类的公用成员和保护成员在派生类中成了私有成员，其私有成员仍为基类私有
保护继承：类的公用成员和保护成员在派生类中成了保护成员，其私有成员仍为基类私有。保护成员的意思是: 不能被外界访问，但可以被自己和自己的子类的成员访问

不难看出C++的三种继承方式太复杂了，然而实际常用的只有公有继承方式，因此Java只保留了公有继承方式，这样的Java不光是降低了学习的难度，还使语言更加的简洁。

2.2 构造函数

无论是Java还是C++的构造函数，都会在对象被创建的时候隐式的被调用，C++一般用于对数据成员的初始化，Java通常除了对成员变量的初始化还作一些其他初始工作。

无论是Java还是C++在声明类时如果没有定义任何的构造函数，那么编译器就会创建一个默认的构造函数（空实现），在对象被实例化的时候系统会主动的调用该构造函数。如果定义了构造函数，那么这个默认构造函数都不会被创建（经常遇到父类实现了有参的构造方法或函数，子类实现无参构造方法或函数的时候编译报错，是因为子类构造函数会隐式的调用父类无参构造函数，然后系统没有给父类创建默认构造函数，用户自己也没有定义无参构造函数，所以出现子类找不到父类的构造方法）。

无论是Java还是C++的子类在被实例化的时候，都会先显示或隐式的调用父类的构造函数。在子类对象被释放的时候，C++的会先调用自己的析构函数之后再调用父类的析构函数。

C++可以通过初始化列表的方式去显示的调用父类指定参数的构造函数，如果不使用这种方式则子类会去隐式的调用父类的无参构造函数。其一般形式：派生类构造函数名（总参数表列）：基类构造函数名（参数表列）{派生类中新增数据成员初始化语句}

Java可以通过关键字super去显示的调用父类指定参数的构造方法，如果子类构造函数没有显示使用super关键字那么Java编译会主动隐式的在构造函数第一行通过super()调用父类的无参构造方法。

2.3 多重继承

C++允许一个派生类同时继承多个基类，这种行为称为多重继承。声明多重继承的方法如下：

//D是多重继承的派生类，它以公用继承方式继承A类，以私有继承方式继承B类，以保护继承方式继承C类。
//D按不同的继承方式的规则继承A,B,C的属性，确定各基类的成员在派生类中的访问权限。
class D:public A,private B,protected C {
    类D新增加的成员
}

多重继承派生类的构造函数形式与单继承时的构造函数形式基本相同，只是在初始表中包含多个基类构造函数，一般格式：派生类构造函数名（总参数表列）：基类1构造函数（参数表列），基类2构造函数(参数表列){派生类中新增数成员｝各基类的排列顺序任意，派生类构造函数的执行顺序同样为:先调用基类的构造函数，再执行派生类构造函数的函数体。调用基类构造函数的顺序是按照声明派生类时基类出现的顺序。

Java不允许子类同时继承多个父类，因为这也太复杂了，不符合Java的设计初衷。但是在有些某些具有多个对象特点的场景下，光靠单继承的方式貌似有些心有余力，Java提供了接口的方式实现了类似C++多继承这样的功能。

2.4 成员函数

除了构造函数和构造方法之外，C++还有成员函数，在Java中被称为成员方法的概念。那么就不得不说是函数/方法重载、重写、隐藏的概念了。

2.4.1 重载

重载相对来说比较简单，它只能在同一个作用域（子类和父类之间的函数无法称为重载，因为跨越了作用域），允许函数/方法名相同，其参数的类型或个数不同。注意返回值不同的函数/方法不能算作重载，因为编译器无法准确的判断你要调用函数的返回值具体类型。基于函数重载的理念，C++使用模板的方式，Java则提出了泛型的概念对其进行扩展。除此之外C++还提供了运算符重载的方案。

2.4.2 隐蔽

函数/方法的隐蔽，指子类的函数或方法屏蔽了与其同名的父类函数或方法。隐蔽一般多发生在C++中，Java程序员一般接触的比较少当然也有这种情况。当发生隐藏的时候，声明类型是什么类，就调用对应类的属性或者方法，而不会发生动态绑定（例如，一个对象不论实例是子类还是父类，在被声明为基类的变量调用访问的时候，则调用的是基类对应的函数或方法；在被声明为子类的变量调用访问的时候，则调用的是子类对应的函数或方法）。

C++规定基类的同名成员（包括成员函数和成员变量）在子类中被屏蔽，成为―不可见的，或者说，子类新增加的同名成员让基类中的同名成员被隐藏。因此如果在定义子类类对象的模块中通过对象名访问同名的成员，则访问的是子类的成员。如下例子：

class Base
{
public:
    void g(float x){ 
        cout << "Base::g(float) " << x << endl; 
    }
    void h(float x){ 
        cout << "Base::h(float) " << x << endl; 
    }
    void j(float x){
        cout << "Base::j(float) " << x << endl; 
    }
};
class Student : public Base
{
public:
    //与父类函数同名，父类函数被隐藏，如果用子类指针或者变量来调用该函数，那么父类的函数是无法被调用到的
    void g(float x){ 
        cout << "Derived::g(flaot) " << x << endl; 
    }
    //与父类函数同名，即使与父类函数参数不同，如果用子类指针或者变量来调用该函数，编译器只会找到该函数的实现，如果传递参数不是int的话，那么编译器会强转int，无法强转过来就会报错
    void h(int x){ 
        cout << "Derived::h(int) " << x << endl; 
    }
    //同上，父类函数j也被隐藏了，如果用子类指针或者变量来调用该函数，编译器只会接收float和int两个参数，否则将报错
    void j(float x,int y){
        cout << "Derived::j(float) " << x << endl; 
    }
};
int main(void)
{
    Student d;
    Base *pb = &d;
    Student *pd = &d;
    //父类的函数g被子类隐藏
    pb->g(3.14f);
    pd->g(3.14f);
    //父类的函数h也被子类隐藏 尽管他们的函数参数不同 但是参数个数相同
    pb->h(3.14f);
    pd->h(3.14f);
    //父类的函数j也被子类隐藏 他们的函数参数不同 参数个数也不相同
    pb->j(3.14f);
    pd->j(3.14f);//编译报错
    //子类定义了一个参数个数不同的同名函数导致父类函数被隐藏，因此这里的编译报找不到该函数
    //这个时候要么在子类重载该函数，要么在子类中去掉该函数，确保父类同名函数不会被隐藏
}
//输出结果：pb因为是父类指针，因此通过它调用的函数都是执行的父类的函数;pd是子类指针，因此通过它调用的函数都是子类的函数，因为父类的函数被隐藏了。
//然而这样的结果对于Java程序员来说可能是一个毁灭性的打击，因为我就面临过这样的困境
//个人理解C++中，在继承父类的时候，新对象包括了两部分（父类的成员与新增的成员），通过指针实现在赋值的过程中编译器作了一层内存强制转换的操作，即父类指针指向了这块内存中父类成员的首地址，子类指针指向了这块内存中子类成员的首地址，上面完全个人理解，也不知道是不是对的。

Java中的隐蔽通常只发生在类中静态方法上，子类存在一个静态方法，且该静态方法与父类的某个静态方法同名，这时父类的静态方法将会被隐藏。除此之外Java中的属性也只能被隐藏（子类与父类具有相同名称的变量，那么无论父类的这个变量是否被静态修饰，都将被隐藏，这一点跟C++差不多，但是特别注意的Java的实例方法却不是这样的）。如下例子：

public class Base{
	public static void staticMethod(){
		System.out.println("父类静态方法");
	}
	public void nomarlMethod(){
		System.out.println("父类普通方法");
	}
}
public class Student extends Base{
    //子类静态方法与父类静态方法重名，父类该方法被隐藏，在子类对象被转换成父类引用的时候，调用该方法打印的是父类的
    public static void staticMethod() {
        System.out.println("子类静态方法");
    }
    //非静态实例方法，无法被隐藏，其实这里是重写
    public void nomarlMethod(){
        System.out.println("子类普通方法");
    }
}
public static void main(String[] agrs){
    Student student = new Student();
    Base father = student;
    //静态方法被隐藏
    //其实对于Java程序员，基本上是通过类名去调用静态方法，所以隐藏的概念对于Java程序员来说基本上感觉不到
    student.staticMethod();
    father.staticMethod();
    //普通实例方法没有被隐藏
    student.nomarlMethod();
    father.nomarlMethod();
}

2.4.3 重写

函数/方法重写又叫覆盖，即子类重写父类的函数或者方法。在父类的函数/方法不适合子类的场景下，允许子类重写父类该方法，其参数的类型和个数还有返回值函数名完全一样。但是C++与Java实现确大不一样。

C++允许在类的继承层次结构中，在不同的层次中可以出现名字相同、参数个数和类型都相同而功能不同的函数。编译系统按照同名覆盖的原则决定调用的对象，上文介绍了这种情况在C++中其实是隐蔽，如果给这样的函数声明为虚函数，那么这种情况就成为了重写。虚函数的作用是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。如下例子：

class Base
{
public:
    virtual void funcA(int x){
        cout << "基类函数funcA被调用" << endl; 
    }
    virtual void funcB(int x){
        cout << "基类函数funcB被调用" << endl; 
    }
};
class Student : public Base{
public:
    //父类该函数被声明为虚函数，这里子类重写了父类该函数
    void funcA(int x){
        cout << "子类函数funcA被调用" << endl; 
    }
    //注意：尽管父类函数声明为虚函数，但是子类函数参数不相同，这里是隐蔽
    void funcB(float x){
        cout << "子类函数funcB被调用" << endl; 
    }
}
int main(void)
{
    Student stu;            //定义了子类对象
    Base base = stu;        //定义了父类对象 注意：这里的"="将stu的内容复制到了base（与java区分），在这里内存存在了两个对象实例分别是stu和base，他们里面的值一样
    Base *baseP = &base;    //定义了父类指针指向变量base
    Base *stuP = &stu;      //定义了父类指针指向变量stu
    //这里的base在内存中的原型其实还是按父类的方式分配，因为=操作符将stu强制转换成Base类型后再进行值复制
    base.funcA(1);          //调用父类函数
    base.funcB(1);          //同上
    //非指针方式无法体现函数的重写与隐藏，因此无法体现多态
    stu.funcA(1);           //调用子类函数
    stu.funcB(2);           //同上
    //指针baseP指向的是变量base,他在内存中的原型是Base，所以这里也不存在什么多态
    baseP->funcA(1);        //调用父类函数
    baseP->funcB(1);        //同上
    //指针stuP为基类类型，指向的确实子类地址，C++的多态开始体现出来
    stuP->funcA(1);         //因为子类重写了父类的函数，这里用基类指针调用了子类的函数
    stuP->funcB(1);         //虽然父类声明为虚函数，但是子类参数不同，所以这里变成了函数隐蔽
    stuP->funcB(1.0f);      //原理同上，函数隐蔽，用基类指针调用该函数，就只会在基类中查找该函数，如果参数不一致编译器进行强制转换，如果强制转换不了则编译器报错
}

Java同样允许子类对父类的方法的实现过程进行重新编写, 返回值和形参都不能改变（即外壳不变，核心重写！）。Java的引用变量有两个类型：一个是编译时类型（由声明该变量时使用的类型决定），一个是运行时类型（由该变量指向的对象类型决定）。其实Java虚拟机有一个RTTI（运行时检查），正是靠此Java程序在运行过程中，如果编译时类型和运行时类型不一致，RTTI会进行动态绑定，实现方法的覆盖，这是Java多态的核心。因此Java程序中的重写并不需要我们去做什么（因为虚拟机已经帮我们做了），所以Java中普通的类实例方法都可以进行重写与覆盖（注意：上文分析了类中静态方法属于隐藏，因为RTTI不支持隐藏）。如下例子：

public class Base{
	public static void staticMethod(){
		System.out.println("父类静态方法");
	}
	public void nomarlMethod(){
		System.out.println("父类普通方法");
	}
}
public class Student extends Base{
    //子类静态方法与父类静态方法重名，属于隐藏
    public static void staticMethod() {
        System.out.println("子类静态方法");
    }
    //非静态普通实例方法，其实这里是重写
    public void nomarlMethod(){
        System.out.println("子类普通方法");
    }
}
public static void main(String[] agrs){
    Student student = new Student();
    Base father = student;
    //子类与父类普通实例方法（参数个数一样，返回值可以不一样），默认子类重写了父类方法
    //特别注意：父类方法如果是private，那么子类无法覆盖该方法，这里编译器不会报错，这种情况最好重新命令
    student.nomarlMethod();
    father.nomarlMethod();
}

2.4.4 总结

C++与Java都支持函数/方法重装，即在同一个作用域（同一个类中），允许存在同名但参数不同的函数/方法。除此之外，C++还支持运算符的重装，Java确禁止了这样的使用
C++与Java都允许子类出现于父类同名同参同参数的函数/方法，但是效果不一样。在C++中的这种情况属于函数隐藏，即通过基类指针指向子类实例对象则基类的函数被调用，只有通过子类指针指向子类实例对象则子类函数被调用；在Java中因为有RTTI在运行时进行动态绑定，从而实现了方法重写，即子类对象在转换成基类引用之后，虚拟机中的RTTI能够检测出该对象其实是子类实例，因此基类引用在调用该方法的时候，RTTI动态实现调用了子类的方法。
C++为了实现多态的效果，引入了虚函数的概念。先定义了一个指向基类的指针变量，并使它指向相应的类对象，然后通过
这个基类指针去调用虚函数，显然对这样的调用方式，编译系统在编译该行时是无法确定调用哪一个类对象的虚函数的（因为编译只作静态的语法检查），在这样的情况下，编译系统把它放到运行阶段处理，在运行阶段确定关联关系。由于是在运行阶段把虚函数和类对象―绑定‖在一起的，因此，此过程称为动态关联（其实这就是C++中的RTTI）。

2.5 类型转型

在各种强类型语言中都离不开类型转换的概念，即从一种数据类型转换到另一种数据类型。类型转换一般涉及到向上转型和向下转型。

2.5.1 C/C++强制隐式转换

C语言中，主要是宽数据类型和窄数据类型之间的转换，从宽到窄依次：double>long long>float>long>int>short>char。C语言规定从窄的数据类型可以默认转换成宽的数据类型，这种叫隐式转换因为编译器默认给你处理了（这种转换比较安全可靠，编译器只需要在多出来的内存中填充0）；如果想从宽的数据类型转换为窄的数据类型，这个过程则不安全，需要使用强制转换表达式，保留低位数据，这种过程叫做显示转换。

C++也保留该种模式，为此还提供了四种转换模式：dynamic_cast（用于安全类型的向下转换）、const_cast（用于映射常量和变量）、static_cast（向上转型和类型自动转换(又叫隐式转换)）、reinterpret_cast（将某一类型映射回原有类型）。C++中的类其实也是一种数据类型，也可以发生数据类型转换，不过这种转换只有在基类和派生类之间才有意义。将派生类赋值给基类（包括将派生类对象赋值给基类对象、将派生类指针赋值给基类指针、将派生类引用赋值给基类引用）这在 C++ 中称为向上转型；相应地将基类赋值给派生类称为向下转型。C++中的赋值的本质是将现有的数据填入已分配好的内存中，当数据较多时很好处理，舍弃即可，所以不会发生赋值错误。但当数据较少时，问题就很棘手，编译器不知道如何填充剩下的内存。因此向上转型非常安全，可以由编译器自动完成（例如：将派生类对象赋值给基类对象时，会舍弃派生类新增的成员，所以不存在安全问题）；向下转型有风险，需要程序员手动干预，有时编译器认为只是错误（例如：基类不包含派生类的成员变量，无法对派生类的成员变量赋值。同理，同一基类的不同派生类对象之间也不能赋值）。如下例子：

class Base
{
public:
    virtual void funcA(int x){
        cout << "基类函数funcA被调用" << endl; 
    }
    virtual void funcB(int x){
        cout << "基类函数funcB被调用" << endl; 
    }
    void funcC(int x){
        LOGE("基类函数funcC被调用");
    }
};
class Student : public Base{
public:
    //父类该函数被声明为虚函数，这里子类重写了父类该函数
    void funcA(int x){
        cout << "子类函数funcA被调用" << endl; 
    }
    //注意：尽管父类函数声明为虚函数，但是子类函数参数不相同，这里是隐蔽
    void funcB(float x){
        cout << "子类函数funcB被调用" << endl; 
    }
    void funcC(int x){
        LOGE("子类函数funcC被调用");
    }
}
void main(){
    Base base;
    Student stu;
    Base objB = stu;                   //向上转型
    //Student objS = (Student)base;    //编译器报错，不允许向下转型
    Base &refB = stu;                  //向上转型
    //Student &stuRef = (Student)base; //编译器报错，不允许向下转型
    Base *pB = &stu;                   //向上转型
    Student *pS= (Student *)&base;     //向下转型，可以通过指针避免编译器检查
    //对象赋值向上转型，即将子类对象赋值给基类对象
    //因为对象赋值其实就是值传递，转型过程中，将子类对象属于父类对象那部分数据一一赋值到objB中
    //父类对象并没有子类对象的那部分公共成员函数，因此通过父类对象调用函数都是调用父类函数（无法体现多态）
    //即使父类函数A被声明了虚函数，因为这里的objB本质还是一个父类对象
    objB.funcA(1);
    objB.funcB(1);
    objB.funcC(1);
    //引用赋值向上转型，即将子类对象赋值给基类引用变量
    //引用赋值的本质其实还是对常指针进行赋值，即将子类对象的地址赋值给引用变量refB对应的常指针上
    //函数A被声明为虚函数，子类重写了该函数；函数B虽然也是虚函数，但是跟C一样属于函数的隐藏
    //因此函数A输出了子类的结果，函数BC没有被重写输出了基类的结果。函数A体现了多态
    refB.funcA(1);
    refB.funcB(1);
    refB.funcC(1);
    //指针赋值向上转型，即将子类对象地址赋值给基类指针
    //这里的结果通引用赋值向上转型，体现了C++的多态
    pB->funcA(1);
    pB->funcB(1);
    pB->funcC(1);
    //向下转型，将基类对象的地址赋值给子类指针
    //经过测试只有通指针赋值方式进行向下转型，向下转型非常不安全，所以这种用法非常少见，基本上不会这样干的
    //函数A定义为虚函数属于函数重写，在运行时检查pS指向对象实际上是父类对象，因此RTTI将动态绑定到父类的函数被调用
    //函数BC属于函数隐藏，这里用的子类指针，RTTI的动态绑定不适用函数隐藏，因此静态调用的子类函数
    pS->funcA(1);
    pS->funcB(1);
    pS->funcC(1);
}

2.5.2 Java的向上向下转型

Java中的基本数据类型转换其实也保留了C语言的这种模式，即在低级类型向高级类型的转换，系统将自动执行程序员无需进行任何操作（隐式转换）；当把高精度类型的变量赋值给低精度的变量时，就必须使用显式类型转换运算（又叫强制类型转换）。而Java中的对象类型转换也分为向上转型和向下转型。由子类转型成基类（在继承图上是向上移动的），一般称为向上转型，由于向上转型是从一个较专用类型向较通用类型转换，所以总是很安全（即子类可能比基类包含更多的方法，但它必须至少具备基类中所有的方法，在向上转型的过程中，类接口中唯一可能发生的事情就是丢失方法）。同样在继承图上是向下移动的过程称为向下转型，通常会出现问题，因为编译器无法知道给定的父类到底属于哪一个子类（例如父类是鸟，子类可能有鸽子或者乌鸦燕子等其他鸟，编译器无法知道到底是哪一种具体的鸟）。因此在向下转型的时候必须通过显示的类型转换，告知编译器具体的特定类型，编译器将坚持向下转型是否合理，如果不合理将抛出异常ClassCastException禁止向下转型，情况远远没这么糟糕，因为Java还提供了instanceof关键字用于检测是否属于某个特定子类。如下例子：

public class Base{
    public void nomarlMethod(){
        System.out.println("父类普通方法");
    }
}
public class Student extends Base{
    //Java的实例方法默认支持方法重写
    public void nomarlMethod(){
        System.out.println("子类普通方法");
    }
}
public static void main(String[] agrs){
    //向上转型，即将子类实例对象赋值给基类引用变量
    Base obj1 = new Student ();
    //通过基类引用变量调用了子类方法
    obj1.nomarlMethod();
    //向下转型，即将父类强制转换成子类
    //向下转型并不安全
    //Java提供了instanceof 用于动态判断引用变量对应的实例对象是否为指定类型
    if(obj1 instanceof Student ){
        Student  obj2 = (Student)obj1;
    }
}

2.5.3 RTTI

RTTI全称运行时类型识别，从上文的类型转换可以看出C++和Java都提供了对RTTI的支持，正因为RTTI，才使他们能够轻松的实现多态。

C++通过RTTI能够使用基类的指针或引用来检查这些指针或引用所指的对象到底是那种实际子类类型（向上转型），还提供dynamic_cast操作符将基类的指针或引用安全的转换为子类类型的指针或引用（向下转型）。当类中含有虚函数时，其基类的指针就可以指向任何子类的对象，这时就有可能不知道基类指针到底指向的是哪个对象的情况，类型的确定其实就是通过RTTI的typeid函数实现。即在转型的过程中，如果类中没有虚函数，那么类型通过编译器时确定，如果类中有虚函数，那么类型确定通过RTTI运行时动态确定。typeid函数的主要作用就是让用户知道当前的变量是什么类型的，如下例子：

//拥有虚函数的基类与子类
class Avirtual{
public:
    virtual void show(){};
};
class Bvirtual : public Avirtual{
public:
    void show(){};
};
//没有虚函数的基类与子类
class Anormal{
public:
    void show(){};
};
class Bnormal : public Anormal{
public:
    void show(){};
};
void test3(){
    //没有虚函数的类家族之间的类型转换，他们的数据类型有编译时决定，即不存在动态绑定
    Anormal an;
    Bnormal bn;
    Anormal objN = bn;                   //向上转型
    Anormal &refN = bn;                  //向上转型
    Anormal *pN = &bn;                   //向上转型
    //通过typeid获取出来的数据类型全是编译时决定的Anormal类型
    LOGE("typeid(objN)=%s",typeid(objN).name());
    LOGE("typeid(refN)=%s",typeid(refN).name());
    LOGE("typeid(pN)=%s",typeid(pN).name());
    LOGE("typeid(*pN)=%s",typeid(*pN).name());
    //拥有虚函数的类家族之间的类型转换，他们的数据类型在RTTI运行时动态确定
    Avirtual av;
    Bvirtual bv;
    Avirtual objV = bv;                   //向上转型
    Avirtual &refV = bv;                  //向上转型
    Avirtual *pV = &bv;                   //向上转型
    //变量objV在内存中实际就是虚函数基类对象类型
    LOGE("typeid(objV)=%s",typeid(objV).name());
    //引用变量refV在内存中引用的是子类对象
    LOGE("typeid(refV)=%s",typeid(refV).name());
    //指针变量pV的数据类型，被定义为Avirtual类型，因此获取出来的类型就是Avirtual
    LOGE("typeid(pV)=%s",typeid(pV).name());
    //指针变量pV指向的对象的数据类型是子类对象，因此RTTI动态绑定类型为Bvirtual 
    LOGE("typeid(*pV)=%s",typeid(*pV).name());
    //总结：虚函数的多态机制其实就是RTTI动态绑定实现
    //     即指针指向的对象和引用对象的数据类型在运行时，通过RTTI动态决定
    //     所以在通过基类指针或引用的子类对象的时候，调用虚函数的时候能够动态的调用子类函数，从而实现了多态

    //通过dynamic_cast关键字进行安全的向下转换 如果类型匹配则能转换成功，如果类型不匹配则转换失败，其返回值是0，跟Java中的instanceof模式一样
    Bvirtual *pVB2 = dynamic_cast<Bvirtual *>(pV);  
    Bvirtual *pVB3 = dynamic_cast<Bvirtual *>(&av); 
    if(pVB3 == nullptr)LOGE("pVB3=null");
}

Java同样也能在运行时识别对象和类的信息，主要通过两种方式：一种是传统的RTTI（嘉定编译时已经知道了所有类型），另一种是反射机制（允许我们在运行时发现和使用类）。在Java中类是程序的一部分，每个类都有一个Class对象，所有的类都是在对其第一次使用时，动态加载到JVM虚拟机中，动态加载使能的行为，在像C++这样的静态加载语言中是很难或者根本不可能赋值的。类加载器首先检查这个类的Class对象是否已经加载，如果尚未加载则根据类名查找.class文件，一旦某个类的Class对象被载入内存，它就被用来创建这个类的所有对象。因此无论何时，只要你想在运行时获取某个类信息或者对象信息，都可以通过反射机制实现；即使向上转型后，JVM也能很轻松的知道对象实例的具体类型，因为这一切对于动态加载的虚拟机都变得透明。

public class Base{
    public void nomarlMethod(){
        System.out.println("父类普通方法");
    }
}
public class Student extends Base{
    //Java的实例方法默认支持方法重写
    public void nomarlMethod(){
        System.out.println("子类普通方法");
    }
}
public static void main(String[] agrs){
    //向上转型，即将子类实例对象赋值给基类引用变量
    Base obj1 = new Student ();
    //向下转型,安全强制转换
    Student obj2;
    if(obj1 instanceof TestJava2){
        obj2 = (Student)obj1;
    }
    //即使类型被转换了，但是在调用方法的时候，RTTI能够动态绑定到子类的方法
    obj1.nomarlMethod();
    obj2.nomarlMethod();
    //向下转型，非安全强制转换 在进行强转的时候RTTI发现无法进行则抛出异常
    Student obj3 = (Student) new Base();
}

3、多态

多态性是面向对象程序设计的一个重要特征。多态性是指具有不同功能的函数可以用同一个函数名，这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性的:向不同的对象发送同一个消息，不同的对象在接收时会产生不同的行为（即像不同的对象调用同一个同名的函数或方法，这些对象执行这个同名函数或方法能够实现不同的功能）。

从系统实现的角度看，多态性分为两类:静态多态性和动态多态性。函数重载和运算符重载实现的多态性属于静态多态性，在程序编译时系统就能决定调用的是哪个函数，因此静态多态性又称编译时的多态性。动态多态性是在程序运行过程中才动态地确定操作所针对的对象，它又称运行时的多态性，人们提出这样的设想，能否用同一个调用形式，既能调用派生类又能调用基类的同名函数？当然这种方式是可以实现的，下面就分别介绍C++和Java的运行时多态性。

3.1 C++运行时多态（虚函数）

C++中不是通过不同的对象名去调用不同派生层次中的同名函数，而是通过指针调用它们。例如用同一个语句pt->display( );可以调用不同子类层次中的display函数，只需在调用前给指针变量pt赋以不同的值(使之指向不同的类对象)即可。C++中的虚函数就是用来解决这个问题的。虚函数的作用是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。

3.1.1 虚函数使用方法

由虚函数实现的动态多态性就是:同一类族中不同类的对象，对同一函数调用作出不同的响应。其使用方法如下：

在基类用virtual声明成员函数为虚函数。在类外实现虚函数时，不必再加virtual。
在子类中重新定义此函数，要求函数名、函数类型、函数参数个数和类型全部与基类的虚函数相同，并根据子类的需要重新实现函数体。当一个成员函数被声明为虚函数后，其派生类中的同名函数都自动成为虚函数，因此在子类重新声明该虚函数时，virtual关键字可加可不加，但习惯上一般在每一层子类声明该函数时都加virtual，使程序更加清晰。如果在子类中没有对基类的虚函数重新实现，则子类简单地继承基类的虚函数。
定义一个指向基类对象的指针变量（引用也可以），并使它指向同一类族中需要调用该函数的对象。
通过该指针变量调用此虚函数，此时调用的就是指针变量指向的对象的同名函数。

通过虚函数与指向基类对象的指针变量的配合使用，就能方便地调用同一类族中不同类的同名函数，只要先用基类指针指向即可。如果指针不断地指向同一类族中不同类的对象，就能不断地调用这些对象中的同名函数。需要说明：有时在基类中定义的非虚函数会在派生类中被重新定义如果用基类指针调用该成员函数，则系统会调用对象中基类部分的成员函数；如果用派生类指针调用该成员函数，则系统会调用派生类对象中的成员函数，这并不是多态性行为(使用的是不同类型的指针),没有用到虚函数的功能。

3.1.2 虚函数使用场景

首先看成员函数所在的类是否会作为基类。然后看成员函数在类的继承后有无可能被更改功能，如果希望更改其功能
的，一般应该将它声明为虚函数。
如果成员函数在类被继承后功能不需修改，或派生类用不到该函数，则不要把它声明为虚函数。不要仅仅考虑到要作为基类而把类中的所有成员函数都声明为虚函数。
应考虑对成员函数的调用是通过对象名还是通过基类指针或引用去访问，如果是通过基类指针或引用去访问的，则应当声明为虚函数。
在定义虚函数时，并不定义其函数体，即函数体是空的。它的作用只是定义了一个虚函数名，具体功能留给派生类去添加。

需要说明的是:使用虚函数，系统要有一定的空间开销。当一个类带有虚函数时，编译系统会为该类构造一个虚函数表，它是一个指针数组，存放每个虚函数的入口地址。因此C++的RTTI在进行动态关联时的时间开销是很少的，因此多态性是高效的。

3.1.3 虚析构函数

析构函数的作用是在对象撤销之前做必要的―清理现场‖的工作。但是如果用new运算符建立了临时对象，若基类中有析构函数，并且定义了一个指向该基类的指针变量。在程序用带指针参数的delete运算符撤销对象时，会发生一个情况:系统会只执行基类的析构函数，而不执行派生类的析构函数。可以将基类的析构函数声明为虚析构函数，当基类的析构函数为虚函数时，无论指针指的是同一类族中的哪一个类对象，系统会采用动态关联，调用相应的析构函数，对该对象进行清理工作。

如果将基类的析构函数声明为虚函数时，由该基类所派生的所有派生类的析构函数也都自动成为虚函数，即使派生类的析构函数与基类的析构函数名字不相同。最好把基类的析构函数声明为虚函数。这将使所有派生类的析构函数自动成为虚函数。

将析构函数声明为虚函数，一般叫做虚析构函数，即使基类并不需要析构函数，也显式地定义一个函数体为空的虚析构函数，以保证在撤销动态分配空间时能得到正确的处理。构造函数不能声明为虚函数，这是因为在执行构造函数时类对象还未完成建立过程，当然谈不上函数与类对象的绑定。

3.1.4 虚函数的示例

C++通过虚函数实现多态，即通过统一的方式（基类指针或引用）让不同的子类实现不同的功能，在我的这个示例中，封装了OpenSL ES的播放器和录音器功能，将OpenSL ES的实现步骤抽离出来并封装在基类SLBase，SLBase按照统一的模式进行OpenSL的引擎创建，输出输入设置，播放器/录音器的创建，缓存的设置等步骤，除此之外将播放器和录音器的不同之处的函数声明为虚函数，在具体的子类实现。最后在主函数中通过SLBase指针调用同一个方法进行任务的开启，最终实现了C++的多态，其Github地址：OpenSL播放器与采集器的封装

3.2 Java运行时多态（默认支持）

Java中的继承允许将对象视为它自己本身的类型或其基类类型来加以处理，这种能力极其重要，因为它允许将多种类型（同一基类的派生类）视为同一类型来处理，而同一份代码也就可以毫无差别的运行在这些不同类型之上。前面我们分析了Java的向上转型，同时引申出来了RTTI的运行时绑定机制，从其中了解到多态的实现主要来源于动态绑定。因为Java属于动态加载语言，所以实现动态绑定相比较C/C++这种静态语言有天生的优势。所以Java的类普通实例方法天生就支持多态，Java的实例方法并不需要我们干些什么，因为这是与生俱来的能力。

Java的多态相比起C++貌似更加的简洁和理解。个人认为最主要的原因还是Java中的类属于引用型数据类型，即对象引用只是存放一个对象的内存地址，并非存放一个对象，参考C++中的引用实现，其实我觉得可以直接把Java中的引用数据类型看成C/C++的指针模式，当然Java虚拟机隐式的帮我们做了很多工作，所以在Java程序员的眼中看到的就跟普通基本数据变量一样。

    class City{
        private String name;    //名称
        private String level;   //几线城市
        public City(String name,String level){
            this.name = name;
            this.level = level;
        }
        public void showEndorsement(){  //展示城市代言
            Log.e("SHEN_JAVA","我是"+name+",我只是一座小小的城");
        }
    }
    class ShangHai extends City{
        public ShangHai() {
            super("shanghai","1++");
        }
        public void showEndorsement(){
            Log.e("SHEN_JAVA","我是上海，我有东方的骄傲");
        }
    }
    class ShenZhen extends City{
        public ShenZhen() {
            super("shenzhen","1+");
        }
        public void showEndorsement(){
            Log.e("SHEN_JAVA","我是深圳，我拥有最快速度");
        }
    }
    class ChengDu extends City{
        public ChengDu() {
            super("chengdu","1");
        }
        public void showEndorsement(){
            Log.e("SHEN_JAVA","我是成都，我是新一线榜首");
        }
    }
    public static void main(String[] agrs){
        //创建一个基类集合
        List<City> chinaCityList = new ArrayList<>();
        chinaCityList.add(new ShangHai());
        chinaCityList.add(new ShenZhen());
        chinaCityList.add(new ChengDu());
        chinaCityList.add(new City("dongguan","2"));
        //遍历基类集合并通过基类引用调用普通实例方法，实现多态效果
        for(City city:chinaCityList){
            city.showEndorsement();
        }
    }

3.3 抽象类

如果声明了一个类，一般可以用它定义对象。但是在面向对象程序设计中，往往有一些类，它们不用来生成对象。定义这些类的惟一目的是用它作为基类去建立派生类。它们作为一种基本类型提供给用户，用户在这个基础上根据自己的需要定义出功能各异的派生类，用这些派生类去建立对象。

这种不用来定义对象而只作为一种基本类型用作继承的类，称为抽象类，由于它常用作基类，通常称为抽象基类。当然无论是C++还是Java作为最成功的两门语言，肯定也少不了对抽象类的支持，它们允许存在这样的函数或方法，只需要进行函数或方法的声明，而不用去实现它，这种函数或方法是不完整的，统称为抽象函数或方法。包括这样的抽象函数或方法的类叫做抽象类，因此抽象类是不允许被实例化，只有其子类将所有的抽象方法或函数全部实现，它们才能摆脱这种不完整的定义，才能被系统实例化。

3.3.1 纯虚函数（C++的抽象函数）

C++提供了纯虚函数的声明，被声明为纯虚函数可以不写出无意义的函数体，只给出函数的原型，并在后面加上“=0”，纯虚函数是在声明虚函数时被"初始化为0"的函数。其一般形式如下：

virtual 函数类型 函数名 (参数表列)=0;

纯虚函数没有函数体；最后面的“=0”并不表示函数返回值为0，它只起形式上的作用，告诉编译系统这是纯虚函数，留待子类中实现；这是一个声明语句，最后应有分号。纯虚函数只有函数的名字而不具备函数的功能，不能被调用，在子类中对此函数提供实现后，它才能具备函数的功能，可被调用。纯虚函数的作用是在基类中为其派生类保留一个函数的名字，以便派生类根据需要对它进行定义。如果在基类中没有保留函数名字，则无法实现多态性。如果在一个类中声明了纯虚函数，而在其派生类中没有对该函数定义，则该虚函数在派生类中仍然为纯虚函数。

不用来定义对象而只作为一种基本类型用作继承的类，称为抽象类，凡是包含纯虚函数的类都是抽象类。因为纯虚函数是不能被调用的，包含纯虚函数的类是无法建立对象的。如果在抽象类所派生出的新类中对基类的所有纯虚函数进行了定义，那么
这些函数就被赋予了功能，可以被调用。这个派生类就不是抽象类，而是可以用来定义对象的具体类。如果在派生类中没有对所有纯虚函数进行定义，则此派生类仍然是抽象类，不能用来定义对象。虽然抽象类不能定义对象(或者说抽象类不能实例化)，但是可以定义指向抽象类数据的指针变量。当派生类成为具体类之后，就可以用这种指针指向派生类对象，然后通过该指针调用虚函数，实现多态性的操作。如下：

class AbBase{
public:
    virtual void show()=0;        //声明为纯虚函数 该类也变成了抽象类 因此不能被实例化或定义
};
class AbStudent : public AbBase{
    void show(){                  //子类给出了纯虚函数的实现 该类将不再是抽象类 能够被实例化
        LOGE("AbStudent-show");
    }
};

void main(){
    AbStudent student;        //子类已经实现纯虚函数（抽象函数）不再是抽象类，能够被定义
    AbBase base1;             //基类没有实现纯虚函数 这里编译器将报错
    AbBase &base2 = student;  //将子类赋值给抽象基类引用 这种做法是OK的
    AbBase *base3 = &student; //将子类的地址赋值给抽象基类指针 这种做法也是OK的
    AbBase *base4 = new Student();//将子类实例化的地址赋值给抽象基类指针 这种做法也是OK的
    //通过抽象基类指针变量或基类引用调用已经实现抽象方法的子类实例对象，实现多态效果
    base2.show();
    base3.show();
    base4.show();
}

3.3.2 抽象方法（Java的抽象方法）

Java也提供了一个叫做抽象方法的机制，这种方法是不完整的，仅有声明而没有方法体，这样的方法用关键abstract修饰。其一般形式如下：

abstract 方法返回值 方法名称(参数列表);

同样包含抽象方法的类叫做抽象类，如果一个类包含一个或多个抽象方法，该类必须被限定为抽象类（否则编译器报错）。因为如果一个类拥有抽象方法变得不完整，那么我们试图产生该类的对象时，编译器是无法进行处理，为此Java编译器为了确保抽象类的纯碎性，强制要求我们用abstract关键字来限定这个类。如下：

    //定义抽象类，拥有三个抽象方法，抽象类一般用于抽象一些公有代码出来形成基类因此又叫抽象基类
    abstract class AbBase{
        abstract void init();
        abstract void start();
        abstract void stop();
        public void run(){
            init();
            start();
            stop();
        }
    };
    //子类实现了基类的三个方法，如果只实现了两个方法，那么编译器强制要求在该类前面加上abstract 
    class Student extends AbBase{
        @Override
        void init() {
            Log.e("SHEN_JAVA","系统初始化");
        }
        @Override
        void start() {
            Log.e("SHEN_JAVA","系统开始运行");
        }
        @Override
        void stop() {
            Log.e("SHEN_JAVA","系统停止运行");
        }
    }
    void test2(){
        AbBase base1 = new AbBase();    //抽象类无法被实例化，因此这里编译器会报错
        AbBase base2 = new Student();   //通过抽象类引用变量执行实例化的子类
        base2.run();
    }

3.3.3 纯虚函数 VS abstract方法

其实C++的纯虚函数与Java中的abstract方法其实没有本质的区别，他们都是为了解决同一个问题而产生的，只是在不同的语言中实现方式不一样，即可以认为纯虚函数就是C++中的抽象方法的具体实现，abstract就是Java中的抽象方法的表示。当然，个人觉得无论怎么看都发觉Java比C++简单的太多了，在C++中涉及到三种情况（对象变量、对象引用变量、对象指针变量），而在Java中虚拟机干了一件天大的好事，就是统一了在C++中出现的这三种情况从而只对程序员开放了一种特有的类型，那就Java的引用数据类型（本质还是地址的指向），哈哈，这不止简化了开发流程，更加的易于理解。

3.4 接口

接口为我们提供了一种将接口与实现分离的更加结构化的方法，但是这种机制在编程语言中并不通用，例如C++对此只有间接的支持，在Java中却存在interface关键字对其提供了直接支持。

Java中的interface关键字使抽象的概念更向前迈进了一步，它将产生一个完全抽象的类，该类根本就没有提供任何具体实现（即接口提供了一系列没有任何实现的方法）。一个接口表示：“所有实现了该特定接口的类看起来都像这样”，因此接口通常被用来建立类与类之间的协议。但是interface不仅仅是一个极度抽象的类，因为它允许我们通过创建一个能够被向上转型为多种基类的类型，来实现某种类似多重继承变种的特性。

就像Java编程思想的作者所说的，Java的接口通常被用来建立类与类之间的协议。当然C++中其实没有类似interface的这样概念，对于C++程序员口中所说的接口通常指的函数或者虚函数或者回调函数吧（千万不要搞混淆了）。

Java中创建一个接口，需要用interface关键字来代替class关键字（就像定义类一样）。可以在interface前面加上public，如果不添加public，则它只有包访问权限（即只能在同一个包内可用）。接口也可以包含域（成员变量），但是他们被隐式的被static和final修饰（即接口中的成员变量被编译器隐式的声明为静态常量，可以通过该接口名进行显示显示的访问）。

Java中的接口不仅仅是一种更纯粹的抽象类，它的目标远远不止于此。因为接口是根本没有任何具体实现，因此也就无法阻止多个接口的组合。这一点很有价值，因为你有时候需要去表示“一个X是A的同时还是一个B以及一个C”，在C++中被称为多重继承（这种方式很复杂，因为每个类都有一个具体的实现），Java通过接口的方式远远降低了这样的复杂性，在Java中你可以执行相同的行为，但是只有一个类可以具体实现，所以可以组合多个接口。如下例子Java通过接口实现C++中的多重继承：

    interface Body{     //身体
        void showBody();
    }
    interface Antler{   //角
        void showAntler();
    }
    interface Head{     //头
        void showHead();
    }
    interface Eye{     //眼
        void showEye();
    }
    interface Squama{   //鳞片
        void showSquama();
    }
    interface Unguis{   //爪
        void showUnguis();
    }
    interface Hand{     //掌
        void showHand();
    }
    interface Ear{      //耳朵
        void showEar();
    }
    abstract class Animal{  //动物
        abstract void show();
    }
    class Snake extends Animal implements Body{
        @Override
        public void showBody() {
            Log.e("SHEN_JAVA","蛇身");
        }
        @Override
        void show() {
            Log.e("SHEN_JAVA","我是一条小蛇，但有点像龙");
            showBody();
        }
    }
    //实现类似C++中的多重继承
    class Dragon extends Animal implements Antler,Head,Eye,Body,Squama,Unguis,Hand,Ear{
        @Override public void showAntler() { Log.e("SHEN_JAVA","鹿角"); }
        @Override public void showHead() { Log.e("SHEN_JAVA","驼头"); }
        @Override public void showEye() { Log.e("SHEN_JAVA","兔眼"); }
        @Override public void showBody() { Log.e("SHEN_JAVA","蛇身"); }
        @Override public void showSquama() { Log.e("SHEN_JAVA","鱼鳞"); }
        @Override public void showUnguis() { Log.e("SHEN_JAVA","鹰爪"); }
        @Override public void showHand() { Log.e("SHEN_JAVA","虎掌"); }
        @Override public void showEar() {Log.e("SHEN_JAVA","牛耳"); }
        @Override
        void show() {
            Log.e("SHEN_JAVA","我是传说中的合体神兽：龙");
            showAntler();
            showHead();
            showEye();
            showBody();
            showSquama();
            showUnguis();
            showHand();
            showEar();
        }
    }
    void test3(){
        //可以通过接口引用变量调用接口方法，实现多态
        List<Body> bodyList = new ArrayList<>();
        bodyList.add(new Snake());
        bodyList.add(new Dragon());    //龙实现了该接口，因此能够被当做Body来处理
        for(Body body:bodyList){
            body.showBody();
        }
    }

4、指针与回收机制

首先在C语言中，函数的内存都是分配在栈中的，当该函数执行完之后，该函数所占用的内存就会被回收掉C语言有跨函数使用的一种功能，而实现这种功能的就是指针。

C/C++的指针

这种功能的优点是使用malloc函数来进行动态分配内存，而所分配的内存是存放在堆中的，故当函数执行完之后，使用动态分配的内存是不会被回收掉的.例如:

int add(int i,int * k){
  k = (int *)malloc( sizeof(int) );
  int j = i;
}

当函数add执行完之后，指针k所指向的内存是不会被回收掉的，但是指针k本身是会被回收的，指针本身占用4个字节，作为形参来进行传递，只是传递的是地址而已。

这里可能有人会有点不理解，因为指针的值是其他变量的地址，而指针本身也只是一个变量而已，但正因为它拥有其他变量的地址，那么它便可以操作这个地址进行分配内存空间。而这个空间的分配不是分配给该指针自己，也是分配给该指针的所拥有其他变量的地址，它自己作为一个变量在函数执行完后还是要被系统回收的。在java中也是类似的。

Java的引用
在java中，实际上每一个new 语句返回的都是一个指针的引用，故对象是可以在函数中进行传递的，也就是引用传递。

所以在java中，基本类型数据存放在栈中，存放的是数据。而产生对象时，只把对象的引用存放在栈中，用于指向某个对象，对象本身存放在堆中。

还有, 调用方法时传递的参数以及在调用中创建的临时变量都保存在栈(Stack)中，速度较快。其他变量，如静态变量、实例变量等，都在堆(Heap)中创建，速度较慢。另外，依赖于具体的编译器/JVM，局部变量还可能得到进一步优化。
从实现上来讲，引用可以理解为一种受限的指针，引用底层可以采用指针来实现，也可以采用句柄的方式实现。
指针是可以进行与整数做加减运算的，两个指针之间也可以进行大小比较运算

和相减运算。引用不行，只能进行赋值运算。

例如：A a=new A(); 我们对对象a不能进行加减运算，而在同一块连续的内存

空间的指针却可以，如果不连续则做加减其实也没有什么意义

静态变量和字符串是在数据区里面的
if else这些代码是放在代码区里面的
栈里面的变量只能在一个方法里面使用，是不能跨函数的
所以栈里面的占用内存(变量等)是由操作系统释放的
堆里面的占用内存(如new A())等由java的垃圾回收器进行回收的
而在c和c++中堆是由程序员手动释放的，
A a = new A();
a是在栈用,new A()是在堆中，里面包含类A以及A里面的变量和方法
a这个变量指向到堆中的内存,并且a只占用4个字节

4.1 垃圾回收的意义

　　在C++中，对象所占的内存在程序结束运行之前一直被占用，在明确释放之前不能分配给其它对象；而在Java中，当没有对象引用指向原先分配给某个对象的内存时，该内存便成为垃圾。JVM的一个系统级线程会自动释放该内存块。垃圾回收意味着程序不再需要的对象是"无用信息"，这些信息将被丢弃。当一个对象不再被引用的时候，内存回收它占领的空间，以便空间被后来的新对象使用。事实上，除了释放没用的对象，垃圾回收也可以清除内存记录碎片。由于创建对象和垃圾回收器释放丢弃对象所占的内存空间，内存会出现碎片。碎片是分配给对象的内存块之间的空闲内存洞。碎片整理将所占用的堆内存移到堆的一端，JVM将整理出的内存分配给新的对象。
　　垃圾回收能自动释放内存空间，减轻编程的负担。这使Java 虚拟机具有一些优点。首先，它能使编程效率提高。在没有垃圾回收机制的时候，可能要花许多时间来解决一个难懂的存储器问题。在用Java语言编程的时候，靠垃圾回收机制可大大缩短时间。其次是它保护程序的完整性，垃圾回收是Java语言安全性策略的一个重要部份。
　　垃圾回收的一个潜在的缺点是它的开销影响程序性能。Java虚拟机必须追踪运行程序中有用的对象，而且最终释放没用的对象。这一个过程需要花费处理器的时间。其次垃圾回收算法的不完备性，早先采用的某些垃圾回收算法就不能保证100%收集到所有的废弃内存。当然随着垃圾回收算法的不断改进以及软硬件运行效率的不断提升，这些问题都可以迎刃而解。

4.2 Java的垃圾回收机制

Java语言规范没有明确地说明JVM使用哪种垃圾回收算法，但是任何一种垃圾回收算法一般要做2件基本的事情：（1）发现无用信息对象；（2）回收被无用对象占用的内存空间，使该空间可被程序再次使用。

4.2.1 Java的垃圾回收算法

大多数垃圾回收算法使用了根集(root set)这个概念；所谓根集就是正在执行的Java程序可以访问的引用变量的集合(包括局部变量、参数、类变量)，程序可以使用引用变量访问对象的属性和调用对象的方法。垃圾回收首先需要确定从根开始哪些是可达的和哪些是不可达的，从根集可达的对象都是活动对象，它们不能作为垃圾被回收，这也包括从根集间接可达的对象。而根集通过任意路径不可达的对象符合垃圾收集的条件，应该被回收。下面介绍几个常用的算法。

引用计数法(Reference Counting Collector)

　　引用计数法是唯一没有使用根集的垃圾回收的法，该算法使用引用计数器来区分存活对象和不再使用的对象。一般来说，堆中的每个对象对应一个引用计数器。当每一次创建一个对象并赋给一个变量时，引用计数器置为1。当对象被赋给任意变量时，引用计数器每次加1当对象出了作用域后(该对象丢弃不再使用)，引用计数器减1，一旦引用计数器为0，对象就满足了垃圾收集的条件。
　　基于引用计数器的垃圾收集器运行较快，不会长时间中断程序执行，适宜地必须实时运行的程序。但引用计数器增加了程序执行的开销，因为每次对象赋给新的变量，计数器加1，而每次现有对象出了作用域生，计数器减1。

tracing算法(Tracing Collector)

　　tracing算法是为了解决引用计数法的问题而提出，它使用了根集的概念。基于tracing算法的垃圾收集器从根集开始扫描，识别出哪些对象可达，哪些对象不可达，并用某种方式标记可达对象，例如对每个可达对象设置一个或多个位。在扫描识别过程中，基于tracing算法的垃圾收集也称为标记和清除(mark-and-sweep)垃圾收集器.

compacting算法(Compacting Collector)

　　为了解决堆碎片问题，基于tracing的垃圾回收吸收了Compacting算法的思想，在清除的过程中，算法将所有的对象移到堆的一端，堆的另一端就变成了一个相邻的空闲内存区，收集器会对它移动的所有对象的所有引用进行更新，使得这些引用在新的位置能识别原来的对象。在基于Compacting算法的收集器的实现中，一般增加句柄和句柄表。

copying算法(Coping Collector)

　　该算法的提出是为了克服句柄的开销和解决堆碎片的垃圾回收。它开始时把堆分成一个对象区和多个空闲区，程序从对象区为对象分配空间，当对象满了，基于coping算法的垃圾回收就从根集中扫描活动对象，并将每个活动对象复制到空闲区(使得活动对象所占的内存之间没有空闲间隔)，这样空闲区变成了对象区，原来的对象区变成了空闲区，程序会在新的对象区中分配内存。
　　一种典型的基于coping算法的垃圾回收是stop-and-copy算法，它将堆分成对象区和空闲区域区，在对象区与空闲区域的切换过程中，程序暂停执行。

generation算法(Generational Collector)

　　stop-and-copy垃圾收集器的一个缺陷是收集器必须复制所有的活动对象，这增加了程序等待时间，这是coping算法低效的原因。在程序设计中有这样的规律：多数对象存在的时间比较短，少数的存在时间比较长。因此，generation算法将堆分成两个或多个，每个子堆作为对象的一代 (generation)。由于多数对象存在的时间比较短，随着程序丢弃不使用的对象，垃圾收集器将从最年轻的子堆中收集这些对象。在分代式的垃圾收集器运行后，上次运行存活下来的对象移到下一最高代的子堆中，由于老一代的子堆不会经常被回收，因而节省了时间。

adaptive算法(Adaptive Collector)

　　在特定的情况下，一些垃圾收集算法会优于其它算法。基于Adaptive算法的垃圾收集器就是监控当前堆的使用情况，并将选择适当算法的垃圾收集器。

4.2.2 System.gc()

命令行参数透视垃圾收集器的运行
　　使用System.gc()可以不管JVM使用的是哪一种垃圾回收的算法，都可以请求Java的垃圾回收。在命令行中有一个参数-verbosegc可以查看Java使用的堆内存的情况，它的格式如下：

java -verbosegc classfile

class TestGC  {  
    public static void main(String[] args) {  
　　    new TestGC();  
　　    System.gc();  
　　    System.runFinalization();  
　　 }  
}

在这个例子中，一个新的对象被创建，由于它没有使用，所以该对象迅速地变为不可达，程序编译后，执行命令： java -verbosegc TestGC 后结果为：
　　[Full GC 168K->97K(1984K)， 0.0253873 secs]
　　机器的环境为，Windows 2000 + JDK1.3.1，箭头前后的数据168K和97K分别表示垃圾收集GC前后所有存活对象使用的内存容量，说明有168K-97K=71K的对象容量被回收，括号内的数据1984K为堆内存的总容量，收集所需要的时间是0.0253873秒（这个时间在每次执行的时候会有所不同）。

需要注意的是，调用System.gc()也仅仅是一个请求(建议)。JVM接受这个消息后，并不是立即做垃圾回收，而只是对几个垃圾回收算法做了加权，使垃圾回收操作容易发生，或提早发生，或回收较多而已。

4.2.3 finalize()

在JVM垃圾回收器收集一个对象之前，一般要求程序调用适当的方法释放资源，但在没有明确释放资源的情况下，Java提供了缺省机制来终止该对象心释放资源，这个方法就是finalize（）。它的原型为：
　　protected void finalize() throws Throwable
　　在finalize()方法返回之后，对象消失，垃圾收集开始执行。原型中的throws Throwable表示它可以抛出任何类型的异常。
　　之所以要使用finalize()，是存在着垃圾回收器不能处理的特殊情况。假定你的对象（并非使用new方法）获得了一块“特殊”的内存区域，由于垃圾回收器只知道那些显示地经由new分配的内存空间，所以它不知道该如何释放这块“特殊”的内存区域，那么这个时候java允许在类中定义一个由finalize()方法。

特殊的区域例如：1）由于在分配内存的时候可能采用了类似 C语言的做法，而非JAVA的通常new做法。这种情况主要发生在native method中，比如native method调用了C/C++方法malloc()函数系列来分配存储空间，但是除非调用free()函数，否则这些内存空间将不会得到释放，那么这个时候就可能造成内存泄漏。但是由于free()方法是在C/C++中的函数，所以finalize()中可以用本地方法来调用它。以释放这些“特殊”的内存空间。2）又或者打开的文件资源，这些资源不属于垃圾回收器的回收范围。
换言之，finalize()的主要用途是释放一些其他做法开辟的内存空间，以及做一些清理工作。因为在JAVA中并没有提够像“析构”函数或者类似概念的函数，要做一些类似清理工作的时候，必须自己动手创建一个执行清理工作的普通方法，也就是override Object这个类中的finalize()方法。例如，假设某一个对象在创建过程中会将自己绘制到屏幕上，如果不是明确地从屏幕上将其擦出，它可能永远都不会被清理。如果在finalize()加入某一种擦除功能，当GC工作时，finalize()得到了调用，图像就会被擦除。要是GC没有发生，那么这个图像就会被一直保存下来。

一旦垃圾回收器准备好释放对象占用的存储空间，首先会去调用finalize()方法进行一些必要的清理工作。只有到下一次再进行垃圾回收动作的时候，才会真正释放这个对象所占用的内存空间。
　　在普通的清除工作中，为清除一个对象，那个对象的用户必须在希望进行清除的地点调用一个清除方法。这与C++"析构函数"的概念稍有抵触。在C++中，所有对象都会破坏（清除）。或者换句话说，所有对象都"应该"破坏。若将C++对象创建成一个本地对象，比如在堆栈中创建（在Java中是不可能的，Java都在堆中），那么清除或破坏工作就会在"结束花括号"所代表的、创建这个对象的作用域的末尾进行。若对象是用new创建的（类似于Java），那么当程序员调用C++的 delete命令时（Java没有这个命令），就会调用相应的析构函数。若程序员忘记了，那么永远不会调用析构函数，我们最终得到的将是一个内存"漏洞"，另外还包括对象的其他部分永远不会得到清除。
　　相反，Java不允许我们创建本地（局部）对象--无论如何都要使用new。但在Java中，没有"delete"命令来释放对象，因为垃圾回收器会帮助我们自动释放存储空间。所以如果站在比较简化的立场，我们可以说正是由于存在垃圾回收机制，所以Java没有析构函数。然而，随着以后学习的深入，就会知道垃圾收集器的存在并不能完全消除对析构函数的需要，或者说不能消除对析构函数代表的那种机制的需要（原因见下一段。另外finalize()函数是在垃圾回收器准备释放对象占用的存储空间的时候被调用的，绝对不能直接调用finalize()，所以应尽量避免用它）。若希望执行除释放存储空间之外的其他某种形式的清除工作，仍然必须调用Java中的一个方法。它等价于C++的析构函数，只是没后者方便。
在C++中所有的对象运用delete()一定会被销毁，而JAVA里的对象并非总会被垃圾回收器回收。In another word, 1 对象可能不被垃圾回收，2 垃圾回收并不等于“析构”，3 垃圾回收只与内存有关。也就是说，并不是如果一个对象不再被使用，是不是要在finalize()中释放这个对象中含有的其它对象呢？不是的。因为无论对象是如何创建的，垃圾回收器都会负责释放那些对象占有的内存

4.2.3 触发主GC（Garbage Collector）的条件

　　JVM进行次GC的频率很高,但因为这种GC占用时间极短,所以对系统产生的影响不大。更值得关注的是主GC的触发条件,因为它对系统影响很明显。总的来说,有两个条件会触发主GC:

　　1)当应用程序空闲时,即没有应用线程在运行时,GC会被调用。因为GC在优先级最低的线程中进行,所以当应用忙时,GC线程就不会被调用,但以下条件除外。

　　2)Java堆内存不足时,GC会被调用。当应用线程在运行,并在运行过程中创建新对象,若这时内存空间不足,JVM就会强制地调用GC线程,以便回收内存用于新的分配。若GC一次之后仍不能满足内存分配的要求,JVM会再进行两次GC作进一步的尝试,若仍无法满足要求,则 JVM将报“out of memory”的错误,Java应用将停止。

　　由于是否进行主GC由JVM根据系统环境决定,而系统环境在不断的变化当中,所以主GC的运行具有不确定性,无法预计它何时必然出现,但可以确定的是对一个长期运行的应用来说,其主GC是反复进行的。

4.2.4 减少GC开销的措施

　　根据上述GC的机制,程序的运行会直接影响系统环境的变化,从而影响GC的触发。若不针对GC的特点进行设计和编码,就会出现内存驻留等一系列负面影响。为了避免这些影响,基本的原则就是尽可能地减少垃圾和减少GC过程中的开销。具体措施包括以下几个方面:

不要显式调用System.gc()

　　此函数建议JVM进行主GC,虽然只是建议而非一定,但很多情况下它会触发主GC,从而增加主GC的频率,也即增加了间歇性停顿的次数。

尽量减少临时对象的使用

　　临时对象在跳出函数调用后,会成为垃圾,少用临时变量就相当于减少了垃圾的产生,从而延长了出现上述第二个触发条件出现的时间,减少了主GC的机会。

对象不用时最好显式置为Null

　　一般而言,为Null的对象都会被作为垃圾处理,所以将不用的对象显式地设为Null,有利于GC收集器判定垃圾,从而提高了GC的效率。

尽量使用StringBuffer,而不用String来累加字符串

　　由于String是固定长的字符串对象,累加String对象时,并非在一个String对象中扩增,而是重新创建新的String对象,如Str5=Str1+Str2+Str3+Str4,这条语句执行过程中会产生多个垃圾对象,因为对次作“+”操作时都必须创建新的String对象,但这些过渡对象对系统来说是没有实际意义的,只会增加更多的垃圾。避免这种情况可以改用StringBuffer来累加字符串,因StringBuffer是可变长的,它在原有基础上进行扩增,不会产生中间对象。

能用基本类型如Int,Long,就不用Integer,Long对象

　　基本类型变量占用的内存资源比相应对象占用的少得多,如果没有必要,最好使用基本变量。

尽量少用静态对象变量

　　静态变量属于全局变量,不会被GC回收,它们会一直占用内存。

分散对象创建或删除的时间

　　集中在短时间内大量创建新对象,特别是大对象,会导致突然需要大量内存,JVM在面临这种情况时,只能进行主GC,以回收内存或整合内存碎片,从而增加主GC的频率。集中删除对象,道理也是一样的。它使得突然出现了大量的垃圾对象,空闲空间必然减少,从而大大增加了下一次创建新对象时强制主GC的机会。

下面这个例子向大家展示了垃圾收集所经历的过程，并对前面的陈述进行了总结:

class Chair {  
　　static boolean gcrun = false;  
　　static boolean f = false;  
　　static int created = 0;  
　　static int finalized = 0;  
　　int i;  
　　Chair() {  
　　    i = ++created;  
　　    if(created == 47)  
　　　      System.out.println("Created 47");  
　　}  
　　protected void finalize() {  
　　    if(!gcrun) {  
　　　      gcrun = true;  
　　　      System.out.println("Beginning to finalize after " + created + " Chairs have been created");  
　　    }  
　　    if(i == 47) {  
　　　      System.out.println("Finalizing Chair #47， " +"Setting flag to stop Chair creation");  
　　　      f = true;  
　　    }  
　　    finalized++;  
　　    if(finalized >= created)  
　　　      System.out.println("All " + finalized + " finalized");  
　　}  
}  
  
public class Garbage {  
　　public static void main(String[] args) {  
　　if(args.length == 0) {  
　　　  System.err.println("Usage: /n" + "java Garbage before/n or:/n" + "java Garbage after");  
　　　  return;  
　　}  
　　while(!Chair.f) {  
　　　  new Chair();  
　　　  new String("To take up space");  
　　}  
　　System.out.println("After all Chairs have been created:/n" + "total created = " + Chair.created +  
　　"， total finalized = " + Chair.finalized);  
　　if(args[0].equals("before")) {  
　　　　System.out.println("gc():");  
　　　　System.gc();  
　　　　System.out.println("runFinalization():");  
　　　　System.runFinalization();  
　　}  
　　System.out.println("bye!");  
　　if(args[0].equals("after"))  
　　　  System.runFinalizersOnExit(true);  
　　}  
}

上面这个程序创建了许多Chair对象，而且在垃圾收集器开始运行后的某些时候，程序会停止创建Chair。由于垃圾收集器可能在任何时间运行，所以我们不能准确知道它在何时启动。因此，程序用一个名为gcrun的标记来指出垃圾收集器是否已经开始运行。利用第二个标记f，Chair可告诉main()它应停止对象的生成。这两个标记都是在finalize()内部设置的，它调用于垃圾收集期间。另两个static变量--created以及 finalized--分别用于跟踪已创建的对象数量以及垃圾收集器已进行完收尾工作的对象数量。最后，每个Chair都有它自己的（非 static）int i，所以能跟踪了解它具体的编号是多少。编号为47的Chair进行完收尾工作后，标记会设为true，最终结束Chair对象的创建过程。

4.2.5 Java的垃圾回收总结

经过上述的说明，可以发现垃圾回收有以下的几个特点：

垃圾收集发生的不可预知性：由于实现了不同的垃圾回收算法和采用了不同的收集机制，所以它有可能是定时发生，有可能是当出现系统空闲CPU资源时发生，也有可能是和原始的垃圾收集一样，等到内存消耗出现极限时发生，这与垃圾收集器的选择和具体的设置都有关系。
垃圾收集的精确性：主要包括2 个方面：（a）垃圾收集器能够精确标记活着的对象；（b）垃圾收集器能够精确地定位对象之间的引用关系。前者是完全地回收所有废弃对象的前提，否则就可能造成内存泄漏。而后者则是实现归并和复制等算法的必要条件。所有不可达对象都能够可靠地得到回收，所有对象都能够重新分配，允许对象的复制和对象内存的缩并，这样就有效地防止内存的支离破碎。
现在有许多种不同的垃圾收集器，每种有其算法且其表现各异，既有当垃圾收集开始时就停止应用程序的运行，又有当垃圾收集开始时也允许应用程序的线程运行，还有在同一时间垃圾收集多线程运行。
垃圾收集的实现和具体的JVM 以及JVM的内存模型有非常紧密的关系。不同的JVM 可能采用不同的垃圾收集，而JVM 的内存模型决定着该JVM可以采用哪些类型垃圾收集。现在，HotSpot 系列JVM中的内存系统都采用先进的面向对象的框架设计，这使得该系列JVM都可以采用最先进的垃圾收集。
随着技术的发展，现代垃圾收集技术提供许多可选的垃圾收集器，而且在配置每种收集器的时候又可以设置不同的参数，这就使得根据不同的应用环境获得最优的应用性能成为可能。

　　针对以上特点，我们在使用的时候要注意：

不要试图去假定垃圾收集发生的时间，这一切都是未知的。比如，方法中的一个临时对象在方法调用完毕后就变成了无用对象，这个时候它的内存就可以被释放。
Java中提供了一些和垃圾收集打交道的类，而且提供了一种强行执行垃圾收集的方法--调用System.gc()，但这同样是个不确定的方法。Java 中并不保证每次调用该方法就一定能够启动垃圾收集，它只不过会向JVM发出这样一个申请，到底是否真正执行垃圾收集，一切都是个未知数。
挑选适合自己的垃圾收集器。一般来说，如果系统没有特殊和苛刻的性能要求，可以采用JVM的缺省选项。否则可以考虑使用有针对性的垃圾收集器，比如增量收集器就比较适合实时性要求较高的系统之中。系统具有较高的配置，有比较多的闲置资源，可以考虑使用并行标记/清除收集器。
关键的也是难把握的问题是内存泄漏。良好的编程习惯和严谨的编程态度永远是最重要的，不要让自己的一个小错误导致内存出现大漏洞。
尽早释放无用对象的引用。大多数程序员在使用临时变量的时候，都是让引用变量在退出活动域(scope)后，自动设置为null，暗示垃圾收集器来收集该对象，还必须注意该引用的对象是否被监听，如果有，则要去掉监听器，然后再赋空值。

4.3 C/C++的智能指针

C/C++中可没有什么垃圾回收机制，针对指针的操作全靠程序员记得不用的把指针变量=NULL。但是在新版本的C++代码中引入了智能指针的概念。

这里我们先介绍对指针的理解，在介绍基于C++设计的智能指针。

4.3.1 之前的学习笔记

野指针NULL把内存比作尺子，很轻松的理解了内存。尺子上的 0 毫米处就是内存的0 地址处，也就是 NULL 地址处。这条栓“野指针”的链子就是这个“NULL” 。定义指针变量的同时最好初始化为 NULL，用完指针之后也将指针变量的值设置为 NULL。也就是说除了
在使用时，别的时间都把指针“栓”到 0 地址处。这样它就老实了。
内存分为三个部分：静态区，栈，堆，常见的内存错误如下六种
a）指针没有指向一块合法的内存，定义了指针变量，但是没有为指针分配内存，即指针没有指向一块合法的内存，特殊注意结构体成员指针未分配内存
b) 未指针分配的内存太小，一般喜欢用strlen(str)来计算字符串的长度而忽略了后面的‘\0’
c)内存分配成功，但并未初始化，在定义一个变量后第一件事就是对其初始化，这时我们不知道分配的内存的值，可以用0或者NULL对其初始化，如char *p=NULL
d)内存越界，内存分配成功，且已经初始化，但是操作越过了内存的边界。这种错误经常是由于操作数组或指针时出现“多 1”或“少 1”
e)内存泄露，也就是说由malloc系列函数或 new操作符分配的内存。如果用完之后没有及时 free或delete，这块内存就无法释放，直到整个程序终止。
f)内存释放后，对内存继续使用，free（p）之后，继续通过 p 指针来访问内存。解决的办法就是给 p 置NULL。
g)函数返回栈内存。这是初学者最容易犯的错误。比如在函数内部定义了一个数组，却用 return语句返回指向该数组的指针。解决的办法就是弄明白栈上变量的生命周期。
进程和线程的区别就是进程拥有独立的用户空间，而线程没有，进程的父子ID号不同，而线程的ID号相同。
e) 一个有10个指针的数组，该指针是指向一个整型数     int  *a[10]
f) 一个指向有10个整型数数组的指针                   int (*a)[10]      ()的优先级比[]的优先级高
g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数    int (*a) (int )
h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数    int (*a[10])(int)函数指针数组
j)一个指向函数的指针。该函数有一个整形指针参数并返回一个整形指针 int * (*a)(int *)
k) char*(*pf[3])(char*p);通过小括号可分析为一个函数，函数的参数是char *p,函数的返回值是char *，在看函数名*pf[3]
不难看出*pf[3]为指针数组，因此pf是一个函数指针数组，这个数组有3个成员，每个成员都是一个函数指针，且这个函数指针指向有一个char *的参数和char *的返回值的函数
l)char*(*(*pf)[3])(char*p); 这是一个指向函数指针数组的指针。。。。其他的不多说了，我也说不清了
在C语言中，关键字static有三个明显的作用：
1). 修饰局部变量，静态局部变量总是存放在内存的静态区，即使这个函数结束，这个变量也不会被销毁，若函数下次再使用这个变量，里面的值依旧没有变
2). 修饰全局变量，静态全局变量也被分配在内存的静态区，因此其作用域仅限于变量被定义的文件模块中，其他文件即使使用extern也无法使用它
3). 修饰函数，被声明为静态的函数称为内部函数，即被修饰的函数作用域仅限于本文件模块中，工程中其他模块不能调用。
关键字const是什么含意
const用来修饰一个只读的变量，可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改

const int a;         // a是一个常整型数

int const a;           // a是一个常整型数

const int *a;    // a是一个指向常整型数的指针（也就是整型数是不可修改的，但指针可以）

int * const a;   // a 是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）

int const * a const;   // a 是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）
const判断方法：const离谁近就修饰谁，离int近者修饰int，离*近者修饰指针
指针NULL赋值
int *p=NULL; //定义指针变量p，将0x00000000赋值给指针变量p，而不是将0x00000000赋值给*p，这个过程叫做初始化，编译的时候进行
int *p=&a;
*p=NULL      //定义了指针变量p，将NULL即0的值赋给了*p,而指针变量p的值是变量a的地址
数组名a和&a区别
int a[10];那么a代表的是数组首元素a[0]的地址，&a代表的是数组a的首地址，因此a+1相当于数组下一个元素的地址，&a+1相当于下一个数组的首地址，两者的值相同但是代表的意义不相同
intmain()
{chara[5]={'A','B','C','D'};
char(*p3)[5]=&a;    //等式左边p3的类型为数组指针，等式右边&a正表示一个数组的地址，因此此句正确
char(*p4)[5]=a;      //等式左边p4的类型为数组指针，等式后面a表示一个元素的地址，等式两边类型不同，因此编译时将报错
return0;}