程序设计语言不得不说一下两大最成功的语言C++和Java，众所周知Java是基于C++的，但是相比之下，Java是一门面向对象的语言，但是C++并不是纯粹的面向对象；C++编程思想的作者这样描述：C++是一门基于对象的语言。
一、对象
客观世界中任何一个事物都可以看成一个对象(object)。对象可大可小，对象是构成系统的基本单位。
C++中的任意一个对象都应当具有这两个要素，即属性(attribute)和行为(behavior)，它能根据外界给的信息进行相应的操作。一个对象往往是由一组属性和一组行为构成的。一般来说，凡是具备属性和行为这两种要素的，都可以作为对象。每个对象都是由数据和函数(即操作代码)这两部分组成的，数据体现了前面提到的属性，调用对象中的函数就是向该对象传送一个消息，要求该对象实现某一行为(功能)。
Java表现了一种更加纯粹的面向对象程序设计方式，把一切事物都当成对象这是Java的另一种思维模式。对象呗视为奇特的变量，它可以存储数据，除此之外你还可以要求他在自身上执行操作。Java程序就是众多对象的集合，他们之间通过发送消息来告知彼此所要做的（想要请求一个对象就必须对该对象发送一条消息，实际上这个步骤跟C++类似就是调用该对象的方法或者函数）。对象具有状态、行为和标识，即任何对象都可以拥有内部数据（他们给出了该对象的状态）和方法（他们产生行为）。并且每一个对象都可以唯一的与其他对象区分开来，即每一个对象在内存中都有一个唯一的地址。
综上所述，C++中认为具有属性和行为两个要素的都可以被的称为对象，而Java更加纯粹扩大了范围认为万物都可以当成一个对象。
C++中类其实是从结构体中引申过来的，因此C++中的类其实就是一种数据类型，只不过这种复合型的数据类型中是一组不同类型的数据集合和若干个函数体。因为有了这些成员变量（属性），还有成员函数（行为）,这样就被称为了对象。
Java中所有的类都是直接或者间接的继承了java.lang.Object类，它是所有类的父类，是Java类层中的最高层类。当创建一个类时，总是在继承。Java中的类中可以定义若干变量和若干方法，不止符合了万物都是类，还符合了C++中定义的属性和行为。
1、对象的声明
无论是C++还是Java，都通过类(class)来表示对象的数据类型。C++中有几种基本类型数据(int/long/short/char)，还有结构体联合体枚举等数据类型，从结构体类型延伸出了class类型。Java中除了基本数据类型之外还有引用数据类型（类，接口，注解等），个人认为引用数据类型的本质其实还是跟指针地址等概念有些类似。
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){
}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){ //公有方法声明和实现
}
}右上可以发现，C++和Java都可以通过权限访问符来对成员变量和成员函数（方法）进行修饰权限，唯一不同的就是C++可以在类外进行成员函数的实现，而Java觉得这样太复杂，因此简化了流程禁止类外实现成员方法。
除此之外，C++提供了构造函数和析构函数，其中构造函数还可以通过初始化列表对成员变量进行初始化，而Java并没有提供析构函数（Java中对象可以被GC自动回收，析构函数的事情GC自动已经做了，因此不需要手动去实现析构函数）和构造函数的初始化列表。因此如果你想要某个类清理一些东西，就必须显式的编写一个特殊方法来做这件事，并确保客户端程序员知道必须调用这一方法。
2、对象的存储
用类去定义对象时，系统会为每一个对象分配存储空间。如果一个类包括了数据和函数，要分别为数据和函数的代码分配存储空间。能否只用一段空间来存放这个共同的函数代码段，在调用各对象的函数时，都去调用这个公用的函数代码。显然，这样做会大大节约存储空间。C++编译系统正是这样做的，因此每个对象所占用的存储空间只是该对象的数据部分所占用的存储空间，而不包括函数代码所占用的存储空间。Java中类的方法存在一个专门的区叫方法区,事实上类刚装载的时候就被装载好了（不过它们在"睡眠"，只是这些方法必须当有对象产生的时候才会"苏醒"）。所以方法在装载的时候就有了只有实例对象调用方法的时候才可用。
1）、C/C++存储机制
C++中的全局变量（包括基础数据类型和对象数据类型），其生命周期从程序启动开始到程序结束为止。全局数据（包括对象和基本数据类型）和静态局部数据（包括对象和基本数据类型）存放在全局存储区（静态存储区），初始化的全局对象和静态局部对象在一块区域， 未初始化的全局对象和未初始化的静态局部对象在相邻的另一块区域，程序结束后由系统释放。
C++中的局部变量（包括基础数据和对象数据类型），其生命在作用域结束时结束，它的析构函数会自动被调用，即对象自动被清理。很显然局部数据（包括对象和基础数据）存放在栈中。
C++中的动态对象，其生命在new的时候开始，它被 delete 时候结束。动态对象存放在堆中，而用于创建动态对象的指针存放在栈中。程序中的指针 d 就是用来创建动态对象的，在 new 的时候被构造，而在 delete 的时候被析构。new 的对象，必须使用 delete 去显式的调用析构函数，否则程序不会去调用其析构函数，从而造成内存泄露。
2）、Java内存机制
Java 把内存划分成两种：一种是栈内存，另一种是堆内存。
在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配，当在一段代码块定义一个变量（局部变量）时，Java 就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java 会自动释放掉为该变量分配的内存空间，该内存空间可以立即被另作它用。
堆内存用来存放由 new 创建的对象和数组，在堆中分配的内存，由 Java 虚拟机的自动垃圾回收器来管理。在堆中产生了一个数组或者对象之后，还可以在栈中定义一个特殊的变量，让栈中的这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或者对象，引用变量就相当于是为数组或者对象起的一个名称。引用变量是普通的变量，定义时在栈中分配，引用变量在程序运行到其作用域之外后被释放。而数组和对象本身在堆中分配，即使程序运行到使用 new 产生数组或者对象的语句所在的代码块之外，数组和对象本身占据的内存不会被释放，数组和对象在没有引用变量指向它的时候，才变为垃圾，不能在被使用，但仍然占据内存空间不放，在随后的一个不确定的时间被垃圾回收器收走（释放掉）。这也是 Java 比较占内存的原因，实际上，栈中的变量指向堆内存中的变量，这就是 Java 中的指针！
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;
}
4）、Java引用类型
Java中有两种数据类型，分别是基本数据类型和引用数据类型（包括类、接口类型、数组类型、枚举类型、注解类型、字符串型）。引用数据类型在被创建时，首先要在栈上给其引用（句柄）分配一块内存，而对象的具体信息都存储在堆内存上，然后由栈上面的引用指向堆中对象的地址。由此可见，Java的引用类型其实采用了C++指针的原理，只不过这些转换都被虚拟机做了，因此Java虽然去掉了指针的概念，但是指针的思想无处不在。
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通过虚拟机自动进行释放。
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();
}2）、this
对于类的非静态成员，每一个对象都有自己的一份数据拷贝，即拥有不同的地址空间（C++可能在堆也可能在栈或者全局区上，Java全部在堆中）。但是他们的成员函数或者方法却是每个对象共享的（代码区），那么调用共享的成员函数或方法是如何找到自己的数据成员的呢，其实就是通过类中隐藏的this指针。当不同的对象调用同一个成员函数或方法的时候，隐式的将this指针作为参数传递了进去，该成员函数或方法在引用成员变量的时候，隐式的做了些转换，当然这些对于我来说都是编译器或者虚拟机自己完成的，我们不用太过于关心。
当然我们也可以显示的使用this。在C++中this就是一个指针，因此在调用的时候需要this->xxx的方式使用；在Java中this其实是自己的引用（指向自己的句柄），在调用的使用需要this.xxx的方式使用。
3）、对象的赋值
C++中如果对一个类定义了两个或多个对象，则这些同类的对象之间可以互相赋值，或者说，一个对象的值可以赋给另一个同类的对象。这里所指的对象的值是指对象中所有数据成员的值。对象之间的赋值也是通过赋值运算符“=”进行的。本来赋值运算符"="只能用来对单个的变量赋值，现在被扩展为两个同类对象之间的赋值，这是通过对赋值运算符的重载实现的。实际这个过程是通过成员复制来完成的，即将一个对象的成员值一一复制给另一对象的对应成员。
Java中也可以通过操作符"="取右边的值复制给左边，右边可以是任何常数变量或者表达式（只要它能生成一个值就行），但是左边必须是一个明确的已经命名的变量。对基本数据类型的赋值很简单，直接将一个地方的内容复制到了另一个地方。但是在为引用数据类型变量进行赋值的时候情况却发生了变化，在对一个对象进行操作时，我们真正操作的是对"对象"的引用，即将“引用”从一个地方复制到另一个地方，由以前的分析可以知道Java的引用内部其实也是通过地址来实现的，因此这就更加的像C++中的指针值传递了。（注意Java的引用本质上还是值传递，只不过引用句柄等价于地址而已）。
综上所述，C++中通过“=”给对象进行赋值，他们只是把对象里面的内容进行复制了一遍，这两个对象位于不同地址空间的变量。而Java中通过“=”给对象进行赋值，是把对象的引用复制了一遍，被赋值后的变量引用指向了新的堆空间，而以前的对象则与该变量断开了联系，最终被垃圾回收器释放（没有任何引用）。
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); 二、继承
继承在面向对象开发思想中是一个非常重要的概念，它使整个程序架构具有一定的弹性，在程序中复用一些已经定义完善的类不仅可以减少软件开发周期，还可以提高软件的可维护性和可扩展性。所谓继承就是在一个已存在的类的基础上建立一个新的类。一个新类从已有的类那里获得其已有特性，这种现象称为类的继承。通过继承，一个新建子类从已有的父类那里获得父类的特性。从另一角度说，从已有的类(父类)产生一个新的子类，称为类的派生。
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、构造函数
无论是Java还是C++的构造函数，都会在对象被创建的时候隐式的被调用，C++一般用于对数据成员的初始化，Java通常除了对成员变量的初始化还作一些其他初始工作。
无论是Java还是C++在声明类时如果没有定义任何的构造函数，那么编译器就会创建一个默认的构造函数（空实现），在对象被实例化的时候系统会主动的调用该构造函数。如果定义了构造函数，那么这个默认构造函数都不会被创建（经常遇到父类实现了有参的构造方法或函数，子类实现无参构造方法或函数的时候编译报错，是因为子类构造函数会隐式的调用父类无参构造函数，然后系统没有给父类创建默认构造函数，用户自己也没有定义无参构造函数，所以出现子类找不到父类的构造方法）。
无论是Java还是C++的子类在被实例化的时候，都会先显示或隐式的调用父类的构造函数。在子类对象被释放的时候，C++的会先调用自己的析构函数之后再调用父类的析构函数。
C++可以通过初始化列表的方式去显示的调用父类指定参数的构造函数，如果不使用这种方式则子类会去隐式的调用父类的无参构造函数。其一般形式：派生类构造函数名（总参数表列）：基类构造函数名（参数表列）{派生类中新增数据成员初始化语句}
Java可以通过关键字super去显示的调用父类指定参数的构造方法，如果子类构造函数没有显示使用super关键字那么Java编译会主动隐式的在构造函数第一行通过super()调用父类的无参构造方法。
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++多继承这样的功能。
4、成员函数
除了构造函数和构造方法之外，C++还有成员函数，在Java中被称为成员方法的概念。那么就不得不说是函数/方法重载、重写、隐藏的概念了。
1）、重载
重载相对来说比较简单，它只能在同一个作用域（子类和父类之间的函数无法称为重载，因为跨越了作用域），允许函数/方法名相同，其参数的类型或个数不同。注意返回值不同的函数/方法不能算作重载，因为编译器无法准确的判断你要调用函数的返回值具体类型。基于函数重载的理念，C++使用模板的方式，Java则提出了泛型的概念对其进行扩展。除此之外C++还提供了运算符重载的方案。
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();
}
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();
}4）、总结
- C++与Java都支持函数/方法重装，即在同一个作用域（同一个类中），允许存在同名但参数不同的函数/方法。除此之外，C++还支持运算符的重装，Java确禁止了这样的使用
- C++与Java都允许子类出现于父类同名同参同参数的函数/方法，但是效果不一样。在C++中的这种情况属于函数隐藏，即通过基类指针指向子类实例对象则基类的函数被调用，只有通过子类指针指向子类实例对象则子类函数被调用；在Java中因为有RTTI在运行时进行动态绑定，从而实现了方法重写，即子类对象在转换成基类引用之后，虚拟机中的RTTI能够检测出该对象其实是子类实例，因此基类引用在调用该方法的时候，RTTI动态实现调用了子类的方法。
- C++为了实现多态的效果，引入了虚函数的概念。先定义了一个指向基类的指针变量，并使它指向相应的类对象，然后通过
这个基类指针去调用虚函数，显然对这样的调用方式，编译系统在编译该行时是无法确定调用哪一个类对象的虚函数的（因为编译只作静态的语法检查），在这样的情况下，编译系统把它放到运行阶段处理，在运行阶段确定关联关系。由于是在运行阶段把虚函数和类对象―绑定‖在一起的，因此，此过程称为动态关联（其实这就是C++中的RTTI）。
5、类型转型
在各种强类型语言中都离不开类型转换的概念，即从一种数据类型转换到另一种数据类型。类型转换一般涉及到向上转型和向下转型。
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);
}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;
}
}6、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();
}三、多态
多态性是面向对象程序设计的一个重要特征。多态性是指具有不同功能的函数可以用同一个函数名，这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性的:向不同的对象发送同一个消息，不同的对象在接收时会产生不同的行为（即像不同的对象调用同一个同名的函数或方法，这些对象执行这个同名函数或方法能够实现不同的功能）。
从系统实现的角度看，多态性分为两类:静态多态性和动态多态性。函数重载和运算符重载实现的多态性属于静态多态性，在程序编译时系统就能决定调用的是哪个函数，因此静态多态性又称编译时的多态性。动态多态性是在程序运行过程中才动态地确定操作所针对的对象，它又称运行时的多态性，人们提出这样的设想，能否用同一个调用形式，既能调用派生类又能调用基类的同名函数？当然这种方式是可以实现的，下面就分别介绍C++和Java的运行时多态性。
1、C++运行时多态（虚函数）
C++中不是通过不同的对象名去调用不同派生层次中的同名函数，而是通过指针调用它们。例如用同一个语句pt->display( );可以调用不同子类层次中的display函数，只需在调用前给指针变量pt赋以不同的值(使之指向不同的类对象)即可。C++中的虚函数就是用来解决这个问题的。虚函数的作用是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。
1）、虚函数使用方法
由虚函数实现的动态多态性就是:同一类族中不同类的对象，对同一函数调用作出不同的响应。其使用方法如下：
- 在基类用virtual声明成员函数为虚函数。在类外实现虚函数时，不必再加virtual。
- 在子类中重新定义此函数，要求函数名、函数类型、函数参数个数和类型全部与基类的虚函数相同，并根据子类的需要重新实现函数体。当一个成员函数被声明为虚函数后，其派生类中的同名函数都自动成为虚函数，因此在子类重新声明该虚函数时，virtual关键字可加可不加，但习惯上一般在每一层子类声明该函数时都加virtual，使程序更加清晰。如果在子类中没有对基类的虚函数重新实现，则子类简单地继承基类的虚函数。
- 定义一个指向基类对象的指针变量（引用也可以），并使它指向同一类族中需要调用该函数的对象。
- 通过该指针变量调用此虚函数，此时调用的就是指针变量指向的对象的同名函数。
通过虚函数与指向基类对象的指针变量的配合使用，就能方便地调用同一类族中不同类的同名函数，只要先用基类指针指向即可。如果指针不断地指向同一类族中不同类的对象，就能不断地调用这些对象中的同名函数。需要说明：有时在基类中定义的非虚函数会在派生类中被重新定义如果用基类指针调用该成员函数，则系统会调用对象中基类部分的成员函数；如果用派生类指针调用该成员函数，则系统会调用派生类对象中的成员函数，这并不是多态性行为(使用的是不同类型的指针),没有用到虚函数的功能。
2）、虚函数使用场景
- 首先看成员函数所在的类是否会作为基类。然后看成员函数在类的继承后有无可能被更改功能，如果希望更改其功能
的，一般应该将它声明为虚函数。 - 如果成员函数在类被继承后功能不需修改，或派生类用不到该函数，则不要把它声明为虚函数。不要仅仅考虑到要作为基类而把类中的所有成员函数都声明为虚函数。
- 应考虑对成员函数的调用是通过对象名还是通过基类指针或引用去访问，如果是通过基类指针或引用去访问的，则应当声明为虚函数。
- 在定义虚函数时，并不定义其函数体，即函数体是空的。它的作用只是定义了一个虚函数名，具体功能留给派生类去添加。
需要说明的是:使用虚函数，系统要有一定的空间开销。当一个类带有虚函数时，编译系统会为该类构造一个虚函数表，它是一个指针数组，存放每个虚函数的入口地址。因此C++的RTTI在进行动态关联时的时间开销是很少的，因此多态性是高效的。
3）、虚析构函数
析构函数的作用是在对象撤销之前做必要的―清理现场‖的工作。但是如果用new运算符建立了临时对象，若基类中有析构函数，并且定义了一个指向该基类的指针变量。在程序用带指针参数的delete运算符撤销对象时，会发生一个情况:系统会只执行基类的析构函数，而不执行派生类的析构函数。可以将基类的析构函数声明为虚析构函数，当基类的析构函数为虚函数时，无论指针指的是同一类族中的哪一个类对象，系统会采用动态关联，调用相应的析构函数，对该对象进行清理工作。
如果将基类的析构函数声明为虚函数时，由该基类所派生的所有派生类的析构函数也都自动成为虚函数，即使派生类的析构函数与基类的析构函数名字不相同。最好把基类的析构函数声明为虚函数。这将使所有派生类的析构函数自动成为虚函数。
将析构函数声明为虚函数，一般叫做虚析构函数，即使基类并不需要析构函数，也显式地定义一个函数体为空的虚析构函数，以保证在撤销动态分配空间时能得到正确的处理。构造函数不能声明为虚函数，这是因为在执行构造函数时类对象还未完成建立过程，当然谈不上函数与类对象的绑定。
4）、虚函数使用示例
C++通过虚函数实现多态，即通过统一的方式（基类指针或引用）让不同的子类实现不同的功能，在我的这个示例中，封装了OpenSL ES的播放器和录音器功能，将OpenSL ES的实现步骤抽离出来并封装在基类SLBase，SLBase按照统一的模式进行OpenSL的引擎创建，输出输入设置，播放器/录音器的创建，缓存的设置等步骤，除此之外将播放器和录音器的不同之处的函数声明为虚函数，在具体的子类实现。最后在主函数中通过SLBase指针调用同一个方法进行任务的开启，最终实现了C++的多态，其Github地址：OpenSL播放器与采集器的封装
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、抽象类
如果声明了一个类，一般可以用它定义对象。但是在面向对象程序设计中，往往有一些类，它们不用来生成对象。定义这些类的惟一目的是用它作为基类去建立派生类。它们作为一种基本类型提供给用户，用户在这个基础上根据自己的需要定义出功能各异的派生类，用这些派生类去建立对象。
这种不用来定义对象而只作为一种基本类型用作继承的类，称为抽象类，由于它常用作基类，通常称为抽象基类。当然无论是C++还是Java作为最成功的两门语言，肯定也少不了对抽象类的支持，它们允许存在这样的函数或方法，只需要进行函数或方法的声明，而不用去实现它，这种函数或方法是不完整的，统称为抽象函数或方法。包括这样的抽象函数或方法的类叫做抽象类，因此抽象类是不允许被实例化，只有其子类将所有的抽象方法或函数全部实现，它们才能摆脱这种不完整的定义，才能被系统实例化。
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();
}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）、纯虚函数 VS abstract方法
其实C++的纯虚函数与Java中的abstract方法其实没有本质的区别，他们都是为了解决同一个问题而产生的，只是在不同的语言中实现方式不一样，即可以认为纯虚函数就是C++中的抽象方法的具体实现，abstract就是Java中的抽象方法的表示。当然，个人觉得无论怎么看都发觉Java比C++简单的太多了，在C++中涉及到三种情况（对象变量、对象引用变量、对象指针变量），而在Java中虚拟机干了一件天大的好事，就是统一了在C++中出现的这三种情况从而只对程序员开放了一种特有的类型，那就Java的引用数据类型（本质还是地址的指向），哈哈，这不止简化了开发流程，更加的易于理解。
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();
}
}
1027
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
