1，软件测试，如何把这个测试做的更好。2，
1，软件测试，如何把这个测试做的更好。
进到一个新项目，作为测试人员应该都是想把测试做好，项目在符合客户质量要求的情况下按时交付的吧。但往往都事与愿违，造成这个结果的原因有很多很多。通过这段时间做自动化测试，站在自动化测试的角度看手工测试，以及排除其他部门的问题，单说测试自身的问题来和大家分析讨论一下怎样我能做到更好。
先说一下背景，我是中途进的项目，项目需要做自动化测试，依据是手工测试人员开发的用例。从测试用例和测试流程两方面来进行阐述吧。
首先说说测试用例。当前大部分的项目一般都是任务重时间紧，往往为了能保证能把项目“做”完，挤压了测试开发、执行和需求分析的时间。测试用例设计开发作为测试团队主要的工作任务，其重要性仅次于需求分析。如果测试用例的质量出现问题会产生一连串的影响，比如不能让新进开发团队的人员了解系统、以手工用例为基础的自动化测试开发人员无从下手或繁重的修改工作、最重要的是增加了回归测试执行的时间及风险。
在测试用例开发上，比较常见的问题就是用例有量无质。用例的数量上去了却无质量可言，大量重复的又缺乏测试必要的用例。做为测试团队重要的输出物之一，如果不能保证用例的质量那系统的质量又从何谈起呢？测试用例的质量我觉得体现在以下两个方面：
1、测试用例不够详尽、缺乏目的性、重复性高
测试用例的详细程度是一个相对的问题。太详尽了使操作步骤过于繁琐冗长，测试人员操作完之后无法对测试用例有一个整体认识；过于简约的用例同样无法让测试人员了解测试目的，应该如何操作。在我的想法中，一个具有一定质量的测试用例应该经过多方面配合的，比如用例描述信息、用例名称及操作步骤等等。描述信息中可以描述出测试用例是由谁、在和情况下、做了什么事及最后的结果；用例名称显示出是对哪个业务进行的正面/反面测试；如果说名称和描述为辅助的信息，那么测试步骤无疑是在一个相对比较重要的位置上了。测试步骤的来源是什么？是系统需求。那么系统需求的好坏就决定了测试步骤的好坏。如果需求详尽，简洁省时的方法当然可以用直接引用的方式，这样正确性有所保证也为开发其他用例节省了时间；相反的，需求不够详尽，是否应将测试步骤进行一定的扩展，避免操作步骤的混淆，让对系统不熟悉的人尽快了解系统功能。在测试开发的迭代周期中，最常见的问题就是需求的更改，这个是无法避免的。那么对于测试用例，我们如何应对这种变化呢？我想除了不要将用例中的期望结果过于详细外，应当勤于进行用例的开发迭代以符合系统需求，关于这一点，我们稍后再说。
测试用例缺乏目的性、重复性高是造成用例数量直线上升，质量直线下降的一个重要因素。假设一个用户注册的场景，用户可通过不同的证件类型完成注册，如何设计这个用例呢？我的想法是，对于注册成功的预期结果，只安排一个用例，在用例的前提条件或描述信息中突出需通过不同证件类型参数进行测试。从开发人员的角度和2/8原则的角度讲，他们的主要精力会放在将正常的注册功能开发完成，即假定用户输入的值都是合法的。实际上，测试往往就是对那些无法顺利完成功能的场景，输入无效值或测试反面场景以覆盖完全的测试场景。在设计用例时，就应当将更多的精力放在这些场景的设计上。有些人可能会说，如果将手工用例参数化，在执行用例的时候，不同的测试人员往往不会按照用例的描述，分不同的数据要求去执行，这个无法保证。从我的角度来说，一方面需要测试领导的信任，一方面也许要对测试人员进行监督。对同事信任，相信他们会进行全面的测试。对按用例要求进行测试的人员给予奖励，对不能认真完成测试用例要求的测试人员实施惩罚，这样鼓励已经做好的人继续保持，还没做好的往好的目标前进。
2、用例更新滞后
在软件开发周期中会经过几次迭代过程，每一次迭代都会经历大小不同的需求变更、系统实现变化等等。在需求发生变化后，应及时更新测试用例，以保证测试用例适用于当前的系统实现，这样才能保证回归测试的执行是有效的，并节省下更多的人力物力到更容易发生错误的地方。除了新需求的增加、老需求的变更，实时的对测试用例进行重构也是必要的，如同对系统代码进行重构一样，这样才能让系统跑的更快更安全，以更少的测试用例覆盖更多的功能点和业务规则。最初开发测试用例，由于对系统需求缺乏深入理解或开发时间紧，不能覆盖全面的测试场景或者用例重复性较高，这都需要及时的通过测试用例的重构提高系统测试用例的有效性。我认为，应该尽量争取在下一个迭代周期结束前进行或完成之前一个迭代周期中测试用例的重构。积压的测试用例越多进行重构的难度越大，耗费的精力越多，风险也就越大。需求的遗忘、变更，需要修改的用例数量之大，加之有限的时间等等，都会给测试用例重构造成隐患，延误回归测试的进度。看着上千的测试用例，谁都会头疼吧。说起来我们有几千个用例测试系统可在真正执行时有多少是能发挥效果的呢？
其次再说说测试流程。最早接触的是CMMI，现在慢慢的随着客户需求日新月异，加上新的流程概念的引入，越来越多的项目采用了敏捷开发的概念。就我对敏捷开发的认识，从形式上来说敏捷与CMMI的区别是，注重敏捷的沟通多于文档这些形式上的产物，当然敏捷开发不是简简单单注意沟通就可以的。对于刚刚引入敏捷概念的项目，团队之间的契合度不高，理解不深，加之大家还没有脱离CMMI的形式，导致项目流程既不敏捷，也不CMMI。说是CMMI可流程执行力度不够，说敏捷沟通又不够。我的理解，敏捷与CMMI在工作内容、职责上并无太大变化，不同的是需要加强团队之间的沟通，任何的变化都应该是连环动起来的，而不是变化传达到第一个人就结束了，就像军训时的向右看齐，只有每一个人都向右看，最后一个人才有可能和第一个人在一个水平线上。在我经历的几个项目中，沟通不够往往表现在几个方面，项目信息共享，包括技术的和业务的、需求变更、用例变更、开发进度等等。有多少会做到开发进度实时更新，更新了有多少人会去看，不如当面锣对面鼓的说清楚。在变化快的情况下，过于依赖文档反而会让大家对项目不甚了解或知之甚少。敏捷强调沟通也是为了避免在文档的更新上各个环节出现之后。再者文档对信息的传达力有多大也是个问题，举个例子，比如用例进行重构，测试人员通过映射表记录用例的变化情况，哪些是过期的，哪些是修改了步骤的，哪些是新增的等等。在设计这个映射表要提供哪些信息时一定要想谁会去看这些信息，所以哪些信息对他们是有用的，能让他们快速的找到他们想了解的东西，这些信息一定要记录。
这里记录了一些在项目中遇到的问题，希望可以给自己更多的思考，在以后自己的工作中可以避免，也是把一些问题拿出来和大家讨论，希望集大家之广议共同提高，有些说的不清楚，更像是抱怨别人的问题，可能因为自己的认识还不够深刻吧，会在以后的时间中改进，多写一些改进措施。对于测试会有这样的现象出现也不是测试单方面的责任，很有可能是需求没有做好，或开发的问题。对于敏捷，我们应该想的更多做的更多，才能把项目做好
现在推广 敏捷 测试 ，发现很多人没有理解敏捷的实质。
2. 可重复级(Repeatable)
3. 已定义级(Defined)
4. 已管理级(Managed)
5. 优化级(Optimizing)
CSCMM与CMM的主要区别：在等级1和等级2之间插入了一个“基本级”，使成熟度等级更加均匀。
意义：以免 软件开发组织长时间达不到2级，会是之失去信心。
0. 初始级。没有定义软件过程。
1. 基本级。定义了软件过程但执行可能不一致。
2. 可重复级。定义了软件过程且执行基本一致。
3. 已定义级。工程过程/管理过程都明确/妥善定义，并且文档化/标准化，成为软件开发组织的 标准软件过程 。组织内所有软件开发项目均采用该 标准软件过程 的经批准的剪裁版本。
4. 定量管理级。在开发过程中，能详细采集软件过程/软件产品的度量数据，从而对成本/进度/质量 定量预测/定量控制。（可见，“定量管理级”这个名字比“已管理级”更传神。）
5. 优化级。能根据 实践总结/新的技术，对标准软件过程不断改进。
1、在软件开发组织中，软件过程要规范化/具体化。
2、在软件开发组织中，要通过正式文档/文件和培训，将其软件过程准确无误地告知所有员工，新员工要进行特别培训。
3、CMM的组织结构：它推荐在最高领导之下设立SEPG（软工过程组）、SQA（质量保证组）、SEG（软工组）
2，java和C++ 的区别，
1．指针
JAVA语言让编程者无法找到指针来直接访问内存无指针，并且增添了自动的内存管理功能，从而有效地防止了c／c++语言中指针操作失误，如野指针所造成的系统崩溃。但也不是说JAVA没有指针，虚拟机内部还是使用了指针，只是外人不得使用而已。这有利于Java程序的安全。
2．多重继承
c++支持多重继承，这是c++的一个特征，它允许多父类派生一个类。尽管多重继承功能很强，但使用复杂，而且会引起许多麻烦，编译程序实现它也很不容易。Java不支持多重继承，但允许一个类继承多个接口(extends+implement)，实现了c++多重继承的功能，又避免了c++中的多重继承实现方式带来的诸多不便。
3．数据类型及类
Java是完全面向对象的语言，所有函数和变量部必须是类的一部分。除了基本数据类型之外，其余的都作为类对象，包括数组。对象将数据和方法结合起来，把它们封装在类中，这样每个对象都可实现自己的特点和行为。而c++允许将函数和变量定义为全局的。此外，Java中取消了c／c++中的结构和联合，消除了不必要的麻烦。
4．自动内存管理
Java程序中所有的对象都是用new操作符建立在内存堆栈上，这个操作符类似于c++的new操作符。下面的语句由一个建立了一个类Read的对象，然后调用该对象的work方法：
Read r＝new Read()；
r.work()；
语句Read r＝new Read()；在堆栈结构上建立了一个Read的实例。Java自动进行无用内存回收操作，不需要程序员进行删除。而c十十中必须由程序贝释放内存资源，增加了程序设计者的负扔。Java中当一个对象不被再用到时，无用内存回收器将给它加上标签以示删除。JAVA里无用内存回收程序是以线程方式在后台运行的，利用空闲时间工作。
5．操作符重载
Java不支持操作符重载。操作符重载被认为是c十十的突出特征，在Java中虽然类大体上可以实现这样的功能，但操作符重载的方便性仍然丢失了不少。Java语言不支持操作符重载是为了保持Java语言尽可能简单。
6．预处理功能
Java不支持预处理功能。c／c十十在编译过程中都有一个预编泽阶段，即众所周知的预处理器。预处理器为开发人员提供了方便，但增加丁编译的复杂性。JAVA虚拟机没有预处理器，但它提供的引入语句(import)与c十十预处理器的功能类似。
7. Java不支持缺省函数参数，而c十十支持
在c中，代码组织在函数中，函数可以访问程序的全局变量。c十十增加了类，提供了类算法，该算法是与类相连的函数，c十十类方法与Java类方法十分相似，然而，由于c十十仍然支持c，所以不能阻止c十十开发人员使用函数，结果函数和方法混合使用使得程序比较混乱。
Java没有函数，作为一个比c十十更纯的面向对象的语言，Java强迫开发人员把所有例行程序包括在类中，事实上，用方法实现例行程序可激励开发人员更好地组织编码。
8 字符串
c和c十十不支持字符串变量，在c和c十十程序中使用Null终止符代表字符串的结束，在Java中字符串是用类对象(strinR和stringBuffer)来实现的，这些类对象是Java语言的核心，用类对象实现字符串有以下几个优点：
(1)在整个系统中建立字符串和访问字符串元素的方法是一致的；
(2)J3阳字符串类是作为Java语言的一部分定义的，而不是作为外加的延伸部分；
(3)Java字符串执行运行时检空，可帮助排除一些运行时发生的错误；
(4)可对字符串用“十”进行连接操作。
9“goto语句
“可怕”的goto语句是c和c++的“遗物”，它是该语言技术上的合法部分，引用goto语句引起了程序结构的混乱，不易理解，goto语句子要用于无条件转移子程序和多结构分支技术。鉴于以广理由，Java不提供goto语句，它虽然指定goto作为关键字，但不支持它的使用，使程序简洁易读。
l0．类型转换
在c和c十十中有时出现数据类型的隐含转换，这就涉及了自动强制类型转换问题。例如，在c十十中可将一浮点值赋予整型变量，并去掉其尾数。Java不支持c十十中的自动强制类型转换，如果需要，必须由程序显式进行强制类型转换。
11.异常
JAVA中的异常机制用于捕获例外事件，增强系统容错能力
try{／／可能产生例外的代码
}catch(exceptionType name){
//处理
}
其中exceptionType表示异常类型。而C++则没有如此方便的机制。
c++ 就是C语言加了一些东西。。就是所谓的++ java 说白了就是C++--加了一些东西减了一些东西。
java是在C++的基础上开发的。java是纯面向对象编程，C++不是，java没有指针，没有内存溢出，C++有。
都能够实现面向对象思想（封装，继乘，多态）。而由于c++为了照顾大量的C语言使用者， 而兼容了C，使得自身仅仅成为了带类的C语言，多多少少影响了其面向对象的彻底性！JAVA则是完全的面向对象语言，它句法更清楚，规模更小，更易学。它是在对多种程序设计语言进行了深入细致研究的基础上，据弃了其他语言的不足之处，从根本上解决了c++的固有缺陷。 Java和c++的相似之处多于不同之处，但两种语言问几处主要的不同使得Java更轻易学习，并且编程环境更为简朴。 我在这里不能完全列出不同之处，仅列出比较显著的区别： 1．指针 JAVA语言让编程者无法找到指针来直接访问内存无指针，并且增添了自动的内存治理功能，从而有效地防止了c／c++语言中指针操作失误，如野指针所造成的系统崩溃。但也不是说JAVA没有指针，虚拟机内部还是使用了指针，只是外人不得使用而已。这有利于Java程序的安全。 2．多重继续 c++支持多重继承，这是c++的一个特征，它答应多父类派生一个类。尽管多重继承功能很强，但使用复杂，而且会引起许多麻烦，编译程序实现它也很不容易。Java不支持多重继承，但允许一个类继承多个接口(extends+implement)，实现了c++多重继承的功能，又避免了c++中的多重继承实现方式带来的诸多不便。 3．数据类型及类 Java是完全面向对象的语言，所有函数和变量部必须是类的一部分。除了基本数据类型之外，其余的都作为类对象，包括数组。对象将数据和方法结合起来，把它们封装在类中，这样每个对象都可实现自己的特点和行为。而c++允许将函数和变量定义为全局的。此外，Java中取消了c／c++中的结构和联合，消除了不必要的麻烦。 4．自动内存管理 Java程序中所有的对象都是用new操作符建立在内存堆栈上，这个操作符类似于c++的new操作符。下面的语句由一个建立了一个类Read的对象，然后调用该对象的work方法： Read r＝new Read()； r.work()； 语句Read r＝new Read()；在堆栈结构上建立了一个Read的实例。Java自动进行无用内存回收操作，不需要程序员进行删除。而c十十中必须由程序贝释放内存资源，增加了程序设计者的负扔。Java中当一个对象不被再用到时，无用内存回收器将给它加上标签以示删除。JAVA里无用内存回收程序是以线程方式在后台运行的，利用空闲时间工作。 另外,站长团上有产品团购,便宜有保证
Java程序中的每个变量要么是基本数据类型（boolean, char, byte, short, int, long, float, double），要么是对对象的引用 C++有许多种基本类型，额外还有struct, union, enum, 数组和指针，C++指针可以指向对象，也可以不指向对象 Java没有枚举、联合类型，因为Java认为没有必要。将可有可无的语言元素去掉是Java对C/C++做出的一大改变，因此，普遍认为Java较C++更轻便，更精简 Java采用Unicode字符集，C++通常用ASCII字符集。但ASCII是Unicode的子集，对于习惯于ASCII的程序员感觉不到区别 Java中的boolean类型不能转换成其他类型，反之亦然。C++最近引进了bool类型，代表布尔类型，整型也作为逻辑判断 模板是一种“泛型编程思想”，它有别于“面向对象编程思想”。C++在很大程度上已经支持了这种新型编程方法，特别是STL的出现 Java目前仍未支持泛型编程，不过据说Sun公司有在Java中引入模板的计划 C++支持“运算符的重载”，这是它的一个很重要的多态特征，是数据抽象和泛型编程的利器。它允许直接对对象进行四则运算，正像基本数据类型那样 Java不支持这种多态机制，也是为降低复杂性 两种语言都支持方法重载(overloading) 在C++中，为了允许运行时动态决定哪个函数被调用，一个函数必须用virtual修饰。virtual关键字被自动继承，用以支持多态 凡是没有用virtual修饰的成员函数（包括static）都是静态绑定的，即在编译时决定调用哪个版本 而在Java中，除了static、final、private是静态绑定以外，所有方法一律按动态绑定处理 C++中有“拷贝构造函数”的概念，在三种情况下，自动调用它 用一个对象初始化另一对象 对象作实参进行函数调用 对象作函数的返回值 通常，当一个对象需要做“深拷贝”(钱能：《C++程序设计教程》)时，我们需要为它事先定义“拷贝构造函数”、“赋值运算符的重载函数”和“析构函数”；否则编译器将以“按位copy”的形式自动生成相应的缺省函数。倘若类中含有指针成员或引用成员，那么这三个默认的函数就隐含了错误 Java则没有这种语法结构和语义逻辑 C++支持inline函数，可以避免函数的堆栈调用，提高运行效率 Java无这种语义 C++中，构造函数的初始化列表是这样使用的：首先按继承顺序调用基类的构造函数构造基类对象，然后按声明顺序调用成员对象的构造函数构造成员对象，最后对列表中出现的成员变量做初始化 Java不采用初始化列表这种构造机制 它们的构造顺序基本一致： 静态变量初始化 静态初始化块（Java） 调用基类的构造函数构造基类对象 实例变量的初始化 构造函数的其余部分 Java使用abstract关键字修饰抽象方法或抽象类 C++的对等语法是“纯虚函数”和“抽象类” 两者都使用抽象类作为继承层次中的基类，提供一般概念，由子类实现其抽象方法，且抽象类都不能被直接实例化为对象 Java中有final关键字，修饰类、方法或变量 final类不能被继承 final方法不能被子类覆盖 final变量就是常量 C++中没有这个关键字，常量可以使用const或#define定义 const还可以修饰成员函数，即“常成员函数”，当一个const成员函数修改成员数据，或调用非const成员函数时，编译器会报错 我们应将不修改成员数据的函数声明为const Java和C++中的static关键字语法和语义基本相同 static成员变量又叫类变量，被类的所有对象共享 A::x (C++)：必须在类体外初始化 A.x (Java)：必须在类体内初始化 static成员方法又叫类方法，访问static变量 A::f( ) (C++) A.f( ) (Java) 两者都有内部类和局部类的语法和语义 Java中没有友元函数和友元类的概念，严格支持封装，不允许外部方法访问类的私有成员 而C++支持friend关键字，允许外部方法访问类的私有成员，因此不是一种纯面向对象的编程语言 Java中类或interface可以用public修饰，也可以不修饰；而C++类不能修饰 三种访问权限的语义相同，语法略有差别 C++中还有继承权限修饰符，Java则没有 class A: protected B, public C (C++) class A extends B (Java) Java有super关键字，指代父类对象，通常被用于调用父类的构造方法或一般方法 C++则没有super关键字 两者都有this，指代当前对象 Java有package的概念，可以将类组织起来，便于打包和部署，也有利于类的安全。C++没有这个概念，一个类可以被任意类访问 Java applet可以被嵌入HTML文档中，然后由Web浏览器下载和执行 Java API有对网络通讯的特别支持 C++则无内置网络功能 C++程序员必须显式地实现动态内存管理，在析构函数中用delete运算符或free( )函数释放对象和其他动态分配的数据空间，否则会造成“内存泄露” 而在Java中，垃圾收集是自动的。当对象的最后一个引用变量被释放掉，这个对象就成为垃圾收集器的候选对象了 因此Java不支持析构函数 finalize( )方法主要被用来释放先前打开的非内存资源，如文件句柄 Java源代码被编译成字节码（.class文件），字节码是一种只有JVM才能识别的二进制低级代码，它与具体的处理器无关，要由安装在OS之上的JVM解释执行，转换成相应平台的机器码，因此Java是体系结构中立和跨平台的 而C++直接被编译成底层平台的二进制机器码，由CPU执行，是平台相关的 因此，当解释执行时，Java程序速度更慢 Java语言支持多线程，允许并发线程的同步与互斥操作 C++则没有这种内在机制
太多了，就说三个吧： 1，Java有接口(interface)，C++没 2，Java不支持多重继承，C++可以 3，Java一般编译为.class的虚拟机代码, C++可以编译为本地平台的二进制代码 4，Java内置了垃圾收集器不用程序管理内存，C++一般需要自己维护内存
首先java和cC++都是经典的语言，但是二者却有着惊人的相似，对于面向对象的思想如出一辙！ 但是C++却相对比java难点，一方面是因为指针和对象的建立与销毁，内存的分配C++要程序员自己处理，而且要编出高效的代码就需要一定的联系与经验的！ Java就不同，可以说是C++的精简版，对很多的处理都做了人性化的简化，更容易上手！ C++对于底层通信，可以说了语言界的老大，而且API很全很丰富，大型的网游，游戏十之八九都是用它开发的。 而Java注重于web开发（后来发展出来的），因为其与平台的无关性，所以今年飞速发展-----可能是web时代的带动！ 你如果有C++基础，学java简直就是飞速，看下就明白了！但是学过java学C++，会比没有基础的人强，但是要费劲点。C++还是非常有市场潜力的！ 语言吗------任何一门语言，只要你精通，很容易找工组！精通最好，慢慢学习，都是种思想！
JAVA和c++的区别还是挺大的，显而易见的不同点。java比c++更为高级，在java当中多数是面向对象，而c++是主函数。但是就一般参加的竞赛来说，c++的执行效率要比java快很多，要是做软件的话，还是java比较人性化，编码易懂。这只是大方面的，在具体携带的时候不同点还是有很多的，如果想知道可以留言
都是面向对象的语言，但是用的地方不一样。
java 程序的总体布局是由很多类组成的，每个类都处于一个文件中。如果所有的类都位于同一个目录(文件夹)中，Java需要使用某个类(文件)的时候，就会自动 地找到它。通过使用import语句，也可以将不同目录中的类(文件)组合起来。
Java和C++中的注释在本质上是完全一样的。
Java中没有全局变量。
Java中没有枚举类型。
Java中没有typedef。
Java中没有结构或联合。
可以像在C++中那样，在Java中对方法(函数)名进行重载，但在Java中不能对运算符进行重载。
Java中没有多重继承，但它确实通过接口恢复了多重继承的很多功能。
Java中没有模板，但它确实通过泛型恢复了模板的很多功能。
在Java中，类可以有一个与类具有相同类型参数的构造器，但这个构造器没什么特殊的地位，不同于C++中的副本构造函数。
Java与C/C++有什么区别
C++和JAVA的区别
JAVA和C＋＋的区别介绍框架纲领如下：
(一) 序言：
(二) 我学习二者的个人感受：
(三) 个人建议：
(四) 用JAVA中继承的特性来描述C＋＋和JAVA的关系图示：
(五) JAVA和C＋＋的区别（前言导读）：
(六) JAVA和C++的基本区别(开始华山论剑)
1)JAVA摒弃的C＋＋内容。
2)JAVA的新特性。
3)JAVA和C＋＋都有却不同的特性.
(七) JAVA和C＋＋的区别详细介绍（对部分知识点的扩充）：
(八) C＋＋与JAVA区别小总结：
开始进行：
（一）序言：本人整理的资料几乎涵盖了所有的方面，也可以说包含了用百度搜索能搜到的几乎所有的内容，并参考有关书籍资料，耗时将近12个小时。可以说它 是互联网上资料最全面、最具有代表性的二者的区别总汇，当然它没有一本专门介绍二者区别的书更具有权威性和全面性，但是我相信你通过这些内容足以解决你在 实际工作或学习中遇到的编程问题！
其中所涉及到的内容不乏有拷贝的内容，但大部分是经过自己分析和思考而整理出来的，并对某些别人上传到互联网上的资料做了进一步的修改和说明。不是说我们从别人那里ctrl+c一下放到自己的家门儿就算是ok了，我们尽可能的要向资料的准确性和版权性付相应的责任。
这样一方面对自己有很大的提高，另一方面只有这样才能给广大同仁提供更准确和更丰富的信息内容，大家才能共同提高和进步.
（二）我学习二者的个人感受：
我最初学习的是Java，后来又学习C＋＋，虽然二者都是面向对象的语言(C＋＋是半面向对象语言)，但是在C＋＋的学习过程中，C＋＋“几乎完全”没有规则性或者超灵活性的语法让一个之前学过JAVA语言的人感到很不爽！！！
Java确实是个很不错的东西，尤其是其背后有强大的类库做支撑，用起来感觉那是相当的爽，但速度也确实是个问题。幸好现在的Java语言，其执行方式已经不仅仅是解释执行方式了，即时编译器（JITC、just-in-time compiler）技术和原型编译技术的出现大大提高了JAVA的运行效率。
C＋＋灵活无比，但纯属高级玩具或者高深的九阳神功，假如玩不好，就把自己绕进去，如练奇门遁甲一般走火入魔，如果玩好了，那可就是强大致极啊！
C++在设计时因为必须完全兼容C语言又必须提供所有的面向对象特性所以最终它的结构变得特别复杂，当引入泛型编程STL（标准模板库）之后显得更加复杂。
Java是在C++的基础上开发出来的，比C++简化很多，容易使用很多，但是在有些方面特别是泛型方面明显没有C++使用起来灵活。在某些功能上也稍逊于C++，例如对于图像的剪切等方面的技术。
（三）个人建议：所以我认为如果先学习C＋＋再来学习JAVA会容易很多。先学C＋＋就好比一开始你是穿着裤子进行110米跨栏，再学习JAVA就好比你是穿着裤衩进行跨栏，没有那么多的乱七八糟的东西或者越弄越复杂的东西，显得干净利落，在增加了多个新特性后又不失功能的强大。要不有人曾经打比方说：Java就是C++这个超级重装骑兵脱下盔甲下了马换上短剑拿起轻盾再背一把可替换的AK47。
当然，如果有人想学习JAVA，也没有必要非得从C＋＋开始学起，我说的是如果有人需要两种语言都学的话，这个流程还是可以考虑的!
（四）下面我用一个JAVA中继承的特性来描述C＋＋和JAVA的关系：
class C＋＋
{
protected String attribute=”构造函数、new关键字等等”;
C++( ){System.out.println(“我C＋＋是JAVA的爸爸！”);
}
void C＋＋的家产( )
{
System.out.println(“我有家财万贯：结构体或联合体、枚举、指针、操作符重载、预处理、支持自动的类型转换、全局变量或全局函数、多 继承析构函数、支持typedef、可以声明无符号整数、goto语句、delete操作符、标准库函数、wchar_t型、支持异常处理等等”);
}
}
class Java extends C＋＋ {
//我完全继承了父亲的属性
Java( ){System.out.println(“我JAVA是C＋＋的儿子！”);
}
void C＋＋的家产( )//儿子重写C＋＋的家产( )这个方法
{
System.out.println(“我有更值钱的东西：我用类来代替结构体、我有API来代替标准库函数、我有finalize( )函数来代替析构函数、我的char类型是16位的Unicode字符来代替wchar_t型、内置的字符串类型String来代替C＋＋中的string类、我捕捉一个被引发的异常来代替C＋＋的异常处理机制。”);
}
void JAVA新属性( )
{
System.out.println(“我不单单和父亲在相同的领域做的比他更好，我还涉及了他没有涉及到的领域：我拥有自己的包、多线程和接口、自动 内存管理机制、>>>操作完成无符号的右移、文档注释等等多元化的市场策略，涉及到了房地产、金融、健身美容、生物医药等领域，呵 呵！”);
} }
（五）JAVA和C＋＋的区别（前言导读）：
JAVA和C++都是面向对象语言。也就是说，它们都能够实现面向对象思想（封装，继乘，多态）。而由于c++为了照顾大量的C语言使用者，从而兼容了C，使得自身仅仅成为了带类的C语言，多多少少影响了其面向对象的彻底性！JAVA则是完全的面向对象语言，它句法更清晰，规模更小，更易学。它是在对多种程序设计语言进行了深入细致研究的基础上，摒弃了其他语言的不足之处，从根本上解决了c++的固有缺陷。
用C++可以使用纯过程化的编程，也可以是基于对象的编程，还可以是面向对象的编程，当然大部分是混合编程，c++可以跨平台（我强调一下必须是用标准C＋＋，就是调用标准库函数写的程序跨平台才能非常容易，不能跨平台的是VC++等IDE（也就是说你用VC＋＋写出来的C＋＋程序就不能跨平台，其实Linux下的G++编译器对标准C++支持得很好，注意：不要混淆C＋＋和VC＋＋的概念。）[/color]java是纯面向对象的语言，其最大的特色Write once ,Run anywhere！
作为一名C++程序员，我们早已掌握了面向对象程序设计的基本概念，而且Java的语法无疑是非常熟悉的。事实上，Java本来就是从C++衍生出来的， 而且Java语言的对象模型几乎就是C++对象模型的简化版。然而，C++和Java之间仍存在一些显著的差异。可以这样说，这些差异代表着技术的极大进 步。一旦我们弄清楚了这些差异，就会理解为什么说Java是一种优秀的程序设计语言。
Java和c++的相似之处多于不同之处，但两种语言因为有几处主要的不同使得Java更容易学习，并且编程环境更为简单。
（六）JAVA和C++的基本区别(开始华山论剑)
先来探讨一下C＋＋和JAVA的基本区别。
这些不同之处大致分为三类：
1)JAVA不支持的C＋＋特性。
2)JAVA的独特之处。
3)C＋＋和JAVA都有但是却不相同的特性。
详细讨论这三类： 1)JAVA摒弃的C＋＋内容.
有些C＋＋的内容特性JAVA并不再支持。在某些情况下，一个特殊的C＋＋特性和JAVA的运行环境不相关。另一些情况下，JAVA的设计者舍弃了C＋＋中某些重复的内容。还有一些情况是，出于对Internet applet的运行安全问题的考虑，JAVA不再支持某些C＋＋的特点。
C＋＋和JAVA之间的最大不同可能是JAVA不再支持指针。指针使C＋＋语言成为功能最强大最重要的一种编程语言。但同时指针在使用不正确的情况下也是C＋＋中最危险的部分。JAVA不支持指针的原因主要有两点：
(1)指针本身就非常不安全。例如，使用C＋＋的状态指针，可以访问程序代码和数据段外的内存地址，一个恶意程序可以利用这个特点破坏系统，完成非法访问(如获取口令等)，或者违反安全限制。 (2)即使指针可以被限制在JAVA的运行系统中(这在理论上是可行的，因为JAVA程序是解释执行的)，JAVA的设计者相信它们仍然是麻烦所在。
注意：既然JAVA中不存在指针，那么也不存在－>操作符。这里还有一些非常重要的”省略”：
a)JAVA不再支持操作符重载。
操作符重载在某些情况下造成类C＋＋程序的含糊不清，JAVA的设计人员感觉它带来的麻烦要比它带来的好处多。
b)JAVA不再包含结构或者联合。在可以完全包含它们的类出现后，这些结构成为冗余部分。
c)JAVA不再包括预处理，也不再支持预处理指令。预处理在C＋＋语言中已经不如C中那么重要，JAVA的设计者认为是彻底消除预处理的时候了。
d)JAVA不支持自动的类型转换，因为这种类型转换导致精度降低例如当从长整型转换为整型时，必须显示强制执行类型转换。
e)在JAVA中的代码必须封装在一个或者多个类中。因此JAVA中不再包含所谓的全局变量或者全局函数。
f)JAVA不再允许默认参数。在C＋＋中，当过程调用时存在没有对应值的参数时可以使用一个预先指定的值。JAVA不再允许这样的操作。
g)JAVA不支持多继承，即不允许一个子类继承多个父类。
h)虽然JAVA支持构造函数，但是不再支持析构函数[/b]。但是，JAVA增加了finalize( )函数。
i)JAVA不再支持typedef.
j)在JAVA中不再可能声明无符号整数。
k)JAVA不再支持goto语句。
l)JAVA不再有delete操作符。
m)JAVA中的<>不再重载I/O操作。
n)JAVA中，对象只能由引用传递，C＋＋中对象可由值或引用传递.
2)、JAVA的新特性。
JAVA中的许多特性是C＋＋中没有的。其中最重要的三个方面是多线程、包和接口，还有其他的许多独特之处都丰富了JAVA编程环境。
1)多线程允许两个或者多个相同的线程并发运行。
而且，这是一种在语言级支持的并发机制。C＋＋中没有类似的机制，或者说C＋＋采用的是单线程的体系结构。如果需要并发执行一个C＋＋程序，必须利用操作系统的功能手工启动。虽然这两种方法都可以同时执行两个或者多个线程，但是JAVA的方法清楚而且便于使用。
2)C＋＋中没有可以与JAVA包对应的特性。[/b]最近似的是用一个公用头文件的一组库函数。然而，在C＋＋中构建和使用库函数与在JAVA中构建包和使用包是完全不同的。
3)JAVA的接口与C＋＋的抽象类相似（C＋＋中的抽象类是包括至少一个纯虚函数的类）。[/b]例如，C＋＋的抽象类和JAVA的接口都不能创建实例。两者都用于指定一个子类实现的一致接口。两者之间最大的不同之处在于接口更清晰的表明了这个概念。
4)JAVA提供一个流线型的内存分配机制。
与C＋＋类似，JAVA支持new这个关键字。但是，不支持delete关键字。当对象的最后一个引用撤销时，对象本身被自动地删除，并进行内存垃圾回收。
5)JAVA丢弃了C＋＋的标准库，将它替换成自己的API类集合。[/b]它们功能上有相似之处，但是名字和参数有显著的不同。同时，因为所有的JAVA API库都是面向对象的，而C＋＋库只有部分是，所以库例程调用的方式不同。
6)JAVA增强了break和continue语句以接收标记。
JAVA中的char类型是国际通用的16位Unicode字符集，所以能自动表达大多数国家的字符。这与C＋＋中的wchar_t型相似。使用Unicode字符增强了代码的可移植性。
7)JAVA增加了>>>操作，完成无符号的右移。
8)除支持单行和多行的注释之外，JAVA增加了第三种注释方法：文档注释。文档注释以结尾。 9)JAVA包含一个内置的字符串类型叫做String。
String在某种程度上和C＋＋提供的标准string类很相似。当然C＋＋中的string只有在程序中声明后方可使用，它并不是内置的类型
3)、JAVA和C＋＋的不同的特性。
1)JAVA和C＋＋都支持布尔类型的数据，但是JAVA实现true和false的方式和C＋＋不同。在C＋＋中，true是非零值，false是零。在JAVA中，true and false都是预先定义好的常量，并且是一个布尔表达式能得到的唯一的两个值。虽然C＋＋也定义了true and false ，并指定为布尔变量，但是C＋＋自动将非零值转换为true,零值转换为false。这种情况在JAVA中不会出现。
2)在创建C＋＋类时，访问说明符应用到一组声明中。而JAVA中，访问说明符仅应用于其限定的声明中。
3)C＋＋支持异常处理，这与JAVA类似，但是在C＋＋中无需捕捉一个被引发的异常。
（七）JAVA和C＋＋的区别详细介绍（对部分知识点的扩充）
(1) JAVA的运行速度（JAVA最大的障碍在于速度）
解释过的Java要比C的执行速度慢上约20倍。无论什么都不能阻止Java语言进行编译。当时刚刚出现了一些准实时编译器，它们能显著加快速度。当然， 我们完全有理由认为会出现适用于更多流行平台的纯固有编译器，但假若没有那些编译器，由于速度的限制，必须有些问题是Java不能解决的。
许多企业的应用开发人员非常喜爱Java的语言特性，但是在开发重要系统时，语言特性和执行效率之间的抉择往往令人伤透脑筋。在关键计算中，用户可能并不 在乎数据如何压缩或者运行的延迟关系如何设置，但是对程序的运行速度却非常重视，这使厂商将Java的编译策略开发放在了首位。现在的Java语言，其执 行方式已经不仅仅是解释执行方式了，即时编译器（JITC、just-in-time compiler）技术和原型编译技术已经被许多厂家采用，包括Sun、IBM、Oracle以及Netscape等公司在内的技术提供商正在利用这些技 术逐步提高Java的执行速度，其中IBM公司早已将Java虚拟机（JVM，JavaVirtual Machine）、操作系统和硬件的特性有机的结合在一起，非常有效地提高了Java的执行效率。
(2)JAVA所有东西都必须置入一个类.
Java是完全面向对象的语言，它不再支持C++程序时所使用的过程式的设计方法，所有函数和变量部必须是类的一部分。除了基本数据类型（例如整型、字符型、布尔型等）之外，其他的数据对Java来说都是对象，包括数组。
对象将数据和方法结合起来，把它们封装在类中，这样每个对象都可实现自己的特点和行为。JAVA不存在全局函数或者全局数据。如果想获得与全局函数等价的 功能，可考虑将static方法和static数据置入一个类里。而c++允许将函数和变量定义为全局的。此外，Java中取消了c／c++中的结构和联 合、枚举这一类的东西，一切只有“类”（Class），消除了不必要的麻烦。
JAVA的语法其实是参照c++的语法诞生的，但是她去除了c++中的多重继承，指针，delete等难于掌握的技术，为了便于移植和安全性，java采用了纯面向对象技术，即使是主函数public static void main(String[] args）{}也要放在主类中，可以看出和C＋＋的明显区别。
(3) 在Java中，类定义采取几乎和C++同样的形式。
但没有标志结束的分号。没有类声明，只有类定义。
(4) Java中没有作用域范围运算符“::”.
Java利用点号做所有的事情，但可以不用考虑它，因为只能在一个类里定义元素。即使那些方法定义，也必须在一个类的内部，所以根本没有必要指定作用域的范围。我们注意到的一项差异是对static方法的调用:使用ClassName.methodName()。
除此以外，package（包）的名字是用点号建立的，并能用import关键字实现C++的“#include”的一部分功能。
例如下面这个语句：
import java.awt.*;
#include并不直接映射成import，但在使用时有类似的感觉。若想使用另一个库里的类，只需使用import命令，并指定库名即可。不存在类似于预处理机的宏。
c／c十十在编译过程中都有一个预编译阶段，即众所周知的预处理器。预处理器为开发人员提供了方便，但增加了编译的复杂性。JAVA虚拟机没有预处理器， 但它提供的引入语句(import)与c十十预处理器(#include)的功能类似。（注意：只是类似而已） (5)JAVA中没有预处理功能的详细介 绍
不再有#define、#include等预处理程序(Preprocessor)的功能。C++语言很重要的一个特点就是它的预处理程序。有些其他程序 语言虽然也加入了#include的功能，但是还是欠缺处理宏(Macro)的能力。#define的功能在Java中我们可以用定义常数 (constant)的方式来取代，而#include在Java中是不需要的，因为在Java中程序在执行时，会把类型数据记录在对象实体之中，我们不 需要靠一些标头文件(header file)来知道我们使用的对象或数值是属于什么数据类型。
如果你使用C++语言时，只使用预处理程序的#include和#define功能的话，那么你大概不会觉得Java这样的设计对你产生什么样的困扰，但是如果你是使用C++语言预处理程序中宏功能的高手，你可能会觉得很不方便，进而怀疑Java如此设计的意义何在。
使用预处理程序虽然可以很方便地达到许多功能，但是站在软件工程的角度上看，对整个软件的维护其实是很不利的。由于C++语言中预处理程序的功能太过强 大，厉害的程序设计高手常会自行开发一套只有自己看的懂的宏语言，一旦整个软件要交给其他人去维护，后继者很难在短时间内了解前一个人所写下的宏功能，增 加软件开发时团队工作及日后维护的困难度。
另外一点则是C++语言的编译器所看到的程序代码，其实和程序设计者看到的程序代码是不同的。程序设计者看到的是尚未经过预处理程序处理过的程序代码，而 编译器看到的则是预处理程序处理过的程序代码，一旦交给预处理程序处理的宏内容有误，编译器产生的错误信息将不会是程序设计师所预料的。而这一点自然也增 加了程序在排错时的困难度。
预处理程序的存在也造成了阅读程序的不便。如果你想使用别人已经完成的C++语言程序，那么通常你不但要阅读他所写下的文件，还必须一并查阅上文件，才能了解其程序的全貌。如果换成是Java程序，只要查看java的程序文件就够了。
(6)与C++类似，Java含有一系列“主类型”（Primitive type），以实现更有效率的访问 在Java中，这些类型包括boolean，char，byte，short，int，long，float以及double.所有主类型的大小都是 固有的，且与具体的机器无关（考虑到移植的问题）。这肯定会对性能造成一定的影响，具体取决于不同的机器。对类型的检查和要求在Java里变得更苛刻。
例如：
条件表达式只能是boolean（布尔）类型，不可使用整数。
必须使用象X+Y这样的一个表达式的结果；不能仅仅用“X+Y”来实现“副作用”。
(7)Java静态引用的字串会自动转换成String对象。[/b][/color] java和C及C++不同，没有独立的静态字符数组字串可供使用。
c和c十十不支持字符串变量，在c和c十十程序中使用Null终止符代表字符串的结束，在Java中字符串是用类对象(string和stringBuffer)来实现的，这些类对象是Java语言的核心，用类对象实现字符串有以下几个优点：
a)在整个系统中建立字符串和访问字符串元素的方法是一致的；
b)Java字符串类是作为Java语言的一部分定义的，而不是作为外加的延伸部分；
c)Java字符串执行运行时检查，可帮助排除一些运行时发生的错误；
d)可对字符串用“十”号进行连接操作。
(8) Java增添了三个右移位运算符“>>>”，具有与“逻辑”右移位运算符类似的功用，可在最末尾插入零值。“>>”则会在移位的同时插入符号位（即“算术”移位）。
(9) 尽管表面上类似，但与C++相比，Java数组采用的是一个颇为不同的结构，并具有独特的行为。就是说Java提供数据下标越界检查，而C++没有提供.
有一个只读的length成员，通过它可知道数组有多大。而且一旦超过数组边界，运行期检查会自动丢弃一个异常。所有数组都是在内存“堆”里创建的，我们 可将一个数组分配给另一个（只是简单地复制数组句柄）。数组标识符属于第一级对象，它的所有方法通常都适用于其他所有对象。
(10) 对于所有不属于主类型的对象，都只能通过new命令创建 和C++不同，Java没有相应的命令可以“在堆栈上”创建不属于主类型的对象。所有主类型都只 能在堆栈上创建，同时不使用new命令。所有主要的类都有自己的“封装（器）”类，所以能够通过new创建等价的、以内存“堆”为基础的对象（主类型数组 是一个例外：它们可象C++那样通过集合初始化进行分配，或者使用new).
(11) Java中不必进行提前声明方法。
若想在定义前使用一个类或方法，只需直接使用它即可——编译器会保证使用恰当的定义。所以和在C++中不同，我们不会碰到任何涉及提前引用的问题。
(12) Java用包代替了命名空间。
由于将所有东西都置入一个类，而且由于采用了一种名为 “封装”的机制，它能针对类名进行类似于命名空间分解的操作，所以命名的问题不再进入我们的考虑之列。数据包也会在单独一个库名下收集库的组件。我们只需简单地“import“（导入）一个包，剩下的工作会由编译器自动完成。
(13) 被定义成类成员的对象句柄会自动初始化成null。
对基本类数据成员的初始化在Java里得到了可靠的保障。若不明确地进行初始化，它们就会得到一个默认值（零或等价的值）可对它们进行明确的初始化（显式 初始化）：要么在类内定义它们，要么在构建器中定义。采用的语法比C++的语法更容易理解，而且对于static和非static成员来说都是固定不变 的。我们不必从外部定义static成员的存储方式，这和C++是不同的。
(14) 在Java里，没有象C和C++那样的指针。
用new创建一个对象的时候，会获得一个引用（或者叫句柄） 例如： Strings = new String("helloworld");
然而，C++引用在创建时必须进行初始化，而且不可重定义到一个不同的位置。但Java引用并不一定局限于创建时的位置。它们可根据情况任意定义，这便消除了对指针的部分需求。
在C和C++里大量采用指针的另一个原因是为了能指向任意一个内存位置（这同时会使它们变得不安全，也是Java不提供这一支持的原因）。指针通常被看作 在基本变量数组中四处移动的一种有效手段。Java允许我们以更安全的形式达到相同的目标。解决指针问题的终极方法是“固有方法”。将指针传递给方法时， 通常不会带来太大的问题，因为此时没有全局函数，只有类。而且我们可传递对对象的引用。Java语言最开始声称自己“完全不采用指针！”但随着许多程序员 都质问没有指针如何工作？于是后来又声明“采用受到限制的指针”（有人管它叫隐藏了的指针）。大家可自行判断它是否“真”的是一个指针。但不管在何种情况 下，都不存在指针“算术”。
JAVA语言让编程者无法找到指针来直接访问内存无指针，并且增添了自动的内存管理功能，从而有效地防止了c／c++语言中指针操作失误，如野指针所造成 的系统崩溃。但也不是说JAVA没有指针，虚拟机内部还是使用了指针，只是外人不得使用而已。这有利于Java程序的安全。
其实，取消指针(Pointer)这样数据类型，可能会让许多熟悉C++语言的程序设计师大吃一惊。在C++语言里，灵活地运用指针是许多程序设计师的得 意之作，但是占整个除错时间最久的也是指针的问题。配合上C++对内存管理的态度，程序设计师必须要自己去追踪自己向系统要到的内存，最后确实地交还给系 统，并且在使用指针时，要小心翼翼地注意不要跨过合法的记忆空间，造成Segmentation Fault或General Protection Fault之类的问题。
Java去掉了指针类型，并不表示程序设计师在开发高级数据结构，像堆栈(stack)、队列(queue)、二元树(binarytree)时，都必须要像在传统Basic上，利用大范围的数组来自行模拟系统内存，自行建构类似指针的表示方式。
相反地，Java提供了和Lisp语言中相似的Reference类型，通过Reference去读取配置到的内存内容，可以确保不会去读取到不属于自己 的内存空间，而另一方面，程序的执行系统也可以动态地去做内存垃圾回收的工作，将没有被reference参考到的内存空间回收给系统使用。 ff(15) Java提供了与C++类似的“构建器”（Constructor）。
如果不自己定义一个，就会获得一个默认构建器。而如果定义了一个非默认的构建器，就不会为我们自动定义默认构建器。这和C++是一样的。注意没有复制构建器，因为所有自变量都是按引用传递的（注意：而C＋＋中对象可由值或引用传递。）
(16) Java中没有“破坏器”（Destructor）。
变量不存在“作用域”的问题。一个对象的“存在时间”是由对象的存在时间决定的，并非由垃圾收集器决定。有个finalize()方法是每一个类的成员， 它在某种程度上类似于C++的“破坏器（就是析构函数的使用）”。但finalize()是由垃圾收集器调用的，而且只负责释放“资源”（如打开的文件、 套接字、端口、URL等等）。如需在一个特定的地点做某样事情，必须创建一个特殊的方法，并调用它，不能依赖finalize()。而在另一方面，C++ 中的所有对象都会（或者说“应该”）破坏，但并非Java中的所有对象都会被当作“垃圾”收集掉。由于Java不支持破坏器的概念，所以在必要的时候，必 须谨慎地创建一个清除方法。而且针对类内的基础类以及成员对象，需要明确调用所有清除方法。
(17) Java具有方法“重载”机制，它的工作原理与C++函数的重载载几乎是完全相同的。
(18) Java不支持默认自变量。
(19) Java中没有goto语句。
Java一方面移除了Goto的功能，它采取的无条件跳转机制是“break 标签”或者“continue 标签” ，另一方面同时扩大了break和continue的功能，可以允许多层循环的break或continue。如此一来不但避免了滥用Goto的可能性，同时也保存下Goto的好处。
“可怕”的goto语句是c和c++的“遗物”，它是该语言技术上的合法部分，引用goto语句引起了程序结构的混乱，不易理解，goto语句主要用于无 条件转移子程序和多结构分支技术。鉴于以上理由，Java不提供goto语句，也不提供goto关键字和of、const关键字，使程序简洁易读。（注 意：有些书上会说java也提供goto关键字，但是不使用，我不知道以前的说法如何，你只要记住java里边没有goto这个东西就可以了。而且不能用 goto做为对象名字、引用或方法名、类名等。）
在程序语言的发展史上，Goto一直是毁誉参半的一项功能。在很多时候使用Goto可以大幅减少不必要的程序代码，但是也由于Goto可以很自由地改变程 序的流程，如果冒然地使用，更可能造成程序结构混乱的情况。一般来说，正确使用Goto的例子多出现在循环内部，想要提早结束某一层循环。在C语言中，我 们可以使用break 或contine来改变某一层循环的流程，但如果想要改变两层以上的环执行流程，不是使用Goto就是以多余的布尔(boolean)变量，配合上一串 if-then-else的判断来达成。
(20) Java采用了一种单根式的分级结构，因此所有对象都是从根类Object统一继承的。
而在C++中，我们可在任何地方启动一个新的继承树，所以最后往往看到包含了大量树的“一片森林”。在Java中，我们无论如何都只有一个分级结构。尽管 这表面上看似乎造成了限制，但由于我们知道每个对象肯定至少有一个Object接口，所以往往能获得更强大的能力。C++目前似乎是唯一没有强制单根结构 的唯一一种OO（面向对象）语言。
(21) Java没有模板或者参数化类型的其他形式。
它提供了一系列集合：Vector（向量），Stack（堆栈）以及Hashtable（散列表），用于容纳Object引用。利用这些集合，我们的一系列要求可得到满足。但这些集合并非是为实现象C++“标准模板库”（STL）那样的快速调用而设计的。Java 1.2中的新集合显得更加完整，但仍不具备正宗模板那样的高效率使用手段。
(22)“垃圾收集”意味着在Java中出现内存漏洞的情况会少得多，但也并非完全不可能。
若调用一个用于分配存储空间的固有方法，垃圾收集器就不能对其进行跟踪监视。
然而，内存漏洞和资源漏洞多是由于编写不当的finalize()造成的，或是由于在已分配的一个块尾释放一种资源造成的（“破坏器”在此时显得特别方 便）。垃圾收集器是在C++基础上的一种极大进步，使许多编程问题消弥于无形之中。但对少数几个垃圾收集器力有不逮的问题，它却是不大适合的。但垃圾收集 器的大量优点也使这一处缺点显得微不足道。
(23) Java内建了对多线程的支持。
利用一个特殊的Thread类，我们可通过继承创建一个新线程（放弃了run()方法）。若将synchronized（同步）关键字作为方法的一个类型 限制符使用，相互排斥现象会在对象这一级发生。在任何给定的时间，只有一个线程能使用一个对象的synchronized方法。在另一方面，一个 synchronized方法进入以后，它首先会“锁定”对象，防止其他任何synchronized方法再使用那个对象。只有退出了这个方法，才会将对 象“解锁”。在线程之间，我们仍然要负责实现更复杂的同步机制，方法是创建自己的“监视器”类。递归的synchronized方法可以正常运作。若线程 的优先等级相同，则时间的“分片”不能得到保证。 (24)我们不是象C++那样控制声明代码块，而是将访问限定符（public，private和 protected）置入每个类成员的定义里。
JAVA中若未规定一个“显式”（明确的）限定符，就会默认为“友好的”（friendly）。这意味着同一个包里的其他元素也可以访问它（相当于它们都成为 C++的“friends”——朋友），但不可由包外的任何元素访问。而在C＋＋中如果未规定就会默认为私有的private。
类——以及类内的每个方法——都有一个访问限定符，决定它是否能在文件的外部“可见”private关键字通常很少在Java中使用，因为与排斥同一个包 内其他类的访问相比，“友好的”访问通常更加有用。 然而，在多线程的环境中，对private的恰当运用是非常重要的。Java的protected 关键字意味着“可由继承者访问，亦可由包内其他元素访问”。注意Java没有与C++的protected关键字等价的元素，后者意味着“只能由继承者访 问”（以前可用“private protected”实现这个目的，但这一对关键字的组合已被取消了）
(25) 嵌套的类。
在C++中，对类进行嵌套有助于隐藏名称，并便于代码的组织（但C++的“命名空间”已使名称的隐藏显得多余）。Java的“封装”或“打包”概念等价于 C++的命名空间，所以不再是一个问题。Java 1.1引入了“内部类”的概念，它秘密保持指向外部类的一个句柄——创建内部类对象的时候需要用到。这意味着内部类对象也许能访问外部类对象的成员，毋需 任何条件——就好象那些成员直接隶属于内部类对象一样。这样便为回调问题提供了一个更优秀的方案——C++是用指向成员的指针解决的。(由于存在前面介绍 的那种内部类，所以Java里没有指向成员的指针。 )
(26) Java不存在“嵌入”（inline）方法。
JAVA所有方法都是在类的主体定义的。所以用C++的眼光看，似乎所有函数都已嵌入，但实情并非如此。Java编译器也许会自行决定嵌入一个方法，但我 们对此没有更多的控制权力。在Java中，可为一个方法使用final关键字，从而“建议”进行嵌入操作。然而，嵌入函数对于C++的编译器来说也只是一 种建议。
(27) Java中的继承具有与C++相同的效果，但采用的语法不同。
Java用extends关键字标志从一个基础类的继承，并用super关键字指出准备在基础类中调用的方法，它与我们当前所在的方法具有相同的名字（然 而，Java中的super关键字只允许我们访问父类的方法——亦即分级结构的上一级）。通过在C++中设定基础类的作用域，我们可访问位于分级结构较深 处的方法。亦可用super关键字调用基础类构建器。正如早先指出的那样，所有类最终都会从Object里自动继承。和C++不同，不存在明确的构建器初 始化列表。但编译器会强迫我们在构建器主体的开头进行全部的基础类初始化，而且不允许我们在主体的后面部分进行这一工作。通过组合运用自动初始化以及来自 未初始化对象句柄的异常，成员的初始化可得到有效的保证。
b举例说明
public class Foo extends Bar
{
publicFoo(String msg)
{
super(msg); Calls base constructor }
public baz(int i)
{ Override
super.baz(i);
Calls base method
}
}
(28) Java中的继承不会改变基础类成员的保护级别。
我们不能在Java中指定public，priv ate或者protected继承，这一点与C++是相同的。此外，在衍生类中的优先方法不能减少对基础类方法的访问。例如，假设一个成员在基础类中属于public，而我们用另一个方法代替了它，那么用于替换的方法也必须属于public（编译器会自动检查）。
(29) Java提供了一个interface关键字，它的作用是创建抽象基础类的一个等价物。
在其中填充抽象方法，且没有数据成员。这样一来，对于仅仅设计成一个接口的东西，以及对于用extends关键字在现有功能基础上的扩展，两者之间便产生 了一个明显的差异。不值得用abstract关键字产生一种类似的效果，因为我们不能创建属于那个类的一个对象。一个abstract（抽象）类可包含抽 象方法（尽管并不要求在它里面包含什么东西），但它也能包含用于具体实现的代码。因此，它被限制成一个单一的继承。通过与接口联合使用，这一方案避免了对 类似于C++虚拟基础类那样的一些机制的需要。
为创建可进行“例示”（即创建一个实例）的一个interface（接口）的版本，需使用implements关键字。它的语法类似于继承的语法，如下所示：
public interface Face
{
public void smile();
} public class Baz extends Bar implements Face
{
public void smile( )
{
System.out.println("a warm smile");
}
}
(30) Java中没有virtual关键字，因为所有非static方法都肯定会用到动态绑定。
在Java中，程序员不必自行决定是否使用动态绑定。C++之所以采用了virtual，是由于我们对性能进行调整的时候，可通过将其省略，从而获得执行 效率的少量提升（或者换句话说：“如果不用，就没必要为它付出代价”）。virtual经常会造成一定程度的混淆，而且获得令人不快的结果。final关 键字为性能的调整规定了一些范围——它向编译器指出这种方法不能被取代，所以它的范围可能被静态约束（而且成为嵌入状态，所以使用C++非virtual 调用的等价方式）。这些优化工作是由编译器完成的。
(31) Java不提供多重继承机制（MI），至少不象C++那样做。
与protected类似，MI表面上是一个很不错的主意，但只有真正面对一个特定的设计问题时，才知道自己需要它。由于Java使用的是“单根”分级结构，所以只有在极少的场合才需要用到MI。interface关键字会帮助我们自动完成多个接口的合并工作。
c++支持多重继承，这是c++的一个特征，它允许多父类派生一个类。尽管多重继承功能很强，但使用复杂，而且会引起许多麻烦，编译程序实现它也很不容 易。Java不支持多重继承，但允许一个类继承多个接口(extends+implement)，实现了c++多重继承的功能，又避免了c++中的多重继 承实现方式带来的诸多不便。
所谓的interface基本上定义了一个类的对外沟通的方法原型，以及类内部的常数，和多重继承不同之处在于interface并不会定义类方法的内容，以及类中的变量数据。
(32) 运行期的类型标识功能与C++极为相似。
例如&#
最低0.47元/天 解锁文章
1206
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
