Differences in Design Objectives - Research Paper Example

? Comparison between C++ and Java Difference in Design Objectives C++ and Java possess differing heritages largely due to different design objectives. C++ is an extension of C and was aimed for systems and application programming. It provided added support for statically typed OOP (Object Oriented Programming), handling exceptions, generic programming and scoped resource management. Moreover, C++ features a standard library that houses algorithms and generic containers. On the other hand Java was created initially as an interpreter for printing systems but it soon encompassed network computing. Later it was adapted as the basis for “HotJava” thin client that depends on a virtual machine that is very portable and secure. Java is provided with a wide-ranging library that supports total abstraction for the fundamental platform. Java is a statically typed OOP like C++ and both languages display a similar syntax though their syntaxes are not compatible with each other. Moreover, Java was designed from scratch and was aimed at portability. (Deitel & Deitel, 2009) Comparison of Features Java and C++ differ significantly when it comes to certain features and implementation in each language. These are discussed below with examples to clarify the differences. Java does not possess multiple inheritances, instead it relies on interfaces. Interfaces in Java are comparable and largely similar to classes in C++ that have nothing except for virtual functions. Java allows inheritance from one base class only even if the other base classes are composed of little else than abstract methods (which are pure virtual functions). However Java allows the implementation of multiple interfaces which is similar to C++ and is nearly similar. (Horstmann & Cornell, 2008) An interface in Java for a Stack would be: public interface Stack { public void Push(Object o); public Object Pop(); }; The structure for C++ is similar and is shown below: class Stack { public: virtual void Push(Object&) = 0; virtual Object& Pop() = 0; }; It must be borne in mind that an interface in Java is not a class and any functions declared in a Java interface are not implementable in the same interface. A Java interface is not allowed any member variables either. This helps Java to eliminate the multiple virtual inheritance problems seen in C++ as it is not possible to inherit identical member variables from more paths than one. Virtual inheritance creates difficulties for the programmers of all kinds. Java solves this by eliminating multiple inheritances of classes by permitting multiple interface implementations. This has simplified Java appreciably in comparison to C++. However there is a drawback too. Java does not allow inheriting implementation from multiple classes in cases where there are no identical member variables too. Most coding situations require that variables have multiple inheritances from base classes that possess data and functions. While C++ can help implement these through careful variable naming, Java disallows it altogether. Another aspect of major difference is garbage collection. Garbage collection is a way to manage memory by freeing memory blocks that are not being referred to anymore. For example if the Java code presented below is considered: Clock a = new Clock(); // a is a new clock // ... a is used for a while a = null; // a is set to null and the system will remove it afterwards The code above creates a new Clock object by using the keyword new. The variable a is used to refer to this new object. a has a similar structure to reference variables used in C++ but Java allows the reassignment of references unlike C++. The variable a is used for some time after which it is reset to null. The Java runtime system keeps a in watch and when it detects that there are no more references to a, it brands a as garbage and clears it up. This aids in returning memory to the heap. In comparison C++ does not offer such an extensive garbage collection system. Although third party freeware and shareware versions for garbage collectors are freely available but they cannot match Java’s precision at eliminating dead memory. (Gupta & Palanki, 2005) Security violations are a direct consequence of allowing programs to use memory management schemes that employ held references and pointers for programs to unused space. If the following code in C++ is considered: void b() { char* c = new char[1000000]; delete [] c; SeachForPasswordsInSeparateThread(c); return; } In this case the last called function i.e. SearchForPasswordsInSeparateThread causes an immediate return but it tends to create a new thread that constantly scans the memory based mega byte that refers to c. The megabyte in question has been returned to the memory heap but other programs and functions could easily access it. If such a structure were used to house sensitive information such as passwords, credit card CVV2 codes or the like then any functions with a dead pointer held into the heap could well easily examine the data. This is clear proof that manual memory management systems are not reliable such as those implemented with C++ frameworks. Java is used extensively to create applets for use with web pages. Most applets are downloaded to the client machine before being executed in web browsers. Manual memory management would allow the use of insecure applets to download malicious code and software into client machines. However, with its memory management techniques, Java does not allow this to occur unlike C++. On the other hand while this feature offers Java security, it also causes Java to slow down as the garbage collector runs because it can consume large amounts of processing power. (Lewis & Neumann, 2004) Another area of interest is the presence of goto statement in C++ while Java possesses labelled break and continue. Structured programming does not discourage the use of the goto statement; it only discourages its use in situations that compromise the single entry / single exit flow methodology. It is allowed to use goto to accomplish tasks similar to for and while loops while structured programming criteria are not violated. However there is little need to do so in both Java and C++ as such statements already exist. The utilisation of break and continue can be seen as a violation of the single entry / single exit paradigm. While using break and continue are serious violations, the use of labelled break and continue can be seen as far more serious violations. Using these statements to exit nested blocks and especially deeply nested blocks can produce errors that are extremely hard to identify. This is all the more true if the enclosing blocks is not aware of the exodus and if the enclosing blocks are not coded to handle the exodus. (Flanagan, 2005) If the following code in C++ is considered: outermost: for (int i=0; i Read More