Download Java vs C++

OOP in Java and C++
CS 123/CS 231
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
public: for interface
private: to make implementation inaccessible
protected: access for subclasses only
In Java
each member is prefixed with a keyword
In C++
public, private, and protected sections
Breaking Encapsulation
Possible in C++ through the friend
keyword
A method or class may be declared as a
friend of an existing class
Allows access to private members
“A friend is someone who has access to
your private parts.”
Inheritance
Feature that allows a class to be defined based
on another class
methods and attributes are inherited
Java and C++ difference
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)
X
int x;
…
x = 5;
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
place where you include code that initializes
the object
Default Constructor
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
by defining the copy-assignment operator
In C++, there is a copy constructor
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
Also, suppose promote() is a method defined
in both classes
Employee variables can refer to Teachers
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
Static Binding
Pointer is typed to know the base class and is
ignorant of the structure or existence of the
derived classes
If the virtual keyword is NOT used, if a derived
class has its own variation on the
implementation of a base class member
function, it will NOT cause the derived class
version to be selected when a function is
invoked on an object of than class through a
variable declared in terms of the base class.
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) // ...
}
C++ and Templates
Templates allow for a generic definition
parameterized definition, where the element
type is the parameter
Example:
template<class T>
class Stack<T> {
T A[MAX]; int top;
public: void push(T element) // …
}
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)