|
|
发表于 2008-12-1 16:37:18
|
显示全部楼层
C语言更好
Java程序中的每个变量要么是基本数据类型（boolean, char, byte, short, int, long, float, double），要么是对对象的引用 ) {$ _ ?: k. m
# }5 S0 [/ W4 I' Q5 r: ^/ PC++有许多种基本类型，额外还有struct, union, enum, 数组和指针，C++指针可以指向对象，也可以不指向对象 ! j& ~1 u; `% s; Y& L* [- \
. U7 _$ I# a/ C' HJava没有枚举、联合类型，因为Java认为没有必要。将可有可无的语言元素去掉是Java对C/C++做出的一大改变，因此，普遍认为Java较C++更轻便，更精简
$ x; ~ r0 d5 j3 K) B) @. J0 \" W" F) ~
Java采用Unicode字符集，C++通常用ASCII字符集。但ASCII是Unicode的子集，对于习惯于ASCII的程序员感觉不到区别 " x9 h' X$ [) q3 a3 \: F! R# ^
3 ~- ~: ~4 l7 {4 JJava中的boolean类型不能转换成其他类型，反之亦然。C++最近引进了bool类型，代表布尔类型，整型也作为逻辑判断 ! J0 |* e5 v+ y* @' j
: r! C* b& p; ^( ~( W3 d
模板是一种“泛型编程思想”，它有别于“面向对象编程思想”。C++在很大程度上已经支持了这种新型编程方法，特别是STL的出现 8 i) N: v. A3 n2 l( ~; b% z
Java目前仍未支持泛型编程，不过据说Sun公司有在Java中引入模板的计划 , P* f& l6 e! N+ m1 S: h2 q# S
W" g# @9 ~& N- ?
C++支持“运算符的重载”，这是它的一个很重要的多态特征，是数据抽象和泛型编程的利器。它允许直接对对象进行四则运算，正像基本数据类型那样 & z4 q, {' h0 H$ b
Java不支持这种多态机制，也是为降低复杂性
h/ B9 K$ x" r# ^2 P
8 u; b8 k! X! U6 ^7 x7 }两种语言都支持方法重载(overloading)
/ F0 `; e) R6 U, T/ A3 e, q9 k
/ d; v; h) h5 ?2 L' W" [在C++中，为了允许运行时动态决定哪个函数被调用，一个函数必须用virtual修饰。virtual关键字被自动继承，用以支持多态
/ n: P* F4 t& E
- A, B$ z* {) S" n- d- W2 n凡是没有用virtual修饰的成员函数（包括static）都是静态绑定的，即在编译时决定调用哪个版本
, r0 G' c- m- B. z3 f5 r1 z- a2 ], u& r9 c
而在Java中，除了static、final、private是静态绑定以外，所有方法一律按动态绑定处理 5 i1 \4 y" d+ _% G3 M8 t5 K/ B( ]% T8 e
C++中有“拷贝构造函数”的概念，在三种情况下，自动调用它
[- O0 i {/ v用一个对象初始化另一对象 6 P5 Y1 _8 Q0 H+ w& R% @
对象作实参进行函数调用
( _ j V9 V4 X: c/ S对象作函数的返回值 3 w9 \$ [3 a+ T( Z: W' E [$ F& h
8 ?9 D: j Q A) J$ x通常，当一个对象需要做“深拷贝”(钱能：《C++程序设计教程》)时，我们需要为它事先定义“拷贝构造函数”、“赋值运算符的重载函数”和“析构函数”；否则编译器将以“按位copy”的形式自动生成相应的缺省函数。倘若类中含有指针成员或引用成员，那么这三个默认的函数就隐含了错误
1 n4 j; @* j# q, y1 S" m! r0 O6 c( x: B
Java则没有这种语法结构和语义逻辑
3 T+ q7 @/ ?: ~C++支持inline函数，可以避免函数的堆栈调用，提高运行效率
4 }0 e' ^! j9 `2 ^6 n$ ^0 a' L2 N. e7 r6 K
Java无这种语义 - |: A+ [( \2 q& G! R3 C1 o
6 a: K7 g$ l/ ~0 q
C++中，构造函数的初始化列表是这样使用的：首先按继承顺序调用基类的构造函数构造基类对象，然后按声明顺序调用成员对象的构造函数构造成员对象，最后对列表中出现的成员变量做初始化
7 u3 I0 \& ^+ n$ G) s7 fJava不采用初始化列表这种构造机制
7 ^, ^ A: S+ |8 Y# c它们的构造顺序基本一致： $ W: ]6 g- f1 ^/ z" {9 H
静态变量初始化 # t* n% W" F$ b: \+ f
静态初始化块（Java）
+ W& v, H5 e! n- V调用基类的构造函数构造基类对象 1 I) C+ Q% T" ]' D6 B1 l
实例变量的初始化
! I9 F! @$ e" {4 j4 n* P构造函数的其余部分 & n2 s2 [6 R; a8 t( s E- C8 X
Java使用abstract关键字修饰抽象方法或抽象类 4 |$ r. E+ m" b) z: d5 y
$ z3 Y2 B6 K( W! X8 ]
C++的对等语法是“纯虚函数”和“抽象类”
/ {$ P4 a) T9 ~' h8 ~6 b
; i, `4 B' Q' `! k; F, h/ x) A两者都使用抽象类作为继承层次中的基类，提供一般概念，由子类实现其抽象方法，且抽象类都不能被直接实例化为对象 & B# D( Z0 |9 T$ P
Java中有final关键字，修饰类、方法或变量
5 ~! y+ U5 X$ d% z S7 wfinal类不能被继承
! y8 T, P) z, a$ H y5 [3 }! U1 C- kfinal方法不能被子类覆盖
1 o, j) A( D% h! a; m6 J lfinal变量就是常量
j, t `/ K8 x7 J
& p6 J+ p: o H: Z2 xC++中没有这个关键字，常量可以使用const或#define定义
5 u3 X m2 D) ]- K! c/ Rconst还可以修饰成员函数，即“常成员函数”，当一个const成员函数修改成员数据，或调用非const成员函数时，编译器会报错 3 t* N; h/ |: J, I' ~+ q6 u. \& V
我们应将不修改成员数据的函数声明为const
7 v( F- [: ~& \& _) U/ bJava和C++中的static关键字语法和语义基本相同
+ S3 a( P" g! M, U3 R& O$ l" ?: F( i8 w; i
static成员变量又叫类变量，被类的所有对象共享
; {& K3 |6 V9 u9 R9 PA::x (C++)：必须在类体外初始化
) T) m# _- M7 w3 u# nA.x (Java)：必须在类体内初始化 , W3 Y" I" [6 r+ C
static成员方法又叫类方法，访问static变量 9 g3 A( P% R. n d
A::f( ) (C++)
: W& g5 L* W! t e" s" \) r }# HA.f( ) (Java)
" v2 Y' i% Z1 y, _8 O4 a. `0 A两者都有内部类和局部类的语法和语义 [0 I4 a/ a% F
. u# x8 n+ S% A3 v, E- {
Java中没有友元函数和友元类的概念，严格支持封装，不允许外部方法访问类的私有成员
* F; i/ I9 s4 `0 u$ k而C++支持friend关键字，允许外部方法访问类的私有成员，因此不是一种纯面向对象的编程语言 1 ]. a0 s) @3 `) r" }' X
Java中类或interface可以用public修饰，也可以不修饰；而C++类不能修饰
/ D0 |" W. r" \1 P( c) o, Y) ^2 b4 P
三种访问权限的语义相同，语法略有差别 1 F- a4 u6 X3 m' }3 M+ i
* c! Q% w; q+ I7 _% w
C++中还有继承权限修饰符，Java则没有 3 U+ f1 Z9 f3 Z0 o/ C
class A: protected B, public C (C++) : V4 |, ^0 h, I
class A extends B (Java) 0 c$ a( ~4 O, s+ x' ]0 ^ D' p
Java有super关键字，指代父类对象，通常被用于调用父类的构造方法或一般方法 6 ~; K; s' S! t8 c" V3 S+ o9 G
C++则没有super关键字
, n' r- L6 ]0 B* U6 J5 I$ U" h. H0 l+ p7 t! K* x" z1 q0 U/ G) X7 J
两者都有this，指代当前对象
* m" j' f* i- s* j
( C" M( T" P7 p8 \" K1 ^3 y3 a) DJava有package的概念，可以将类组织起来，便于打包和部署，也有利于类的安全。C++没有这个概念，一个类可以被任意类访问 ; I% F* ~+ {- Z% h. ^$ R3 z, j
Java applet可以被嵌入HTML文档中，然后由Web浏览器下载和执行
( Y1 p1 Y% z! `- N, `Java API有对网络通讯的特别支持 ; f2 d+ P0 H) o4 n6 h* ^7 e# J
& S& E/ F0 X( ?% M% K5 V" J- p& g
C++则无内置网络功能 5 h7 J7 |) |" S
C++程序员必须显式地实现动态内存管理，在析构函数中用delete运算符或free( )函数释放对象和其他动态分配的数据空间，否则会造成“内存泄露” 1 y8 w3 {1 }7 }8 U" A
; I$ S3 s! Q% H8 m) ]而在Java中，垃圾收集是自动的。当对象的最后一个引用变量被释放掉，这个对象就成为垃圾收集器的候选对象了 . l7 o [5 {% j" K6 i. M* v
因此Java不支持析构函数 ; g# q" a/ y7 w% H1 u5 ^
finalize( )方法主要被用来释放先前打开的非内存资源，如文件句柄 - ?/ m) P& T& S' ^+ k
Java源代码被编译成字节码（.class文件），字节码是一种只有JVM才能识别的二进制低级代码，它与具体的处理器无关，要由安装在OS之上的JVM解释执行，转换成相应平台的机器码，因此Java是体系结构中立和跨平台的
: P/ ?$ }! x% k' z+ a6 X% s$ f/ ]( y( K# a. i+ n9 I
而C++直接被编译成底层平台的二进制机器码，由CPU执行，是平台相关的
' v* [% @; v4 b' N
. b* x0 {4 [) T0 G& O7 ~. W1 C因此，当解释执行时，Java程序速度更慢
% Z3 P; b: G! h2 I% w5 @Java语言支持多线程，允许并发线程的同步与互斥操作
7 o* n- ?. c9 Y9 _7 rC++则没有这种内在机制
0 J5 B: b% |% j: A9 v# R- y4 f3 u# |, M0 e+ [' d& O9 p
Javadoc.exe可以将Java程序的内容和结构转换成HTML格式的文档6 j! O- _& {$ }2 P* p8 e, e
# u" t5 s' i7 ~4 p" @$ q; w1 w
我还是认为C语言更好吧 |
评分
-
1
查看全部评分
-
|
楼主: 深情少年
|小黑屋|手机版|Archiver|美河学习在线
( 浙网备33020302000026号 )
发表于 2008-11-30 23:26:27
发表于 2008-11-30 23:27:52
楼主
在线QQ客服2
添加客服QQ