Download Object-Oriented Languages: Java vs C++

OOP Languages:
Java vs C++
CS 124
Outline







Program Structure and Execution
Encapsulation and Inheritance
Objects, Variables, and Arrays
Constructors
Methods, Operators, and Binding
Containers and Reuse
GUI Programming
Program Structure


Class definition similar in Java and C++
Java: two types of programs



application (with main() function)
applet (typically embedded in a web page)
C++


a program is (still) a collection of functions that
may use objects and classes
main() function serves as driver
Program Execution

Java: Virtual Machine (VM)




programs: both compiled and interpreted
compiler produces .class from .java
VM loads .class file(s) as needed
C++: compiled, linked, and loaded



modules separately compiled
linked to produce executable
static vs dynamic libraries
Encapsulation

Enforced through access keywords




In Java



public: for interface
private: to make implementation inaccessible
protected: access for subclasses only
each member is prefixed with a keyword
another access level: package-access
In C++


public, private, and protected sections
friend keyword used to break encapsulation
Inheritance

Feature that allows a class to be defined based on
another class


Java and C++ difference



methods and attributes are inherited
Java: public class A extends B { … }
C++: class A: public B { … }
(different types of inheritance)
Multiple inheritance possible in C++, not in Java

But in Java, one may implement several interfaces
Objects and Identity

Questions:



How/when are objects created?
What is the relationship between a variable and
an object?
Difference between Java and C++


distinction between primitive (built-in) type
variables and variables for objects
reference relationship between variable and
actual object
Variables for Built-in Types

Variables for built-in types (C++ and Java)
int x;
…
x = 5;
X
X
5
Reference Variables
(in Java)

Reference type variables
X
Button x;
…
x = new Button(“click”);
Button Object
X
“click”
Variables That “hold” Objects
(in C++)

Declaration of an object variable allocates
space for the object
Button x(“Click”);
X
“click”
Pointers (in C++)

Variables can be explicitly declared as
pointers to objects
X
Button *x;
…
x = new Button(“click”);
Button Object
X
“click”
Disposing of
Allocated Memory

In Java, garbage collection is automatic



Memory allocated objects are reclaimed when no
variables refer to them
Need to set reference variables to null when the
object is no longer needed
In C++, object destruction is the
programmers responsibility using the delete
keyword
delete in C++

There should be a delete for every new




SomeClass *x = new SomeClass(…);
// … use object pointed to by x
delete x; // done using object
Memory leak



Occurs when you forget to delete
Wasted memory
Can this occur in Java?
Object Construction

Constructor


Default Constructor


place where you include code that initializes the
object
no additional info required
User-defined Constructor

with parameters that specify values or sizes
Arrays

int x[20]; Button b[20];



Valid declarations in C++, not in Java
Creates 20 ints and 20 Button objects
In Java,


Declaration and array creation separate
For object arrays, individual object creation
necessary
Pointers and Arrays


In C++, there is a close relationship between
pointers and arrays
Instead of int x[20]; can issue
int *x; x = new int[20];
to allow for dynamic allocation


Usage of the array (e.g., x[3] = 5;) identical in
both cases
To deallocate, use delete [] x;
Constructors in Java and C++

In Java,



a constructor is invoked only through the new
keyword
recall that all object variables are references
In C++,


a constructor is called upon variable declaration,
or explicitly through new with pointers, or in other
situations
other types of constructors
C++ Destructor

Special method whose signature is a ~
followed by the name of the class


e.g., ~SomeClass();
Particularly if the class contains pointers and
the constructor contains calls to new, a
destructor needs to be defined

e.g., SomeClass() { A = new int[20]; }
~SomeClass() { delete [] A; }
C++ Control Over Copy and
Assignment

In C++, the semantics of “a = b”
(assignment) can be specified


In C++, there is a copy constructor


by defining the copy-assignment operator
specifies what happens during object copying,
e.g., when function parameters are passed
There is more low-level control

shallow copy vs deep copy
Methods



Defines object behavior
Static methods vs instance methods
Method overloading


within class, two methods with the same name but
different signatures
Method overriding

same signatures across different classes
(subclass and superclass)
Operators


In C++, operators like =, +, *, ==, etc. can be
defined, just like methods
Example:


class Matrix {
// ...
Matrix operator+(Matrix m) { … } // …
}
c = a + b; // equiv to c = a.operator+(b);
Method Binding

Let Teacher be a subclass of Employee


Employee variables can refer to Teachers



Also, suppose promote() is a method defined in
both classes
In Java, Employee e; … e = new Teacher();
In C++, Employee *e; … e = new Teacher;
e.promote() (or (*e).promote() ) calls which
promote() method?
Static vs Dynamic Binding

In C++, Employee’s promote() is called


Determined at compile time and deduced from the
type of the variable (static binding)
In Java, Teacher’s promote is called

Determined at run-time because the actual type of
the referred object is checked then (dynamic
binding)
* C++ uses virtual functions for dynamic binding
Another example
class Employee{
public:
double salary()
{return sal;}
double computeRaise()
{return 25;}
Employee(double salary)
{sal = salary;}
private:
double sal;
};
class Manager: public
Employee
{
public:
double computeRaise()
{return 100;}
Manager(double Salary) :
Employee (salary)
{}
};
Sample continued
Driver Code:
Manager * boss1 = new Manager(2000);
double boss1Salary = boss1->salary(); // 2000
Employee *boss2 = new Manager(2300);
double *boss2Salary = boss2->salary(); //2300
double boss1Raise = boss1->computeRaise(); // 100
double boss2Raise = boss2->computeRaise(); // 25
C++ Run Time Binding

If the intent is for the selection of the function
to be determined by the object’s class, not by
the declaration of the pointer used to address
it:


Declare some base class members to be virtual
If virtual, the compiler will deposit the “type field”
of the class in the object
Virtual Functions



Base class usually defines a body for a virtual
function.
Inherited by derived class as default if it
chooses not to override the implementation
Virtual keyword in function declaration, not
in definition
Containers




Examples: Lists, Stacks, Files, etc.
Structures that “contain” elements
Often, the element’s type has little or nothing
to do with the containers’ operations
Possible room for re-use

unified container code for a stack of integers, a
stack of webpages, a stack of strings, ...
Java and the Object Hierarchy

All classes extend the Object class:


A variable of class Object can refer to any Java
object
Example:

public class Stack
{
Object A[]; int top; …
void push(Object elt) ...
}
Templates

Templates allow for a generic definition


C++ Example:


parameterized definition, where the element type
is the parameter
template<class T>
class Stack<T>
{
T A[MAX]; int top;
public: void push(T element) // …
}
Java counterpart (as of Java 1.5): generics
C++ Templates



<class T> indicates that a template is being declared
T is the type name (can be a class)
Usage example:



Stack <int> iStack;
Stack <Cards> cStack;
 where Cards is a user defined class
A type used as a template argument must provide
the interface expected by the template
Defining a Template


When defining a template member outside of
its class, it must be explicitly declared a
template
Example

template <class T> Stack<T>::Stack()
C++ Standard Containers








Vector : 1-D array of T
list : double linked list of T
dequeue : double-ended queue of T
queue : queue of T
stack : stack of T
map : associative array of T
set : set of T
bitset : set of booleans
GUI Programming

In Java, GUI is part of its development kit



java.awt.* is a collection of classes that support
visual programming and graphics
visual objects (buttons, text fields, etc), layout
managers, events, etc.
In C++


not part of the language
libraries dependent on platform (e.g., MFCs and
Motif)