java引用是什么意识？JAVA 中的 -> 是什么意思

大家好，今天给各位分享java引用是什么意识的一些知识，其中也会对JAVA 中的 -> 是什么意思进行解释，文章篇幅可能偏长，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在就马上开始吧！

java中什么是类爆炸

可能是由于设计者对面向对象设计经验的缺少，也可能设计者是一个刻板的教条主义者，结果出品了一个很不理想的设计，其中可能就体现在类的数量爆炸的问题。

类爆炸的现象已经发生在我们的软件系统中了。比如我们某期的系统中各种模块文件的数量已经达到一千多个了，虽然比起操作系统这样的系统来说，由一千多个模

块组成的系统不算什么，但是我们目前的软件团队维护这么多的模块真的是有些吃力。由于我们使用的是VB，这还导致另一个问题，VB能装载的文件总数是有限

制的，最后用户提出了新的需求需要新的模块来完成实现，系统却已经不允许加入新的模块了，最后不得不对系统进行拆分或者对某些模块进行合并。

类爆炸的直接原因是设计者对类的抽象粒度没能把握好，只要两个事务有所差别就用不同的类来设计。粒度能多小就做多小，以为这样可以减少耦合。事实是如此

吗？最近组长让我写一份设计问题，他已经规定了设计文档的规范和大纲，规范中说“本系统编码使用了三种类：界面类、实体类、记录集类，并调用了公用模块中

相应函数”，这可能是他从别的设计规范中继承抄袭过来的。但是我最后提交的设计文档没有实体类和记录集类，组长问我为什么没有这两种类，我说我不需要这两

种类，我这个功能一个界面就可完成了。但是他觉得，如果我没有那两个类就应该在设计文档中说明没有那两个类，我说我的设计文档中没有描述那两个类就表明我

没有那两个类，而不需要在文档中说明“实体类，无；记录集类，无”。

如果每一个功能的完成都必须设计成“界面类、实体类、记录集类”这三种类来联合完成，我们就陷入了教条主义的深渊中。曾经和某个项目经理探讨过，“a=c

与a=b=c”的取舍问题，我的观点是根据具体情况来决定是使用“a=c”的结构还是使用“a=b=c”的结构，他的观点是每个功能都一律使用

“a=b=c”的结构，这导致我很郁闷。为什么要在很简单的情况下，本来可以直接就让“a=c”，何必非要加一个中间件“b”，通过“b”来让

“a=c”？不是我不知道“a=b=c”的结构的用意，而是我觉要根据具体情况来应用。我们的系统的类爆炸就是因为不分优劣一律使用“a=b=c”的结构

而爆炸的。对于面向对象的初期使用者来说，总会津津乐道他在系统中实现了面向对象的设计，尽管那个设计比较糟糕。其实这位项目经理只是给了一个系统的规范

文档而已，至于说是他设计了系统的架构，那还远远谈不到。系统中有什么类，类如何创建，类如何组织，类之间如何通信，他都没有做。只是在文档里说了“本系

统编码使用了三种类：界面类、实体类、记录集类，并调用了公用模块中相应函数”，一句话了事。系统中到底有多少类，他不知道。

我在阅读设计专家关于面向对象设计和设计模式的文章时，这些专家一再强调要谨慎使用面向对象和设计模式，否则后果就是苦果。我在应用面向对象时一向比较小心，一步一步的学习使用，而不是一步到位，毕竟我是个初学者。

再举一个例子。我们的系统中有一个连接类，大家都知道这个类是用来连接数据库的。不过我想很少有人知道为什么设计者要设计出这样一个类来。是因为他刚刚读

过设计模式中有一个“单例模式”。对于我们现在的这个系统来说，使用一个数据库连接对象就可以了，设计者为了避免每个程序员都去创建新的数据库连接，就使

用“单例模式”设计出一个连接类来。“单例模式”的用意就是某个类的实例在整个系统中只能有一个实例存在。比如我们用的windows剪贴板，在整个系统

中只能有一个剪贴板，大家都不会去new一个新的剪贴板出来。

我感到非常的郁闷，在一个公用模块里申明一个系统变量connection就可以了，告诉大家这个对象是我们的数据库连接对象，大家都用这个对象，为什么

再来一个clsConnection类对connection重新包装一下？，这反而就有问题了，我可以new出无数个clsConnection的实

例，没有达到“单例模式”的用意，因为在clsConnection类里没有提供静态方法来总是返回系统中已经存在的连接对象，这成了“多例模式”了。也

许设计者的另一个用意是要使用设计模式中的“简单工厂模式”。不过，不管是想练习什么模式，对于一个connection根本没有必要再包装了。这好比我

们有一个系统级变量，为了避免大家都去申明这个变量就用一个类来包装这个变量。那么系统中已经存在这样一个类，为了避免大家乱用这个类，就再来一个类来包

装这个类？层层包裹下去，怎么才算安全？（这里的例子是应用VB做的系统，JAVA使用者请勿随意理解。这里有语言差异。）

使用面向对象设计技术会产生良好的系统，但是，类是面向对象中的东西，那么类爆炸也必然是使用面向对象的产物，这是不良设计导致的。

我们有的程序员有些过于遵守规范而显得有些刻板了。举个例子。某个程序员做了一个类A和一个类B，实体B是实体A的载体（规范中要求每个实体都要对应一个

类），类A提供了一个修改自身的方法，当实体B的某个属性改变时必须要改变实体A的某个属性。我看了源代码，发现一条SQL语句就可以解决这个问题，但是

这个程序员为了用类A的修改方法，在类B中写了一个循环，先找出所有属于实体B的实体A，并创建类A的实例，然后调用类A的修改方法。代码不但冗长还效率

低下。这个程序员有自已的理由去那样做，理由1是上面领导制定的规范要求这样做，理由2是这是一种面向对象的应用，因为类A已经提供了修改实体A的方法，

别人就应该重用这个方法。一切讲究重用。

我想提出的是，如果重用这个方法即不使代码简洁又不能提高效率而且还造成强烈的耦合，为什么还要重用它？在面向对象中，大家知道类的构造函数是用来做什么

的吗？重载方法又是为什么吗？为什么一个类可以有多个不同的构造函数？不同的构造函数是为了达到不同的目的，而不仅仅是为了实例化一个类。方法的重载也是

为了实现不同的目的。当类A提供的方法不能很好的完成任务时，我们就应该舍弃它或者重载它。如果规范要求必须类B调用类A的方法（这个“必须”很值得疑

问）时，那么应该在类A中提供不同的修改方法以使设计合理。类A可以有这样的两个方法：方法1（以实体A自身的引用为参数）,方法2（以实体B的引用为参

数）。

关于重用。

我们现在设计系统一直想达到重用的目的。但是考虑我们所做软件的性质，我们对系统组件应该达到什么样的重用程度。我们的组件是不是要发布出去供第三方二次

开发？我们的组件是不是每年能达到2次重用？业务组件和与业务无关的组件重用的能力是不是有很大区别？我们不同的客户的业务规范是不是相差比较大？

由于我们现在对业务抽象的不到位，设计出来的类的粒度控制的不够好。业务相关和业务无关的对象的分离做的不够好，因此，实现组件甚至一个子系统的重用是很难的，只能为不同的客户去修改现有的代码，这显然不是重用，而是维护。我们的代码一年连一次重用的机会都没有。

关于创新。

如果没有创新的设计，后果是可想而知的，不管我们了解的业务再多，我们总是用最原始或者最笨拙的设计去实现业务。这样我们对业务了解的越多，系统做的越

大，代码就越混乱越不稳定。能达到将就凑乎的使用已经是不错的了。当硬件技术飞速发展的时候，软件技术却落后，结果是什么？那么，在我们公司，业务和技

术，哪个是硬件哪个是软件？当所有程序员都意识到争当项目经理和项目组长可以不去编写程序而待遇却提高了时，结果是什么？设计需要创新，了解业务却是一种

带有明显的“被动”特征。用户不告诉你他的业务规则你就不知道，告诉你，你就知道。当用户停止提供需求时，这段时间内，需求调研人员应该做什么工作？是不

是留下了大量的需求文档，是不是去抽象业务规则了？需求调研人员是不是能发现不同客户的不同业务之间的相似性为设计人员提供指导？

我们无法为客户去创新业务，但我们应该去创新我们的设计。一个软件的设计很难保持三年不变，如果三年后还不能有所创新而发生变换，那就落后了。为了适应新

的形式，微软敢于修改自己的操作系统的内核使系统升级。不升级意味着失去财富，而升级时难免要修改部分内核。那么，应用创新技术付出的代价大还是保持原有

系统不变的受益大？我们要考虑新系统生产时的阵痛和它以后带来的长远利益。

公司的人员流动的特征我们是否加以分析了，流走的是什么的样人，进来的又是什么样的人。这些人的技术能力、性格、悟性又是如何？我们拥有了许多安于现状不

具创新的老员工，我们该怎么对待他们？如果一个员工的性格激烈但悟性良好能有创新，我们是不是排击他了？兢兢业业、按部就班、任由指挥是不是就是一个优秀

的员工？

一个公司，各种性格的员工的存在应该有一个比例。全部都是不安分的创新者是不好的，充斥大量的安分守己、明哲保身、上面怎么说下面就怎么做的员工也是不好的现象。公司员工的性格和悟性的分布应该象一个波浪一样，有浪头有浪波，这样才能形成巨浪。

关于沟通。

公司越大，我发现员工之间的沟通越差。当我们还是一家小公司的时候，我可以认识所有的人，现在仅能认识个别几个人。沟通，不是由领导来强调下面的人去做

的，而是由领导来启动和带动的。所谓“领导”两个字，就是“领”和“导”，什么意思？大家自然知道。如何才能称得上一个领导，他必须具有领头和导向的作

用。各个部门的领导肩负着不同的“领导”。技术领导，他的技术是不是一定要强？若不强，是不是他能通过沟通的艺术来让下面的人服从？

沟通是一个大的问题。比如我早已经应用过一个比较好的数据库设计模型，但是新项目的设计者从来也没有咨询过我是怎么做的，结果他自己搞出一个很糟糕的数据

模型。沟通是一个双向过程。被动的沟通与主动的沟通的效果自然是不同的。我们现在缺乏主动沟通，就是被动沟通都不能好好的参与。所以，沟通出现了“推模

式”和“拉模式”。举个例子，我有些编程技巧放到公司网站了，很少有人去用主动的看，如果他主动去看了，这种行为模式称作“拉模式”。为了让更多的人知道

我的技巧，我只能主动把技术文章发到每个人的邮箱里，我的这种行为模式是一种“推模式”。我把技术文章推到每个人的邮箱里了，那么接收邮件的人是不是“拉

过来”看一眼？我发现，有一部分人是从来不看的，技术人员也不看。到底为什么不看？看不起我的文章还是太了解我而觉得没有必要看？他的心态我没有办法了

解，总之，沟通是有障碍的。

“聚集”沟通需要大家坐在一起去探讨某些问题，但这可能会浪费参与人的时间。因此我一直以为“推模式”的沟通还是可取的。使用邮件来沟通，想看则看不想看

就不看，尊重接收邮件的人的参与意识。但是发邮件会引来一些误会。一部分人会把你的邮件当作垃圾，心里不喜欢你给他发邮件但又不能说出来。一部分人会认为

发邮件的人脑子有毛病或者出风头，我觉得应该让每一个人都摆正心态：尊重发邮件的人。历来都有“枪打出头鸟”的现象，人在浪头上，难免遭遇不恰当的言语。

因此，永远低调和保持沉默便成为一种人生哲学。激进主义是用来推动社会前进的，保守主义是用来维持社会稳定的。我们允许这些同时存在。

由对事演化到对人。

当我们探讨问题时一般都是本着“对事不对人”的态度的。对于言者也许是这样的心里，但听者可能认为言者就是“对人不对事”。我们没有办法使他消除那种心里，因为那是他的性格使然。但是我们希望每个人都心胸开阔一些。

在探讨关于类爆炸的问题时，我说了一些题外话。

当我和一些同事在探讨设计中的缺陷时，发现大家的眼睛都还是明亮的，知道问题所在。不幸的是，几乎所有的人保都持沉默而不将问题暴露出来。当我暴露问题时，会得到个别人的善意的奉劝：“不要去做”。

JAVA 中的 -> 是什么意思

本文主要是讲解 Java中的运算符。对于运算符而言是编程参与计算的基础核心内容。最基础的加减乘除取余。到后面的逻辑运算大于小于等于不等于。

本文内容思维导图

先从最简单的算术运算符说起。

算术运算符

算术运算符又分为：一元运算符和二元运算符，并且在 Java中包含三元运算符，就是条件运算符或者叫作三目运算符只是名字不同，含义相同。

一元运算符

一元运算符只有一个变量就可以进行操作。常用的一元运算符就是自加，自减。一共四个一元运算符。

示例代码，这里使用 JShell快速查看结果。

需要注意其中的自加和自减的规则。当运算符在前的时候++ a;运算符的优先级比较高，所以会先处理这个代码，所以可以看到代码里面直接返回了结果 4。但是 a++的时候却没有直接返回结果，因为他的运算符比价低。所以重新调用该变量就会打印出来当前的值。

代码定义如下：

运行查看结果：

二元运算符

二元运算符一共5个。分辨是加减乘除取余（+、-、*、/、%）。

其中，在进行除法运算的时候，遵守除数不能为 0；

如果除数为 0就会报错，错误如下：

代码示例如下：

运行查看结果，编译，运行：

赋值运算符

对于赋值运算符基本上贯穿了整个类的周期。常用的=赋值。和简写赋值和算术运算符的使用方式。赋值运算符有如下图所示的使用方式。

使用 JShell进行测试代码如下：

代码示例如下：

inta=0;

a=3;

System.out.println(a);// 3

a+=3;

System.out.println(a);// 6

a-=3;

System.out.println(a);// 3

a*=3;

System.out.println(a);// 9

a/=3;

System.out.println(a);// 3

a%=2;

System.out.println(a);// 1

比较运算符

比较运算符，也可以说是布尔运算符。主要是比较两个表达式的结果。（表达式）操作符（表达式）

根据上面的运算符进行案例演示，一定要动手练习。更能加深印象。

只要知道比较运算是最终得到一个布尔类型的值。并且在进行比较运算的时候，一定要注意其优先级。代码这次自己动手做吧。有上面的演示，应该很容易就搞定。

逻辑运算符

对于逻辑运算符，主要就是 3个。逻辑与、逻辑或、逻辑非。和数学中的与或非意思一致。

格式：表达式1逻辑运算符表达式2

逻辑运算符大多数情况下会和其他的运算符一起使用，主要做一些简单或复杂的逻辑运算。并且通常都是和 if, for等逻辑表达式一起使用。

简单的说一说，对于逻辑与和逻辑或不同点。逻辑与为第一个表达式和第二个表达式都等于真值的情况下才会表达式成立。逻辑或是第一个表达式为真值的情况下，就不会在执行第二个表达式。因为不管第二个表达式是否成立，该逻辑运算都是真值了。

位运算符

对于任何编程语言而言，最终的操作都是二进制表示，因为计算机只认识二进制，而八进制，十进制或者十六进制都是为了让开发人员方便开发。对于 Java来说，也可以针对数的某个值进行运算。这就需要位运算符的参与了。也是为了方便对二进制进行操作。

位运算符主要有一下运算符：

位与&

按位与和逻辑运算符的逻辑与很类似，一个比较的表达式，一个是按照位来进行判断。在二进制中，位与的判断为都为 1的记做 1否则记做 0。

按位与规则如下：

0& 0= 0;

0& 1= 0;

1& 0= 0;

1& 1= 1;

先看一个都是正整数的值 10& 2。

最终得出结果 0000 1010& 0000 0010= 0000 0010转换成十进制就是2。

对于负值的位与运算有点区别的地方就是参与运算的是补码。

举例说明： 10&-2

具体如何得到补码，可以参考我之前写的文章基础类型的相互转换。这里对于负值的情况需要了解什么是原码，反码和补码。参与运算的是补码。-2的原码是 1000 0010反码是 1111 1101补码在反码的基础最后一位加 1得到1111 1110。

最终结果得到 0000 1010& 1111 1110= 0000 1010十进制也就是 10。

这个时候怎么校验结果是否正确呢？直接写 Java代码就好了，打开 jshell:

位或|

按位或，和逻辑或很类似，只要二者有一位 1结果就是 1。

按位或规则如下：

0| 0= 0;

0| 1= 1;

1| 0= 1;

1| 1= 1;

根据上面的运算得到了 10| 2= 10。

负值有略有不同。

还是要灵活运用原码反码和补码，特别是负数的情况下，因为正数的原码和补码一致。

位反~

按位反，和逻辑非类似。是对位进行直接取反。

按位反规则如下：

~1= 0;

~0= 1;

先用 2进行运算处理：

在进行-2的运算操作

-2的原码需要转换成补码，用补码进行取反运算。得到 1的二进制。

代码演示如下：

位异或 ^

位异或是基于二进制的位运算。采用符号 XOR在 Java中使用 ^进行表示。两个值相同取 0，不同的取 1。

按位异或规则如下：

1 ^ 1= 0;

0 ^ 0= 0;

1 ^ 0= 1;

0 ^ 1= 1;

举例 10 ^ 2

举例 10 ^-2

代码演示结果的准确性：

异或在代码优化和实际的工作中会经常用到。后续实战中用到了在详细分析用法，现在知道进行异或运算即可。

位左移<<

将一个操作数进行二进制位往左移，移动后空出来的低位用 0进行填充。移除的高位舍去。高位丢弃，低位补零。

操作数<<移动的位数

举例说明 10<< 2

位左移代码演示：

位右移>>

将一个操作数进行二进制往右移，移动后，有两种情况，一种有无符号一种是有符号。也就是最高位为 0移动后高位补 0，如果最高位（符号位）为 1，移动后空缺位都为 1.

操作数>>移动的位数

举例说明 10>> 2

对于负数举例-2>> 2空缺位补 1：

位右移代码演示：

注意这两者的区别。

无符号位右移>>>

这个是和右移操作上是一致的，但是不管是否最高位（符号位）为 1，空缺位都使用 0进行补齐。

操作数>>>移动的位数

举例说明 10>>> 2

对于负数来说。这里有点区别，因为对于负值来说，上面其实都是 32位，为了让大家看起来舒服转换成了对应的 8位的。因为无符号位右移会改变正负值，所以 32位的负值和 8位的负值是不一致的。

并且 Java在处理 byte, short, char等值进行移位操作前，会先将类型转换成 int因为 int占用 32位。

所以-2>>> 2的时候，8位运算应该是如下：

因为会先转换成 32位。所以 32位的-2等于如下：

也就是结果： 1073741823

无符号位右移代码如下：

理解原理。更能发现问题。

类型比较运算符

这里说的类型比较是对象的比较。判断每个定义的变量是否是某个类。该类可以是（接口、抽象类）。

语法规则：

boolean=变量 instanceof类

举例说明：

运行查看结果：

这里需要注意：

null值是没有引用的，所以和任何值都不相等。

instanceof比较的是引用类型，不能用于基础类型的比较。

条件（三目）运算符

三目运算在 Java中只有一个就是?:

三目运算的语法格式：

大部分情况下，对于三目运算是 if和 else的简写。举例说明：

Stringmsg=a>b?"a比 b大":"a比 b小";

System.out.println(msg);

//上面的结果和下面一致

if(a>b){

msg="a比 b大！";

}else{

msg="a比 b小！";

}

//msg是"a比 b小！"

运算符的优先级

所有的数学运算都是从左向右进行运算的，对于 Java来说大部分运算也是遵守从左向右的规则。但是一元运算符，赋值运算符和三目运算符例外。他们是从右向左进行运算。

运算符的内容告一段落，接下来就是开始逻辑表达式的学习。教程编写不易。希望各位大看官点赞收藏加关注。更多内容大放送。

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里无用内存回收程序是以线程方式在后台运行的，利用空闲时间工作。

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中字符串是用类对象(string和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++则没有如此方便的机制。

附:

Java群体每天都在扩大，它既包括一些世界最大的ISV，也包括公司CIO、信息技术人员、系统分析人员、C/S开发人员、编程人员、多媒体设计者、市场行销人员、教育工作者、经理、影视生产者甚至业余爱好者等广泛的用户。从传统上看，这样一些人在一起有效地工作是不多见的。当我们谈到开放系统时，我们往往是就已发表的API及规格，或者源码的可得性，或者硬件、联网及操作系统而言的，没有一个人是从人的开放意义上来谈的。Java完成了开放系统的闭合链。它开发了人力资源，而反过来又开辟了共同工作的道路。

一谈到Java，人们马上会想起一种类似于C++的、适用于分布环境的面向对象编程语言，想到这种语言的简单、稳定、安全、与体系结构无关、可移植、可解释、高性能、多线程和动态性等特征。这些都是Java作为一种程序设计语言的主要特征。

Java是由Sun公司的一个技术小组研制出来的。在实现Java语言的过程中，Sun小组的技术人员很快就意识到:C++无法成为一种完全面向对象的、网络化的开发语言。C++是通过给原先的C语言增加面向对象功能而开发出来的，因此,它存在着先天不足。这主要体现在C++种类繁多，功能大量冗余，同时又没有任何一种C++编译器能够支持它的全部功能。鉴于这种情况，Sun公司的技术人员决定不扩充C++，而开发一种全新的计算机语言(Java的前身Oak)。但是，C++已经成了大多数编程人员所熟练掌握的语言，Java的设计显然不能无视这个现实。如果Java和C++之间的差别过大，那么程序员们在学会这种语言的过程中无疑要花费大量的时间和精力。因此，Java保留了尽可能多的C++风格。

Java自诞生起，为网络用户创造了无数客户端的小应用程序，由于这类应用程序效果良好、数量巨大，以至于许多用户想到Java编程语言时，会在脑海中出现一个不完全正确的印象-Java是用来编写小的客户端程序的。其实，随着技术的进步，Java语言正在逐步改变自己执行效率较低、无法担任企业关键计算任务的形象，不断向计算技术的核心地带前进。今天的Java技术正沿着网络渗入各个应用领域。

企业计算：企业计算是Java最重要的技术主题。Sun公司已经公布了企业JavaBean（EJB，Enterprise JavaBean）的规格，随后众多公司开始开发企业应用领域的Java技术。IBM公司也已经为Windows NT开发了IBM HPCJ（High Performance Compiler for Java）12.0版，同时研制了IBM JDK（JavaDevelopment Kit）for Windows NT，Novell公司也在宣布了一个新的服务器端的企业Java平台，而Sun公司也在积极地升级自己的JDK系统，这个形势表明，Java正在稳步走向企业高端计算。对于Java来说，与其它编程语言争夺企业计算主力编程工具的优势在于：其一，Java在进行面向对象的编程工作时，比其它的编程语言如C++更加简单，因此保证了编程的高效率，减少了编程投入；其二，Java虚拟机技术所提供的"一次编程，到处使用"的跨平台能力非常适合网络环境，这给Java在网络服务器端的发展提供了便利条件；其三，Java拥有强大的提供商和支持者队伍，该队伍包括IBM、Oracle、Novell、Sybase和Netscape等公司。

提速运行：许多企业的应用开发人员非常喜爱Java的语言特性，但是在开发重要系统时，语言特性和执行效率之间的抉择往往令人伤透脑筋。在关键计算中，用户可能并不在乎数据如何压缩或者运行的延迟关系如何设置，但是对程序的运行速度却非常重视，这使厂商将Java的编译策略开发放在了首位。现在的Java语言，其执行方式已经不仅仅是解释执行方式了，即时编译器（JITC、just-in-time compiler）技术和原型编译技术已经被许多厂家采用，包括Sun、IBM、Oracle以及Netscape等公司在内的技术提供商正在利用这些技术逐步提高Java的执行速度，其中IBM公司早已将Java虚拟机（JVM，JavaVirtual Machine）、操作系统和硬件的特性有机的结合在一起，非常有效地提高了Java的执行效率。

嵌入计算：嵌入式Java是一个潜力巨大的应用技术，该技术充分发挥了Java小巧灵活的特点。以HP公司为例，该公司以自己的方式制造编译工具和Java虚拟机，其目的是将Java嵌入各种设备，如打印机、医学监视器和自动提款机等。嵌入设备依靠一个实时操作系统来处理某一个实时生效的事件，Java被嵌入这些设备后，通过实时扩展（real-time extension）开始发挥作用，使设备具备了一定的智能性，增强了嵌入设备的可管理性和可用性，大大提高了设备的工作效率。各厂商对这一潜力巨大的市场都非常重视，目前该市场缺乏的是一个标准，如果存在标准的话，相信很快就会有大量使用嵌入Java技术的设备上市。

微软刚刚发行的Windows XP放弃了对Java的支持，但Java能够独立运行于很多操作平台上，其中也包括Linux，并且在某些特性上要比在Windows上发挥得更好，我们完全有理由抛弃Windows而选择使用Linux来做Java开发。现在，你可以左手拿着Linux，右手拿着Java，然后对面带微笑手里拿着Windows XP的Bill Gates说："让你的XP去见鬼吧！"

对于软件开发者来讲，任何一种编程语言都不可能是完美的。如果希望更好地理解Java语言，最好的方法是把这种语言与其同类型的语言相比较。既然Java类似于C++，把它同C++进行一番比较也是顺理成章的事情,哪一个好，哪一个不好，每个开发人员都有各自的看法。我个人认为Java开发要比C++好一些。当然每个人的看法和喜好是不同的。后面的文章将向大家介绍Java和C++的不同和对其的改进。孰强孰弱，大家自然就会明白了。

我们知道，Java一开始采用C++的语法格式，基本上是为了让程序设计者可以很快地熟悉 Java的语法格式，缩短学习Java的时间，毕竟C和C++仍旧是最多人会的一种程序语言。但是如果我们仔细检查Java程序语言的许多细节设计，我们可以发现Java去掉了不少C++的特点，并且加入一些新的特性。这些与C++的差异包括：

1.不再有#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的程序文件就够了。

2.不再有structure、union及typedef

事实上，早在C++中就可以去掉C语言中的structure和union等对复杂数据的自定结构类型，因为类(Class)的定义方式可以完全做到这项功能。而typedef也是不必要的，一切都用类就可以了。虽然C++这样的设计是为了和C语言兼容，但是使用多余的语言特点不但不必要，而且容易造成对程序认识的混淆。

3.不再有函数

在Java程序语言中，去掉了程序向导语言中最重要的单元--函数(Function)。如果我们以对象向导的观念来看待函数，就可以了解函数在对象向导的概念中，是不必要的。在对象向导的程序观念里，对象的数据才是真正的主体，而处理对象数据的方法则必须依附在对象内才有意义。因此，去掉函数并不表示不再有子程序等模组化程序的概念，相反地，是利用对象中的方法来取代函数，再一次强化对向导的发展策略。

4.不再有多重继承(Multiplelnheritance)

在C++中，多重继承是一项很强的功能，但也是一般人难以掌控的部分。去掉多重继承虽然降低了Java语言的功能，但是也大幅简化撰写程序时的困难度。虽然移除了多重继承的功能，但是Java提供了interface的方式，可以达到部分多重继承的功用。所谓的interface基本上定义了一个类的对外沟通的方法原型，以及类内部的常数，和多重继承不同之处在于interface并不会定义类方法的内容，以及类中的变量数据。

5.不再有Goto

在程序语言的发展史上，Goto一直是毁誉参半的一项功能。在很多时候使用Goto可以大幅减少不必要的程序代码，但是也由于Goto可以很自由地改变程序的流程，如果冒然地使用，更可能造成程序结构混乱的情况。一般来说，正确使用Goto的例子多出现在循环内部，想要提早结束某一层循环。在C语言中，我们可以使用break或contine来改变某一层循环的流程，但如果想要改变两层以上的环执行流程，不是使用Goto就是以多余的布尔(boolean)变量，配合上一串if-then-else的判断来达成。

Java一方面移除了Goto的功能，而另一方面同时扩大了break和continue的功能，可以允许多层循环的break或continue。如此一来不但避免了滥用Goto的可能性，同时也保存下Goto的好处。

6.不再有OperatorOverloading

在C++中，Operator Overloading同样也是一项值得讨论的设计。几乎在所有C++的书中，都会引用一些例子，告诉你使用OperatorOverloading可以使你的程序看起来更为自然。如下面是一个程序设计师自定义的复数类：

//C++中自定义的复数类及0pemtor Overloading

class Complex{

public：

Complex(double real,double image){

Real_number=real；

Image_number=image；

}

Complex operator+(Complex&rhs){

Return Complex(rhs．real_number+real_number，

rhs．image_number+image_，nulnbef)；

}

private：

doublereal_number//实部

doublejmage_nunmber；//虚部

}

在这里，如果你使用+来作为复数的加法符号，大家都不会有疑义，但是如果你使用的是*或》这样的符号，那么别人看到你的程序之后，难保不会产生认识上的错误。这也是Operator Overloading一大问题，当大家都对运算符赋予自己的定义后，整个程序的可读性就会大受影响。Operator Overloading的存在并不是必要的，我们一样可以定义类中的方法来达到同样的目的，至于Java去掉这项功能的利弊，恐怕就要读者自己去评断了。

7.取消自动类型转换

Java是一个严格进行类型检查的程序语言，对于下面这样的程序，在C++的编译器上编译时最多只会出现警告的信息，但是在Java里则不予通过：

Int aInteger； Double aDouble=2.71828； AInteger= aDouble；

虽然这样的转型在C++里是合法的，但是也会造成数据精确度的损失。Java为了要确定写程序的人充分地了解这点，必须要程序设计强制转型(type casting)，Java的编译器才会接受：

int aInteger；

doublea Double=2.71828；

aInteger=(int)aDouble；

8.不再有指针

取消指针(Pointer)这样数据类型，可能会让许多熟悉C++语言的程序设计师大吃一惊。在C++语言里，灵活地运用指针是许多程序设计师的得意之作，但是占整个除错时间最久的也是指针的问题。配合上C++对内存管理的态度，程序设计师必须要自己去追踪自己向系统要到的内存，最后确实地交还给系统，并且在使用指针时，要小心翼翼地注意不要跨过合法的记忆空间，造成Segmentation Fault或General Protection Fault之类的问题。

Java去掉了指针类型，并不表示程序设计师在开发高级数据结构，像堆栈(stack)、队列(queue)、二元树(binarytree)时，都必须要像在传统Basic上，利用大范围的数组来自行模拟系统内存，自行建构类似指针的表示方式。

相反地，Java提供了和Lisp语言中相似的Reference类型，通过Reference去读取配置到的内存内容，可以确保不会去读取到不属于自己的内存空间，而另一方面，程序的执行系统也可以动态地去做内存垃圾回收的工作，将没有被reference参考到的内存空间回收给系统使用。

9.和C++连接

不管Java是多么强大，总是有人需要把它和C++连接起来。因为只要有一个新的程序语言或是软件开发工具一出现，大家就会问："它是否具有和原有程序库连接的能力呢?"也因为C++语言在电脑界中占了很重要的地位。大家的问题其实就等于是直接问"它是否可以和C++连接?"。目前在Java中，的确提供了和C++语言连接的方法，它的做法基本上是先将C++语言所写的程序建构成动态链接函数库(DynamicLinking Library，DLL)，再由Java程序去调用DLL里的函数。

这种连接的方式，使得DLL中的函数，从Java的眼光看就是一个"方法"。不过因为这种方法是直接由其他的程序语言所提供，而不是以Java语言所写的，所以它被称之为"原生方法"(NativeMethod)。

由于Java Applet一些安全上的限制，所以这种连接外部程序的方法只能用在Java Application内。

小结：

事实上，constant和typedef这两条语句包含了#define语句的作用。现在，结构和联合已经被Java的类所代替。删除这些特性的原因是:由于其希望维持与C语言的向后兼容性，C++的语言规范包含了大量冗余。比如，类实际上就已经包括了结构和联合的作用，因此这两种数据结构完全可以取消。关于#define语句，Java语言规范的制订者认为:尽管该语句的出发点是为了增强程序的可读性，但实际效果却恰恰相反，它常常导致难读的代码，故应该予以取消。Java不再支持独立函数，因此任何函数都必须封装到某个类中。由于人们普遍认为， C++所用的超类是非常不稳定的，因此Java抛弃了C++中的多继承并代之以接口。Java的接口指的是，在别的类看来一个类所能实现的方法。它所显示的只是一个类的方法或常量和变量，而不是这个类的全部结构。

最后，Java还取消了C++中的GOTO语句、操作符重载、自动类型转换及指针数据类型。 GOTO语句引起的争议已经有很多年了，可一直阴魂不散，这跟某些程序员对该语句一直情有独钟有关。C++仍然支持数据类型的自动转换，但Java要求编程人员显式实现数据类型之间的转换。自动数据类型转换使得两个数据类型互不兼容的变量可以相互赋值，而不需要给出显式说明。这有时会导致一些问题，其中最常见的是精确度损失。比方说，如果把一个带符号的32位整数赋给一个无符号整数，则所有的结果均为正数。Java的设计者们认为这很容易引起程序错误，从而决定不支持这种转换方式。

java引用是什么意识和JAVA 中的 -> 是什么意思的问题分享结束啦，以上的文章解决了您的问题吗？欢迎您下次再来哦！