|
|
发表于 2008-12-1 16:37:18
|
显示全部楼层
C语言更好
Java程序中的每个变量要么是基本数据类型（boolean, char, byte, short, int, long, float, double），要么是对对象的引用 - k; z( _1 w8 m' ^3 C1 s
7 t, c8 E1 A1 r# Q# Y# Y3 vC++有许多种基本类型，额外还有struct, union, enum, 数组和指针，C++指针可以指向对象，也可以不指向对象
& y. D8 l! Y8 {7 L6 }' y. ^3 v# c. i \3 J
Java没有枚举、联合类型，因为Java认为没有必要。将可有可无的语言元素去掉是Java对C/C++做出的一大改变，因此，普遍认为Java较C++更轻便，更精简 ( @" |& U, w0 Z0 g8 O7 E: {
) v. \4 e- l. z! G
Java采用Unicode字符集，C++通常用ASCII字符集。但ASCII是Unicode的子集，对于习惯于ASCII的程序员感觉不到区别
, V& X z7 R" _9 \6 q. u- @$ r; X; B) A& t1 F" R
Java中的boolean类型不能转换成其他类型，反之亦然。C++最近引进了bool类型，代表布尔类型，整型也作为逻辑判断
( x4 |+ C$ j. L* l- a$ ~- I1 G, O" z L; D
模板是一种“泛型编程思想”，它有别于“面向对象编程思想”。C++在很大程度上已经支持了这种新型编程方法，特别是STL的出现 0 i% a$ K3 K" m0 e
Java目前仍未支持泛型编程，不过据说Sun公司有在Java中引入模板的计划
# o4 P* U- x6 i. `. Q6 G
* Y# j" [# i8 K, ZC++支持“运算符的重载”，这是它的一个很重要的多态特征，是数据抽象和泛型编程的利器。它允许直接对对象进行四则运算，正像基本数据类型那样
! _1 q! ~; y5 }$ j+ QJava不支持这种多态机制，也是为降低复杂性
4 q: b4 `/ X, g, S: R4 k- \" X9 L" w1 z4 T
两种语言都支持方法重载(overloading)
& Z; `6 C" R/ ]2 a# g2 ^& t+ g9 W; m. s* L e! c
在C++中，为了允许运行时动态决定哪个函数被调用，一个函数必须用virtual修饰。virtual关键字被自动继承，用以支持多态 ' t0 U* O9 W$ a# F! Z A3 \
& q4 N3 ~6 a( E H) k a
凡是没有用virtual修饰的成员函数（包括static）都是静态绑定的，即在编译时决定调用哪个版本
! }; r0 z' X9 U9 h8 h
2 N2 ?: r9 |5 W$ h' ]9 r* |6 f而在Java中，除了static、final、private是静态绑定以外，所有方法一律按动态绑定处理
1 r, {: Z; P% s5 m" l, F/ O' GC++中有“拷贝构造函数”的概念，在三种情况下，自动调用它
9 y7 m' a! y8 |' {- o* T用一个对象初始化另一对象 0 g0 I/ G, F2 G! ~$ Y$ ]4 C
对象作实参进行函数调用 g5 }( I( D- J2 o6 G/ k/ ?
对象作函数的返回值 8 h, C' h8 o" a
9 Y* F! L6 t8 O4 x
通常，当一个对象需要做“深拷贝”(钱能：《C++程序设计教程》)时，我们需要为它事先定义“拷贝构造函数”、“赋值运算符的重载函数”和“析构函数”；否则编译器将以“按位copy”的形式自动生成相应的缺省函数。倘若类中含有指针成员或引用成员，那么这三个默认的函数就隐含了错误 8 j% ~1 ~. O& [
2 V* W! s# z1 h, J3 W
Java则没有这种语法结构和语义逻辑
! D: }9 M# @& AC++支持inline函数，可以避免函数的堆栈调用，提高运行效率
) k6 `+ w2 w6 y R& z
2 X7 x/ K" e( N) cJava无这种语义
+ Y' B5 R. }# o" F! x! Y- n
+ b& Q! m8 G% u2 f5 CC++中，构造函数的初始化列表是这样使用的：首先按继承顺序调用基类的构造函数构造基类对象，然后按声明顺序调用成员对象的构造函数构造成员对象，最后对列表中出现的成员变量做初始化 9 Z+ @9 \/ a) Q) b- J+ ^, @9 G
Java不采用初始化列表这种构造机制
/ A* ]$ G' F5 T$ j" j它们的构造顺序基本一致： . I$ c$ Q+ q+ {2 ?7 x- z3 Q7 H
静态变量初始化
6 W* l+ y& s2 `+ Y4 a静态初始化块（Java）
& V/ E# s/ y+ ?. G调用基类的构造函数构造基类对象
% }8 K* W2 |; Y0 s* h: `9 l& v实例变量的初始化 ' [8 C. \. K9 ]& X# z
构造函数的其余部分 9 X% M2 i" X8 n! \6 @6 @( g
Java使用abstract关键字修饰抽象方法或抽象类 ! D* W- {( a- c8 l0 U
$ y* {: {! d+ A; \1 `2 g( P3 N6 l
C++的对等语法是“纯虚函数”和“抽象类”
: X2 p' y4 z. j% V, d5 U+ b0 t1 l9 g! \9 ~* Q
两者都使用抽象类作为继承层次中的基类，提供一般概念，由子类实现其抽象方法，且抽象类都不能被直接实例化为对象 6 {6 i3 ^& N0 q( y3 `9 H b4 b
Java中有final关键字，修饰类、方法或变量 $ t! h" J' L/ |% {: j8 m
final类不能被继承 2 H' X# e, ^( p' U. a- y
final方法不能被子类覆盖 . O; C& l, w- p& Q7 v3 N
final变量就是常量
# | z3 a! h' r% ^
) P& y6 y/ }" C3 B/ ^* {C++中没有这个关键字，常量可以使用const或#define定义
& b! b9 Q$ X% Z( }+ }9 Q5 Kconst还可以修饰成员函数，即“常成员函数”，当一个const成员函数修改成员数据，或调用非const成员函数时，编译器会报错
+ T+ q& C' T: ]6 [* e- }8 }. A6 p9 o# C我们应将不修改成员数据的函数声明为const 6 T3 |+ C! E" l2 |" {
Java和C++中的static关键字语法和语义基本相同 - ^. T& h) H* F0 q* a& B4 r$ o
/ w6 ]7 ?+ z6 J4 g( F! d2 k$ p
static成员变量又叫类变量，被类的所有对象共享 8 |6 f# S6 |# M5 X- [
A::x (C++)：必须在类体外初始化 * n5 V- v* A- j
A.x (Java)：必须在类体内初始化
7 E6 `7 |7 i* _static成员方法又叫类方法，访问static变量
( k' c0 a( L, ?3 _A::f( ) (C++) ; w( t7 {, T Z1 H
A.f( ) (Java)
4 R# {8 N+ b3 d( a2 K _两者都有内部类和局部类的语法和语义
! n1 P* H% F% B) Q5 f) [9 s( B. `+ K% J4 a: n2 I
Java中没有友元函数和友元类的概念，严格支持封装，不允许外部方法访问类的私有成员 ! C7 v) _+ I4 h5 x0 U& K
而C++支持friend关键字，允许外部方法访问类的私有成员，因此不是一种纯面向对象的编程语言
# y0 r) N# X5 s- Y. w# AJava中类或interface可以用public修饰，也可以不修饰；而C++类不能修饰 ( @# }* |7 k" |$ @; F& C8 _
. ~0 ]! q8 E7 e- t4 K7 M
三种访问权限的语义相同，语法略有差别
- b3 B( b) f/ K
, T3 a1 ~3 b( H; MC++中还有继承权限修饰符，Java则没有
2 g' e: n j" |2 Y' _class A: protected B, public C (C++) 9 ] y8 G! Z8 X. Y0 v
class A extends B (Java)
5 s& y: G3 {* {; ?- W& `7 L4 fJava有super关键字，指代父类对象，通常被用于调用父类的构造方法或一般方法 5 Z: e8 C9 Q( G" p/ f# V
C++则没有super关键字 7 k7 R7 _6 k9 Z# j
4 E" X' A" _! L5 b' I$ n9 X0 K两者都有this，指代当前对象
: ~' d' T# @/ s1 r% u% n1 I6 E% `, ^: S
" r( [2 i4 C* g) b" e% P EJava有package的概念，可以将类组织起来，便于打包和部署，也有利于类的安全。C++没有这个概念，一个类可以被任意类访问 6 L. u& m6 O" U9 ]) A) T8 _
Java applet可以被嵌入HTML文档中，然后由Web浏览器下载和执行 4 o$ p+ h+ f4 B6 B% W' p' n
Java API有对网络通讯的特别支持
# C" w! |( @ _6 a4 ]% D8 p3 M" ]; M( ?! x) f4 x
C++则无内置网络功能
$ s2 |& z' I) U9 oC++程序员必须显式地实现动态内存管理，在析构函数中用delete运算符或free( )函数释放对象和其他动态分配的数据空间，否则会造成“内存泄露”
4 B4 E x( W# h' e4 Y9 H4 C! D8 b( V, d
而在Java中，垃圾收集是自动的。当对象的最后一个引用变量被释放掉，这个对象就成为垃圾收集器的候选对象了
, o7 n, y P' [$ U因此Java不支持析构函数 4 v1 e0 e+ Y3 Q2 z8 P
finalize( )方法主要被用来释放先前打开的非内存资源，如文件句柄 2 U" d! c' h. @5 F
Java源代码被编译成字节码（.class文件），字节码是一种只有JVM才能识别的二进制低级代码，它与具体的处理器无关，要由安装在OS之上的JVM解释执行，转换成相应平台的机器码，因此Java是体系结构中立和跨平台的
# a5 o8 t' Y! J0 w$ w
! d6 c: |+ U1 r7 D# ]5 R而C++直接被编译成底层平台的二进制机器码，由CPU执行，是平台相关的 & e5 a: l8 i. R9 L
( v" x3 l$ g0 s+ N1 |
因此，当解释执行时，Java程序速度更慢 " W, O9 j6 C" }1 P$ w- [# O+ L/ h1 w1 j
Java语言支持多线程，允许并发线程的同步与互斥操作
( x6 U( d, q1 w. yC++则没有这种内在机制
- g/ r; o$ s& g; g. y- F
# ^0 F! G9 ]+ s5 i9 R# @Javadoc.exe可以将Java程序的内容和结构转换成HTML格式的文档
+ z% U8 v Y9 U5 x* A8 ] ^4 y m; z1 b v( _5 b- ?& c5 k4 g5 S# X- _. X0 U) b
我还是认为C语言更好吧 |
评分
-
1
查看全部评分
-
|
楼主: 深情少年
发表于 2008-11-30 23:26:27
发表于 2008-11-30 23:27:52
楼主
添加客服QQ
