C++与Java面向对象编程对比教程：从入门到高级

需积分: 9 69 浏览量更新于2024-07-23 收藏 5.51MB PDF 举报

本教程《面向对象编程：C++与Java的比较》由Avinash C. Kak撰写，是一本针对高级编程教育课程和专业开发人员设计的参考书籍，英文版，ISBN号为0471268526，由John Wiley & Sons出版，于2003年发行，共1115页。该书旨在通过对比C++和Java这两种流行的面向对象编程语言，帮助读者理解它们的异同，以便更好地在实际项目中应用。 1. **为什么要学习面向对象编程（Why OO Programming）**：章节一探讨了面向对象编程的概念，它如何与现实世界中的事物相平行，强调其在解决复杂问题时的优势。 2. **入门与基础知识**：从基础开始，第二章至第五章涵盖了类的基本概念，包括类的定义、字符串处理、容器类的使用以及基本数据类型及其输入输出操作。 3. **声明、定义和初始化**：第七章深入讲解了变量的声明、函数和方法的定义以及对象的初始化过程，这对于理解两种语言的语法结构至关重要。 4. **对象引用与内存管理**：第八章详细介绍了对象的引用机制以及内存分配，这对于理解程序的内存使用和性能优化非常重要。 5. **函数和方法**：第九章讲解了函数和方法的定义与调用，这是构建对象行为的核心部分。 6. **异常处理**：第十章讨论了错误处理和异常处理，确保程序的健壮性。 7. **深入理解类和对象**：第十一章继续探索类的高级特性，包括类的设计原则和继承等。 8. **C++特有技术：重载运算符和泛型编程**：第十二和十三章分别介绍了C++中如何重载运算符以提供自定义的行为，以及泛型和模板，展示了C++的灵活性。 9. **模型化OO程序**：第十四章涉及如何使用建模工具来可视化和设计面向对象程序，这对于理解和实现复杂的系统架构很有帮助。 10. **类的扩展与多继承**：最后两章关注类的扩展和多继承在C++中的实现，以及这如何影响代码的组织和维护。通过阅读这本书，无论是初学者还是经验丰富的开发者，都能获得关于C++和Java面向对象编程的深入理解和实践指导，对构建高效、可维护的Web和互联网应用程序有着重要的参考价值。

Suppose your program uses third-party classes that are stored in directories directory_1 and

directory_2,

[5]

you'd want to invoke javac and java with the following syntax on Unix and Linux

platforms:

javac -classpath .:directory_1:directory_2 sourceCode.java

java -classpath .:directory_1:directory_2 className

and on Windows platforms by

[6]

javac -classpath .;directory_1; directory_2 source.java

java -classpath .;directory_1; directory_2 className

where the symbol ’.’ is used to designate the current directory where presumably the main

application resides. Note that the delimiter between the directories for Unix and Linux platforms is

the character ’:’ and for the Windows platform the character ’;’. The third-party classes, or, for that

matter, even your previously programmed classes may come packaged in the form of an archive

called the JAR archive.

[7]

If that's the case, you'd need to specify the pathname to such archives in

your classpath specification, as for example in

javac -classpath .:/path_to_archive/archive.jar your_program.java

java -classpath .:/path_to_archive/archive.jar your_class_name

If the classpath strings become too long, you can create shell files containing the above invocations

on Unix and Linux platforms. On Windows platforms, the same is accomplished by using batch files.

On Unix and Linux platforms, it is also possible to set up aliases for the compiler and the application

launcher that include the classpath string.

On Unix and Linux platforms and on some of the older Windows platforms, instead of using the

classpath option as shown above, it is also possible to set the CLASSPATH environment variable.

For example, if you are using either the csh or the tcsh shells, you can define a classpath by, say,

including the following in a .cshrc file,

setenv CLASSPATH .:directory_1:directory_2:....

which would create the same classpath setting as our earlier examples. If, on the other hand, you

are using either sh, ksh, or bash, you can achieve the same effect by including the following strings

in your .profile file:

CLASSPATH=.:directory_1:directory_2:....

export CLASSPATH

If desired, you can "unset" the value of the environmental variable by invoking unsetenv

CLASSPATH in csh and tcsh and by invoking unset CLASSPATH in sh and ksh.

Even if you use the CLASSPATH environment variable, you may still have to use the -classpath

option as shown previously to customize the classpath for a particular application. The classpath as

set by the -classpath option overrides the classpath as set by the environmental variable. Note

again the importance of including the character ’.’ in the CLASSPATH environment variable since,

as was the case with the -classpath option, setting the environment variable overrides the default.

Getting to the program itself, the code that is inside the class definition is very much like the C or

the C++ code we showed earlier. We have the function main() in line (B) and the method

[8]

addArray() inside the class definition in line (E). In Java, any class can include main(). When a

class includes main(), the class becomes executable as an application. Since main() does not

return anything in Java, its return type is declared as void. The significance of the labels public

and static in the header for main will be explained in Chapter 3. In the body of main, we

declare the identifier data as an array of ints and initialize it at the same time, very much like we

did for C and C++.

The invocation System.out.println( … ) in line (D) is a call to the println() method that

is defined for the output stream object out. More precisely, out is a field of type OutputStream

defined in the class System. System is a class that comes with the java. lang package.

[9]

This

package is loaded in automatically by the Java compiler. println() is a method defined for the

class OutputStream. One could also use the method print() via the invocation System.

out.print( … ) if it is not necessary to display the output in a separate line of text. The

println and the print methods are as defined for the PrintStream class. The argument to

these methods must either be a string or a type that Java would know how to convert into a string

for display. In our example, the second part of the argument, of type int, gets converted into a

string automatically.

The rest of the program consists of the method addArray() in line (E), which is very much like the

C++ function of the same name in the earlier program, except for the manner in which the size of

the array is determined inside the function. For both C and C++, the size of the array had to be

passed explicitly to the function. But in Java, that is not necessary. Arrays in Java are objects that

have data members

[10]

associated with them. The data member that is associated with an array

object is length. When we access this data member through the call data.length, we can

determine the length of the array data.

Also note from the above examples that C++ and Java have exactly the same way of commenting

code. You can either use the C-style comment delimiters /* …. */ or //. However, the latter can only

be used for comments on a single line, because the compiler will not see any characters past //.

With regard to comments in Java programs, a special tool called javadoc can automatically

generate documentation for your program using text that is delimited by /** and */. This tool

generates HTML files that can be viewed with a browser.

[1]

It is important to bear in mind that while an array name can "decay" into a pointer, it is not a

pointer. The extent to which an array name decays into a pointer depends, among other things, on

whether an array name is the name of a parameter of a callable function. So, whereas the array

name data in main will act like a pointer in some contexts only, the array name a in the function

addArray of the program AddArray1. c will act like a pointer in practically all contexts.

[2]

The C++ Standard Library consists of these header files: algorithm, bitset, complex,

deque, exception, fstream, functional, iomanip, ios, iosfwd, iostream,

istream, iterator, limits, list, locale, map, memory, new, numeric,

ostream, queue, set, sstream, stack, stdexcept, streambuf, string,

typeinfo, utility, valarray, vector. Of these, the following are informally referred to

as the Standard Template Library (STL): algorithm, bitset, deque, functional,

iterator, list, map, queue, set, stack, valarray and vector.

[3]

Operator overloading, discussed in detail in Chapter 12, allows the same operator to be used in

different ways. The operands determine as to which meaning of such an operator applies in a given

context.

[4]

You do not need to specify the classpath for the classes that come with the Java platform. Both

the compiler and the application launcher can locate those automatically.

[5]

By directory name here is meant the pathname to the directory.

[6]

If you are using a Cygnus emulation of Unix on Windows, you may need to place the classpath

string between double quotes.

[7]

A JAR file in Java is an archive file, just like a Unix tar (tape archive) file. Jar files are created and

manipulated by using the Java jar tool. To create a JAR archive of all your classes, including the

sources, in your current directory, you'd say

2.2 SIMPLE PROGRAMS:TERMINAL I/O

Let's now compare simple C, C++, and Java programs for eliciting information from a user and then

printing something out in response on the terminal.

Here is a C program that asks the user to type in a sequence of integers, all in one line. The

integers are allowed to be anywhere in a line, not necessarily starting at the beginning, and the

entry of the data is considered completed when the user presses ‘Enter’ on the keyboard. The

program sums up all the integers and types out the sum.

Therefore, if a user types in

####3#######56##20#1#####19########<Enter>

where # stands for a space, the program should print out 99. The following C program does the job.

/* TermIO.c */

#include <stdio.h>

main()

{

int i;

int sum = 0;

char ch;

printf("Enter a sequence of integers: ");

while ( scanf( "%d", &i ) == 1 ) { /* (A) */

sum += i; /* (B) */

while ( ( ch = getchar() ) & = ' ') /* (C) */

;

if ( ch == '\n' ) break;

ungetc( ch, stdin ); /* (D) */

}

printf( "The sum of the integers is: %d\n", sum );

return 0;

}

The integers are read in by the scanf() function call in line (A) and the summing of the numbers

done in line (B). Lines (C) through (D) take care of the following property of scanf: Most

conversion specifiers for this function skip over the whitespace characters—meaning the tabs, the

space, the newline character, and so on—before the beginning of an input item (and not after).

Therefore, after consuming an integer, scanf will simply wait for the next integer, ignoring any

blank spaces and the end of the data entry line. This creates a problem at the end of the data line

when the user hits "Enter"—scanf will simply gobble up the newline character and wait for the next

integer. The statements in lines (C) through (D) peek ahead, while consuming blank spaces, and

look for the newline character in case the user has hit "Enter" on the keyboard. If the character

found after all the blank spaces have been consumed does not turn out to be a newline character,

we put it back in the input stream in line (D).

Here is a C++ program that does the same thing:

//TermIO.cc

#include <iostream>

using namespace std;

int main()

{

int sum = 0;

cout << "Enter a sequence of integers: ";

int i;

while ( cin >> i ) { //(A)

sum += i;

while ( cin.peek() == ' ' ) cin.get(); //(B)

if ( cin.peek() == '\n' ) break; //(C)

}

cont << "Sum of the numbers is: " << sum << endl;

return 0;

}

This program uses the input stream object cin whose name is usually pronounced "c-in" for

"console-in." This object is of type istream and it knows how to read data from a user's terminal.

The expression in line (A)

cin >> i;

causes the input operator ’>>’, which is also known as the extraction operator , to extract one int at

a time from the input stream object cin. As the user makes keystrokes, the corresponding

characters are entered into the operating system's keyboard buffer and then, when the user hits the

"Enter" key on the keyboard, the operating system transfers the contents of the keyboard buffer into

the cin stream's internal buffer. The operator ’>>’ then extracts the needed information from this

buffer. Clearly, the program will block if the user did not provide the necessary keystrokes.

[11]

The

operator ’>>’, originally defined to be the right bitwise shift operator, has been overloaded in C++

for extracting information from input stream objects when used in the manner shown here. Because

the operator has been overloaded for all the built-in data types, it can be used to extract an int, a

float, a double, a string, and so on, from an input stream object.

To understand the controlling expression in line (A) of the while loop:

while ( cin >> i )

the expression

cin >> i

returns the input stream object itself, meaning cin. However, the returned cin will evaluate to

false when either the end-of-file is encountered or when the extraction operator runs into an

illegal value. As an example of the latter case, if you were trying to read a floating point number into

an int variable, the extraction operator, when it runs into the decimal point, would place the input

stream object in an error state and cause cin to evaluate to false.

Lines (B) and (C) deal with the fact that the default behavior of the extraction operator ’>>’ skips

over the white space characters, which includes blank space, tabs, newlines, and so on. So the

controlling expression in line (A) will not by itself stop the while loop when the user hits "Enter"

after entering the desired number of integers in a line. We invoke

[12]

peek() on the object cin in

lines (B) and (C) to ascertain the character immediately after the most recently consumed integer. If

it's a blank space, we consume it in line (B) by invoking get() on the object cin; and do the same

to all the successive blank spaces until there are no more blank spaces left. If the next character is

a newline, it would be trapped in line (C) and the while loop of line (A) exited. Otherwise, we

continue reading the data in the next iteration of the loop.

This program also demonstrates that, unlike in C, C++ allows you to declare a variable anywhere in

a program. We declared the variable i after the cout statement asking the user to enter data.

[13]

This feature improves the readability of large C++ programs as one can declare variables just

before they are actually needed.

We will now show an equivalent Java program:

剩余933页未读，继续阅读

0x07c00

粉丝: 28
资源: 10

C++与Java面向对象编程对比教程：从入门到高级

面向对象编程C++与JAVA比较教程

面向对象编程C++和Java比较教程

面向对象编程C++和Java比较教程 中英文完整版 pdf

面向对象编程：C++与Java比较教程 英文版

Java面向对象编程：从C++到Java—理解面向对象

C++与Java面向对象编程对比教程精华版

Java面向对象编程基础与C++比较

面向对象编程：C++与Java发展及应用概述

C++与Java面向对象编程对比精要：教程+作业解答

C++与JAVA面向对象编程对比分析

最新资源

面向对象编程C++和Java比较教程中英文完整版 pdf

面向对象编程：C++与Java比较教程英文版