JAVA OBJECT-ORIENTED PROGRAMMING

Transcription

1 SE2205B - DATA STRUCTURES AND ALGORITHMS JAVA OBJECT-ORIENTED PROGRAMMING Kevin Brightwell Thursday January 12th, 2017 Acknowledgements:Dr. Quazi Rahman 1 / 36

2 LECTURE OUTLINE Composition Inheritance The Object Class Polymorphism Encapsulation Abstraction Generic Types Useful Interfaces 2 / 36

3 COMPOSITION STUDENT CLASS Defines when an object is made up of ("composed") of other objects public class Student { /** full name of the student, see next slide */ private final Name fullname; /** identification number */ private final String id; public Student(Name studentname, String studentid) { fullname = studentname; id = studentid; public Name getname() { return fullname; public String getid() { return id; 3 / 36

4 COMPOSITION NAME CLASS //This class has been used in the previous slide public class Name{ /** first name */ private String first; /** last name */ private String last; public Name(String firstname, String lastname) { first = firstname; last = lastname; public void setfirst(string firstname) { first = firstname; public void setlast (String lastname) { last = lastname; public String getfullname() { return first + ' ' + last; 4 / 36

5 LECTURE OUTLINE Composition Inheritance The Object Class Polymorphism Encapsulation Abstraction Generic Types Useful Interfaces 5 / 36

6 INHERITANCE Process of sharing code between components (improving DRY) Parent is known as "base," "parent" or "super" class Children are known as "derived" classes Derived classes automatically inherits all components of the parent No-private components are exposed to derived classes protected privacy allows for only derived classes to access a component 6 / 36

7 INHERITANCE 7 / 36

8 INHERITANCE In a derived class, derived constructors must call the super constructor public class Vehicle { // this should be private, protected is usually an anti-pattern protected final String make; public Vehicle(String make) { this.make = make; public class Boat extends Vehicle { private final int length; public Boat(String make, int length) { super(make); this.length = length; 8 / 36

9 INHERITANCE Given the following code: package ca.uwo.a; public class A { private int a; /*default*/ int b; protected int c; public int d; public A() { package ca.uwo.b; public class B extends A { public B() { this.a = 1; this.b = 2; this.c = 3; this.d = 4; Modifier A.a A.b A.c A.d Accessible? 9 / 36

10 INHERITANCE ACCESS MODIFIERS private Only accessible to the class it is defined in default Only accessible to classes within the same package protected Only accessible to classes that are sub-classes of the the declaring class public Accessible to everyone 10 / 36

11 INHERITANCE OVERRIDING METHODS When a subclass defines a method with the same signature of the base class Same name, return type and parameters Objects of the derived class that invoke the method will use the derived method If needed, it is possible to access the base class by using the super keyword in the overriding method 11 / 36

12 public class A { public A() { INHERITANCE public class B extends A { public B() { public int dostring(string value) { return // Required (ish) public int dostring(string value) { int fromsuper = super.dostring(value); return fromsuper + 2; Driver: A a = new A(); System.out.println( "A#doString(\"foo\"): " + a.dostring("foo")); Output: A#doString("foo"): 3 B#doString("foo"): 5 B b = new B(); System.out.println( "B#doString(\"foo\"): " + b.dostring("foo")); 12 / 36

13 INHERITANCE OVERRIDING METHODS super can not be chained, however you can access "higher" classes by specifying the type name: Class.super. Placing in a method signature prevents the method from being overridden. public class A { public A() { public final int dostring(string value) { return value.length(); public class B extends A { public B() // Fails to compile public int dostring(string value) { int fromsuper = super.dostring(value); return fromsuper + 2; 13 / 36

14 INHERITANCE OVERLOADING METHODS Overloading occurs when using the same name, but different parameters The return type must not vary public class A { public int doval(string value) { return value.length(); public int doval(int value) { return value.length(); 14 / 36

15 INHERITANCE MULTIPLE INHERITANCE A class may extend a single parent class C++ allows for multiple inheritance, Java allows this via multiple interfaces 15 / 36

16 LECTURE OUTLINE Composition Inheritance The Object Class Polymorphism Encapsulation Abstraction Generic Types Useful Interfaces 16 / 36

17 THE OBJECT CLASS Every class is descended from java.lang.object Thus, every type has a super class of Object class Foo extends Object { // implicitly // / 36

18 ABSTRACT CLASSES An abstract class is equivalent to a class with virtual methods in C++ Abstract classes define methods that require a subclass to implement them Any method can be abstract, but constructors can not be The keyword, abstract is placed after the modifier for a method, no implementation is provided abstract class AbstractFoo { public AbstractFoo() { class RealFoo extends AbstractFoo { public RealFoo() { super(); // Abstract method: public abstract void public void bar() { 18 / 36

19 INTERFACES An interface is identical to a "purely virtual" class in C++ No methods in an interface are defined All methods in an interface must be public They are implicitly public Interfaces allow for Java's "multiple inheritance" interface IFoo { // implicitly p ublic void foo(); interface IBar { void bar(); class RealFoo implements IFoo, IBar public void foo() public void bar() { 19 / 36

20 LECTURE OUTLINE Composition Inheritance The Object Class Polymorphism Encapsulation Abstraction Generic Types Useful Interfaces 20 / 36

21 POLYMORPHISM Polymorphism is the provision of a single "interface" to entities of different types Inheritance is "subtype" polymorphism When a method is called on a polymorphic type, the actual definition that is called can vary based on the subtype 21 / 36

22 POLYMORPHISM public class A { public int dostring(string value) { return value.length(); public class B extends A public int dostring(string value) { int fromsuper = super.dostring(value); return fromsuper + 2; Driver: A a = new A(); System.out.println( a.dostring("foo")); 3 5 Output: a = new B(); System.out.println( a.dostring("foo")); 22 / 36

23 LECTURE OUTLINE Composition Inheritance The Object Class Polymorphism Encapsulation Abstraction Generic Types Useful Interfaces 23 / 36

24 ENCAPSULATION Hiding the fine detail of a class Also known as "information hiding" Only exposing "required" components Attempt to make things as "private as possible" Keeps interfaces "thin" Only enough information is exposed to use the class 24 / 36

25 LECTURE OUTLINE Composition Inheritance The Object Class Polymorphism Encapsulation Abstraction Generic Types Useful Interfaces 25 / 36

26 ABSTRACTION A process by which a designer asks what instead of why Figure out what a user needs to do, not how it will be implemented Client interface is what Implementation is how 26 / 36

27 ABSTRACTION In Java, most abstraction occurs by creating interfaces and only giving interfaces to clients Interfaces provide well-regulated communication between a hidden implementation and a client 27 / 36

28 ABSTRACTION Specifying methods should include specifying: Precondition Responsibilities of client code Postcondition Specifies conditions of the objects after the method runs These are generally specified via comments Additionally, preconditions are often specified via annotations This allows for static code analysis 28 / 36

29 ABSTRACTION PARAMETER Condition Parameter must not be null Parameter must be positive Docs: jsr / 36

30 ABSTRACTION VERIFYING PRECONDITIONS Google provides a library called Guava Guava has a type called Preconditions After using a static import, the methods can be used to verify preconditions If a condition is not met, these methods will throw NullPointerException or IllegalArgumentException 30 / 36

31 ABSTRACTION VERIFYING PRECONDITIONS import static com.google.common.base.preconditions.*; public class A { // must specify non-null string and i > 10 public void check(@nonnull String value, int i) { checknotnull(value, "value == null"); // NullPointerException checkargument(i > 10, "i <= 10"); // IllegalArgumentException // do something with value and i 31 / 36

32 LECTURE OUTLINE Composition Inheritance The Object Class Polymorphism Encapsulation Abstraction Generic Types Useful Interfaces 32 / 36

33 GENERIC TYPES Generic's are Java's equivalent to C++'s templates Generic's allow types to abstract across different types Java provides an Iterator<T> type, simplified: interface Iterator<T> { boolean hasnext(); T next(); The type, T can be any reference type (non-primitive), e.g. String and Vehicle Generics are used heavily in the Collections framework 33 / 36

34 LECTURE OUTLINE Composition Inheritance The Object Class Polymorphism Encapsulation Abstraction Generic Types Useful Interfaces 34 / 36

35 USEFUL INTERFACES COMPARABLE<T> Comparable<T> defines that a type may be compared to type T Specifying multiple Comparable<T> values allows for comparing against multiple types 35 / 36

36 USEFUL INTERFACES COMPARABLE<T> EXAMPLE class Bar { class Foo implements Comparable<Foo>, Comparable<Bar> { private int v; Foo(int v) { this.v = public int compareto(foo other) { checknotnull(other); // make sure other is not null return Integer.compareTo(this.v, public int compareto(bar other) { return -1; // this always < other 36 / 36