C++与java语法的异同整理
⽂章⽬录
Java与C++与基础语法异同
java C++
double 要⽤%f；double 要⽤%d
布尔型：boolean；布尔型：bool
字符型占2个字节,Unicode编码格式字符型占1个字节,Assci编码格式
If , while,for 中进⾏真假判断时只能使⽤逻辑表达式，不能⽤1和0数字来表⽰
真假
可以⽤0和1来表⽰真假
如果你定义了有参的构造函数，则当你调⽤⽆参的构造函数时，必须⾃⼰定义⽆
参的构造函数；
不需要
java 中数组是引⽤类型，只能在堆中创建数组可以在栈中创建
较长的整数后要加L，隐含为long类型较长的整数不需要加L
安全性⾼：当⾼级类型转换为低级类型会报错！例；想要将double转换为float,
float a=2.0f(F)
取余时：被除数和除数可以是实数；但所得余数的正负只和被除数相同
Java中没有指针：A a=new A();  A *a=new A();
java中不⾏C和C++ 中枚举类型enum是可以⽤0，1……来表⽰的java不存在全局变量或者全局函数C++可以定义全局变量和全局函数
java不⽀持运算符重载C++⽀持运算符重载
java不⽀持默认函数参数C++⽀持默认的函数参数
java中类继承，如果⽗类⽅法要重写，不⽤加任何关键字C++要加 virtual 关键字
Java中，super可以表⽰⽗类，this表⽰类本⾝
字符串是⽤类对象(String和StringBuffer)来实现的 [1]c和c++不⽀持字符串变量，在c和c++程序中使⽤null终⽌符代表字符串的结束
java类继承采⽤关键字“extends"C++类继承采⽤符号“：”
java中运算符都⽤运算符“.”C++中的域运算符⽤“：：”，指针运算⽤“->"
Java增添了三个右移位运算符“>>>”，具有与“逻辑”右移位运算符类似的功
⽤，可在最末尾插⼊零值。“>>”则会在移位的同时插⼊符号位（即“算术”移
位）
静态引⽤的字串会⾃动转换成String对象c\c++没有独⽴的静态字符数组字串可供使⽤
java中采⽤关键字“import”以包的形式导⼊，⽂件层级之间采⽤符号“.”隔开C++中包含⽂件采⽤预处理命令“#include”，⽂件层级之间⽤符号“\”隔开
java中声明常量的关键字是“final”，只不过 java中关键字final还有另外的作
⽤： 当⼀个成员函数被定义为final，则这个成员函数不能被重写；当⼀个类被
定义为final，则这个类不能被继承
C++中声明常量的关键字是“const”
java的接⼝是通过使⽤关键字“interface”定义实现的，java的接⼝可以多继
承，⼀个接⼝可以拥有⼏个⽗接⼝（也叫做接⼝的扩展），实现接⼝的类必须要C++的接⼝是通过定义纯虚类来实现的
承，⼀个接⼝可以拥有⼏个⽗接⼝（也叫做接⼝的扩展），实现接⼝的类必须要
有关键字“implement”来定义
C++的接⼝是通过定义纯虚类来实现的
在java中⽅法的局部变量位于栈上，类对象位于堆上，所以⽅法内部类对象不能
使⽤局部变量，但是可以使⽤常量
Java中创建多线程有两种⽅法，⼀种是类实现“Runable”接⼝，⼀种是类继承“Thread”虚类，然后这两种⽅法都要对run（）函数进⾏重写C++创建多线程有三种办法，⼀种是⽤Windows的API函
数“CreateThead()”，⼀种是MFC中的函
数“AfxBeginThread（）”，⼀种是MS的“_beginthreadex()”函数
java C++
[1] c和c++不⽀持字符串变量，在c和c++程序中使⽤null终⽌符代表字符串的结束，在Java中字符串是⽤类对象(String和StringBuffer)来实现的，这些类对象是Java语⾔的核⼼，⽤类对象实现字符串有以下⼏个优点：
(1)在整个系统中建⽴字符串和访问字符串元素的⽅法是⼀致的；
(2)字符串类是作为Java语⾔的⼀部分定义的，⽽不是作为外加的延伸部分；
(3)Java字符串执⾏运⾏时检空，可帮助排除⼀些运⾏时发⽣的错误；
(4)可对字符串⽤“⼗”进⾏连接操作。
Java多线程的调度⽅法有：
setPriority（设置优先级），sleep（睡眠），join（加⼊），yield（让步）；
关键字“synthronized（锁的标志）”，同步代码块的格式为： synthronized(threadname)
Java多线程间实现通信，需要⽤到如下3个⽅法：
wait()表⽰让当前线程进⼊等待状态
notify()表⽰恢复⼀个等待中的线程
notifyAll()恢复所有等待中的线程
java的认知& java与C++的异同
java C++
java为解释性语⾔(源代码通过java编译器编译成字节码交由JVM解释执⾏)C/C++为编译型语⾔(源代码经过编译和链接后⽣成可执⾏的⼆进制编码)
java的执⾏速度⽐C/C++的执⾏速度慢，java能够跨平台执⾏C/C++不可以
java纯⾯向对象（所有代码在类中实现，除基本类型外，所有类型都为类）C++兼具⾯向过程和⾯向对象编程的特点java中没有指针的概念，防⽌了C++语⾔中操作指针可能引起的系统问题，使程序变得更加安全c++有指针概念
java不⽀持多继承(java引⼊了接⼝的概念，可以同时实现多个接⼝，也具有多态性)C++⽀持多继承(⽆接⼝概念)
java⾃⼰提供了垃圾回收器来实现垃圾的⾃动回收，不需要显⽰的管理内存的分配。(java不存在析构函数，引⼊了finalize()⽅法，当垃圾回收将要释放⽆⽤内存时，会⾸先调⽤该⽅法)C++需要开发⼈员去管理对内存的分配，包括申请和释放。(释放资源的代码放在析构函数中)
java没有预处理器，不⽀持预处理功能(包括头⽂件和宏的定义)注：java提供了import 机制与C++的
预处理器功能类似。
C++⽀持预处理
java不⽀持goto**[1]**语句(java中goto是保留关键字)C++⽀持goto语句
java不⽀持强制类型转换(java需要开发⼈员显⽰的强制类型转换) [2]C++⽀持⾃动强制类型转换
java具有平台⽆关性(每种类型分配固定的长度)C++具有平台性(同⼀种类型在不同的平台分配的长度不同)
java包含⼀些标准库，⽤于完成特定的任务，同时这些库简单易⽤，能够⼤⼤的缩短开发周期。(提供
了访问数据库的JDBC库，⽤于实现分布式对象的RMI等标准库)
C++依靠⼀些⾮标准的，由其他⼚商提供的库
java的程序代码是在包package⾥⾯==[3]==C++中所有的程序代码都在⼀个“.h”或者“.cpp”⽂件⾥⾯
[1] 注:goto语句也称为⽆条件转移语句，其⼀般格式如下：
goto 语句标号； 其中语句标号是按标识符规定书写的符号， 放在某⼀语句⾏的前⾯，标号后加冒号(：)。语句标号起标识语句的作⽤，与goto 语句配合使⽤。
如： label: i++;
[2] 注:java引⼊泛型的概念，更好的处理类型的问题
java和c\C++的简单区别(string)：
C中没有String引⽤类型，它是⽤字符数组表⽰，⽤‘\0’表字符结束；⽽C++和java中有String引⽤类型；
另外，C++中的String对象可以⽤s[i]进⾏操作，⽽Java中则不可以，需要转换为char[]才⾏；
[3] package（包）的名字是⽤点号建⽴的，并能⽤import关键字实现C++的“#include”的⼀部分功能。例如下⾯这个语句：
import java.awt.*;
（#include并不直接映射成import，但在使⽤时有类似的感觉。）
补充
1. 最⼤的障碍在于速度：解释过的Java要⽐C的执⾏速度慢上约20倍。⽆论什么都不能阻⽌Java语⾔进⾏编译。写作本书的时候，刚刚
出现了⼀些准实时编译器，它们能显著加快速度。当然，我们完全有理由认为会出现适⽤于更多流⾏平台的纯固有编译器，但假若没有那些编译器，由于速度的限制，必须有些问题是Java不能解决的。
2. 所有东西都必须置⼊⼀个类。不存在全局函数或者全局数据。如果想获得与全局函数等价的功能，可考虑将static⽅法和static数据置
⼊⼀个类⾥。注意没有象结构、枚举或者联合这⼀类的东西，⼀切只有“类”（Class）。
3. 尽管表⾯上类似，但与C++相⽐，Java数组采⽤的是⼀个颇为不同的结构，并具有独特的⾏为。有⼀个只读的length成员，通过它可
知道数组有多⼤。⽽且⼀旦超过数组边界，运⾏期检查会⾃动丢弃⼀个异常。所有数组都是在内存“堆”⾥创建的，我们可将⼀个数组分配给另⼀个（只是简单地复制数组句柄）。数组标识符属于第⼀级对象，它的所有⽅法通常都适⽤于其他所有对象。
4. 对于所有不属于主类型的对象，都只能通过new命令创建。和C++不同，Java没有相应的命令可以“在堆栈上”创建不属于主类型的
对象。所有主类型都只能在堆栈上创建，同时不使⽤new命令。所有主要的类都有⾃⼰的“封装（器）”类，所以能够通过new创建等价的、以内存“堆”为基础的对象（主类型数组是⼀个例外：它们可象C++那样通过集合初始化进⾏分配，或者使⽤new）。
5. Java中不必进⾏提前声明。若想在定义前使⽤⼀个类或⽅法，只需直接使⽤它即可——编译器会保
证使⽤恰当的定义。所以和在
C++中不同，我们不会碰到任何涉及提前引⽤的问题。
6. Java没有预处理机。若想使⽤另⼀个库⾥的类，只需使⽤import命令，并指定库名即可。不存在类似于预处理机的宏。
7. Java⽤包代替了命名空间。由于将所有东西都置⼊⼀个类，⽽且由于采⽤了⼀种名为“封装”的机制，它能针对类名进⾏类似于命名
空间分解的操作，所以命名的问题不再进⼊我们的考虑之列。数据包也会在单独⼀个库名下收集库的组件。我们只需简单
地“import”（导⼊）⼀个包，剩下的⼯作会由编译器⾃动完成。
8. 被定义成类成员的对象句柄会⾃动初始化成null。对基本类数据成员的初始化在Java⾥得到了可靠的保障。若不明确地进⾏初始化，
它们就会得到⼀个默认值（零或等价的值）。可对它们进⾏明确的初始化（显式初始化）：要么在类内定义它们，要么在构建器中定义。采⽤的语法⽐C++的语法更容易理解，⽽且对于static和⾮static成员来说都是固定不变的。我们不必从外部定义static成员的存储⽅式，这和C++是不同的。
9. 在Java⾥，没有象C和C++那样的指针。⽤new创建⼀个对象的时候，会获得⼀个引⽤（本书⼀直将其称作“句柄”）。例如：
  String s = new String(“howdy”);
  然⽽，C++引⽤在创建时必须进⾏初始化，⽽且不可重定义到⼀个不同的位置。但Java引⽤并不⼀定局限于创建时的位置。它们可根据情况任意定义，这便消除了对指针的部分需求。在C和C++⾥⼤量采⽤指针的另⼀个原因是为了能指向任意⼀个内存位置（这同时会使它们变得不安全，也是Java不提供这⼀⽀持的原因）。指针通常被看作在基本变量数组中四处移动的⼀种有效⼿段。Java允许我们以更安全的形式达到相同的⽬标。解决指针问题的终极⽅法是“固有⽅法”（已在附录A讨论）。将指针传递给⽅法时，通常不会带来太⼤的问题，因为此时没有全局函数，只有类。⽽且我们可传递对对象的引⽤。Java语⾔最开始声称⾃⼰“完全不采⽤指针！”但随着许多程序员都质问没有指针如何⼯作？于是后来⼜声明“采⽤受到限制的指针”。⼤家可⾃⾏判断它是否“真”的是⼀个指针。但不管在何种情况下，都不存在指针“算术”。
10. Java提供了与C++类似的“构建器”（Constructor）。如果不⾃⼰定义⼀个，就会获得⼀个默认构建器。⽽如果定义了⼀个⾮默认
的构建器，就不会为我们⾃动定义默认构建器。这和C++是⼀样的。注意没有复制构建器，因为所有
⾃变量都是按引⽤传递的。
11. Java中没有“破坏器”（Destructor）。变量不存在“作⽤域”的问题。⼀个对象的“存在时间”是由对象的存在时间决定的，并⾮
由垃圾收集器决定。有个finalize()⽅法是每⼀个类的成员，它在某种程度上类似于C++的“破坏器”。但finalize()是由垃圾收集器调⽤的，⽽且只负责释放“资源”（如打开的⽂件、套接字、端⼝、URL等等）。如需在⼀个特定的地点做某样事情，必须创建⼀个特殊的⽅法，并调⽤它，不能依赖finalize()。⽽在另⼀⽅⾯，C++中的所有对象都会（或者说“应该”）破坏，但并⾮Java中的所有对象都会被当作“垃圾”收集掉。由于Java不⽀持破坏器的概念，所以在必要的时候，必须谨慎地创建⼀个清除⽅法。⽽且针对类内的基础类以及成员对象，需要明确调⽤所有清除⽅法。
12. Java具有⽅法“过载”机制，它的⼯作原理与C++函数的过载⼏乎是完全相同的。
13. Java不⽀持默认⾃变量。
14. Java中没有goto。它采取的⽆条件跳转机制是“break 标签”或者“continue 标准”，⽤于跳出当前的多重嵌套循环。
java类的概念
14. Java中没有goto。它采取的⽆条件跳转机制是“break 标签”或者“continue 标准”，⽤于跳出当前的
多重嵌套循环。
15. Java采⽤了⼀种单根式的分级结构，因此所有对象都是从根类Object统⼀继承的。⽽在C++中，我们可在任何地⽅启动⼀个新的继承
树，所以最后往往看到包含了⼤量树的“⼀⽚森林”。在Java中，我们⽆论如何都只有⼀个分级结构。尽管这表⾯上看似乎造成了限制，但由于我们知道每个对象肯定⾄少有⼀个Object接⼝，所以往往能获得更强⼤的能⼒。C++⽬前似乎是唯⼀没有强制单根结构的唯⼀⼀种OO语⾔。
16. Java没有模板或者参数化类型的其他形式。它提供了⼀系列集合：Vector（向量），Stack（堆栈）以及Hashtable（散列表），⽤
于容纳Object引⽤。利⽤这些集合，我们的⼀系列要求可得到满⾜。但这些集合并⾮是为实现象C++“标准模板库”（STL）那样的快速调⽤⽽设计的。Java 1.2中的新集合显得更加完整，但仍不具备正宗模板那样的⾼效率使⽤⼿段。
17. “垃圾收集”意味着在Java中出现内存漏洞的情况会少得多，但也并⾮完全不可能（若调⽤⼀个⽤于分配存储空间的固有⽅法，垃圾
收集器就不能对其进⾏跟踪监视）。然⽽，内存漏洞和资源漏洞多是由于编写不当的finalize()造成的，
或是由于在已分配的⼀个块尾释放⼀种资源造成的（“破坏器”在此时显得特别⽅便）。垃圾收集器是在C++基础上的⼀种极⼤进步，使许多编程问题消弥于⽆形之中。但对少数⼏个垃圾收集器⼒有不逮的问题，它却是不⼤适合的。但垃圾收集器的⼤量优点也使这⼀处缺点显得微不⾜道。
18. Java内建了对多线程的⽀持。利⽤⼀个特殊的Thread类，我们可通过继承创建⼀个新线程（放弃了run()⽅法）。若将
synchronized（同步）关键字作为⽅法的⼀个类型限制符使⽤，相互排斥现象会在对象这⼀级发⽣。在任何给定的时间，只有⼀个线程能使⽤⼀个对象的synchronized⽅法。在另⼀⽅⾯，⼀个synchronized⽅法进⼊以后，它⾸先会“锁定”对象，防⽌其他任何synchronized⽅法再使⽤那个对象。只有退出了这个⽅法，才会将对象“解锁”。在线程之间，我们仍然要负责实现更复杂的同步机制，⽅法是创建⾃⼰的“监视器”类。递归的synchronized⽅法可以正常运作。若线程的优先等级相同，则时间的“分⽚”不能得到保证。
19. 我们不是象C++那样控制声明代码块，⽽是将访问限定符（public，private和protected）置⼊每个类成员的定义⾥。若未规定⼀
个“显式”（明确的）限定符，就会默认为“友好的”（friendly）。这意味着同⼀个包⾥的其他元素也可以访问它（相当于它们都成为C++的“friends”——朋友），但不可由包外的任何元素访问。类——以及类
内的每个⽅法——都有⼀个访问限定符，决定它是否能在⽂件的外部“可见”。private关键字通常很少在Java中使⽤，因为与排斥同⼀个包内其他类的访问相⽐，“友好的”访问通常更加有⽤。然⽽，在多线程的环境中，对private的恰当运⽤是⾮常重要的。Java的protected关键字意味着“可由继承者访问，亦可由包内其他元素访问”。注意Java没有与C++的protected关键字等价的元素，后者意味着“只能由继承者访问”（以前可⽤“private protected”实现这个⽬的，但这⼀对关键字的组合已被取消了）。
20. 嵌套的类。在C++中，对类进⾏嵌套有助于隐藏名称，并便于代码的组织（但C++的“命名空间”已使名称的隐藏显得多余）。Java
的“封装”或“打包”概念等价于C++的命名空间，所以不再是⼀个问题。Java 1.1引⼊了“内部类”的概念，它秘密保持指向外部类的⼀个句柄——创建内部类对象的时候需要⽤到。这意味着内部类对象也许能访问外部类对象的成员，⽏需任何条件——就好象那些成员直接⾪属于内部类对象⼀样。这样便为回调问题提供了⼀个更优秀的⽅案——C++是⽤指向成员的指针解决的。
21. 由于存在前⾯介绍的那种内部类，所以Java⾥没有指向成员的指针。
22. Java不存在“嵌⼊”（inline）⽅法。Java编译器也许会⾃⾏决定嵌⼊⼀个⽅法，但我们对此没有更多的控制权⼒。在Java中，可为
⼀个⽅法使⽤final关键字，从⽽“建议”进⾏嵌⼊操作。然⽽，嵌⼊函数对于C++的编译器来说也只是⼀种建议。
23. Java中的继承具有与C++相同的效果，但采⽤的语法不同。Java⽤extends关键字标志从⼀个基础类的继承，并⽤super关键字指出
准备在基础类中调⽤的⽅法，它与我们当前所在的⽅法具有相同的名字（然⽽，Java中的super关键字只允许我们访问⽗类的⽅法——亦即分级结构的上⼀级）。通过在C++中设定基础类的作⽤域，我们可访问位于分级结构较深处的⽅法。亦可⽤super关键字调⽤基础类构建器。正如早先指出的那样，所有类最终都会从Object⾥⾃动继承。和C++不同，不存在明确的构建器初始化列表。但编译器会强迫我们在构建器主体的开头进⾏全部的基础类初始化，⽽且不允许我们在主体的后⾯部分进⾏这⼀⼯作。通过组合运⽤⾃动初始化以及来⾃未初始化对象句柄的异常，成员的初始化可得到有效的保证。
  public class Foo extends Bar {
  public Foo(String msg){
  super(msg);// Calls base constructor
  }
  public baz(int i){// Override
  super.baz(i);// Calls base method
  }
  }
24. Java中的继承不会改变基础类成员的保护级别。我们不能在Java中指定public，private或者protected继承，这⼀点与C++是相同
的。此外，在衍⽣类中的优先⽅法不能减少对基础类⽅法的访问。例如，假设⼀个成员在基础类中属于public，⽽我们⽤另⼀个⽅法代替了它，那么⽤于替换的⽅法也必须属于public（编译器会⾃动检查）。
25. 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");
  }
  }
26. Java中没有virtual关键字，因为所有⾮static⽅法都肯定会⽤到动态绑定。在Java中，程序员不必⾃⾏决定是否使⽤
27. JAVA和C++都是⾯向对象语⾔。也就是说，它们都能够实现⾯向对象思想（封装，继承，多态）。⽽由于C++为了照顾⼤量的C语⾔
使⽤者， ⽽兼容了C，使得⾃⾝仅仅成为了带类的C语⾔，多多少少影响了其⾯向对象的彻底性！JAVA则是完全的⾯向对象语⾔，它句法更清晰，规模更⼩，更易学。它是在对多种程序设计语⾔进⾏了深⼊细致研究的基础上，据弃了其他语⾔的不⾜之处，从根本上解决了c++的固有缺陷。 Java和c++的相似之处多于不同之处，但两种语⾔⼏处主要的不同使得Java更容易学习，并且编程环境更为简单。
C++中的虚函数和JAVA中的抽象⽅法区别
C++虚函数与JAVA中抽象函数⽐较
1：java中没有虚函数的概念，但是有抽象函数的概念，⽤abstract关键字表⽰，java中抽象函数必须在抽象类中，⽽且抽象 函数不能有函数体，抽象类不能被实例化，只能由其⼦类实现抽象函数，如果
某个抽象类的⼦类仍是抽象类，那么该⼦类不需要实现其⽗类的抽象函数。
2：C++中的有虚函数的概念，⽤virtual 关键字来表⽰，每个类都会有⼀个虚函数表，该虚函数表⾸先会从⽗类中继承得到⽗类的虚函数表， 如果⼦类中重写了⽗类的虚函数（不管重写后的函数是否为虚函数），要调⽤哪个虚函数，是根据当前实际的对象来判断的（不管指针所属类型是否为当前类，有可 能是⽗类型），指针当前指向的是哪种类型的对象，就调⽤哪个类型中类定义的虚函数。每个类只有⼀张虚拟函数表，所有的对象共⽤这张表。
C++的函数多态就是通过虚函数来实现的。
3：C++中，如果函数不是虚函数，则调⽤某个函数，是根据当前指针类型来判断的，并不是根据指针所指向对象的类型。
4：Java中，如果函数不是抽象函数，⽽是⼀个普通函数，它是默认实现类似C++中虚函数功能的，也就是说，调⽤某个函数，是根据当前指针所指向对象的类型来判断的，⽽不是根据指针类型判断。正好与C++中的普通函数相反。即：JAVA⾥⾃动实现了虚函数。
两者的对应关系如下:
C++java
虚函数普通函数
纯虚函数抽象函数
抽象类抽象类
虚基类接⼝

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。