java中建构函式名与类名相同，java没有解构函式，java不需要手动释放资源，它是有垃圾回收机制的。
不要随便地将建构函式和解构函式的定义体放在类宣告中。inline不inline，并不会影响建构函式的预设语义，不会因为不是inline的，就不执行基类的构造。并且分析在外的建构函式，仍然可能是inline的。如果建构函式过于复杂，那么就是写在类定义内，仍然是不会被inline的。
我认为原因是这样的：C++提倡实现与介面相分离，宣告中，只给出需要的引数，甚至只是引数型别，而没有引数名。如果你写在宣告中，不是要给出函式体，那样实现程式码大家都能看到了，也许直接去改写你的.h，然后再重新编译，以达到对private成员的直接控制，这样不利于封装。C++的设计，使得一般的具体编译器实现都能做到，把宣告放在.h中，实现放在.cpp中，编译生成.obj，把.cpp档案删除掉（或者就是不发放给使用的使用者），使用者只要这个.obj和.h，就可以将别人实现的程式码库，并到自己的程式中用。如果建构函式是在类定义内直接给出程式码的，这就等于让使用者随便改了。它可能比别的一般函式负面效果还大。
建构函式、解构函式、虚拟函式可否内联，有何意义在语法上没有错误首先要掌握一点，建构函式、解构函式、虚拟函式可以宣告为行内函数，这在语法上是正确的。
When the object is referenced via a pointer or a reference, a call to a virtual function cannot be inlined, since the call must be resolved dynamically. Reason: the piler can't know which actual code to call until run-time (i.e., dynamically), since the code may be from a derived class that was created after the caller was piled. Therefore the only time an inlinevirtual call can be inlined is when the piler knows the "exact class" of the object which is the target of the virtual function call. This can happen only when the piler has an actual object rather than a pointer or reference to an object. I.e., either with a local object, a global/static object, or a fully contained object inside a posite.
请问：编译器自动生成的合成解构函式做释放资源的工作吗？谢谢！不会，如果需要释放资源就要自己写解构函式
在建构函式中开启资料库连线，JAVA没有解构函式怎么自动去关闭子类的构造方法会预设的呼叫父类的无引数够造方法，如在student类中，在构造方法publicStudent(Stringname,intage,Stringschool){super()这是预设的语句，不用显示的呼叫this.name=namethis.age=agethis.school=school}
java中主函式和建构函式谁先载入
当然是先主函式。
程式的入口就是主函式。
至于建构函式。。只有要用到这个类的时候 。就是new出这个类以后才会载入，
我去。后边的人为什么要说建构函式呢。。。主函式可是static的静态的呀 。。在最刚开始载入的时候就载入了的！
需要一个带注释的c#程式其中最好标明建构函式，解构函式，属性等～～namespace GXLogic
{
public class GetLogicDisposedList
{
#region 成员变数
public string PeancyTimeL违法时间起
public string PeancyTimeH违法时间迄
public string DisposeTimeL处理时间
public string DisposeTimeH处理时间
public string PlateType号牌种类
public string PlateNumber号牌号码
public string PeancyAdress违法地点
public string Derection行驶方向
public string PeancyType违法行为
public string DisposedPerson处理人（当资料为处理型别时候——处理人）
#endregion
public GetLogicDisposedList()
{
PeancyTimeL = ""
PeancyTimeH = ""
DisposeTimeL = ""
DisposeTimeH = ""
PlateType = ""
PlateNumber = ""
PeancyAdress = ""
Derection = ""
PeancyType = ""
DisposedPerson = ""
}
这就是建构函式,解构函式C#很少用.你想了解这些可以看看C++
编写类String 的建构函式、解构函式 已知类String 的原型为： class String { public: String(const charString的解构函式
String::~String(void)
{
delete [] m_data
由于m_data是内部资料型别，也可以写成 delete m_data
}
String的普通建构函式
String::String(const char *str)
{
if(str==NULL)
{
m_data = new char[1]若能加 NULL 判断则更好
*m_data = ‘\0’
}
else
{
int length = strlen(str)
m_data = new char[length+1]若能加 NULL 判断则更好
strcpy(m_data, str)
}
}
拷贝建构函式
String::String(const String &other)
{
int length = strlen(other.m_data)
m_data = new char[length+1]若能加 NULL 判断则更好
strcpy(m_data, other.m_data)
}
赋值函式
String &String::operate =(const String &other)
{
检查自赋值
if(this == &other)
return *this
释放原有的记忆体资源
delete [] m_data
分配新的记忆体资源，并复制内容
int length = strlen(other.m_data)
m_data = new char[length+1]若能加 NULL 判断则更好
strcpy(m_data, other.m_data)
返回本物件的引用
return *this
}
[转载]为什么建构函式不能宣告为虚拟函式，解构函式可以建构函式不能宣告为虚拟函式，解构函式可以宣告为虚拟函式，而且有时是必须宣告为虚拟函式。
不建议在建构函式和解构函式里面呼叫虚拟函式。
建构函式不能宣告为虚拟函式的原因是:1构造一个物件的时候，必须知道物件的实际型别，而虚拟函式行为是在执行期间确定实际型别的。而在构造一个物件时，由于物件还未构造成功。编译器无法知道物件
的实际型别，是该类本身，还是该类的一个派生类，或是更深层次的派生类。无法确定。。。
2 虚拟函式的执行依赖于虚拟函式表。而
虚拟函式表在建构函式中进行初始化工作
，即初始化vptr，让他指向正确的虚拟函式表。而在构造物件期间，虚拟函式表还没有被初
始化，将无法进行。
编译器在呼叫基类的建构函式的时候并不知道你要构造的是一个基类的物件还是一个派生类的物件。
解构函式设为虚拟函式的作用:解释：在类的继承中，如果有基类指标指向派生类，那么用基类指标delete时，如果不定义成虚拟函式，派生类中派生的那部分无法析构。例：#include "stdafx.h"
#include "stdio.h"class A{public:A()virtual~A()}A::A(){}A::~A(){
printf("Delete class APn")}
class B : public A{public:B()~B()}B::B(){ }B::~B(){
printf("Delete class BPn")}
int main(int argc, char* argv[]){
A *b=new Bdelete breturn 0}
输出结果为：Delete class B
Delete class A
如果把A的virtual去掉：那就变成了Deleteclass A也就是说不会删除派生类里的剩余部分内容，也即不呼叫派生类的虚拟函式
因此在类的继承体系中，基类的解构函式不宣告为虚拟函式容易造成记忆体泄漏。所以如果你设计一定类可能是基类的话，必须要宣告其为虚拟函式。正如Symbian中的CBase一样。
Note：1.
如果我们定义了一个建构函式，编译器就不会再为我们生成预设构造函数了。
2. 编译器生成的解构函式是非虚的，除非是一个子类，其父类有个虚析构，此时的函式虚特性来自父类。
3. 有虚拟函式的类，几乎可以确定要有个虚解构函式。
4. 如果一个类不可能是基类就不要申明解构函式为虚拟函式，虚拟函式是要耗费空间的。5.
解构函式的异常退出会导致析构不完全，从而有记忆体泄露。最好是提供一个管理类，在管理类中提供一个方法来析构，呼叫者再根据这个方法的结果决定下一步的操作。6.
在建构函式不要呼叫虚拟函式。在基类构造的时候，虚拟函式是非虚，不会走到派生类中，既是采用的静态系结。显然的是：当我们构造一个子类的物件时，先呼叫基类的建构函式，构造子类中基类部分，子类还没有构造，还没有初始化，如果在基类的构造中呼叫虚拟函式，如果可以的话就是呼叫一个还没有被初始化的物件，那是很危险的，所以C++中是不可以在构造父类物件部分的时候呼叫子类的虚拟函式实现。但是不是说你不可以那么写程式，
你这么写，编译器也不会报错。只是你如果这么写的话编译器不会给你呼叫子类的实现，而是还是呼叫基类的实现。7.在解构函式中也不要呼叫虚拟函式。在析构的时候会首先呼叫子类的解构函式，析构掉物件中的子类部分，然后在呼叫基类的解构函式析构基类部分，如果在基类的解构函式里面呼叫虚拟函式，会导致其呼叫已经析构了的子类物件里面的函式，这是非常危险的。8.
记得在写派生类的拷贝函式时，呼叫基类的拷贝函式拷贝基类的部分，不能忘记了。
写一个复数Complex类，该类有建构函式、解构函式、 、=运算过载函式和列印函式，并在main函式中测试#include <iostream>
using namespace std
class Complex{
double real
double imag
public:
Complex(double pr=1, double pi=1){
real=primag=pi
cout <<"构造物件...\n"
}
~Complex(){ cout <<"析构物件...\n"}
Complex&operator=(const Complex&c){
if(this==&c)
return *this
real=c.real
imag=c.imag
return *this
}
void display(){
cout <<real<<(imag>=0 ? "+" : "")<<imag<<"i"<<endl
}
}
int main(){
Complex c1(3.3,-4.4),c2
c2=c1
c1.display()
c2.display()
return 0
}
