Java_Language

Java Tutorial2D Graphics in JavaJava Stack-Walking APIClass - Java ReflectionCommon Java PitfallsDocumenting Java CodeGenerating Java CodeInstalling Java (Standard Edition)Java AgentsJava Alternative CollectionsJava AnnotationsJava Apache Commons LangJava AppDynamics and TIBCO BusinessWorks Instrumentation for Easy IntegrationJava AppletsJava ArraysJava AssertingJava Atomic TypesJava AudioJava AutoboxingJava Basic Control StructuresJava BenchmarksJava BigDecimalJava BigIntegerJava Bit ManipulationJava BufferedWriterJava ByteBufferJava Bytecode ModificationJava C++ ComparisonJava Calendar and its SubclassesJava Character encodingJava Choosing CollectionsJava Classes and ObjectsJava ClassloadersJava Collection Factory MethodsJava CollectionsJava Command line Argument ProcessingJava Comparable and ComparatorJava Compiler - javacJava CompletableFutureJava Concurrent CollectionsJava Concurrent Programming (Threads)Java Console I/OJava ConstructorsJava Converting to and from StringsJava Creating Images ProgrammaticallyJava Currency and MoneyJava Date ClassJava Dates and Time (java.time.*)Java Default MethodsJava deploymentJava Dequeue InterfaceJava Disassembling and DecompilingJava Dynamic Method DispatchJava Editions, Versions, Releases and DistributionsJava EncapsulationJava Enum MapJava Enum starting with numberJava EnumsJava EnumSet classJava Exceptions and exception handlingJava Executor, ExecutorService and Thread poolsJava ExpressionsJava File I/OJava FileUpload to AWSJava Floating Point OperationsJava Fluent InterfaceJava FTP (File Transfer Protocol)Java Functional InterfacesJava GenericsJava Getters and SettersJava HashtableJava HttpURLConnectionJava Immutable ClassJava Immutable ObjectsJava InheritanceJava InputStreams and OutputStreamsJava InterfacesJava Iterator and IterableJava JavaBeanJava JAX-WSJava JAXBJava JMXJava JNDIJava JShellJava Just in Time (JIT) compilerJava JVM FlagsJava JVM Tool InterfaceJava Lambda ExpressionsJava LinkedHashMapJava List vs SET



Java C++ Comparison

From WikiOD

Java and C++ are similar languages. This topic serves as a quick reference guide for Java and C++ Engineers.

Remarks[edit | edit source]

Classes Defined within Other Constructs#[edit | edit source]

Defined within Another Class[edit | edit source]

C++[edit | edit source]

Nested Class[ref] (needs a reference to enclosing class)

class Outer {
   class Inner {
      public:
         Inner(Outer* o) :outer(o) {}

      private:
         Outer*  outer;
   };
};

Java[edit | edit source]

[non*static] Nested Class (aka Inner Class or Member Class)

class OuterClass {
    ...
    class InnerClass {
        ...
    }
}

Statically Defined within Another Class[edit | edit source]

C++[edit | edit source]

Static Nested Class

class Outer {
   class Inner {
      ...
   };
};

Java[edit | edit source]

Static Nested Class (aka Static Member Class)[ref]

class OuterClass {
    ...
    static class StaticNestedClass {
        ...
    }
}

Defined within a Method[edit | edit source]

(e.g. event handling)

C++[edit | edit source]

Local Class[ref]

void fun() {
   class Test {
      /* members of Test class */
   };
}

See also Lambda expressions

Java[edit | edit source]

Local Class[ref]

class Test {
    void f() {
        new Thread(new Runnable() {
            public void run() {
                doSomethingBackgroundish();
            }
        }).start();
    }
}

Overriding vs Overloading[edit | edit source]

The following Overriding vs Overloading points apply to both C++ and Java:

  • An overridden method has the same name and arguments as its base method.
  • An overloaded method has the same name but different arguments and does not rely on inheritance.
  • Two methods with the same name and arguments but different return type are illegal. See related Stackoverflow questions about "overloading with different return type in Java" - Question 1; Question 2

Polymorphism[edit | edit source]

Polymorphism is the ability for objects of different classes related by inheritance to respond differently to the same method call. Here's an example:

  • base class Shape with area as an abstract method
  • two derived classes, Square and Circle, implement area methods
  • Shape reference points to Square and area is invoked

In C++, polymorphism is enabled by virtual methods. In Java, methods are virtual by default.

Order of Construction/Destruction[edit | edit source]

Order of Construction/Destruction

Object Cleanup[edit | edit source]

In C++, it's a good idea to declare a destructor as virtual to ensure that the subclass' destructor will be called if the base-class pointer is deleted.

In Java, a finalize method is similar a destructor in C++; however, finalizers are unpredictable (they rely on GC). Best practice - use a "close" method to explicitly cleanup.

protected void close() {
    try {
       // do subclass cleanup
    }
    finally {
       isClosed = true;
       super.close();
    }
}

protected void finalize() {
    try {
       if(!isClosed) close();
    }
    finally {
       super.finalize();
    }
}

Abstract Methods & Classes[edit | edit source]

Concept C++ Java
Abstract Method

declared without an implementation

pure virtual method

virtual void eat(void) = 0;

abstract method

abstract void draw();

Abstract Class

cannot be instantiated

cannot be instantiated; has at least 1 pure virtual method

class AB {public: virtual void f() = 0;};

cannot be instantiated; can have non-abstract methods

abstract class GraphicObject {}

Interface

no instance fields

no "interface" keyword, but can mimic a Java interface with facilities of an abstract class very similar to abstract class, but 1) supports multiple inheritance; 2) no instance fields

interface TestInterface {}

Accessibility Modifiers[edit | edit source]

Modifier C++ Java
Public - accessible by all no special notes no special notes
Protected - accessible by subclasses also accessible by friends also accessible within same package
Private - accessible by members also accessible by friends no special notes
default class default is private; struct default is public accessible by all classes within the same package
other Friend - a way to grant access to private & protected members without inheritance (see below)

C++ Friend Example[edit | edit source]

class Node {
  private:
    int key;  Node *next;
    // LinkedList::search() can access "key" & "next"
    friend int LinkedList::search();
};

The Dreaded Diamond Problem[edit | edit source]

The diamond problem is an ambiguity that arises when two classes B and C inherit from A, and class D inherits from both B and C. If there is a method in A that B and C have overridden, and D does not override it, then which version of the method does D inherit: that of B, or that of C? (from Wikipedia)

The Dreaded Diamond Problem

While C++ has always been susceptible to the diamond problem, Java was susceptible until Java 8. Originally, Java didn't support multiple inheritance, but with the advent of default interface methods, Java classes can not inherit "implementation" from more than one class.

java.lang.Object Class[edit | edit source]

In Java all classes inherit, either implicitly or explicitly, from the Object class. Any Java reference can be cast to the Object type.

C++ doesn't have a comparable "Object" class.

Java Collections & C++ Containers[edit | edit source]

Java Collections are symonymous with C++ Containers.

Java Collections Flowchart[edit | edit source]

Java+Collections+Flowchart.png

C++ Containers Flowchart[edit | edit source]

C-Container-Flowchart.png

Integer Types[edit | edit source]

Bits Min Max C++ Type

(on LLP64 or LP64)

Java Type
8 -2(8-1) = -128 2(8-1)-1 = 127 char byte
8 0 2(8)-1 = 255 unsigned char --
16 -2(16-1) = -32,768 2(16-1)-1 = 32,767 short short
16 0 (\u0000) 2(16)-1 = 65,535 (\uFFFF) unsigned short char (unsigned)
32 -2(32-1) = -2.147 billion 2(32-1)-1 = 2.147 billion int int
32 0 2(32)-1 = 4.295 billion unsigned int --
64 -2(64-1) 2(16-1)-1 long* long long
64 0 2(16)-1 unsigned long*

unsigned long long

--

* Win64 API is only 32 bit

Lots more C++ types

Static Class Members[edit | edit source]

Static members have class scope as opposed to object scope

C++ Example[edit | edit source]

// define in header
class Singleton {
   public:
      static Singleton *getInstance();

   private:
      Singleton() {}
      static Singleton *instance;
};

// initialize in .cpp
Singleton* Singleton::instance = 0;

Java Example[edit | edit source]

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

Classes Defined within Other Constructs[edit | edit source]

Defined within Another Class[edit | edit source]

C++[edit | edit source]

Nested Class[ref] (needs a reference to enclosing class)

class Outer {
   class Inner {
      public:
         Inner(Outer* o) :outer(o) {}

      private:
         Outer*  outer;
   };
};

Java[edit | edit source]

[non*static] Nested Class (aka Inner Class or Member Class)

class OuterClass {
    ...
    class InnerClass {
        ...
    }
}

Statically Defined within Another Class[edit | edit source]

C++[edit | edit source]

Static Nested Class

class Outer {
   class Inner {
      ...
   };
};

Java[edit | edit source]

Static Nested Class (aka Static Member Class)[ref]

class OuterClass {
    ...
    static class StaticNestedClass {
        ...
    }
}

Defined within a Method[edit | edit source]

(e.g. event handling)

C++[edit | edit source]

Local Class[ref]

void fun() {
   class Test {
      /* members of Test class */
   };
}

Java[edit | edit source]

Local Class[ref]

class Test {
    void f() {
        new Thread(new Runnable() {
            public void run() {
                doSomethingBackgroundish();
            }
        }).start();
    }
}

Pass-by-value & Pass-by-reference[edit | edit source]

Many argue that Java is ONLY pass-by-value, but it's more nuanced than that. Compare the following C++ and Java examples to see the many flavors of pass-by-value (aka copy) and pass-by-reference (aka alias).

C++ Example (complete code)[edit | edit source]

  // passes a COPY of the object
  static void passByCopy(PassIt obj) {
     obj.i = 22;  // only a "local" change
  }

  // passes a pointer
  static void passByPointer(PassIt* ptr) {
     ptr->i = 33;
     ptr = 0; // better to use nullptr instead if '0'
  }

  // passes an alias (aka reference)
  static void passByAlias(PassIt& ref) {
     ref.i = 44;
  }

  // This is an old-school way of doing it.
  // Check out std::swap for the best way to do this
  static void swap(PassIt** pptr1, PassIt** pptr2) {
     PassIt* tmp = *pptr1;
     *pptr1 = *pptr2;
     *pptr2 = tmp;
  }

Java Example (complete code)[edit | edit source]

   // passes a copy of the variable
   // NOTE: in java only primitives are pass-by-copy
   public static void passByCopy(int copy) {
      copy = 33;  // only a "local" change
   }

   // No such thing as pointers in Java
   /*
   public static void passByPointer(PassIt *ptr) {
      ptr->i = 33;
      ptr = 0; // better to use nullptr instead if '0'
   }
   */

   // passes an alias (aka reference)
   public static void passByAlias(PassIt ref) {
      ref.i = 44;
   }

   // passes aliases (aka references),
   // but need to do "manual", potentially expensive copies
   public static void swap(PassIt ref1, PassIt ref2) {
      PassIt tmp = new PassIt(ref1);
      ref1.copy(ref2);
      ref2.copy(tmp);
   }

Inheritance vs Composition[edit | edit source]

C++ & Java are both object-oriented languages, thus the following diagram applies to both.

Inheritance vs Composition Example

Outcast Downcasting[edit | edit source]

Beware of using "downcasting" - Downcasting is casting down the inheritance hierarchy from a base class to a subclass (i.e. opposite of polymorphism). In general, use polymorphism & overriding instead of instanceof & downcasting.

C++ Example[edit | edit source]

// explicit type case required
Child *pChild =  (Child *) &parent;

Java Example[edit | edit source]

if(mySubClass instanceof SubClass) {
   SubClass mySubClass = (SubClass)someBaseClass;
   mySubClass.nonInheritedMethod();
}

Abstract Methods & Classes[edit | edit source]

Abstract Method[edit | edit source]

declared without an implementation

C++[edit | edit source]

pure virtual method

virtual void eat(void) = 0;

Java[edit | edit source]

abstract method

abstract void draw();

Abstract Class[edit | edit source]

cannot be instantiated

C++[edit | edit source]

cannot be instantiated; has at least 1 pure virtual method

class AB {public: virtual void f() = 0;};

Java[edit | edit source]

cannot be instantiated; can have non-abstract methods

abstract class GraphicObject {}

Interface[edit | edit source]

no instance fields

C++[edit | edit source]

nothing comparable to Java

Java[edit | edit source]

very similar to abstract class, but 1) supports multiple inheritance; 2) no instance fields

interface TestInterface {}

Credit:Stack_Overflow_Documentation