名词解释

绑定：将一个方法调用同一个方法主体(所在的类)关联起来。分为：前期绑定和后期绑定。
前期绑定：在程序执行前进行绑定。(在程序执行之前根据编译时类型绑定，调用开销较小)。
后期绑定：在运行时根据对象的类型进行绑定。也叫做“动态绑定”和“运行时绑定”。()
Java中除了static方法和final方法(private方法属于final方法)之外，其他所有的方法都是后期绑定。成员变量属于前期绑定

多态的意义
多态通过分离做什么和怎么做，从另一角度将接口和实现分离开来。多态不但能够改善代码的组织结构和可读性，还能创建可扩展的程序——即无论在项目最初创建时还是在需要添加新功能时都可以“生长”的程序。

“封装”通过合并特征和行为来创建新的数据类型。“实现隐藏”则通过将细节“私有化”把接口和实现分离开来(理解：“私有化”每个实现类都有自己的实现方法)。而多态的作用则是消除类型之间的耦合性。

1、封装：将对象的数据与操作数据的方法结合起来，通过方法将对象的数据和实现细节保护起来，称为封装。
2、继承：一种由已有类创建新类的机制。
3、多态：一个对象变量可以指向多种实际类型的现象。
4、接口：用来实现类似多重继承功能的一种结构，它在语法上与类相似，它也有属性和方法，接口间也可以形成继承关系，但继承和类有很大的差别，它的属性都是常量，方法都是抽象方法，没有方法体。
5、异常：在程序执行中，任何中断正常程序流程的异常条件就是错误或异常。
6、构造方法：名字与他所在类的名字相同，并且不返回任何数据类型。
7、线程生命周期：一个线程从创建、运行到消亡的过程。
8、final类：不能被继承，即不可能有子类。
9、内部类：可将一个类定义置入另一个类定义中。
10、方法的覆盖：如果子类中定义的某个成员方法与父类中的某个方法的名称，返回类型和参量完全相同为覆盖。。
11、JDBC：是一种用于执行SQL语句的JAVA API，可以为多种关系数据提供统一访问，他由一组用JAVA语言编写的类和接口组成。
12、抽象类：声明方法的存在而不实现的类。
13、static块：静态变量或静态方法，不需要实例化就可以被调用的。
14、斐波那契数列：若一个数列前两项等于一，从第三项起，每一项等于前两项之和。
15、多线程同步处理：当多个线程想访问一个资源时，在任何给定的时间都只有一个线程可以访问。
16、匿名同步类：如果只需要内部类的一个对象，那么你不必给该类一个名字，这时候我们称为匿名内部类。
17、死锁：当一个线程需要一个资源，而另一个线程持有该资源的锁，就会发生死锁
18、方法的重载：JAVA语言允许用相同的方法名定义类中若干个成员方法，只要每个方法有自己唯一的一组形式参数，这种现象称为方法的重载。
19、面向对象：在编程过程中采用的封装、继承、多态的编程方法。
20、脏读数据; 脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。
21、多线程：在单的程序中可以同时运行多个不同的线程，执行不同的任务。
22、类：具有相同的特性和行为的集合。
23、堆栈调用机制：我们可以从线程当前堆栈中了解到调用它的那几个那几个函数分别是谁，呈现出一种堆栈的特征，最后别调用的函数出现在最上方，成为，堆栈调用机制。
24、对象：对象是在其类模型基础上构造出的，是类的具体的实例。一个类可以生成任意多的对象。
25、单态模式：Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个
实例存在。Singleton模式就为我们提供了这样实现的可能。使用Singleton的好处还在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收(garbage collection)。
26、事件(Event)：当用户在界面上执行一个操作(如按下键盘或单击、拖动鼠标)时，都将产生一个事件。可见，事件用来描述不同类型用户操作的对象。Java有很多不同类型的事件类，对应不同类型的用户动作
27、事件源(Event source)：产生事件的组件就是一个事件源。例如，在一个Button上单击鼠标时，将产生一个ActionEvent类型的事件，那么这个Button就是事件源。
28、事件处理器(Event handle)：事件处理器就是一个方法，它接收一个事件对象，对其进行解释，并做出相应的处理。
29、异常：Java程序中，由于程序员的疏忽或环境的变化，在程序运行时出现的打断正常程序流程的不正常情况。
30、输入流：Java可以打开一个从某种数据源(如文件、内存等)到程序的一个流，从这个流中读取数据，这就是输入流。它只能从流中读出，不能向流中写入。21、输出流：Java可以打开一个从程序到某种数据宿(如文件、内存等)的一个流，把数据顺序写入这个流以便输出，这就是输出流。它只能向流中写入，不能从流中读出。
31、重载：在同一个类中，一个方法名被用来定义多个方法，要求参数表必须不同，以此区分不同方法体，但返回类型、修饰符可相同或不相同。它实现了Java的编译时多态。
32、重写：当子类成员方法与父类成员方法具有相同的名字、参数列表、返回值类型时，子类方法重写了父类方法，在父类中定义的方法就被隐藏。它实现了Java的运行时多态。
33、构造方法：构造方法是类的一种特殊方法，方法名与类名相同，在类实例化对象时被调用，用于初始化类的成员变量、分配资源或其他辅助工作。
34、包：包是类和接口的集合，它把同一种类型的类(接口)组织在一起，使得程序功能清楚、结构分明，更重要的是可实现不同程序间类的重用。
35、JVM：Java虚拟机的缩写，是一个软件系统，可以解释并运行Java字节码。
36、API：应用程序接口的缩写，Java API是Java平台定义的一套类和接口的程序库。
37、容器异常：Spring 提供容器功能，容器可以管理对象的生命周期、对象与对象之间的依赖关系，您可以使用一个配置文件(通常是XML)，在上面定义好对象的名称、如何产生(Prototype 方式或Singleton 方式)、哪个对象产生之后必须设定成为某个对象的属性等，在启动容器之后，所有的对象都可以直接取用，不用编写任何一行程序代码来产生对象，或是建立对象与对象之间的依赖关系。换个更直白点的说明方式：容器是一个Java 所编写的程序，原先必须自行编写程序以管理对象关系，现在容器都会自动帮您作好。

C++多态及多态模型
一、名词解释
1）虚函数：类的成员函数前面加上virtual关键字，则这个成员函数是虚函数；虚函数是存在代码段的，虚函数的指针是存在虚表中的；（注意：必须是类的成员函数，静态成员函数不能定义成虚函数）
2）
重写（覆盖）：在子类中定义了一个和父类中完全相同的成员函数（函数名，参数，返回类型完全相同，但协变除外）
协变：子类和父类有同名且参数相同的函数，返回类型即：父类的返回类型为父类的指针或引用，子类的返回类型为子类的指针或引用；
 
重定义（隐藏）：在子类中定义了一个和父类同名的成员（成员变量，成员函数）；这时在子类中要调用父类的此成员，需显示调用；
 
重载：在同一作用域内，函数名相同，参数不同，返回类型可同可不同（根据平台确定，在Windows平台上返回类型可以相同，在linux平台上返回类型不同）；注意：c语言不支持函数重载
二、什么是多态？
“多态”顾名思义“多种形态”；具体来讲就是当用基类的指针或引用调用重写的虚函数时，当指向的是父类对象时，调用的就是父类的虚函数，指向子类对象时，调用的就是父类的虚函数。
三、如何形成多态？
1、虚函数的重写；
2、使用基类的指针或引用调用重写的虚函数；
四、如何实现多态
1、虚表：虚函数表是通过一块连续内存来存储虚函数的地址。这张表解决了继承、虚函数(重写)的问题。在有虚函数的对象实例中都存在一张虚函数表，虚函数表就像一张地图，指明了实际应该调用的虚函数。
2、查看虚表
 

由上图可看出a对象中，有一个_vfptr的指针数组；便是a的虚表，里面存了虚函数f1(),f2()的地址；
 
3、单继承对象模型
 
4、多继承对象模型
typedef void(*VFUNC) ();
void PintVtable(int VTable)
{
	printf("虚表：0x%p\n",VTable);
	int* VArray = (int*)VTable;
	for(size_t i = 0 ;VArray[i] != 0 ;i++)
	{
      printf(" 第%d个虚函数地址 :0x%p,->", i , VArray[i]);
      VFUNC f = (VFUNC)VArray[i];
      f();
	}
	cout<<endl;
}
class Base1
{
public :

   virtual void func1()
  {
   cout<<"Base1::func1" <<endl;
  }
 virtual void func2()
 {
   cout<<"Base1::func2" <<endl;
 }
private :
  int b1 ;
};
class Base2
{
public :
  virtual void func1()
  {
   cout<<"Base2::func1" <<endl;
  }
  virtual void func2()
  {
   cout<<"Base2::func2" <<endl;
  }
private :
  int b2 ;
};
class Derive : public Base1, public Base2
{
public :
  virtual void func1()
  {
    cout<<"Derive::func1" <<endl;
   }
  virtual void func3()
  {
    cout<<"Derive::func3"<<endl;
  }
private:
	int d1;
};
void TestMu()
{
   Base1 B1;
   Base2 B2;
   Derive d;
   PintVtable(*((int*)(&d)));
   PintVtable(*((int*)((char*)(&d)+sizeof(B1))));
}

5、菱形继承
单继承：一个类只有一个直接父类
多继承：一个类有两个或两个以上直接父类
6、菱形的虚拟继承
class A
{
public:
	virtual void fun1()
	{
		cout<<"A::fun1()"<<endl;
	}
public:
	int a;
};
class B :virtual public A
{
public:
	virtual void fun1()
	{
		cout<<"B::fun1()"<<endl;
	}
	virtual void fun2()
	{
		cout<<"B::fun2()"<<endl;
	}
public:
	int b;
};
class C:virtual public A
{
public:
	virtual void fun1()
	{
		cout<<"C::fun1()"<<endl;
	}
	virtual void fun3()
	{
		cout<<"C::fun3()"<<endl;
	}
public:
	int c;
};
class D:public B,public C
{
public:
	virtual void fun1()
	{
		cout<<"D::fun1()"<<endl;
	}
	virtual void fun2()
	{
		cout<<"D::fun2()"<<endl;
	}
public:
	int d;
};
void Test()
{
	D d;
	d.A::a = 0;
	d.B::a = 1;
	d.C::a = 5;
	d.b = 2;
	d.c = 3;
	d.d = 4;
    PintVtable(*((int*)(&d)));
    PintVtable(*((int*)((char*)(&d)+12)));
    PintVtable(*((int*)((char*)(&d)+28)));
    


}





四、总结
1、子类重写父类的虚函数，要求函数名，参数列表，返回类型完全相同（协变除外）
2、父类中定义了虚函数，在派生类中该函数始终保持虚函数的特性（即在子类该虚函数的virtual关键字可以省略，但最好写上）
3、如果在类外定义虚函数，只能在声明此函数时加virtual;
4、构造函数不能定义成虚函数（此时对象还不完整）；
5、不要在构造函数和析构函数里面调用虚函数，在构造函数和析构函数中，对象可能是不完整的，可能会出现未定义的行为；
6、最好将基类的析构函数定义成虚函数；（此时父类的析构函数和子类的析构函数构成重写）；
举一个例子说明这个问题：
#include<iostream>
using namespace std;
class A
{
public:
A()
{
cout<<"A::A()"<<endl;
}
~A()
{
cout<<"A::~A()"<<endl;
}
};
class B:public A
{
public:
  B()
{
        _a = new int[10];
cout<<"B::B()"<<endl;
}
~B()
{
delete[] _a;
cout<<"B::~B()"<<endl;
}
private:
int* _a;
};
int main()
{
A* p = new B();
delete p;
   cout<<endl;
}
在上面的代码中，没有将父类的析构函数定义成虚函数，当使用delete时，只调用了父类的析构函数，而没有调用子类的析构函数，在上面的例子中，导致了内存泄漏；
而将父类的析构函数定义成虚函数时；
 
这样便实现了多态，调用的是子类的析构函数（注意：子类的析构函数会自动调用父类的构造函数），这样可以避免内存泄漏问题；
 
 
 
 

类：具有相同数据结构和相同操作的一类对象的描述。

对象：描述其属性的数据以及对这些数据施加的一组操作封装在一起构成的统一体。

C++的三大特性为：继承，多态，封装

继承指的是通过继承已存在的类所拥有的成员而生成新的类。

封装指的是在类所拥有的成员中，隐藏掉那些没有必要展现给该类调用者的成员。

多态指的是针对同一种消息，不同的对象可以进行不同的操作。
补充：

1、封装可以隐藏实现细节，使得代码模块化，信息隐藏。

2、继承可以扩展已存在的模块，它们目的都是为了：代码重用。

3、而多态是为了实现另一个目的：接口重用。

多态：不同对象收到相同的消息时，产生不同的动作。继承：允许在已有类的基础上创建新的类，新类可以从一个或多个类中继承成员函数和数据成员，并且可以重新定义或加进新的数据和函数，从而形成类的层次或等级。封装：把数据和实现操作的代码集中起来放在对象内部，并尽可能隐藏对象的内部细节。

运算符重载：是对已有的运算符赋予多重含义，使同一个运算符作用于不同类型的数据导致不同的行为。

流：指的是数据从一个源流到一个母的抽象，它是负责在数据的生产者和数据的消费者之间建立联系，并管理数据的流动

 

引用：引用是给对象取的一个别名，用&操作符实现。

内联函数：指用inline关键字修饰的函数。在类内定义的函数被默认成纯虚函数。

构造函数：构造函数是类的一个特殊成员函数，它的函数名与类名相同，它可以有任意类型的参数，但不能具有返回类型。创建一个对象时，自动调用构造函数。 

析构函数：析构函数处理对象的善后工作，函数名与类名相同，但它前面必须有一个~；它没有参数，也没有返回类型。

拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于：

1、通过使用另一个同类型的对象来初始化新创建的对象。

2、复制对象把它作为参数传递给函数。

3、复制对象，并从函数返回这个对象。

如果在类中没有定义拷贝构造函数，编译器会自行定义一个。如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。拷贝构造函数的最常见形式如下：


classname (const classname &obj) {

                                                                      // 构造函数的主体

}


如：Line( const Line &A) {}

在这里，A 是一个对象引用，该对象是用于初始化另一个对象的。

this指针：在 C++ 中，每一个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数。因此，在成员函数内部，它可以用来指向调用对象。

友元函数没有 this 指针，因为友元不是类的成员。只有成员函数才有 this 指针。

 

友元函数：是指某些虽然不是类成员却能够访问类的所有成员的函数。在函数前加上关键字friend即说明了一个友元函数。优点：能够提高效率，表达简单、清晰。缺点：友元函数破环了封装机制，尽量不使用成员函数，除非不得已的情况下才使用友元函数。

 

重载函数：允许在作用域内定义多个同名函数，使这些同名函数表示类似的操作。

运算符重载：运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。

 

继承：面向对象的程序设计语言的特点之一。即一个对象获得另一个对象的特性的过程。如将公共属性和服务放到基类中，而它的各派生类除了有各自的特有属性和服务外还可以共享基类的公共属性和服务。这样的好处是容易建立体系，增强代码重复性。

继承：通过继承机制，可以利用已有的数据类型来定义新的数据类型。所定义的新的数据类型不仅拥有新定义的成员，而且还同时拥有旧的成员。我们称已存在的用来派生新类的类为基类，又称为父类。由已存在的类派生出的新类称为派生类，又称为子类。

派生类：利用继承机制，新的类可以从已有的类中派生。

单继承:一个派生类只有一个基类，成为单继承。

重继承:一个派生类拥有多个基类，成为多继承。

多重继承：指的是一个类可以同时继承多个父类的行为和特征功能。

继承类型：

当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型。我们几乎不使用 protected 或 private 继承，通常使用 public 继承。当使用不同类型的继承时，遵循以下几个规则：

1、公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类（函数）的公有和保护成员来访问。

2、保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。

3、私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。

 

多态：通过继承相关的不同的类，它们的对象能够对同一函数调用作出不同的响应，它是通过虚函数实现的。多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数

虚函数:在基类中说明为virtual并在派生类中重定义的函数。重定义将忽略基类中的函数定义，指明了函数执行的实际操作。当一个基类指针指向包含虚函数的派生对象时，C++将根据指针指向的对象类型来决定调用哪一个函数，实现了运行时的多态性。这里的重定义类似于函数重载，不同的是重定义的虚函数的原型必须和基类中指定的函数原型完全匹配。构造函数不能是虚函数，而析构函数则可以是。

纯虚函数:在基类中只有声明没有实现的虚函数。形式为：virtual type funname（paralist）＝0。这时基函数只提供派生类使用的接口，任何类要使用必须给出自己的定义。

虚函数：是在基类中使用关键字 virtual 声明的函数，在派生类中重新定义基类中定义的成员函数。

在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。

在基类中被冠以virtual的成员函数，它提供了一种接口界面。

在某个基类中声明为virtual并在一个或多个派生类中被重新定义的成员函数。

虚基类：在C++中，一个类不能被多次说明为一个派生类的直接基类，但可以不止一次地成为间接基类。

 

模板：C++语言具有类属机制的叫模板。