OOP in Java and C++

1. OOP in Java and C++ CS 123/CS 231

2. Outline • Program Structure and Execution • Encapsulation and Inheritance • Objects, Variables, and Arrays • Constructors • Methods, Operators, and Binding • Containers and Reuse • GUI Programming

3. 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

4. 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

5. 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

6. 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.”

7. 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

8. 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

9. Variables for Built-in Types • Variables for built-in types (C++ and Java) int x; … x = 5; X X 5

10. Reference Variables(in Java) • Reference type variables Button x; … x = new Button(“click”); X Button Object “click” X

11. Variables That “hold” Objects (in C++) • Declaration of an object variable allocates space for the object Button x(“Click”); X “click”

12. Pointers (in C++) • Variables can be explicitly declared as pointers to objects Button *x; … x = new Button(“click”); X Button Object “click” X

13. Disposing ofAllocated 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

14. 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?

15. 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

16. 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

17. Pointers and Arrays • In C++, there is a close relationship between pointers and arrays • Instead of int x[20]; can issueint *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;

18. 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

19. 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; }

20. 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

21. 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)

22. 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);

23. 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?

24. 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

25. 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.

26. 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) {} }; Another example

27. 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

28. 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

29. 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

30. 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, ...

31. 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) // ...}

32. 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) // …}

33. 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

34. 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()

35. 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

36. 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)