javac代码风格 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+(Complexrhs){

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的优势是什么？

Java语言是目前的排行第一的语言，其优势也是非常突出的，那么具体体现在哪里呐？

我来给你说一下Java的优势：

1.java的风格类似C++但不同于C++,从某种意义上讲，java是C++的一个变种；

2.java摒弃了C、C++中的容易引发错误和难以理解的指针，结构，以及内存管理等；

3.java提供了丰富的类库，很方便开发程序；

4.java是完全面向对象的语言，支持 继承，重载，多态等面向对象的特性；

5.C++是面向对象和面向过程的混合语言， C是纯面向过程的语言；

6.java是一种强类型的语言，比C/C++检查还要严格，java区分大小写字母；

7.java提供了自动垃圾回收机制gc，有效避免了C、C++的内存泄漏问题；

8.java禁止非法访问内存，因为java没有指针，内存的申请和释放；

9.跨平台，java的源代码编译成结构中立的中间格式，这种格式与机器无关，只要在安装有JVM（java虚拟机）的电脑上，都能运行这种与机器无关的中间文件；java一次编译，到处运行；

10.对于不同的操作系统，会有不同的java虚拟机，这也就决定了java的可移植性；

11.java支持多线程，简单理解，如果是单核CPU，那么会通过时间片轮转的方式，多线程执行程序，如果是多核CPU，那么就可以理解为，两个或多个线程同时运行。

一、做网站

Java可以用来做网站，很多大型网站都是用Java写的，比如我们熟悉的B站，所以想学习Java的同学还可以负责网站方面的制作，这方面的岗位（网站开发）也比较多，一直以来都相当流行。

二、做安卓软件

安卓是基于Linux的操作系统，其中源代码就是Java，市面上所有的安卓手机都是修改Java运行的，对于更多的开发人员来说，他们更多的时间是花在开发APP上面。你随便打开一个App应用，他们就是用Java语言做的。

三、做游戏

电脑上的大多数游戏也是用Java来开发的，最经典的就是《我的世界》，还有当今世界最具影响力的游戏英雄联盟，吃鸡也是用Java写的

四、写软件

很多编程语言都是可以来写软件的，但Java是现在应用最广泛的，比如：企业级应用开发，还有OA、邮箱、物流、医疗、投票、金融、考试、矿山等信息方面的系统，Java都占有极为重要的地位。现在国内的最热门的就是手机应用，学习Java去做手机应用还是比较吃香的。

说啦这么多那么应该如何学习Java那？

在这个里我使用脑图给大家出一个，Java的学习线路供大家参考：

还有一些资料：

Java在市场中的占有率是非常之高的，希望大都成为优秀的程序员！！！

什么是良好的编程风格（Java编程）

首先,编程风格并不同于其他的style，目的并不是形成自己独树一帜的风格，而是为了让你的程序易读,有利于团队合作以及别人帮你改错。

风格是通用的

C语言和C++语言的编程风格 （Java见下）

第一章:缩进格式

Tab是8个字符,于是缩进也是8个字符.有很多怪异的风格,他们将缩进格式定义为4个字符(设置为2个字符!)的深度,这就象试图将PI定义为3一样让人难以接受.

理由是:缩进的大小是为了清楚的定义一个块的开始和结束.特别是当你已经在计算机前面呆了20多个小时了以后,你会发现一个大的缩进格式使得你对程序的理解更容易.

现在,有一些人说,使用8个字符的缩进使得代码离右边很近,在80个字符宽度的终端屏幕上看程序很难受.回答是,但你的程序有3个以上的缩进的时候,你就应该修改你的程序.

总之,8个字符的缩进使得程序易读,还有一个附加的好处,就是它能在你将程序变得嵌套层数太多的时候给你警告.这个时候,你应该修改你的程序.

第二章:大符号的位置

另外一个C程序编程风格的问题是对大括号的处理.同缩进大小不同,几乎没有什么理由去选择一种而不选择另外一种风格,但有一种推荐的风格,它是Kernighan和Ritchie的经典的那本书带来的,它将开始

的大括号放在一行的最后,而将结束大括号放在一行的第一位,如下所示:

if (x is true) { we do y }

然而,还有一种特殊的情况:命名函数:开始的括号是放在下一行的第一位,如下:

int function(int x) { body of function }

所有非正统的人会非难这种不一致性,但是,所有思维正常的人明白: (第一) KR是___对___的,(第二)如果KR不对,请参见第一条. (:-))......另外,函数也是特殊的,不一定非得一致.

需要注意的是结束的括号在它所占的那一行是空的,__除了__它跟随着同一条语句的继续符号.如"while"在do-while循环中,或者"else"在if语句中.如下:

do { body of do-loop } while (condition);

以及

if (x == y) { .. } else if (x y) { ... } else { .... }

理由: KR.

另外,注意到这种大括号的放置方法减小了空行的数量,但却没有减少可读性.于是,在屏幕大小受到限制的时候,你就可以有更多的空行来写些注释了.

第三章:命名系统

C是一种简洁的语言,那么,命名也应该是简洁的.同MODULE-2以及ASCAL语言不同的是,C程序员不使用诸如ThisVariableIsATemporaryCounter之类的命名方式.一个C语言的程序员会将之命名为"tmp",这很容易书写,且并不是那么难以去理解.

然而,当混合类型的名字不得不出现的时候,描述性名字对全局变量来说是必要的了.调用一个名为"foo"全局的函数是很让人恼火的.全局变量(只有你必须使用的时候才使用它) ,就象全局函数一样,需要描述性的命名方式.假如你有一个函数用来计算活动用户的数量,你应该这样命名--"count_active_users()"--或另外的相近的形式,你不应命名为"cntusr()".

有一种称为Hungarian命名方式,它将函数的类型编码写入变量名中,这种方式是脑子有毛病的一种表现---编译器知道这个类型而且会去检查它,而这样只会迷惑程序员. --知道为什么Micro$oft为什么会生产这么多"臭虫"程序了把!!.

局部变量的命名应该短小精悍.假如你有一个随机的整数循环计数器,它有可能有"i",如果没有任何可能使得它能被误解的话,将其写作"loop_counter"是效率低下的.同样的,""tmp"可以是任何临时数值的函数变量.

如果你害怕混淆你的局部变量的名字,还有另外一个问题,就是称

function-growth-hormone-imbalancesyndrome.

第四章:函数

函数应该短小而迷人,而且它只作一件事情.它应只覆盖一到两个屏幕(80*24一屏),并且只作一件事情,而且将它做好.(这不就是UNIX的风格吗,译者注).

一个函数的最大长度和函数的复杂程度以及缩进大小成反比.于是,如果你已经写了简单但长度较长的的函数,而且你已经对不同的情况做了很多很小的事情,写一个更长一点的函数也是无所谓的.

然而,假如你要写一个很复杂的函数,而且你已经估计到假如一般人读这个函数,他可能都不知道这个函数在说些什么,这个时候,使用具有描述性名字的有帮助的函数.

另外一个需要考虑的是局部变量的数量.他们不应该超过5-10个,否则你有可能会出错.重新考虑这个函数,将他们分割成更小的函数.人的大脑通常可以很容易的记住7件不同的事情,超过这个数量会引起混乱.你知道你很聪明,但是你可能仍想去明白2周以前的做的事情.

第5章:注释

注释是一件很好的事情,但是过多的注释也是危险的,不要试图区解释你的代码是注释如何如何的好:你应该将代码写得更好,而不是花费大量的时间去解释那些糟糕的代码.

通常情况下,你的注释是说明你的代码做些什么,而不是怎么做的.而且,要试图避免将注释插在一个函数体里:假如这个函数确实很复杂,你需要在其中有部分的注释,你应该回到第四章看看.你可以写些简短的注释来注明或警告那些你认为特别聪明(或极其丑陋)的部分,但是你必须要避免过多.取而代之的是,将注释写在函数前,告诉别人它做些什么事情,和可能为什么要这样做.

第六章:你已经深陷其中了.

不要着急.你有可能已经被告之"GUN emacs"会自动的帮你处理C的源代码格式,而且你已经看到它确实如此,但是,缺省的情况下,它的作用还是不尽如人意(实际上,他们比随便敲出来的东西还要难看- ainfinite number of monkeys typing into GNU emacs would never make a good program)

于是,你可以要么不要使用GUN emacs,要么让它使用sanervalules.使用后者,你需要将如下的语句输入到你的.emacs文件中.(defun linux-c-mode() "C mode with adjusted defaults for use with the Linux kernel."(interactive) (c-mode) (c-set-style"KR") (setq c-basic-offset8))

这会定义一个M-x Linux-c-mode的命令.当你hacking一个模块的时候,如何你将-*- linux-c -*-输入在最开始的两行,这个模式会自动起作用.而且,你也许想加入如下

(setq auto-mode-alist (cons '("/usr/src/linux.*/.*.〖ch〗$" . linux-c-mode) auto-mode-alist))

到你的.emacs文件中,这样的话,当你在/usr/src/linux下编辑文件的时候,它会自动切换到linux-c-mode .

但是,假如你还不能让emaces去自动处理文件的格式,不要紧张,你还有一样东西: "缩进" .

GNU的缩进格式也很死板,这就是你为什么需要加上几行命令选项.然而,这还不算太坏,因为GNU缩进格式的创造者也记得KR的权威, (GNU没有罪,他们仅仅是在这件事情上错误的引导了人们) ,你要做的就只有输入选项"-kr -i8"(表示"KR,缩进8个字符).

"缩进"有很多功能,特别是当它建议你重新格式你的代码的时候,你应该看看帮助.但要记住: "缩进"不是风格很差的程序的万灵丹.

JAVA编程风格简析

很久以来都在体会着JAVA的风格，现在做一简单陈述，希望大家多提宝贵意见。

对于一种好的编程语言，学习它的编程风格是很重要的。每种语言都有自己的编写和注释约定，当然所有语言都建立在最基本的约定之上。编程中最重要的并不是让代码按自己希望的方式运行，而是程序中那种自明的编程风格（这对于程序员的益处相信众多程序员都身有体会）！但这还不够，程序还应该具有可读、相对持久和可维护性。可读性非常重要，因为你不希望自己以前的作品在之后的阅读中给自己留下障碍，当然，更重要的是自己的程序能让其他程序员读懂并且修改。

下面我把工作中所理解的java风格做一简单总结，这是我所理解的好的编程风格和应用中我们应当如何使用java编写自己的代码的小Guide。这并不完全，希望大家帮我陆续总结各自的经验。

一般性概述

好的编程风格固然重要，但是你一定听说过一些程序员的个人风格。其实我们完全不必为那些所谓条条框框所累，但是作为原则是我们至少不能打破这些常规。我们应该在保持自己风格的同时尽量的把自己与编程潜原则靠拢。

可读性很容易达到，比如，让自己的代码缩排排列、名字采用描述性但不要过长（短名应仅仅用在非远程）、特殊名称比如pi应当被定义为final类型。模块性是编程需要注意的另一重点，把代码划分到类里，在类中把功能划分到方法中，别让一个类太大，否则在使用、修改和理解上都会造成不必要的麻烦，方法也一样，如果一个方法长度超过50行，它产生错误的概率将接近100％，尽量把大方法划分为小方法，编程中为避免重复编写，还应尽量调用JAVA标准类库。

尽量避免在写代码和注释时使用不同语言，经常见到论坛有朋友询问诸如在java中调用c、调用php、调用shell之类的问题，其实在编程中，我们应尽量使用一种语言去完成事情。另外就是不必最优化自己的代码，应该选择相对较优的算法就可以了。

类、方法和fields

类应体现出某种物质的基本概念，比如要编程实现“汽车”的组成，那么所有的汽车都可以用类Car实现。这个类应当包括域描述、属性描述和car的状态（color, number of doors, age等）和由car可完成的操作（getColor, setColor等）。为了提高类的可重用性，不要在类中有过多的描述，当然这也会增加错误产生的机会。

类名首字母大写，比如Date, String, Hashtable等 ... ...

类如下定义：(未使用Javadoc做注释):

public class Car {

/* Instance variables are placed either in the beginning

or at the end of the class */

private int age;

private Color color;

/* The constructor should be placed in the beginning */

public Car(int age, Color color) {

this.age = age;

this.color = color;

}

/* Example method */

public int getAge() {

return age;

}

/* The main method is optional, but looks like this.

If it exists, it is either the first or the last

method in the class */

public static void main(String [] args) {

...

}

}

注意类名和大括号间的空格！

方法

方法一般定义为public。当然，如果方法仅仅在当前类用到可以定义为private，而如果希望一个子类沿用这个方法则不同，这时候的方法应定义为protected。

java中的方法定义很有趣，它们一般小写字母开头，如果有两个字组成，第二个字的首字母则大写。因此名字的描述性是至关重要的。这使你不用阅读整篇代码来判断这是一个什么方法。在给自己的方法取名时应尽量不要太短或者太长，另一个需要注意的是大多方法使用动词（动宾短语）。

例如：

public void eat() {}

public void eatBananas() {}

Selector（选择器）方法有get前缀，后缀是它们将要get的，比如

public int getBananas() {}

Mutator（存取器）方法则有set前缀，后缀则是他们要set的，比如

public void setBananas(int amount) {}

注意mutators大多无返回值。

方法的参数应当以如下方式给出：

public void aMethod(type parameter1, type parameter2, ... , type parametern) {}

如果参数过长，也可以断开为几行，应对齐向下排列如：

public void aMethod(type parameter1, type parameter2,... ,

type parametern, type parameter n+1,... ,

type parameterm, type parameter m+1) {}

另外要注意类的左束括号应在方法的右束括号之后而非下一行:

public int aMethod() {

int i = 0;

if(i == 0)

System.out.println("success！");

}

为了文件可读性好，还要注意语句最好写在同一行，当然一行写不下是可以断行的，比如行字母超过80。

fields

比如变量，如果不希望它永久有效，应设为private。如果一个变量在类中不发生任何动作（比如数据结构中的node）则可以设置为public，常量一般声明为public。如果不能确定一个变量到底该声明为什么，应暂且声明为private。

field的名字一般使用小写字母，不要使用下横线或其他特殊字符。 如果变量包含两个字，那么第二个字的首字母大写。比如：

int i, j, k;

Date date;

double myField;

常量一般全部大写，也可以包含下横线：

public static final int MAX_SIZE_OF_DATABASE

fields的名字通常为名词。较重要的fields更应具备描述性，比如程序中包含一个游戏的得分，那可以用score来代表。如果变量变化较频繁，那使用一个单一字符来代表就ok了：

i, j, k 通常代表整数

r, t, u, v, w 通常代表实数

x, y, z 通常是并列出现或代表浮点数

s, s1, s2, 通常代表字符串

c, ch 通常代表字符

f, file 通常代表文件

tmp, temp 通常代表临时变量

ctr, cnt, cntr 一般代表计数器(如果i, j, k这些变量已被使用)

dummy, foo, bar 一般代表哑元变量

args 是main-method的主参数名

缩排与换行

每行长度不得超过80字符。如果需要可以折行时，也应当与上一行有共同的缩排距离。代码应如何交错、如何建立新行、在哪里建立允许、哪里不允许都有一些一般约定，缩排空格一般为2个或4个空格。

条件表达式

如果见到如下语法表达式：

if (expr)

statement1;

else

statement2;

代码行向右错排两个空格如上所示。

如果在一个表达式中有超过一条的声明，则需要大括号:

if (expr){

statement1;

statement2;

} else{

statement3;

statement4;

}

有时我们会希望在表达式中使用表达式（比如条件嵌套），这时应注意else表达式，它的位置很容易出错！如例：

if (expr1) {

statement1;

statement2;

} else if (expr2)

statement3;

else if (expr3) {

statement4;

statement5;

} else {

statement6;

statement7;

}

注意大括号位置！

Loops

while-loop语法如下：

while (expr) {

statement1;

statement2;

}

for-loop语法如下：

for (expr1; expr2; expr3){

statement1;

statement2;

}

注意大括号位置！仅一条声明时大括号省略：

while (expr)

statement;

for (expr1; expr2; expr3)

statement;

例如，我们写一个procedure写出1到10这十个数字：

for (i = 1; i = 10; i++)

System.out.println(i);

try-catch语法形如：

try {

statements;

} catch (ExceptionClass e) {

statements;

}

如果try-catch语句后跟随finally子句则形如：

try {

statements;

} catch (ExceptionClass e) {

statements;

} finally {

statements;

}

新行

每一行最好只阐述一件事情。比如，一行包含一个声明、一个条件语句、一个循环等。不论多小，最好不要一行办两件事及以上。例如不要把一个if表达式或循环语句的主体放置在同一行，这样的表达式断行的易读性会更高。通常，互相协作的代码应放在一起，为保证代码美观可读，我们应将代码的不同代码段放置在不同的段落。不过要牢记断行不要太过分！比如:

public int factorial(int n) {

int result = 1;

for(int i = 1; i = n; i++)

result*=i;

return result;

}

给自己的代码加入注释

注释就是类的描绘、方法存在的原因、它完成了什么以及它对它其中（变量）的作用域。假定阅读你代码的人已经知道这是什么语言，所以不需要注释语句功能，尽量使用简短而有描述力的注释。

Java有两种类型的注释：

//This is a comment that continues until the end of the line.

/* This is a comment. It goes on and on and on and on and on and on and on

and on and on and on and on and on and on and on and on and on and on and

on and on and on and on and on and on and on and on and ends like this: */

/**

* This is a JavaDoc comment. More about JavaDoc in the next section.

*/

如果在注释中加入注释则会出错：

/* You are not allowed to do anything like this /* because the compiler will

complain, if you are lucky */ DON'T DO THIS! And don't write comments in

upper case either... */

注释应放在它要解释内容上下，这样会让代码更易于理解。

不要注释一些语言的语句功能：

i++; // Add 1 to i

更不要让自己的代码处于这种状态：

for(int i = 1; i = n; i++)

/* don't place comments where

they don't belong */

result*=i;

较短的注释既可被放在被注释代码上下，而长注释则习惯性的放在代码之上：

/* Comments can be placed before the

block that is to be commented */

for(int i = 1; i = n; i++)

result*=i;

或者:

for(int i = 1; i = n; i++){

result*=i; // short comments can be placed like this

tmp++; // if necessary, they continue here

}

不要写没用的注释：

i++; // change this later

Excuse me,这句肯定是胡扯！

不要写自己都看不懂的注释：

i++; // BMW

BMW? 如果你能连续十天记住这是什么意思的话，那么你的记忆真是不错了。所以不要写没人能看懂的注释，ok？

最后重申一下：写简短而富于描述性的注释，把它们放在该放的地方，而不要考验你自己的记忆力！

JavaDoc - 文档工具

JavaDoc不仅是另一种给代码加注释的仿佛咱，更是一个文档工具。类、方法和一些重要地方需要用JavaDoc来注释。这并不是说你可以放弃常规的注释，这两者在代码中应该是相辅相成、互相弥补的关系。

类被注释如：

/**

* Car represents cars ... A description of the class

* should be place here. Note that the description begins

* on the second line and that there is a space between

* the asterix and the text. Next we will add some fields

* indicating who the authors of the class are and

* other useful information. Notice the newline!

*

* @author Jerry Meng

* @version %I%, %G%

*/

public class Car {

注意JavaDoc结束和类开始间无空行。

方法被注释如：

/**

* A description of what the method does...

*

* @param n a description of the parameter

* @return a description of the return value

*/

public int factorial(int n) {

某些不是全部，被JavaDoc注释区域如：

/**

* Short description of the variable (one line)

*/

type variable;

什么应当使用JavaDoc做注释？如何注释的恰当呢？

可以这样想，JavaDoc中所作的注释都可以在类的文档中看到。所有读这个类的文档的读者都会明白这个类所完成的功能、它包括的方法、如何使用这些方法及方法的返回值。一些作用域，比如public的变量或常量将会一目了然。任何不了解这个类内部结构的人都可以轻松的调用它。这便是你用JavaDoc可以轻松提供的信息。而使用一般注释的地方，一般是给那些可能修改你的类代码的程序员，它们一般描述了类的内部信息和结构。

下面我写一下car的类来描述一个编程风格好的java类应该是怎样的。当然这仅仅是一个小例子(apart from selector and mutator methods)，仅仅是在考虑JAVA编程风格上一个参考而已。

import java.awt.Color;

/**

* This is a class representing cars. A car has certain features, such

* as color, age, number of doors etc and a car can be repainted,

* the tank can be filled etc.

*

* @author Jerry Meng

* @version %I%, %G%

*/

public class Car {

/**

* The maximum size of the tank in litres.

*/

private static final double TANK_SIZE = 100.0;

/**

* The color of the car.

*/

private Color color;

/**

* The age of the car.

*/

private int age;

/**

* The number of doors of the car.

*/

private int doors;

/**

* The amount of gasoline in the tank.

*/

private double gasoline;

/**

* Class constructor, which constructs a brand new, black car with

* five doors and a full tank.

*/

public Car() {

this(Color.black, 0, 5, TANK_SIZE);

}

/**

* Class constructor specifying the color, age, number of doors

* and litres of gasoline

*

* @param color The color of the car

* @param age The age of the car

* @param doors The number of doors

* @param km Kilometres driven

* @param gasoline The litres of gasoline

*/

public Car(Color color, int age, int doors, double gasoline) {

this.color = color;

this.age = age;

this.doors = doors;

this.gasoline = gasoline;

}

/**

* Returns the color of the car

*/

public Color getColor() {

return color;

}

/**

* Repaints the car (i.e. changes its color)

*/

public void setColor(Color color) {

this.color = color;

}

/**

* Returns the age of the car

*/

public int getAge() {

return age;

}

/**

* Returns the number of doors of the car

*/

public int getDoors() {

return doors;

}

/**

* Returns the amount of gasoline in the tank

*/

public double getGasoline() {

return gasoline;

}

/**

* Fills the tank. The amount of gasoline cannot exceed

* the size of the tank. In that case, the tank will be

* filled to the maximum and the rest will run out in

* the sand.

*

* @param gas The amount of gasoline to put in the tank

*/

public void setGasoline(double gas) {

if(gasoline + gas = TANK_SIZE)

gasoline+=gas;

else

gasoline = TANK_SIZE;

}

}

c /c++ ,java 之间有什么区别？

区别太多。先列几条吧。

1. c是面向过程的语言。c++和Java都是面向对象的。在c中没有类或者对象的概念。

2. java运行在虚拟机上，号称与平台无关。也就是你开发的java程序无论是unix，linux还是windows都可以正常运行。但是实际上这是一个良好的愿望，实际跨平台时还会有各种各样的问题。c和c++都是直接编译成可执行文件，是否能跨平台主要看你用到的编译器特性是否有多平台支持。

3. 因为c和c++是直接编译成可执行文件，所以运行效率要比java高。至于c和c++哪个更快，两种语言的拥趸已经吵了很多年。

4. java因为是运行在虚拟机上，不需要考虑内存管理和垃圾回收机制。也是就你可以声明一个对象而不用考虑释放他，虚拟机帮你做这事情。而c和c++语言本身没有多少内存管理的概念，写c和c++程序如果用到指针就一定要考虑内存申请和释放。内存泄漏是c和c++最头疼的问题。

5. 代码重用：java中有一个根类object，所有的类都是其子类，通过这种方式将容器和算法分离，实现一种操作作用于多种对象，提高代码重用。c++中没有总根对象，但是c++提供了另一个更强大的功能“模板”，同样高效地实现了一种操作作用于多种对象，提供了高效的代码重用方法。

6. 数据结构：java内建了丰富的数据结构：列表，集合等等（很久没用java了，有些记不太清）。而c++则用“模板”同样提供了各种数据结构（容器）。

7. c语言在一些比较低层，和硬件打交道的地方用得比较多。另外很多开源软件由于unix/linux开发习惯也大多采用c来开发。Java是现在最流行的开发语言，c++比起java稍稍不那么流行一些，但是功能很强大。如能深入掌握，可以写出兼顾效率和美观的优秀代码。

JAVA的技术特点是什么?

JAVA的技术特点是什么?

Java由美国SUN公司(被oracle公司收购)发明于1995年，是目前业界应用最广泛、使用人数最多的语言，连续多年排名世界第一，可以称之为“计算机语言界的英语”。

那么Java这么高的评价它的特点有哪些，下面我来为题主解答：

一、跨平台/可移植性

这是Java的核心优势。Java在设计时就很注重移植和跨平台性。比如：Java的int永远都是32位。不像C++可能是16，32，可能是根据编译器厂商规定的变化。这样的话程序的移植就会非常麻烦。

Java首先利用文本编辑器编写 Java源程序，源文件的后缀名为.java；再利用编译器（javac）将源程序编译成字节码文件，字节码文件的后缀名为.class； 最后利用虚拟机（解释器，java）解释执行。如下图所示：

二、安全性

Java适合于网络/分布式环境，为了达到这个目标，在安全性方面投入了很大的精力，使Java可以很容易构建防病毒，防篡改的系统。比如Java取消了强大但又危险的指针。由于指针可进行移动运算，指针可随便指向一个内存区域，而不管这个区域是否可用，这样做是危险的。

三、面向对象

面向对象是一种程序设计技术，非常适合大型软件的设计和开发。由于C++为了照顾大量C语言使用者而兼容了C，使得自身仅仅成为了带类的C语言，多少影响了其面向对象的彻底性！Java则是完全的面向对象语言。

四、简单性

Java就是C++语法的简化版，我们也可以将Java称之为“C++-”。跟我念“C加加减”，指的就是将C++的一些内容去掉；比如：头文件，指针运算，结构，联合，操作符重载，虚基类等等。同时，由于语法基于C语言，因此学习起来完全不费力。

五、高性能

Java最初发展阶段，总是被人诟病“性能低”；客观上，高级语言运行效率总是低于低级语言的，这个无法避免。Java语言本身发展中通过虚拟机的优化提升了几十倍运行效率。比如，通过JIT(JUST IN TIME)即时编译技术提高运行效率。 将一些“热点”字节码编译成本地机器码，并将结果缓存起来，在需要的时候重新调用。这样的话，使Java程序的执行效率大大提高，某些代码甚至接近C++的效率。

因此，Java低性能的短腿，已经被完全解决了。业界发展上，我们也看到很多C++应用转到Java开发，很多C++程序员转型为Java程序员。

六、分布式

Java是为Internet的分布式环境设计的，因为它能够处理TCP/IP协议。事实上，通过URL访问一个网络资源和访问本地文件是一样简单的。Java还支持远程方法调用(RMI,Remote Method Invocation)，使程序能够通过网络调用方法。

七、多线程

多线程的使用可以带来更好的交互响应和实时行为。 Java多线程的简单性是Java成为主流服务器端开发语言的主要原因之一。

八、健壮性

Java是一种健壮的语言，吸收了C/C++ 语言的优点，但去掉了其影响程序健壮性的部分（如：指针、内存的申请与释放等）。Java程序不可能造成计算机崩溃。即使Java程序也可能有错误。如果出现某种出乎意料之事，程序也不会崩溃，而是把该异常抛出，再通过异常处理机制加以处理。

以上几种特性你了解到啦吗？    记得给个赞！

当然这些还没完，Java除啦这些特性还有一些其他的特点我也来给你讲一讲！！

1.java的风格类似C++,从某种意义上讲，java是C++的一个变种。但是java摒弃了C、C++中的容易引发错误和难以理解的指针，结构，以及内存管理等；

2.java是一种强类型的语言，比C/C++检查还要严格，java区分大小写字母；

3.java禁止非法访问内存，因为java没有指针，内存的申请和释放；

4.对于不同的操作系统，会有不同的java虚拟机，这也就决定了java的可移植性；

5.java提供了自动垃圾回收机制gc，有效避免了C、C++的内存泄漏问题；

记得给个赞！