事实上, Java 本来正是从
C++衍生出来的。 

 

C++和 Java
之间仍存在一些领会的差别。能够这样说,那些差距意味着着技术的特大提升。一旦大家弄明白了那一个差异,就会清楚为什么说
Java 是一种出色的顺序设计语言。那里将引导大家认识用于区分Java 和
C++的局地生死攸关特色。

 

(1) 最大的绊脚石在于速度:解释过的 Java 要比 C
的施行进程慢上约 20 倍。无论怎么都不可能阻止 Java
语言举行编译。出现了有的准实时编写翻译器,它们能一目了然加快捷度。当然,大家一齐有理由认为会现出适用于更加多流行平台的纯固有编写翻译器,但即使没有那么些编写翻译器,由于速度的限量,必须有个别标题是Java
无法缓解的。

(2) 和 C++一样, Java 也提供了两种类型的注释。

 

(3)
全体东西都不可能不置入三个类。不存在全局函数只怕全局数据。若是想获取与大局函数等价的效劳,可考虑将
static 方法和 static
数据置入3个类里。注意没有象结构、枚举大概联合这一类的事物,一切唯有“类”(
Class)!

(4) 全部办法都以在类的重心定义的。所以用
C++的见解看,如同具有函数都已停放,但实际并非如此。

(5) 在 Java 中,类定义选取差不离和
C++一样的款型。但从没标明截止的分店。没有 class foo
那种格局的类表明,唯有类定义。

1 class aType()
2   void aMethod() {/* 方法主体 */}
3 }

 

(6) Java 中尚无功效域范围运算符“ ::”。 Java
利用点号做有所的政工,但能够不要考虑它,因为只幸亏一个类里定义成分。就算那多少个方法定义,也务必在2个类的里边,所以根本未曾须求钦定成效域的限定。大家注意到的一项差别是对
static 方法的调用:使用 ClassName.methodName()。 除此以外,
package(包)的名字是用点号建立的,并能用 import 关键字贯彻 C++的“
#include”的一片段机能。例如上面那一个讲话:

1 import java.awt.*;

( #include 并不间接照射成
import,但在动用时有类似的感觉到。)

 

(7) 与 C++类似, Java 含有一多级“主类型”( Primitive
type),以落到实处更有功用的拜会。在 Java 中,那些种类包含 boolean, char,
byte , short, int, long, float 以及
double。全部主类型的尺寸都以原有的,且与现实的机器毫不相关(考虑到移植的题材)。那必将会对品质造成一定的熏陶,具体取决于不一致的机器。对项指标检查和供给在
Java 里变得更严俊。例如:
■条件表明式只能是 boolean(布尔)类型,不可采纳整数。
■必须利用象 X+Y 那样的三个表明式的结果;不可能仅仅用“
X+Y”来贯彻“副功效”。

(8) char(字符)类型应用国际通用的 16 位 Unicode
字符集,所以能自行表明超过八分之四国度的字符。

(9) 静态引用的字串会自动转换来 String 对象。和 C 及
C++差异,没有独自的静态字符数组字串可供使用。

 

(10) Java 扩大了四个右移位运算符“
>>>”,具有与“逻辑”右移位运算符类似的效用,可在最末尾插入零值。“
>>”则会在移动的同时插入符号位(即“算术”移位)。

(11) 固然表面上接近,但与 C++比较, Java
数组采取的是3个颇为不相同的构造,并有所独特的一举一动。有一个只读的 length
成员,通过它可见道数组有多大。而且只要当先数组边界,运转期检查会自动甩掉1个要命。全部数组都是在内部存款和储蓄器“堆”里创造的,我们可将二个数组分配给另三个(只是简短地复制数组句柄)。数组标识符属于第一流对象,它的享有办法一般都适用于别的具有目的。

(12) 对于所有不属于主类型的指标,都不得不通过 new 命令创制。和 C++分化,
Java
没有相应的吩咐能够“在仓库上”创设不属于主类型的指标。全数主类型都只可以在库房上创建,同时不选取new
命令。全体重庆大学的类都有友好的“封装(器)”类,所以能够透过 new
创制等价的、以内部存款和储蓄器“堆”为根基的靶子(主类型数组是几个不及:它们可象
C++那样通过集合初步化进行分红,也许采用 new)。

(13) Java
中不用进行提前表明。若想在概念前应用一个类或艺术,只需直接使用它即可——
编写翻译器会确认保证使用合适的概念。所以和在
C++中差别,大家不会赶上别的关系提前引用的题材。

 

(14) Java
没有预处理机。若想利用另二个Curry的类,只需采纳import
命令,并点名库名即可。不设有类似于预处理机的宏。

(15) Java
用包代替了命名空间。由于将全部东西都置入3个类,而且由于接纳了一种名为“封装”的体制,它能针对类名进行类似于命名空间分解的操作,所以命名的难点不再进入大家的设想之列。数据包也会在单独二个库名下收集库的零部件。大家只需不难地“
import”(导入)贰个包,剩下的工作会由编写翻译器自动完毕。

(16) 被定义成类成员的靶子句柄会自动开头化成
null。对基本类数据成员的起首化在 Java
里取得了牢靠的维持。若不显明地进行发轫化,它们就会获取贰个暗中同意值(零或等价的值)。可对它们举办精通的发轫化(显式开始化):要么在类内定义它们,要么在塑造器中定义。选拔的语法比C++的语法更易于精晓,而且对于
static 和非 static 成员来说都以永恒不变的。大家不要从表面定义 static
成员的存款和储蓄格局,那和 C++是例外的。

(17) 在 Java 里,没有象 C 和 C++这样的指针。用 new
创制多个对象的时候,会得到叁个引用。例如:

1 String s = new String("howdy");

不过,
C++引用在创立时必须进行起首化,而且不可重定义到一个见仁见智的地方。但Java
引用并不一定局限于创制时的岗位。它们可依照事态任意定义,那便解决了对指针的局地要求。在C

C++里大气使用指针的另3个原因是为了能指向自由一个内部存款和储蓄器地方(那还要会使它们变得不安全,也是Java
不提供这一支撑的案由)。指针平常被视作在大旨变量数组中随处移动的一种有效手法。
Java
允许大家以更安全的款型达到相同的对象。化解指针难点的极端方法是“固有方法”。将指针传递给艺术时,平时不会带来太大的题材,因为那时并未大局函数,唯有类。而且我们可传递对目的的引用。
Java
语言最早先声称自个儿“完全不使用指针!”但随着许多程序员都狐疑没有指针如何做事?于是后来又声称“接纳受到限制的指针”。我们可自行判断它是还是不是“真”的是三个指针。但不论是在何种情状下,都不设有指针“算术”。

(18) Java 提供了与 C++类似的“创设器”(
Constructor)。要是不谐和定义1个,就会取得一个暗许营造器。而一旦定义了二个非默认的营造器,就不会为大家自行定义默许创设器。这和C++是同等的。注意没有复制构建器,因为全数自变量都以按引用传递的。

(19) Java 中并未“破坏器”(
Destructor)。变量不存在“功效域”的题材。3个目标的“存在时间”是由对象的存在时间决定的,并非由垃圾收集器决定。有个
finalize()方法是每三个类的成员,它在某种程度上接近于 C++的“破坏器”。但
finalize()是由垃圾收集器调用的,而且只负责释放“能源”(如打开的公文、套接字、端口、
U奔驰G级L
等等)。如需在1个特定的地址做某样事情,必须创造四个特有的法门,并调用它,不可能依赖finalize()。而在一方面,
C++中的全数目的都会(可能说“应该”)破坏,但并非 Java
中的全部指标都会被看作“垃圾”收集掉。由于 Java
不扶助破坏器的概念,所以在须求的时候,必须审慎地创设一个拔除方法。而且针对性类内的基本功类以及成员对象,须求明显调用全部清除方法。

(20) Java 具有艺术“过载”机制,它的做事规律与
C++函数的过载差不多是完全相同的。

(21) Java 不援救私下认可自变量。

(22) Java 中没有 goto 。它选取的义务诊治跳转搭飞机制是“ break 标签”大概“
continue 标准”,用于跳出当前的不可胜道嵌套循环。

(23) Java 选拔了一种单根式的各自结构,由此具有目的都以从根类 Object
统一继承的。而在
C++中,大家可在任哪个地方方起步3个新的继承树,所以最后往往看出包括了大量树的“一片森林”。在Java
中,我们无论如何都只有二个分级结构。尽管那表面上看就像造成了限定,但鉴于大家了然各类对象自然至少有三个Object
接口,所未来往能取得更强硬的力量。
C++近日仿佛是唯一没有强制单根结构的唯一一种 OO
语言。

(24) Java 没有模板也许参数化类型的其余花样。它提供了一名目繁多集合:
Vector(向量), Stack(堆栈)以及 Hashtable(散列表),用于容纳 Object
引用。利用那个聚集,大家的一文山会海须求可取得满意。但这一个聚集并非是为兑现象
C++“标准模板库”( STL)那样的火速调用而规划的。 Java 1.2中的新集合显得特别完整,但仍不享有正宗模板那样的高功用使用手腕。

(25) “垃圾收集”意味着在 Java
中出现内部存款和储蓄器漏洞的景色会少得多,但也绝不全盘不恐怕(若调用3个用来分配存款和储蓄空间的本来方法,垃圾收集器就不能够对其进展跟踪监视)。不过,内部存款和储蓄器漏洞和财富漏洞多是出于编写不当的
finalize()造成的,或是由于在已分配的3个块尾释放一种能源造成的(“破坏器”在此时展现尤其福利)。垃圾收集器是在
C++基础上的一种巨大升高,使不少编制程序难题消弥于无形之中。但对少数多少个废物收集器力有不逮的题材,它却是非常小适合的。但废品收集器的大方亮点也使这一处缺点显得卑不足道。

(26) Java 内建了对二十八线程的支撑。利用二个与众差别的 Thread
类,大家可通过一而再次创下立三个新线程(放任了run()方法)。若将
synchronized(同步)关键字作为艺术的四个品类限制符使用,互相排斥现象会在目的那顶尖爆发。在别的给定的时光,只有2个线程能应用二个目标的synchronized
方法。在单方面,3个synchronized
方法进入未来,它首先会“锁定”对象,制止别的任何 synchronized
方法再使用至极指标。只有退出了那些法子,才会将指标“解锁”。在线程之间,我们如故要承担落到实处更复杂的一路机制,方法是创制自个儿的“监视器”类。递归的
synchronized
方法能够不荒谬运维。若线程的优先等级相同,则时间的“分片”无法博取有限支撑。

 

(27) 我们不是象
C++那样控制注解朝码块,而是将造访限定符( public, private 和
protected)置入各种类成员的概念里。若未规定一个“显式”(鲜明的)限定符,就会私下认可为“友好的”(
friendly
)。那意味着同2个包里的其它因素也足以访问它(约等于它们都改成C++的“
friends” —— 朋友),但不可由包外的别样因素访问。类——
以及类内的种种方法——
都有八个走访限定符,决定它是还是不是能在文书的表面“可知”。 private
关键字日常很少在 Java
中选拔,因为与排斥同贰个包内其余类的拜访相比较,“友好的”访问日常特别实惠。然则,在八线程的条件中,对
private 的适度运用是不行重庆大学的。 Java 的 protected 关键字表示“
可由继任者访问,亦可由包内别的因素访问”。注意 Java 没有与 C++的
protected 关键字等价的要素,后者意味着“只可以由继任者访问”(在此在此之前可用“
private
protected”达成这些指标,但这一对关键字的整合已被撤除了)。

(28) 嵌套的类。在
C++中,对类进行嵌套有助于隐藏名称,并方便代码的组织(但
C++的“命名空间”已使名称的藏身显得多余)。 Java
的“封装”或“打包”概念相当于 C++的命名空间,所以不再是三个题材。Java 1.1
引入了“内部类”的定义,它神秘保持指向外部类的1个句柄——
创造内部类对象的时候须要用到。那意味着在那之中类对象也许能访问外部类对象的分子,毋需任何条件——
就好象那个成员直接隶属于个中类对象一样。那样便为回调难题提供了二个更不错的方案——
C++是用指向成员的指针消除的。

(29) 由于存在前面介绍的那种内部类,所以 Java
里没有指向成员的指针。

(30) Java 不设有“嵌入”( inline)方法。 Java
编写翻译器可能会自行决定嵌入二个方法,但大家对此并未越来越多的控制权力。在 Java
中,可为2个主意应用 final
关键字,从而“提出”举行停放操作。但是,嵌入函数对于
C++的编写翻译器来说也只是一种提出。

(31) Java 中的继承具有与 C++相同的法力,但运用的语法分歧。 Java 用
extends 关键字标明从三个基础类的继续,并用 super
关键字提出准备在基础类中调用的措施,它与大家当前所在的艺术具有同等的名字(然则,
Java 中的 super 关键字只同意大家访问父类的情势——
亦即分级结构的上一流)。通过在
C++中设定基础类的成效域,大家可访问位于分级结构较深处的办法。亦可用super
关键字调用基础类创设器。正如开首建议的那样,全部类最后都会从 Object
里活动延续。和
C++分歧,不设有分明的营造器初步化列表。但编写翻译器会迫使大家在营造器主体的开始实行全方位的底蕴类初叶化,而且不允许大家在大旨的背后部分开展这一办事。通过整合使用自动早先化以及来自未初叶化对象句柄的尤其,成员的伊始化可取得管用的保障。

1 public class Foo extends Bar {
2   public Foo(String msg) {
3     super(msg); // Calls base constructor
4   }
5   public baz(int i) { // Override
6     super.baz(i); // Calls base method
7   }
8 }

 

(32) Java
中的继承不会变动基础类成员的掩护级别。大家无法在 Java 中钦定 public,
private 可能protected 继承,那或多或少与
C++是一样的。其它,在衍生类中的优先方法不能够压缩对基础类措施的造访。例如,假若四个分子在基础类中属于
public,而大家用另2个方法代替了它,那么用于替换的主意也务必属于public(编写翻译器会自行检查)。

(33) Java 提供了一个 interface
关键字,它的意义是成立抽象基础类的1个等价物。
在内部填充抽象方法,且并未数据成员。那样一来,对于唯有设计成1个接口的事物,以及对于用
extends
关键字在现有功效基础上的增加,两者之间便发出了一个眼看的歧异。不值得用
abstract
关键字发生一种恍若的功效,因为大家不可能成立属于相当类的多个指标。二个abstract
(抽象)类可含蓄抽象方法(尽管并不须要在它当中包括哪些东西),但它也能包罗用于具体落到实处的代码。因而,它被界定成一个纯粹的接续。通过与接口联合利用,这一方案制止了对近似于
C++虚拟基础类那样的局地机制的内需。为创建可开始展览“例示”(即创办二个实例)的贰个interface(接口)的本子,需利用 implements
关键字。它的语法类似于继续的语法,如下所示:

1 public interface Face {
2   public void smile();
3 }
4 public class Baz extends Bar implements Face {
5   public void smile( ) {
6     System.out.println("a warm smile");
7   }
8 }

 

(34) Java 中没有 virtual
关键字,因为具备非 static 方法都必然会用到动态绑定。在 Java
中,程序员不必自行决定是或不是利用动态绑定。 C++之所以选取了
virtual,是出于大家对质量举行调整的时候,可因此将其简要,从而获取执行效能的为数不多调升(或然换句话说:“假诺不用,就没必要为它付出代价”)。
virtual平日会促成一定水准的模糊,而且获得让人悲伤的结果。 final
关键字为品质的调动规定了一些限制——
它向编译器建议那种方法无法被替代,所以它的限量恐怕被静态约束(而且成为嵌入状态,所以选择C++非virtual
调用的对等格局)。那些优化学工业作是由编写翻译器完结的。

(35) Java 不提供多重继承机制( MI),至少不象 C++那样做。与 protected
类似, MI
表面上是二个很不利的意见,但唯有真正面对八个特定的设计难点时,才通晓自身索要它。由于Java
使用的是“单根”分级结构,所以唯有在极少的地方才需求用到 MI。 interface
关键字会扶助大家机关实现四个接口的晤面工作。

(36) 运行期的品类标识效率与 C++极为相似。例如,为获得与句柄 X
有关的新闻,可利用下述代码:

1 X.getClass().getName();

为开始展览一个“类型安全”的压缩造型,可应用:

1 derived d = (derived)base;

那与旧式风格的 C
造型是同样的。编写翻译器会活动调用动态造型机制,不供给采纳额外的语法。固然它并不象C++的“
new casts”那样拥有易于定位造型的帮助和益处,但 Java
会检查采用情形,并丢掉那几个“万分”,所以它不会象
C++那样允许坏造型的存在。

(37) Java
选用了不相同的老大控制机制,因为那时候早就不设有营造器。可添加三个finally
从句,强制执行特定的讲话,以便举行需要的清除工作。 Java
中的全体尤其都是从基础类 Throwable
里继续而来的,所以可保险大家收获的是3个通用接口。

 1 public void f(Obj b) throws IOException {
 2   myresource mr = b.createResource();
 3   try {
 4     mr.UseResource();
 5   } catch (MyException e) {
 6     // handle my exception
 7   } catch (Throwable e) {
 8     // handle all other exceptions
 9   } finally {
10     mr.dispose(); // special cleanup
11   }
12 }

 

(38) Java 的百般规范比
C++的雅观得多。扬弃二个不当的足够后,不是象
C++那样在运作时期调用三个函数, Java
十分规范是在编写翻译时期检查并执行的。除此以外,被代表的方法必须信守那一情势的底子类版本的不行规范:它们可抛弃钦定的可怜或然从那个可怜衍生出来的此外越发。那样一来,我们最终得到的是进一步“健壮”的十分控制代码。

(39) Java 具有艺术过载的能力,但不允许运算符过载。 String
类不可能用+和+=运算符连接差异的字串,而且String
表明式使用自动的类型转换,但那是一种很是的内建事态。

(40) 通过先行的预订, C++中日常现身的 const 难点在 Java
里已获得了决定。我们不得不传递指向对象的句柄,本地副本永远不会为大家自动生成。若希望利用类似
C++按值传递那样的技能,可调用 clone(),生成自变量的3个地面副本(尽管clone()的筹划如故尚显粗糙)。根本不设有被活动调用的副本构建器。为成立三个编写翻译期的常数值,可象上边那样编码:

1 static final int SIZE = 255
2 static final int BSIZE = 8 * SIZE

 

(41)
由于安全地点的原由,“应用程序”的编制程序与“程序片”的编制程序之间存在着强烈的距离。二个最强烈的标题是程序片分化意大家举行磁盘的写操作,因为那样做会招致从远程站点下载的、不明来历的先后恐怕胡乱改写我们的磁盘。随着
Java 1.1
对数字签名技术的引用,这一状态已怀有改变。依照数字签名,大家可适用知道一个程序片的万事小编,并证实他们是否已获得授权。
Java 1.2
会进一步增强程序片的力量。

(42) 由于 Java
在少数场面或然来得限制太多,所以有时候不愿用它实施象一贯访问硬件那样的首要任务。Java
解决那个题材的方案是“固有方法”,允许大家调用由其他语言写成的函数(近日只帮忙C

C++)。那样一来,我们就自然能够解决与平台有关的标题(采纳一种不得移植的花样,但这么些代码随后会被割裂起来)。程序片无法调用固有方法,唯有应用程序才得以。

(43) Java
提供对注释文书档案的内建支持,所以源码文件也得以分包它们本身的文书档案。通过四个单独的次序,那个文书档案音讯能够领取出来,并重复格式化成
HTML。那无疑是文书档案管理及采纳的高大进步。

(44) Java 包罗了一些标准库, 用于完成一定的任务。
C++则凭借一些非标准化准的、由其余厂商提供的库。那些任务包含(或不久就要包涵):
■连网
■数据库连接(通过 JDBC)
■多线程
■分布式对象(通过 PRADOMI 和 CORBA)
■压缩
■商贸
是因为这个库简单易用,而且十分规范,所以能一点都不小加速应用程序的支出进程。

(45) Java 1.1 包罗了 Java Beans
标准,后者可创造在可视编制程序环境中使用的零件。由于遵循同样的正经,所以可视组件能够在装有厂商的费用环境中接纳。由于我们并不借助于一家厂商的方案进行可视组件的规划,所以组件的精选余地会加大,并可增进组件的意义。除外,
Java Beans
的设计卓殊简单,便于程序员明白;而那多少个由差别的厂商开发的专用组件框架则须求进行更深切的读书。

(46) 若访问 Java
句柄退步,就会舍弃1次格外。那种屏弃测试并不一定要正辛亏使用2个句柄以前开始展览。根据Java
的设计规范,只是说尤其必须以某种情势废弃。许多C++运维期系统也能撤废那一个由于指针错误造成的相当。

(47) Java 日常突显越发健壮,为此选择的手法如下:
■对象句柄开端化成 null(3个最首要字)
■句柄肯定会收获检查,并在失误时放弃非凡
■全部数组访问都会获得检查,及时发现边界违例景况
■自动垃圾收集,幸免现身内部存款和储蓄器漏洞
■明显、“傻瓜式”的老大控制机制
■为四线程提供了简单的语言补助
■对互连网程序片实行字节码校验

 

商贸公司,可爱博主:AlanLee

博客地址:http://www.cnblogs.com/AlanLee

正文来源和讯,欢迎大家参加博客园。

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图