Object Oriented Programming

OOP The fundamental idea behind object-oriented programming is: The real world consists of objects. Computer programs may contain computer world representations of the things (objects) that constitute the solutions of real world problems. Real world objects have two parts: Properties (or state :characteristics that can change), Behavior (or abilities :things they can do). To solve a programming problem in an object-oriented language, the programmer no longer asks how the problem will be divided into functions, but how it will be divided into objects. The emphasis is on data

Kinds of Objects Human Entities: employee, customer, worker, manager… Graphics program: point, line, circle… Data storage: linked list, stack, matrix… Car, Robot …

Classes and objects class: A program entity that represents either: 1. A program / module, or 2. A template for a new type of objects. The Robot class is a template for creating Robot objects. object: An entity that belongs to the corresponding class. object-oriented programming (OOP): Programs that perform their behavior as interactions between objects.

What is a class? Essentially a struct with built-in functions class Circle { double radius = 0.0; double Area() double pi = 3.141592; return (pi * radius * radius); } 5

A swap method? Does the following swap method work? Why or why not? public static void main(String[] args) { int a = 7; int b = 35; // swap a with b? swap(a, b); System.out.println(a + " " + b); } public static void swap(int a, int b) { int temp = a; a = b; b = temp; It's basically not possible to write a swap method that accepts two ints. swap can't escape from itself to modify the outside world.

Value semantics value semantics: Behavior where values are copied when assigned, passed as parameters, or returned. Primitive types use value semantics. When one variable is assigned to another, its value is copied. Modifying the value of one variable does not affect others. int x = 5; int y = x; // x = 5, y = 5 y = 17; // x = 5, y = 17 x = 8; // x = 8, y = 17

Reference semantics (objects) reference semantics: Behavior where variables actually store the address of an object in memory. When one variable is assigned to another, the object is not copied; both variables refer to the same object. Modifying the value of one variable will affect others. int[] a1 = {4, 15, 8}; int[] a2 = a1; // refer to same array as a1 a2[0] = 7; System.out.println(a1[0]); // 7 index 1 2 value 7 15 8 index 1 2 value 4 15 8 a1 a2

References and objects Arrays and objects use reference semantics. Why? efficiency. Copying large objects slows down a program. sharing. It's useful to share an object's data among methods. When an object is passed as a parameter, the object is not copied. The parameter refers to the same object. If the parameter is modified, it will affect the original object This is called shallow copy Deep Copy The object is copied, became two independent objects a copy is made not only of the top-level object, but of all the objects referenced by the original object.

Objects object: An entity that encapsulates data and behavior. data: variables inside the object behavior: methods inside the object You interact with the methods; the data is hidden in the object. Constructing (creating) an object: Type objectName = new Type(parameters); Calling an object's method: objectName.methodName(parameters);

Classes class: A program entity that represents either: 1. A program / module, or 2. A template for a new type of objects. object-oriented programming (OOP): Programs that perform their behavior as interactions between objects. abstraction: Separation between concepts and details. Objects and classes provide abstraction in programming. Treat objects as black boxes – deal only with the interface

Blackbox analogy creates iPod blueprint state: current song volume battery life behavior: power on/off change station/song change volume choose random song creates iPod #1 state: song = "1,000,000 Miles" volume = 17 battery life = 2.5 hrs behavior: power on/off change station/song change volume choose random song iPod #2 state: song = "Letting You" volume = 9 battery life = 3.41 hrs iPod #3 state: song = "Discipline" volume = 24 battery life = 1.8 hrs

Encapsulation By default the class definition encapsulates, or hides, the data inside it. Key concept of object oriented programming. The outside world can see and use the data only by calling the build-in functions. Called “methods” 13

Encapsulation To create software models of real world objects both data and the functions that operate on that data are combined into a single program entity. Data represent the properties (state), Functions represent the behavior of an object. Data and its functions are said to be encapsulated into a single entity. An object’s functions, called member functions typically provide the only way to access its data. The data is hidden, so it is safe from accidental alteration. This simplifies writing, debugging, and maintaining the program.

Encapsulation encapsulation: Hiding implementation details from clients. Encapsulation enforces abstraction. separates external view (behavior) from internal view (state) protects the integrity of an object's data

Class Members Methods and variables declared inside a class are called members of that class. Member variables are called fields. Member functions are called methods. In order to be visible outside the class definition, a member must be declared public. As written in the previous example, neither the variable radius nor the method Area could be seen outside the class definition. 16

Making a Method Visible To make the Area() method visible outside we would write it as: public double Area() { return pi * radius * radius; } We will keep the radius and pi field private. 17

Interface vs. Implementation The public definitions form the interface for the class A contract between the creator of the class and the users of the class. Should never change. Implementation is private Users cannot see. Users cannot have dependencies. Can be changed without affecting users. 18

Our task In the following slides, we will implement a Point class as a way of learning about defining classes. We will define a type of objects named Point. Each Point object will contain x/y data called fields. Each Point object will contain behavior called methods. Client programs will use the Point objects.

Point objects (desired) Point p1 = new Point(5, -2); Point p2 = new Point(); // origin, (0, 0) Data in each Point object: Methods in each Point object: Field name Description x the point's x-coordinate y the point's y-coordinate Method name Description setLocation(x, y) sets the point's x and y to the given values translate(dx, dy) adjusts the point's x and y by the given amounts distance(p) how far away the point is from point p

Point class, version 1 The above code creates a new type named Point. public class Point { int x; int y; } Save this code into a file named Point.java. The above code creates a new type named Point. Each Point object contains two pieces of data: an int named x, and an int named y. Point objects do not contain any behavior (yet).

Accessing fields Other classes can access/modify an object's fields. access: variable.field modify: variable.field = value; Example: Point p1 = new Point(); Point p2 = new Point(); System.out.println("the x-coord is " + p1.x); // access p2.y = 13; // modify

A class and its client Point.java is not, by itself, a runnable program. A class can be used by client programs. Point.java (class of objects) public class Point { int x; int y; } PointMain.java (client program) public class PointMain { main(String args) { Point p1 = new Point(); p1.x = 7; p1.y = 2; Point p2 = new Point(); p2.x = 4; p2.y = 3; ... } x 7 y 2 x 4 y 3

Instance methods instance method (or object method): Exists inside each object of a class and gives behavior to each object. public type name(parameters) { statements; } Mutator methods Change field values Access methods Returns a result without any change

Mutator method answers public void setLocation(int newX, int newY) { x = newX; y = newY; } public void translate(int dx, int dy) { x = x + dx; y = y + dy; // alternative solution that utilizes setLocation setLocation(x + dx, y + dy);

Accessor method questions Write a method distance that computes the distance between a Point and another Point parameter. Use the formula: Write a method distanceFromOrigin that returns the distance between a Point and the origin, (0, 0).

Accessor method answers public double distance(Point other) { int dx = x - other.x; int dy = y - other.y; return Math.sqrt(dx * dx + dy * dy); } public double distanceFromOrigin() { return Math.sqrt(x * x + y * y);

tells Java how to convert an object into a String The toString method tells Java how to convert an object into a String Point p1 = new Point(7, 2); System.out.println("p1: " + p1); // the above code is really calling the following: System.out.println("p1: " + p1.toString()); Every class has a toString, even if it isn't in your code. Default: class's name @ object's memory address (base 16) Point@9e8c34

toString syntax public String toString() { code that returns a String representing this object; } Method name, return, and parameters must match exactly. Example: // Returns a String representing this Point. return "(" + x + ", " + y + ")";

Constructors constructor: Initializes the state of new objects. public type(parameters) { statements; } runs when the client uses the new keyword no return type is specified; it implicitly "returns" the new object being created If a class has no constructor, Java gives it a default constructor with no parameters that sets all fields to 0.

Constructor example public class Point { int x; int y; // Constructs a Point at the given x/y location. public Point(int initialX, int initialY) { x = initialX; y = initialY; } ...

Multiple constructors A class can have multiple constructors. Each one must accept a unique set of parameters. Exercise: Write a Point constructor with no parameters that initializes the point to (0, 0). // Constructs a new point at (0, 0). public Point() { x = 0; y = 0; }

Common constructor bugs 1. Re-declaring fields as local variables ("shadowing"): public Point(int initialX, int initialY) { int x = initialX; int y = initialY; } This declares local variables with the same name as the fields, rather than storing values into the fields. The fields remain 0. 2. Accidentally giving the constructor a return type: public void Point(int initialX, int initialY) { x = initialX; y = initialY; This is actually not a constructor, but a method named Point

A field that cannot be accessed from outside the class Private fields A field that cannot be accessed from outside the class private type name; Examples: private int id; private String name; Client code won't compile if it accesses private fields: PointMain.java:11: x has private access in Point System.out.println(p1.x); ^

Accessing private state // A "read-only" access to the x field ("accessor") public int getX() { return x; } // Allows clients to change the x field ("mutator") public void setX(int newX) { x = newX; Client code will look more like this: System.out.println(p1.getX()); p1.setX(14);

The this keyword this : Refers to the implicit parameter inside your class. (a variable that stores the object on which a method is called) Refer to a field: this.field Call a method: this.method(parameters); One constructor this(parameters); can call another:

Fixing shadowing Inside setLocation, public class Point { private int x; private int y; ... public void setLocation(int x, int y) { this.x = x; this.y = y; } Inside setLocation, To refer to the data field x, say this.x To refer to the parameter x, say x

Calling another constructor public class Point { private int x; private int y; public Point() { this(0, 0); // calls (x, y) constructor } public Point(int x, int y) { this.x = x; this.y = y; ... Avoids redundancy between constructors Only a constructor (not a method) can call another constructor