ONE ORIENTATION in Font

Print Denso QR Bar Code in Font ONE ORIENTATION

Beyond the syntax structure, C++ is more complex than Java. For example, for some operations, Java uses a descriptive word where C++ uses a symbol. Further, Java doesn t allow some often confusing C++ operations. C++ is committed to supporting C, a language that is very complex because it is more system oriented than developer oriented; C++ pulled C to function orientation. For example, method-name(parameter-list) is an extension of function-name(parameter-list), and class-name.member-name is an extension of structure-name.field-name. A structure is a compound data type without the processes. (A very basic example of C complexity is that, even though the function-name(parameter-list) syntax is based on the mathematical function syntax, it s actually very different. In math, f(x) means that x is the focus, and f serves x; in C, very often f is the focus, and x serves f. This is plainly evidenced in the fact that the parentheses can occur without anything in them. And the syntax is an example of overextension of a concept.) Java, a younger language than C++, was created to be committed to function orientation, then to C++ syntax; Java pulled function orientation to C++. C++ allows extreme control over a system, which also allows the most possible efficiency during program execution, so it is generally thought of as the most powerful language. But, in a different way, Java can be thought of as the most powerful language, because it allows the most possible efficiency during program development: Java was designed on how C++ is mostly used. This view is supported by all of function orientation. Function orientation causes the computer to do more during execution than it would have to for a structured program, but the development efficiency is worth the execution inefficiency. Further, the increasing speed of computers decreases the impact of inefficiency, and Java is becoming more efficient as it matures (being redesigned on how Java is mostly used). Besides, ultimately, computers are supposed to do as much productive work as possible. An example of C++ complexity and extreme confusion is its memory address management, which came from C. Java does this implicitly for objects and doesn t allow it otherwise. The result is that, in Java, pointers are not directly accessible (and references don t require an identifying character). Table 1-4 is the simplest possible explanation of C++ s memory address management, as it appears in code; this table might not be found in any other books. By the way, the type of address is important because it indicates the length, then the data type, of the item in the heap. Table 1-4. C++ Memory Address Management Operator X Context & (reference) * (pointer) data-type Suffix: Definition / Parameter Declaration

data-type Suffix: Initialization (Left of =) / Binding (Parameter)

Further, C++ allows pointer manipulation, which can easily lead to reading something that is supposed to be unattainable and writing something in the wrong place, corrupting data even of unrelated applications. Java doesn t allow pointer manipulation. Similarly, C++ allows an array index to be set to any integer, regardless of array size; this then translates to a memory address, and the same corruption can occur. So, the programmer must always manually program a check for array overflow and underflow (where the index is less than zero). Java, very simply, does this automatically. Another example of C++ complexity also regarding memory is memory reclamation when an object is no longer referenced by other objects. Without proper memory reclamation, a program is more likely to run out of memory. In C++, this must be coded specifically by the programmer, who must mentally track when an object is likely no longer referenced by other objects, or the programmer must create a tracking mechanism for each object. (Because of the specific programming, C++ also has a destructor method. Its name is the same as the class name, prefixed by a tilde: ~class-name().) Java has a built-in tracking mechanism and an automatic memory reclamation process termed garbage collection. In short, Java is smoother than C++. Further, Java is actually more function oriented than C++. For one thing, it defaults any method to support polymorphism, whereas C++ requires an explicit usage (because polymorphism isn t of the highest execution efficiency). For another thing, Java has everything defined in a class, including main(). C++ has main() defined in a file that might or might not have any class definitions (because C++ is file oriented, because its core is C). But Java isn t perfectly clear, either. Sometimes it tries to be a little bit too smooth, and this is actually counterproductive to clarity. The big culprit here is its overuse (overloading) of the period (or dot) operator. Again, Java uses . to indicate things like class-name. data-name and object-name.method-name(), but it also uses . to indicate the levels of a package (library) structure and the levels of a class family. Further, it uses . to indicate .class, which is a mechanism that dynamically analyzes objects. Still further, it uses . to indicate a chaining of command parts, which syntactically merges the output of a method with a member name. All of these uses make this logical syntax possible: pkg-lvl1.pkg-lvl2.base-class.derived-class.object.class.method().data Using four differing operators for clarity, this could be mentally translated to /pkg-lvl1/pkg-lvl2\base-class\derived-class.object.class.method():data Though it s a little misleading, the fact that .class is a constant makes it fairly clear. Along with all of that, the period operator makes the two-dimensional processing (interobject method calls) very inconspicuous, especially when an object name is the same as a convention word or a keyword from another language for example, is (abbreviating, for example, InputStream) or from . It must be remembered that, regardless of the appearance of the words, execution always jumps to that object, which then executes that method, and then the rest of the command gets executed.