1. 1 Object-Oriented Programming Concepts

2. 2 Recap from last lecture Variables and types –int count Assignments –count = 55 Arithmetic expressions –result = count/5 + max Control flow –if – then – else –while – do –do – while –For SubPrograms –Methods

3. 3 Programming Programming consists of two steps: design (the architects) coding (the construction workers) –Object oriented design –Object oriented programming

4. 4 What Is an Object? Real world examples: bicycle; dog; dinosaur; table; rectangle; color. Objects have two characteristics: state (attributes) and behavior Software objects maintain its state in variables or data, and implement the behavior using methods. An Object

5. 5 What Is an Object? Real-world objects can be represented using software objects: e.g., electronic dinosaur, bicycle Software objects may correspond to abstract concepts: e.g., an event A Bicycle Object

6. 6 What Is an Object? Methods to brake, change the pedal cadence, and change gears. Concept of encapsulation: hiding internal details from other objects: you do not need to know how the gear mechanism works. In Java, both methods and variables can be hidden A Bicycle Object

7. 7 What Are Messages? Software objects interact and communicate with each other using messages (method invocation) A message with parameters

8. 8 What Are Messages? Three components comprise a message: 1.The object to whom the message is addressed (Your Bicycle) 2.The name of the method to perform (changeGears) 3.Any parameters needed by the method (lower gear)

9. 9 What Are Classes? A class is a blueprint or prototype that defines the variables and the methods common to all objects of a certain kind. Instantiation of a class: create an instance (object) according to the blueprint specification.

10. 10 What Are Classes? Consist of public API and private implementation details

11. 11 Object vs Class Each object has its own instance variables: e.g., each bicycle has its own (x,y) position.

12. 12 Object vs Class Usually no memory is allocated to a class until instantiation, whereupon memory is allocated to an object of the type. Except when there are class variables. All objects of the same class share the same class variables: e.g., extinct variable of dinosaur class; tax rate of certain class of goods.

13. 13 What Is Inheritance? A class inherits state and behavior from its superclass. A subclass can define additional variables and methods. A subclass can override methods of superclass (e.g., change gear method might be changed if an additional gear is provided.) Can have more than one layer of hierarchy Software Reuse

14. 14 What is an Interface? Definition: An interface is a device that unrelated objects use to interact with each other. An object can implement multiple interfaces. Object 1 Interface A Interface B Interface C Object

15. 15 Primitive and Reference Data Type int x; x = 5; x: 5 Point p1, p2; p1 = new Point(); p2 = p1; p1:p2: x: 0 y: 0 Primitive Data Type Reference Data Type

16. 16 Brief Introduction to Classes A point in 2-D space: public class SimplePoint { public int x = 0; public int y = 0; } Upon instantiation

17. 17 Brief Introduction to Classes A simple rectangle class: public class SimpleRectangle { public int width = 0; public int height = 0; public SimplePoint origin = new SimplePoint(); } Reference type vs primitive type

18. 18 A Brief Introduction to Classes A Point Class with a constructor: public class Point { public int x = 0; public int y = 0; // a constructor! public Point(int x, int y) { this.x = x; this.y = y; } } new Point(44,78);

19. 19 A Brief Introduction to Classes More sophisticated Rectangle Class: public class Rectangle { public int width = 0; public int height = 0; public Point origin; // four constructors public Rectangle() { origin = new Point(0, 0); } public Rectangle(Point p) { origin = p; }

20. 20 A Brief Introduction to Classes public Rectangle(int w, int h) { this(new Point(0, 0), w, h); } public Rectangle(Point p, int w, int h) { origin = p; width = w; height = h; } // a method for moving the rectangle public void move(int x, int y) { origin.x = x; origin.y = y; }

21. 21 A Brief Introduction to Classes // a method for computing the area of the rectangle public int area() { return width * height; } // clean up! protected void finalize() throws Throwable { origin = null; super.finalize(); }

22. 22 Basic Structures of a Class Class Declaration Variable Instance Variable Class Variable Constructor Method Instance Method Class Method Cleanup Rectangle2.java

23. 23 Creating Classes A blueprint or prototype that you can use to create many objects. Type for objects. classDeclaration { classBody }

24. 24 The Class Declaration Simplest class declaration class NameOfClass {... } e.g., class ImaginaryNumber{... } Start with capital letter by convention

25. 25 The Class Declaration Class declaration can say more about the class: declare what the class's superclass is declare whether the class is public, abstract, or final (if not specified, then default) list the interfaces implemented by the class

26. 26 Declaring a Class's Superclass All class has a superclass. If not specified, superclass is Object class by default To specify an object's superclass explicitly, class NameOfClass extends SuperClassName{... } e.g., class ImaginaryNumber extends Number {... } Part of java.lang package

27. 27 Declare whether the Class is Public, Final, or Abstract Modifier class NameOfClass {... } Default: accessible only by classes within same package Public: accessible by classes everywhere Final: the class cannot be further subclassed. Abstract: some methods are defined but unimplemented; must be further subclassed before instantiation.

28. 28 Listing the Interfaces Implemented by a Class An interface declares a set of methods and constants without specifying the implementation for any of the methods. e.g., class ImaginaryNumber extends Number implements Arithmetic {... } Contains unimplemented methods such as add(), substract()

29. 29 The Class Declaration

30. 30 The Class Body Contains two different sections: variable declarations and methods. classDeclaration { memberVariableDeclarations methodDeclarations } e.g., class TicketOuttaHere { Float price; String destination; Date departureDate; void signMeUp(Float forPrice, String forDest, Date forDate) { price = forPrice; destination = forDest; departureDate = forDate; }

31. 31 Declaring Member Variables a member variable declaration type variableName; e.g., class IntegerClass { int anInteger;... // define methods here... } IntegerClass anIntergerObject; anIntegerObject = new IntegerClass(); Lowercase by convention All variables must have a type; “class”is also a type

32. 32 Statement for Member Variable Declaration [accessSpecifier] [static] [final] [transient][volatile] type variableName accessSpecifier defines which other classes have access to the variable (public, private, or protected) static indicates that the variable is a class member variable, not an instance member variable. final indicates that the variable is a constant: class Avo { final double AVOGADRO = 6.023e23;} transient variables are not part of the object's persistent state volatile means that the variable is modified asynchronously By convention, all capitals

33. 33 Managing Inheritance All classes inherit from the Object class.

34. 34 Creating Subclasses class SubClass extends SuperClass {... } A Java class can have only one direct superclass. Java does not support multiple inheritance.

35. 35 What Member Variables Does a Subclass Inherit? Rule: A subclass inherits all of the member variables within its superclass that are accessible to that subclass. –Member variables declared as public or protected. Do not inherit private member variables. –Member variables declared with no access modifier so long as subclass is in the same package –If subclass declares a member variable with the same name, the member variable of the superclass is hidden.

36. 36 Hiding Member Variables class Super { Number aNumber; } class Sub extends Super { Float aNumber; }

37. 37 What Methods Does a Subclass Inherit? Rule: A subclass inherits all of the methods within its superclass that are accessible to that subclass. –public or protected methods, but not private methods –no access modifier but in the same package –If subclass declares a method with the same name, the method of the superclass is overridden.

38. 38 Overriding Methods A subclass can either completely override the implementation for an inherited method or the subclass can enhance the method by adding functionality to it.

39. 39 Replacing a Superclass's Method Implementation An example: Thread class has an empty implementation of run(). class BackgroundThread extends Thread { void run() {... }

40. 40 Adding to a Superclass's Method Implementation Another Example: want to preserve initialization done by superclass in constructor: class MyWindow extends Window { public MyWindow(Frame parent) { super(parent);... // MyWindow-specific initialization here... } Superclass constructor

41. 41 Methods a Subclass Cannot Override A subclass cannot override methods that are declared final in the superclass.

42. 42 M ethods a Subclass Must Override Subclass must override methods that are declared abstract in the superclass, or the subclass itself must be abstract.

43. 43 Being a Descendent of Object Every class in the Java system is a descendent (direct or indirect) of the Object class. Your class may want to override: –clone –equals –finalize –toString Your class cannot override (they are final): –getClass –notify –notifyAll –wait –hashCode

44. 44 Summary You should know Objects are created from classes An object's class is its type Difference between reference and primitive types. You also should have a general understanding or a feeling for the following: How to create an object from a class What constructors are What the code for a class looks like What member variables are How to initialize objects What methods look like