|
|
发表于 2008-12-1 16:37:18
|
显示全部楼层
C语言更好
Java程序中的每个变量要么是基本数据类型（boolean, char, byte, short, int, long, float, double），要么是对对象的引用 ' [5 Y0 H* ] ^1 N# J7 f6 s( H
% O, K! U# s% ^: b( q& DC++有许多种基本类型，额外还有struct, union, enum, 数组和指针，C++指针可以指向对象，也可以不指向对象
* e: @6 E+ l2 o( C4 g0 z$ ?* q7 b: s% P& U( z# p
Java没有枚举、联合类型，因为Java认为没有必要。将可有可无的语言元素去掉是Java对C/C++做出的一大改变，因此，普遍认为Java较C++更轻便，更精简 6 k, H! U9 a X' h
0 h* f* o; W" u
Java采用Unicode字符集，C++通常用ASCII字符集。但ASCII是Unicode的子集，对于习惯于ASCII的程序员感觉不到区别
" }6 p I4 S% r6 H6 @; _; e& [1 ^2 b( ^
Java中的boolean类型不能转换成其他类型，反之亦然。C++最近引进了bool类型，代表布尔类型，整型也作为逻辑判断 % g9 o4 V, l, G' |4 j# k& V" y
9 @2 k/ S' y7 j! U
模板是一种“泛型编程思想”，它有别于“面向对象编程思想”。C++在很大程度上已经支持了这种新型编程方法，特别是STL的出现
/ M- A- c- p3 P4 |* G4 iJava目前仍未支持泛型编程，不过据说Sun公司有在Java中引入模板的计划
9 `9 L: ?5 g' |/ }5 h2 D+ i/ k6 a5 T. \
C++支持“运算符的重载”，这是它的一个很重要的多态特征，是数据抽象和泛型编程的利器。它允许直接对对象进行四则运算，正像基本数据类型那样 + ?' i% d. Y$ ^2 V$ h8 Y4 D
Java不支持这种多态机制，也是为降低复杂性 $ H3 F9 L0 Y, |
+ ?* r. A' _; S) N两种语言都支持方法重载(overloading) + {/ T X7 }$ D' {% K+ J
# C/ g5 g0 G& c) M) e, C7 ]7 K" ?
在C++中，为了允许运行时动态决定哪个函数被调用，一个函数必须用virtual修饰。virtual关键字被自动继承，用以支持多态
/ d9 k! x$ G; c0 ~
& u# G/ H6 O* s s凡是没有用virtual修饰的成员函数（包括static）都是静态绑定的，即在编译时决定调用哪个版本
1 v7 }8 T) { O- w1 [0 S- h& [8 X% d5 N6 T' G8 l
而在Java中，除了static、final、private是静态绑定以外，所有方法一律按动态绑定处理
* ~8 C8 w9 P, |" ~; Q, J1 g' cC++中有“拷贝构造函数”的概念，在三种情况下，自动调用它 ( e" g8 |5 t) S0 R( G: L
用一个对象初始化另一对象 3 q/ [. w2 m a5 }; P
对象作实参进行函数调用 0 p( l6 e, z9 u0 B! \! P* c% E4 |
对象作函数的返回值 - J3 g, O$ q9 c1 x: d g
. G% J; K! K6 K通常，当一个对象需要做“深拷贝”(钱能：《C++程序设计教程》)时，我们需要为它事先定义“拷贝构造函数”、“赋值运算符的重载函数”和“析构函数”；否则编译器将以“按位copy”的形式自动生成相应的缺省函数。倘若类中含有指针成员或引用成员，那么这三个默认的函数就隐含了错误 2 R/ C, |4 i- z+ d+ K, u; H) b3 B
: t' }0 d l# _5 G
Java则没有这种语法结构和语义逻辑 9 `8 Y0 b% w o% g2 E1 ~
C++支持inline函数，可以避免函数的堆栈调用，提高运行效率
3 D* k% O# B$ P' d& c% v8 h
) p$ N- g% J6 L1 A. p5 i# `, WJava无这种语义
% e2 \" a e2 |1 r
7 U) ^5 y) M7 T+ S1 k# z; ZC++中，构造函数的初始化列表是这样使用的：首先按继承顺序调用基类的构造函数构造基类对象，然后按声明顺序调用成员对象的构造函数构造成员对象，最后对列表中出现的成员变量做初始化
5 p m8 y; t! y8 e6 fJava不采用初始化列表这种构造机制 3 c1 Y2 ]+ e, h; g' \/ p6 K
它们的构造顺序基本一致：
, x$ E8 k/ p" q8 l N静态变量初始化
3 O+ j. ~: Z t" ^静态初始化块（Java） : u6 |- u4 j( Z
调用基类的构造函数构造基类对象 / `/ ?1 z' H1 q. t" S
实例变量的初始化 ( i% q" z/ k) W$ ]3 B) X7 \
构造函数的其余部分
3 m) E4 `2 m- E% qJava使用abstract关键字修饰抽象方法或抽象类
- [! t7 O( I" H; Y$ d- t, h4 I6 c4 p1 M. l
C++的对等语法是“纯虚函数”和“抽象类”
; W( M+ X6 _6 n0 p ^, B
' N4 U# W# B7 s, g/ n6 q7 q两者都使用抽象类作为继承层次中的基类，提供一般概念，由子类实现其抽象方法，且抽象类都不能被直接实例化为对象 - p z% p t6 p" q2 N
Java中有final关键字，修饰类、方法或变量
" S; \8 z) Y6 A/ Efinal类不能被继承
. @7 w9 X" q9 X8 B- Pfinal方法不能被子类覆盖 / L6 o y4 F0 U, ?/ o
final变量就是常量 ! ^5 s' ?5 Q+ g g) y: P5 L
5 G/ f' ]; h" S1 X1 wC++中没有这个关键字，常量可以使用const或#define定义 0 u$ C, {1 ?4 f0 k) d' a1 J: R
const还可以修饰成员函数，即“常成员函数”，当一个const成员函数修改成员数据，或调用非const成员函数时，编译器会报错 ; P! T5 e5 s8 }
我们应将不修改成员数据的函数声明为const
3 t1 ]7 d! `/ U1 X# b# r7 MJava和C++中的static关键字语法和语义基本相同 2 m3 r |3 u) ?$ N x
/ N% Z0 ?" L( r( }- k) H4 P# R( W1 _
static成员变量又叫类变量，被类的所有对象共享 6 z9 O6 [- a, M* v
A::x (C++)：必须在类体外初始化 ! y: q. E' L. X7 H9 @
A.x (Java)：必须在类体内初始化
; m O" N* q0 A" Z" ]static成员方法又叫类方法，访问static变量
) ~6 j4 z4 |# r0 \: ` m5 EA::f( ) (C++)
m. S5 E- U5 X/ |% x5 s' s# e% eA.f( ) (Java)
" y7 x8 K6 |% {两者都有内部类和局部类的语法和语义
9 q# s- \( ^5 T6 y& ^0 w3 G6 B2 @: M/ k' [; [) o
Java中没有友元函数和友元类的概念，严格支持封装，不允许外部方法访问类的私有成员 0 c2 X9 W3 U8 @: a* b5 ?# y
而C++支持friend关键字，允许外部方法访问类的私有成员，因此不是一种纯面向对象的编程语言
% o1 ~! q9 F w0 t6 X, WJava中类或interface可以用public修饰，也可以不修饰；而C++类不能修饰 6 Q7 j/ E# n% j1 _- D/ s/ n/ j
@% R! D* j7 z- l0 X# D
三种访问权限的语义相同，语法略有差别
- m5 Y& b1 Y$ t
, {* F' J1 e5 F5 |; f7 ~C++中还有继承权限修饰符，Java则没有
- H8 j# b+ G* {class A: protected B, public C (C++) ( T1 L8 E6 V9 W
class A extends B (Java)
6 |/ c0 {% q9 r' l _$ w3 BJava有super关键字，指代父类对象，通常被用于调用父类的构造方法或一般方法
$ _& m6 I" s$ x5 U3 pC++则没有super关键字 4 L$ a& y' _4 O7 ?) G% y; n
& B. d+ \0 U) C8 w两者都有this，指代当前对象
& @. q; g6 o1 c: S# S+ |1 q. @& \# ~8 L! h/ w D- A
Java有package的概念，可以将类组织起来，便于打包和部署，也有利于类的安全。C++没有这个概念，一个类可以被任意类访问
$ T" h, x9 L# x- N' G8 \6 L+ @# j1 p aJava applet可以被嵌入HTML文档中，然后由Web浏览器下载和执行 2 `' V1 B2 ]6 V+ s/ @
Java API有对网络通讯的特别支持 ) q2 N, C! e; a8 v1 x5 s" |. s& K
$ h7 ]5 P* K( }8 k; \9 M
C++则无内置网络功能
% {9 C- T O8 ]% U0 cC++程序员必须显式地实现动态内存管理，在析构函数中用delete运算符或free( )函数释放对象和其他动态分配的数据空间，否则会造成“内存泄露”
( _2 W/ X% d3 V* L5 g/ A- _6 I" @& x& v
而在Java中，垃圾收集是自动的。当对象的最后一个引用变量被释放掉，这个对象就成为垃圾收集器的候选对象了
4 `! f |4 _* f5 W' T/ Q9 j3 }因此Java不支持析构函数
3 R; i/ W" u% U7 A) Pfinalize( )方法主要被用来释放先前打开的非内存资源，如文件句柄
; H: q& o5 @: W1 F1 ?. e6 SJava源代码被编译成字节码（.class文件），字节码是一种只有JVM才能识别的二进制低级代码，它与具体的处理器无关，要由安装在OS之上的JVM解释执行，转换成相应平台的机器码，因此Java是体系结构中立和跨平台的 0 J) ?% Z# f: y, V
" D3 _1 G3 \3 D+ O
而C++直接被编译成底层平台的二进制机器码，由CPU执行，是平台相关的
( C. N% G) ?2 Y' e* y) I5 A
, s; G8 Y# `! R% Y. N8 v; e因此，当解释执行时，Java程序速度更慢 ) G( ~! u/ u* z: k1 ]# m, G: C
Java语言支持多线程，允许并发线程的同步与互斥操作 . Y V2 b7 p I, e) |: }
C++则没有这种内在机制
2 O& `" V: X* x' m. j+ T) V5 C& X, W
Javadoc.exe可以将Java程序的内容和结构转换成HTML格式的文档" L$ S/ ]1 n' O9 A' u
& K1 U5 x9 f" A8 I% i# Y我还是认为C语言更好吧 |
评分
-
1
查看全部评分
-
|
楼主: 深情少年
发表于 2008-11-30 23:26:27
发表于 2008-11-30 23:27:52
楼主
