Basic Object Oriented Concepts CS 3340 The goals

Basic Object. Oriented Concepts CS 3340

The goals of OOP • • Objectives: modular programming. reusable code/modules. inheritance. can define interfaces 2

OOP Conceptual • • • Abstraction Encapsulation Information Hiding Polymorphism Hierarchy Implementation • • Class Object Inheritance Interface 3

Abstraction • "Extracting the essential details about an item or group of items, while ignoring the unessential details. “ • model defines an abstract view to the problem. 4

Example of Abstraction Example: Administration of employees in an institution. • Description: The head of the administration comes to you and ask you to create a program which allows to administer the employees. Well, this is not very specific. For example, what employee information is needed by the administration? What tasks should be allowed? • • Solution: Employees are real persons who can be characterized with many properties; very few are: name, size, date of birth, shape, social number, room number, hair color, hobbies. • Not all of these properties are necessary to solve the administration problem. Only some of them are problem specific. Consequently you create a model of an employee for the problem. This model only implies properties which are needed to fulfill the requirements of the administration, for instance name, date of birth and social number. • These properties are called the data of the (employee) model. Now you have described real persons with help of an abstract employee. 5

Levels of Abstraction- highest • "Community of Objects that must interact in order to achieve their common goal" GOAL: Make sure you have a good design for Abstraction at the Highest level. 6

Mid-level Abstraction • Grouping of Objects working together into a single unit 7

Low level abstraction • Deals with an action/method inside of a Class. 8

Upstream/Downstream Abstraction • Downstream o Creation of Children Classes to further abstract related class details. o When not to do downstream abstraction • when abstracting based on a range of values e. g. height in People. Should you split People into Tall, Medium and Short subclasses? o If it is functional more usefull to have AND o They values are treated differently • when abstracting based on a limited set of values e. g. People has attribute gender. . . should we split into subclasses Male, Female? • Upstream o The idea here is we have a class (or classes) that we create a parent for. o Often not a good idea as used by programmers to fix a design flaw. o Consider creating a interface before the creation of a real super-class. 9

Techniques to achieve abstraction • Division into parts , “has-a” • Division into specialization, “is-a” • Multiple views 10

division into parts – “has-a” • Goal: By "Divide and Conquer" type technique we try to take apart the item under examination into its constituent parts. • sometimes this process is referred to as "has-a". . . like "a car has a engine". 11

division into specializations – “is-a” • Goal: By "Divide and Conquer" type technique we try to break down into more and more specialized units. • sometimes referred to as "is-a" abstraction. . . . A car is a vehicle. 12

Multiple Views • Goal: By creating "multiple views" of the same item, you can uncover essential details. • How does driver view a car? • How does a passenger view a car? • How about a mechanic? • and the designer? • the manufacuter? 13

Encapsulation • Enclosing all parts of an abstraction within a container • Protects access to the encapsulated (hidden) data or operation • Increases modularity. Language Specific Most languages like Java have a "protection type" that can be applied to data and operations. Publish access operations so users of a class are encoraged to use these and not directly/access data. get. X(), set. X() operations. In Java: Can do information hidding with protection type declarations of private, public, protected, package protected. 14

Information Hiding • Hiding parts of the abstraction • Example: Leaf class –only access the data through operations/methods 15

Polymorphism • made possible by inheritance in which a name denotes instances of many different classes, as long as they are related by a common super-class. Example: public void paint() { Iterator it = shapes. iterator(); while (it. has. Next()) { // polymorphism: shape can refer to squares, //circles, triangles, etc. Shape shape = (Shape)shapes. next(); shape. draw(); } } 16

Are there better forms of polymorphism? • a = BAD, an Account can have either Person OR Corporation associated with it. Violates encapsulation • b = GOOD, Use polymorphism via inheritance to represent the disjunction. 17

Inheritance • A class inherits state and behavior from its superclass. • powerful and natural mechanism for organizing & structuring software programs. 18

Concept: Classes are like Abstract Data Types • An Abstract Data Type (ADT) bundles together: o some data, representing an object or "thing" o the operations on that data • The operations defined by the ADT are the only operations permitted on its data • Example: a Checking. Account, with operations deposit, withdraw, get. Balance, etc. • Classes enforce this bundling together o If all data values are private, a class can also enforce the rule that its defined operations are the only ones permitted on the data 19

Example of a class Employee { // Fields private String name; //Can get but not change private double salary; // Cannot get or set // Constructor Employee(String n, double s) { name = n; salary = s; } // Methods void pay () { System. out. println("Pay to the order of " + name + " $" + salary); } public String get. Name() { return name; } // getter } 20

Approximate Terminology • • instance = object field = instance variable method = operation = class function sending a message to an object = calling a method 21

Inheritance • a mechanism that enables one class to inherit all the behaviors and attributes of another class. • subclass = a class that inherits from another class. • superclass = a class that is its inheritance to another class. 22

More on inheritance • Note: Subclasses can override methods they have inherited if they want to change the corresponding behavior. For example, the method to calculate the Expected Lifespan for each Class of Dog, Cat, and Horse may be different from their superclass Four. Legged Animal. 23

Inheritance: Classes form a hierarchy • Classes are arranged in a treelike structure called a hierarchy • Every class may have one or more subclasses 24

Another Example of a hierarchy—this one dealing with windows Container Panel Scroll. Pane Window Dialog Frame File. Dialog A File. Dialog is a Window is a Container 25

Concept: Objects inherit from superclasses • A class describes fields and methods • Objects of that class have those fields and methods • But an object also inherits: o the fields described in the class's superclasses o the methods described in the class's superclasses • A class is not a complete description of its objects! 26

Example of inheritance class Person { String name; int age; void birthday () { age = age + 1; } } class Employee extends Person { double salary; void pay () {. . . } } Every Employee has name and age fields and birthday method as well as a salary field and a pay method. 27

Concept: Objects must be created • int n; does two things: o It declares that n is an integer variable o It allocates space to hold a value for n o For a primitive, this is all that is needed • Employee secretary; also does two things o It declares that secretary is type Employee o It allocates space to hold a reference to an Employee o For an object, this is not all that is needed • secretary = new Employee ( ); o This allocate space to hold a value for the Employee o Until you do this, the Employee is null 28

Notation: How to declare and create objects Employee secretary; // declares secretary = new Employee (); // allocates space Employee secretary = new Employee(); // does both • But the secretary is still "blank" (null) secretary. name = "Adele"; // dot notation secretary. birthday (); // sends a message 29

Notation: How to reference a field or method • Inside a class, no dots are necessary class Person {. . . age = age + 1; . . . } • Outside a class, you need to say which object you are talking to if (john. age < 75) john. birthday (); • If you don't have an object, you cannot use its fields or methods! 30

Concept: this object • Inside a class, no dots are necessary, because o you are working on this object • If you wish, you can make it explicit: class Person {. . . this. age = this. age + 1; . . . } • this is like an extra parameter to the method • You usually don't need to use this 31

Concept: A variable can hold subclass objects • Suppose B is a subclass of A o o A objects can be assigned to A variables B objects can be assigned to B variables B objects can be assigned to A variables, but A objects can not be assigned to B variables • Every B is also an A but not every A is a B • You can cast: b. Variable = (B) a. Object; o In this case, Java does a runtime check 32

Example: Assignment of subclasses class Dog {. . . } class Poodle extends Dog {. . . } Dog my. Dog; Dog rover = new Dog (); Poodle your. Poodle; Poodle fifi = new Poodle (); my. Dog = rover; your. Poodle = fifi; my. Dog = fifi; your. Poodle = rover; your. Poodle = (Poodle) rover; // ok //ok // illegal //runtime check 33

Concept: Methods can be overridden class Bird extends Animal { void fly (String destination) { location = destination; } } class Penguin extends Bird { void fly (String whatever) { } } • So birds can fly. Except penguins. 34

Concept: Don't call functions, send messages Bird some. Bird = pingu; some. Bird. fly ("South America"); • Did pingu actually go anywhere? o You sent the message fly(. . . ) to pingu o If pingu is a penguin, he ignored it o Otherwise he used the method defined in Bird • You did not directly call any method o You cannot tell, without studying the program, which method actually gets used o The same statement may result in different methods being used at different times 35

Sneaky trick: How to use overridden methods class Family. Member extends Person { void birthday () { // override birthday() in Person super. birthday (); // call overridden method give. Present (); // and add your new stuff } } 36

Concept: Constructors make objects • Every class has a constructor to make its objects • Use the keyword new to call a constructor secretary = new Employee ( ); • You can write your own constructors; but if you don’t, • Java provides a default constructor with no arguments o It sets all the fields of the new object to zero o If this is good enough, you don’t need to write your own • The syntax for writing constructors is almost like that for writing methods 37

• Syntax for constructors Do not use a return type and a name; use only the class name • You can supply arguments Employee (String the. Name, double the. Salary) { name = the. Name; salary = the. Salary; } 38

Trick: Give field and parameter the same name • A parameter overrides a field with the same name • But you can use this. name to refer to the field • class Person { String name; int age; Person (String name, int age) { this. name = name; this. age = age; } } • Using the same name is a common and useful convention 39

Internal workings: Constructor chaining • If an Employee is a Person, and a Person is an Object, then when you say new Employee () o o o The Employee constructor calls the Person constructor The Person constructor calls the Object constructor The Object constructor creates a new Object The Person constructor adds its own stuff to the Object The Employee constructor adds its own stuff to the Person 40

The case of the vanishing constructor • If you don't write a constructor for a class, Java provides one (the default constructor) o The one Java provides has no arguments • If you write any constructor for a class, Java does not provide a default constructor • Adding a perfectly good constructor can break a constructor chain • You may need to fix the chain 41

Example: Broken constructor chain class Person { String name; Person (String name) { this. name = name; } } class Employee extends Person { double salary; Employee ( ) { super(); salary = 12. 50; } } Java tries to execute an implicit super() at this point • cannot resolve symbol – constructor Person() 42

• Fixing a broken constructor chain Special syntax: super(. . . ) calls the superclass constructor • When one constructor calls another, that call must be first class Employee { double salary; Employee (String name) { super(name); // must be first salary = 12. 50; } } • Now you can only create Employees with names • This is fair, because you can only create Persons with names 43

Trick: one constructor calling another • this(. . . ) calls another constructor for this same class Something { Something (int x, int y, int z) { // do a lot of work here } Something ( ) { this (0, 0, 0); } } • It is poor style to have the same code more than once • If you call this(. . . ), that call must be the first thing in your constructor 44

Concept: You can control access class Person { public String name; private String age; protected double salary; public void birthday { age++; } } • Each object is responsible for its own data • Access control lets an object protect its data and its methods • Access control is the subject of a different lecture 45

Concept: Classes can have fields and methods • Usually a class describes fields (variables) and methods for its objects (instances) o These are called instance variables and instance methods • A class can have its own fields and methods o These are called class variables and class methods • There is exactly one copy of a class variable, not one per object • Use the special keyword static to say that a field or method belongs to the class instead of to objects 46

Example of a class variable class Person { String name; int age; static int population; Person (String name) { this. name = name; this. age = 0; population++; } } 47

Advice: Restrict access • Always, always strive for a narrow interface • Follow the principle of information hiding: o the caller should know as little as possible about how the method does its job o the method should know little or nothing about where or why it is being called • Make as much as possible private • Your class is responsible for it’s own data; don’t allow other classes to screw it up! 48

Advice: Use setters and getters class Employee extends Person { private double salary; private boolean male; public void set. Salary (double new. Salary) { salary = new. Salary; } public double get. Salary () { return salary; } public boolean is. Male() { return male; } } • This way the object maintains control • Setters and getters have conventional names: set. Data. Name, get. Data. Name, is. Data. Name (booleans only) 49

Kinds of access • Java provides four levels of access: o public: available everywhere o protected: available within the package (in the same subdirectory) and to all subclasses o [default]: available within the package o private: only available within the class itself • The default is called package visibility • In small programs this isn't important. . . right? 50

From Budd Book on OOP 1. Everything is an Object (in pure OOP) 2. Computation is done via Objects Communicating with each other by requesting objects to perform actions. At some point at least a few object need to perform some work besides passing on requests to other objects/agents. 3. Each Object has its own memory (and in pure OOP consists of other objects) 4. Every object is an instance of a class. 5. A Class is a repository for behavior associated with an object and the kind of information stored in an instances memory. 6. Classes are organized into a single rooted tree structure. Memory and behavior of an instance of a class is automatically available (inheritance) to 51 any class associated with a descendant.