Java vs C++深度对比：关键特性与差异解析

JAVA和C++有什么不同，哪个更好用？

JAVA和C++的比较作为一名C++程序员，我们已经掌握了面向对象编程的基本概念，对Java的语法当然也非常熟悉。
事实上，Java最初是从C++衍生而来的。
“但是，C++和Java之间仍然存在一些显着的差异。
可以说，这些差异代表了技术的巨大进步。
一旦我们了解了这些差异，我们就会明白为什么Java是一种优秀的编程语言。
本附录将带您了解通过一些区分Java和C++的重要特性(1)最大的障碍是速度级别：Java解释比C慢大约20倍。
没有什么可以阻止它在撰写本文时，刚刚出现了几种可以显着加快速度的近实时编译器，我们有充分的理由认为将会有适合更流行平台的纯原生编译器，但事实并非如此。
由于速度限制，没有那些编译器。
肯定有一些问题是Java无法解决的。
2）像C++一样，Java也提供了两种类型的注释（3）一切都必须放在类中。
如果没有全局函数或全局数据函数，请考虑将静态方法和静态数据放在类中。
请注意，没有大象结构。
，枚举或者组合，一切都只是“类”！(4)所有方法都定义在类的主体中，因此从C++的角度来看，所有函数似乎都是嵌入的，但实际上并非如此（嵌入问题将在后面讨论）。
(5)在Java中，类定义的形式与C++类似，但没有结束分号。
。
classfoo形式中没有类声明，只有类定义。
classaType()voidaMethod(){/*方法体*/}}(6)Java中没有作用域运算符“::”。
您可以忘记它，因为您只能在类中定义组件。
这些方法定义也必须位于类内，因此根本不需要指定范围。
我们注意到的一个区别是ClassName.methodName()的使用。
另一方面，包名称（package.）可能是使用点创建的。
使用import关键字+“#include”函数的一部分在C+中实现。
例如，以下语句：importjava.awt.*;（#include没有直接映射到import，但使用时有类似的感觉。
）(7)与C++类似。
，Java包含一系列“原始类型”来实现更高效的访问。
在Java中，这些类型包括boolean、char、byte、short、int、long、float和double。
所有主要类型的尺寸都是固有的并且独立于特定机器（考虑到转换问题）。
根据机器的不同，肯定会对性能产生一些影响。
Java中的类型检查和要求变得更加严格。
例如：■条件表达式只能是布尔类型，不能使用整数。
■必须使用X+Y等表达式的结果；你不能仅仅使用“X+Y”来达到“副作用”。
(8)类型char（字符）使用国际通用的16位Unicode字符集，因此可以自动表示大多数国家的字符。
(9)静态引用的字符串会自动转换为String对象。
与C和C++不同，没有可用的独立静态字符数组。
(10)Java增加了三个右移运算符“>>>>”，其作用与“逻辑”右移运算符类似，可以在末尾插入值0。
“>>”将在移位期间插入符号位（即“算术”移位）。
(11)虽然表面上相似，但与C++相比，Java数组使用完全不同的结构并且具有独特的行为。
拥有只读长度成员可以让您知道数组有多大。
当超出数组边界时，运行时检查会自动抛出异常。
所有数组都是在“堆”内存中创建的，我们可以将一个数组分配给另一个数组（只需复制数组句柄）。
数组标识符是第一级对象，它们的所有方法通常适用于所有其他对象。
(12)所有非主类型的对象只能通过new命令创建。
与C++不同，Java没有相应的语言，命令可以在“堆栈上”创建非主类型的对象。
所有主要类型都可以在堆栈上创建，而无需使用新命令。
所有主类都有自己的“包装”类，因此可以通过new创建等效的基于内存“堆”的对象（主类型数组是一个例外：它们可以通过集合进行初始化，如C++赋值或使用new）。
(13)Java中不需要预声明。
如果您想在定义之前使用某个类或方法，只需直接使用它即可-编译器将确保使用适当的定义。
因此，与C++不同，我们不会遇到与初始引用相关的任何问题。
(14)Java没有预处理器。
如果您想使用另一个库中的类，只需使用导入命令并指定库名称即可。
没有类似预处理器的宏。
(15)Java使用包而不是命名空间。
由于所有内容都放入类中，并且由于一种称为“封装”的机制对类名执行类似于命名空间分隔的操作，因此命名问题不再是我们考虑的问题。
该包还以单个库名称收集库组件。
我们只需要“导入”一个包，编译器就会完成剩下的工作。
(16)定义为类成员的对象句柄将自动初始化为null。
Java中可靠地保证了底层类数据成员的初始化。
如果未显式初始化，它们将收到默认值（零或等效值）。
它们可以显式初始化（​​显式初始化）：通过在类中或构造函数中定义它们。
语法没问题使用更容易理解的C++语法，并且对于静态和非静态成员都是固定的。
我们不必从外部定义静态成员的存储方法，这与C++不同。
(17)Java中没有像C和C++那样的指针。
当你用new创建一个对象时，你会得到一个引用（本书总是称它为“句柄”）。
例如：Strings=newString("howdy");但是，C++引用必须在创建时进行初始化，并且不能在不同位置重新定义。
但Java引用不一定限于创建它们的位置。
它们可以根据情况任意定义，这消除了一些对指针的需要。
在C和C++中使用多个指针的另一个原因是能够指向任何内存位置（这也使得它们不安全，这也是Java不提供支持这一点的原因）。
指针通常被认为是移动原始变量数组的有效方法。
Java允许我们以更安全的形式实现相同的目标。
指针问题的最佳解决方案是“固有方法”（在附录A中讨论）。
将指针传递给方法通常不会引起太大问题，因为没有全局函数，只有类。
我们可以传递对该对象的引用。
最初的Java语言宣称它“根本不使用指针！”但正如许多程序员开始问的那样，如果没有指针，它如何工作？所以后来又说“指针的使用是有限的”。
它是一个指针，你可以自己判断它是否“正确”。
但无论如何，不​​存在“算术”指针。
(18)Java提供了类似于C++的“构造函数”。
如果您自己不定义生成器，您将拥有一个默认生成器。
而如果定义了非默认生成器，则不会自动为我们确定默认生成器。
这就像C++。
请注意，没有复制构造函数，因为所有参数都是通过引用传递的。
(19)Java中没有“析构函数”。
变量不存在“范围”问题。
对象的“生命周期”是由对象的年龄决定的，而不是由垃圾收集器决定的。
每个类都有一个Finalize()方法，类似于C++“析构函数”。
但Finalize()由垃圾收集器调用，只负责释放“资源”（例如打开的文件、套接字、端口、URL等）。
如果您想在特定位置执行某些操作，则必须创建一个特殊的方法并调用它。
您不能依赖Finalize()。
另一方面，C++中的所有对象都会执行（或“应该”）销毁，但Java中并非所有对象都会被收集为“垃圾”。
因为Java不支持析构函数的概念，所以你必须小心需要时创建清理方法对于类基类和对象成员需要显式调用所有delete方法(20)Java有一个方法“重载”机制让它发挥作用。
其原理与C++函数重载几乎相同。
(21)Java不支持默认参数。
(22)Java中没有goto。
它应用的无条件跳转机制是“中断标号”或“继续标准”。
。
摆脱当前的多重嵌套循环(23)Java采用单根层次结构，因此所有对象都统一继承自根类Object。
在C++中，我们可以在任何地方开始一个新的继承树，因此我们常常会得到一个包含大量树的“森林”。
在Java中，我们可以启动一个新的继承树。
任何地方。
无论如何，只有一个层次结构，尽管从表面上看这似乎是一种限制，因为我们知道每个对象必须至少有一个层次结构。
对象接口，因此它通常具有更强大的功能。
目前，C++似乎是唯一不强制执行单根构造的面向对象语言。
（24）Java没有提供一系列集合：Vector（向量）、Stack（堆栈）和Hashtable（哈希表），用来保存ObjectReferences。
使用这些集合可以满足我们的广泛要求。
然而，这些集合并不是为像C++“标准模板库”(STL)那样的快速调用而设计的。
25)“垃圾收集”是指Ja。
内存泄漏在VA中很少见，但并非完全不可能（如果您调用固有方法来分配存储空间，垃圾收集器无法跟踪它）。
然而，内存泄漏和资源泄漏的可能性不大。
这可能是由于录制不当造成的。
Finalize()或通过在分配的块末尾释放资源（“销毁器”）。
“这个时候就特别方便了）。
垃圾收集器是基于C++的巨大进步，让很多编程问题变得隐形。
但是对于一些垃圾收集器处理不了的问题就不太合适了。
但是垃圾收集器的诸多优点使得这26）Java内置了对多线程的支持，我们可以通过继承（run()方法）创建一个新线程。
如果使用synchronized关键字作为方法的限定符，则在任何给定时间都会在对象级别发生互斥，只有一个线程可以使用该方法。
另一方面，synchronized方法进入后，首先会发生互斥。
“锁定”该对象，防止任何其他同步方法使用该对象。
只有退出该方法后，该对象才会被“打开”。
我们仍然负责通过创建自己的“监视器”类来实现线程之间更复杂的同步机制。
递归同步方法效果很好。
如果线程具有相同的优先级，则无法保证时间“切片”。
（27）相反为了像C++那样控制声明性代码块，我们在每个类成员的定义中包含访问限定符（public、private和protected）。
如果未指定限定符“clear”，则默认为“Friendly”。
这意味着同一包中的其他元素也可以访问它（相当于它们成为C++“朋友”），但包之外的任何元素都无法访问它。
类（以及类中的每个方法）都有一个访问限定符，用于确定它是否在文件外部“可见”。
private关键字在Java中很少使用，因为“友好”访问通常比排除来自同一包中其他类的访问更有用。
然而，在多线程环境中，正确使用private非常重要。
Java的protected关键字的意思是“可以被包中的后继者和其他元素访问”。
请注意，Java没有与C++的protected关键字等效的关键字。
后者的意思是“只能由继承人访问”（之前可以使用“privateprotected”来达到此目的，但该关键字组合已被删除）。
(28)嵌套类。
在C++中，嵌套类有助于隐藏名称并促进代码组织（但C++“命名空间”使名称隐藏变得多余）。
Java的“封装”或“封装”的概念相当于C++的命名空间，所以这不再是问题。
Java1.1引入了“内部类”的概念，它秘密地维护外部类的可处理性——创建内部类的对象时需要。
这意味着内部类对象可以无条件地访问外部类对象的成员-就​​好像这些成员直接依赖于内部类对象一样。
这为回调问题提供了更好的解决方案——C++通过指向成员的指针来解决它。
(29)由于前面介绍的内部类的存在，Java中没有指向成员的指针。
(30)Java中没有“嵌入”（内联）方法。
Java编译器可以选择嵌入一个方法，但我们无法对此进行控制。
在Java中，您可以使用方法的final关键字来“提示”嵌入操作。
然而，嵌入函数只是对C++编译器的一个建议。
(31)Java中的继承与C++具有相同的效果，但使用不同的语法。
Java使用extend关键字来标记从基类继承，并使用super关键字来指示基类中要调用的方法，该方法与我们正在使用的方法同名（尽管Java中的super关键字只允许我们方法访问超类——即层次结构中的上一层）。
通过在C++中确定基类的作用域，我们可以访问层次结构中更深层的方法。
肌肉层发生器也可以使用super关键字来调用base。
如前所述，所有最终类都会自动继承自Object。
与C++不同，没有显式的生成器初始化列表。
但是编译器会强制我们在生成器主体的开头进行所有基类初始化，并且不会让我们在主体的后面进行这些初始化。
通过使用自动初始化和未初始化对象句柄异常的组合，有效地保证了成员初始化。
(32)Java中的继承不会改变基类成员的保护级别。
我们不能像在C++中那样在Java中指定公共、私有或受保护的继承。
此外，派生类中的首选方法不能损害对基类方法的访问。
例如，如果基类中的某个成员是公共的，并且我们用另一个方法替换它，则用于替换的方法也必须是公共的（编译器会自动检查这一点）。
(33)Java提供了interface关键字，用于创建相当于抽象基类的关键字。
用抽象方法填充它，没有数据成员。
这样，仅设计为接口的东西与使用extend关键字扩展现有功能的东西之间存在明显的区别。
使用abstract关键字来创建相同的效果是不值得的，因为我们无法创建该类的对象。
抽象类可以包含抽象方法（尽管不要求其中包含任何内容），但它也可以包含具体实现的代码。
因此，它仅限于单一继承。
与接口结合使用，这种方法避免了对类似于C++虚拟基类的机制的需要。
要创建可以“实例化”（即创建实例）的接口实例，请使用implementation关键字。
它的语法类似于继承语法。
(34)Java中没有virtual关键字，因为所有非静态方法都不可避免地会使用动态绑定。
在Java中，程序员不必自己决定是否使用动态链接。
C++之所以使用virtual，是因为我们在调优性能时，可以忽略它，从而获得执行效率的小幅提升（或者换句话说：“不用则不用付费”）。
虚拟性常常会导致一定程度的混乱和令人不快的结果。
Final关键字指定性能调整的某些范围-它告诉编译器该方法不可替换，因此其范围可以静态绑定（并且嵌入，因此使用C++非虚拟调用等效项）。
这些优化由编译器执行。
(35)Java至少不提供多重继承（MI）机制与C++不同。
与protected类似，MI从表面上看是一个好主意，但直到实际遇到特定的设计问题时您才知道自己需要它。
由于Java使用“单根”层次结构，因此仅在极少数情况下才需要MI。
interface关键字将帮助我们自动组合多个接口。
(36)运行时类型识别功能与C++非常相似。
例如，要获取有关X句柄的信息，可以使用以下代码：旧式C样式保持不变。
编译器会自动调用驱动机制，不需要额外的语法。
虽然它没有像C++的“newcasts”那样容易定位强制转换的优点，但Java仍然会检查使用情况并抛出那些“异常”，因此它不允许像C++那样的错误强制转换。
(37)Java应用了不同的异常处理机制，因为目前没有生成器。
您可以添加finally子句来强制执行特定命令，以便执行必要的清理。
Java中的所有异常都继承自Throwable基类，因此我们可以确保我们有一个通用的接口。
(38)Java的异常规范比C++的好得多。
抛出错误异常后，Java异常规范将在编译期间检查并强制执行，而不是像C++那样在运行时调用函数。
此外，替换方法必须符合该方法的基类版本的异常规范：它们可能会抛出指定的异常或从这些异常派生的其他异常。
这样，我们得到的是更“健壮”的异常处理代码。
(39)Java有重载方法的能力，但不允许运算符重载。
String类无法使用+和+=运算符连接不同的字符串，并且String表达式使用自动类型转换，但这是内置的特殊情况。
(40)根据事先约定，C++中常见的const问题已在Java中得到控制。
我们只能传递对象的句柄，永远不会自动为我们创建本地副本。
如果你想在C++中使用像传值这样的技术，你可以调用clone()来创建参数的本地副本（尽管clone()的设计仍然很初级——参见第12章）。
不会自动调用复制生成器。
要创建编译时常量值，请编写如下代码：staticfinalintSIZE=255staticfinalintBSIZE=8*SIZE(41)出于安全原因，“应用程序”编程和“程序切片”之间存在显着差异。
最明显的问题之一是该程序不允许我们写入磁盘，因为这样做会导致从远程站点下载的未知程序不加区别地覆盖我们的磁盘。
随着Java1.1中数字签名技术的引入，这种情况发生了改变。
基于数字签名，我们可以准确地知道一个程序的所有作者并对其进行验证他们已获得授权。
Java1.2将进一步增强程序切片的能力。
(42)由于Java在某些情况下似乎非常有限，因此人们有时会犹豫是否使用它来执行重要任务，例如直接访问硬件。
Java解决这个问题的办法是“内部方法”，它允许我们调用其他语言编写的函数（目前只支持C和C++）。
这样我们肯定能够解决与平台相关的问题（以不可移植的形式，但随后该代码将被隔离）。
部分程序无法本机调用方法，只有应用程序可以。
(43)Java提供了对注释文档的内置支持，因此源代码文件也可以包含自己的文档。
通过一个单独的程序，可以提取该文档信息并将其重新格式化为HTML。
这无疑是文档管理和应用方面的一大进步。
(44)Java包含许多标准库。
用于执行特定任务。
C++依赖于其他供应商提供的许多非标准库。
这些任务包括（或即将包括）：■网络■数据库连接（通过JDBC）■多线程■分布式对象（通过RMI和CORBA）■压缩■商务由于这些库易于使用且非常标准，因此可以大大加快应用程序的速度发展。
(45)Java1.1包括JavaBeans标准，该标准可以创建在可视化编程环境中使用的组件。
因为它们遵循相同的标准，所以可视化组件可以在所有供应商的开发环境中使用。
由于我们不依赖单一制造商的解决方案来设计可视化组件，因此扩大了组件的选择范围并提高了组件的性能。
此外，JavaBeans的设计对于程序员来说简单易懂，而不同供应商开发的专用组件框架则需要更深入的研究。
(46)如果访问Java处理程序失败，则会抛出异常。
该跌落测试不一定必须在使用手柄之前立即进行。
根据Java的设计规范，它只是说必须以某种形式抛出异常。
许多C++运行时系统也会抛出由指针错误引起的异常。
(47)一般来说，Java似乎更加健壮，为此采取的措施如下：■对象控制器初始化为null（关键字）■明确检查控制器，出现错误时将抛出异常■所有数组访问及时检查检测边界违规■自动垃圾收集，防止内存泄漏■机制检查显式的、“愚蠢的”异常处理■为多线程提供简单的语言支持■实现现在验证网络程序上的字节码如果您有信心，请继续阅读

简述javacc++的区别

C++是“带有类的C”。
最大的区别是C++是面向对象的，而C是面向过程的。
定义一个类意味着定义一个对象类型。
此类允许您定义对象的实例。
每种类型的对象都有自己的属性和方法，方法的工作方式类似于C中的函数。
它只适用于特定的对象，而C中的函数可以在任何进程中调用。
C是最古老的语言，至少有30年的历史，并且仍然是最高效的高级语言。
随着面向对象思想的出现，C++出现了，和C一样，也有相应的编译器，后来Java作为一种纯面向对象的静态语言出现，具有类似C的语法，但抛弃了C++中被诟病的复杂设计。
后来出现了C#语言，是微软以C之名抄袭Java的产品。
最初的目的是为了争夺Java服务器端编程市场。
现在ASP.net是一种以C#为核心的语言。
开发系统。
总的来说，C/C++仍然走在工业发展的最前沿，包括硬件驱动。
C++在服务器端编程（包括企业应用程序的开发）中也占有不可动摇的地位。

JAVA与C++的区别详解

JAVA和C++都是面向对象的语言，都支持封装、继承、多态等面向对象的思想。
但是，C++一旦兼容了C语言，其面向对象的能力就变得有些欠缺，而JAVA则是完全面向对象的语言。
JAVA语句更清晰，体积更小，更容易学习。
它通过使用多种编程语言克服了C++的固有缺点。
JAVA和C++的相似之处多于差异，但它们之间的主要区别使得JAVA更容易学习，并且编程环境更简单。
例如，JAVA禁止直接内存访问，其自动内存管理功能有效防止C/C++中的指针操作错误，降低系统崩溃的风险。
C++支持多重继承，但其实现复杂且容易出现问题。
JAVA不支持多重继承，但允许单个类继承多个接口，实现了C++的多重继承特性，避免了多重继承带来的不便。
从数据类型和类来看，JAVA是一种完全面向对象的语言，所有的函数和变量都必须是类的一部分。
除了基本数据类型外，其余的都作为类对象，包括数组，来实现数据和方法的封装。
C++允许将函数和变量定义为全局的。
另外，JAVA消除了C/C++中的结构体和联合体，使程序开发变得更加容易。
JAVA支持自动内存管理。
所有对象都在堆栈上创建，不需要程序员手动删除，这增加了程序安全性。
在C++中，程序员必须手动释放内存资源，这增加了程序员的工作量。
无用的JAVA内存回收程序以线程方式在后台运行，利用空闲时间来工作。
关于运算符重载，JAVA不支持运算符重载，但C++支持。
这被认为是C++的一个重要特性。
为了保持语言简单，JAVA不支持重载运营商。
JAVA不支持预处理功能，而C/C++在编译过程中有一个预处理步骤。
JAVA虚拟机没有预处理器，但提供了类似于C/C++预处理器功能的import语句。
关于函数参数，JAVA默认不支持函数参数，但C++支持。
这使得JAVA功能参数设置更加清晰，减少混乱。
说到字符串处理，JAVA使用类对象（String和StringBuffer）来实现字符串。
这些类对象是Java语言的核心。
这使得创建字符串和访问字符串元素的方法在整个系统中保持一致，并且还执行运行时检查以帮助消除一些运行时错误。
关于控制流，JAVA没有提供跳转语句来提高程序的可读性和结构的清晰度。
在C和C++中，使用跳转运算符可能会导致程序结构混乱。
关于类型转换，JAVA不支持C++中的自动强制转换。
如有必要，转换必须由程序显式执行。
关于异常处理，JAVA提供了异常机制来拦截异常事件，提高系统的容错能力，而C++则没有这么方便的异常处理机制。