SOFTWARE DEVELOPMENT 1. Objects III 2018W A. Ferscha (Institute of Pervasive Computing, JKU Linz)

Transcription

1 SOFTWARE DEVELOPMENT 1 Objects III 2018W (Institute of Pervasive Computing, JKU Linz)

2 PRINCIPLES OF OO PROGRAMMING Data Abstraction Polymorphism Encapsulation Inheritance Program elements (objects) are changeable, meaning they can be extended restricted redefined abstracted (pool similarities, form classes) polymorphed (the same behavior can be implemented differently) Software Development 1 // 2018W // 2

3 HIERARCHICAL CLASSIFICATION Objects of the real world can be ordered in different categories, e.g. persons, animals, media, bank accounts, It seems obvious to order the world in hierarchical classes. Example: Each car is a motor vehicle, and each motor vehicle is a transport. But there are also trucks that are motor vehicles, and each train, ship or aircraft is also a transport. transport motor vehicle train ship aircraft car truck InterCity tram Software Development 1 // 2018W // 3

4 IDEA: INHERITANCE (VERERBUNG) Both cars and trucks have driver seats and doors, therefore these are properties of the superclass motor vehicle. They also have common behavior, like close door or drive, so these are also part of motor vehicle. But the subclass car also has properties and behaviors of its own, e.g. back seat, trunk, or enter in the back. Trucks have unique properties and behaviors too, e.g. cargo area, trailer or load. Subclasses (like car or truck) include all properties (fields) and behaviors (methods) of their superclass, but may have additional ones. Classes inherit fields (properties) and methods (behavior) of their superclass. Software Development 1 // 2018W // 4

5 INHERITANCE New class B is derived (abgeleitet) from the existing class A B inherits from A or B extends A B is a subclass (Unterklasse, abgeleitete Klasse) of A A is a superclass (Oberklasse) of B A B Relations between A and B B is a subclass of A B is an A (B adopts everything without limitations, conformity) B is a specialization of A (B has unique behavior), or A is generalization of B (A collects common traits) B implements A (B realizes concepts from A) B uses A (technical, B uses code from A) Advantages Common fields and methods only have to be specified once, and are easy to change later on. Software Development 1 // 2018W // 5

6 INHERITANCE IN JAVA; DIAGRAMS class A { type field; type method(... ); field: type A method(...): type class B extends A { type additionalfield; type additionalmethod(... ); Example: public class Person { public String firstname, lastname; public class Student extends Person { public int matriculationnumber; Student inherits the fields firstname and lastname, but they are not mentioned again in the diagrams. B additionalfield: type additionalmethod(...): type Person firstname: String lastname: String Student matriculationnumber: int Software Development 1 // 2018W // 6

7 WHAT IS INHERITED? Subclass inherits all fields and methods, that can be reached: All fields and methods that have been declared public or protected. If the superclass is in the same package, fields and methods without any access modifier are also inherited. Overview of access modifiers: Field/method visible for: public protected default private defining class yes yes yes yes subclass in the same package yes yes yes no subclass in another package yes yes no no different class, same package yes yes yes no different class, other package yes no no no private fields and methods are not inherited. Software Development 1 // 2018W // 7

8 INHERITANCE HIERARCHY Inheriting repeatedly produces an inheritance hierarchy. Example: Person Athlete Student Sports Student Computer Science Student Multiple inheritance: Sports Student inherits from both Athlete and Student. In Java: Multiple inheritance is not allowed. Inheritance hierarchy is a tree with Object as the root class. Interfaces mostly compensate the lack of multiple inheritance. Software Development 1 // 2018W // 8

9 INHERITANCE HIERARCHY :: EXAMPLE 3 account classes: Find common fields and methods and pool them in a single superclass CurrentAccount balance: double interestrate: double owner: Person overdraw: double CurrentAccount( owner: Person, overdraw: double) getbalance(): double deposit(amount: double) withdraw(amount: double) TimeAccount balance: double interestrate: double owner: Person runtime: int TimeAccount( owner: Person, runtime: int) getbalance(): double deposit(amount: double) withdraw(amount: double) SavingsAccount balance: double interestrate: double owner: Person mindeposit: int SavingsAccount( owner: Person, mindeposit: int) getbalance(): double deposit(amount: double) withdraw(amount: double) Software Development 1 // 2018W // 9

10 INHERITANCE HIERARCHY :: EXAMPLE Account balance: double interestrate: double owner: Person getbalance(): double deposit(amount: double) withdraw(amount: double) CurrentAccount overdraw: double CurrentAccount( owner: Person, overdraw: double) runtime: int TimeAccount TimeAccount( owner: Person, runtime: int) SavingsAccount mindeposit: int SavingsAccount( owner: Person, mindeposit: int) Software Development 1 // 2018W // 10

11 INHERITANCE HIERARCHY :: EXAMPLE public class Account { protected double balance; protected double interestrate; protected Person owner; public double getbalance() { return balance; No Constructor! Compiler generates default- Constructor, that initializes all fields with 0, null, Account balance: double interestrate: double owner: Person getbalance(): double deposit(amount: double) withdraw(amount: double) public boolean deposit(double amount) { balance += amount; return true; Methods to deposit or withdraw money. If the transfer was successful, return true. public boolean withdraw(double amount) { balance -= amount; return true; SWE1.07 / at / jku / pervasive / swe1 / vo7 / Account.java Software Development 1 // 2018W // 11

12 INHERITANCE HIERARCHY :: EXAMPLE public class CurrentAccount extends Account { private double overdraw; Superclass if specified with keyword extends. public CurrentAccount(Person owner, double overdraw) { this.owner = owner; this.overdraw = overdraw; interestrate = 2.0; balance = 0.0; New Constructor. Default-Constructor will not be generated! Account CurrentAccount overdraw: double CurrentAccount( owner: Person, overdraw: double) public boolean withdraw(double amount) { if (getbalance()-amount > overdraw) return super.withdraw(amount); else return false; Method withdraw is being overwritten. More on that later. SWE1.07 / at / jku / pervasive / swe1 / vo7 / CurrentAccount.java Software Development 1 // 2018W // 12

13 INHERITANCE HIERARCHY :: EXAMPLE public class TimeAccount extends Account { Account private int runtime; public TimeAccount(Person owner, int runtime) { this.owner = owner; this.runtime = runtime; interestrate = 4.0; balance = 0.0; Private field runtime is only visible within this class, not even in subclasses. Inherited fields from superclass Account are visible. They were declared protected. runtime: int TimeAccount TimeAccount( owner: Person, runtime: int) SWE1.07 / at / jku / pervasive / swe1 / vo7 / TimeAccount.java Software Development 1 // 2018W // 13

14 INHERITANCE HIERARCHY :: EXAMPLE public class SavingsAccount extends Account { Account private int mindeposit; public SavingsAccount(Person owner, int mindeposit) { this.owner = owner; this.mindeposit = mindeposit; interestrate = 3.0; balance = 0.0; Method deposit is being overwritten. More on that later. SavingsAccount mindeposit: int SavingsAccount( owner: Person, mindeposit: int) public boolean deposit(double amount) { if (amount > mindeposit) return super.deposit(amount); else return false; SWE1.07 / at / jku / pervasive / swe1 / vo7 / SavingsAccount.java Software Development 1 // 2018W // 14

15 ALLOWED OBJECT ASSIGNMENTS Account Person me =..., you =...; CurrentAccount TimeAccount SavingsAccount CurrentAccount mycurrentaccount; SavingsAccount mysavingsaccount; Account myaccount, youraccount; mycurrentaccount = new CurrentAccount(me, -500); mysavingsaccount = new SavingsAccount(me, 100); myaccount = mycurrentaccount; myaccount youraccount Account mycurrentaccount mysavingsaccount CurrentAccount SavingsAccount :CurrentAccount owner: Person = me overdraw = -500 :SavingsAccount owner: Person = me mindeposit = 100 Software Development 1 // 2018W // 15

16 ALLOWED OBJECT ASSIGNMENTS Account youraccount = new SavingsAccount(you, 80); CurrentAccount TimeAccount SavingsAccount //invalid: mycurrentaccount = mysavingsaccount; //invalid: mycurrentaccount = new SavingsAccount(me, 50); // assume that creating Account makes sense: myaccount = new Account(); //invalid: mycurrentaccount = myaccount; Account myaccount :Account owner = null... mycurrentaccount CurrentAccount :CurrentAccount owner: Person = me overdraw = -500 SavingsAccount Software Development 1 // 2018W // 16 youraccount mysavingsaccount :SavingsAccount owner: Person = me mindeposit = 100 :SavingsAccount owner: Person = you mindeposit = 80

17 TYPE CONVERSION OF OBJECTS Account Each CurrentAccount / SavingsAccount object is also an Account object: CurrentAccount TimeAccount SavingsAccount Therefore myaccount = mycurrentaccount; is a legal assignment. The actual object that is bound to a reference does not necessarily have to be exactly of the class the reference was declared with: It can also be of any subclass. The object is polymorph. But not every Account object is a CurrentAccount object: mycurrentaccount = myaccount; may be valid, but does not have to be! If the object referenced by myaccount is of class CurrentAccount, then the assignment is valid. If it is a SavingsAccount object, it is not! Compiler can not know of which class an object is before running the application, therefore such an assignment will produce a runtime error. Software Development 1 // 2018W // 17

18 TYPE CONVERSION OF OBJECTS Account CurrentAccount TimeAccount SavingsAccount General classes (superclasses) can be converted to specialized classes (subclasses) with a type cast: myaccount = mycurrentaccount; mycurrentaccount = (CurrentAccount)myAccount; This leads to a type check of the referenced object at runtime. If we try to convert to a class that is not valid for the referenced object, a runtime error is generated: mysavingsaccount = (SavingsAccount)myAccount; Exception in thread "main" java.lang.classcastexception: CurrentAccount cannot be cast to SavingsAccount at Account.main(Account.java:43) To check if an object is an instance of a specific class, or any subclass of this class, there is the instanceof-operator: if (myaccount instanceof SavingsAccount) mysavingsaccount = (SavingsAccount)myAccount; Software Development 1 // 2018W // 18

19 THE CLASS OBJECT If there is no explicit superclass (no extends ), then Java always assumes extends Object! Object is the superclass of all classes, the root of the class hierarchy. Some methods of Object should be overwritten appropriately: public String tostring() This method should always return a useful textual representation of the object. E.g. the println method will use tostring to convert objects to text. public boolean equals(object obj) Compares with the parameter for equality. The default implementation will just compare the references. protected Object clone() Returns an identical copy of this object. Take a look at the Java API documentation for more methods of Object. Software Development 1 // 2018W // 19

20 KEYWORD super Similar to the way this references fields, methods and constructors of the current object and class, super is used to access members of the superclass. class A { x is newly declared. A.x and B.x are different fields! int x; public A() { x = 1; class B extends A { int x; public B(int newx) { x = newx; Assign a value to B.x. If we do not explicitly call a super constructor, the default super constructor A() is called at the beginning. class C extends B { int x; public C(int x) { super(3); this.x = x; super.x += 5; ((A)this).x += 5; Call constructor of B with parameter 3; this needs be done at the beginning! x... parameter x this.x... object field of C super.x... object field of B ((A)this).x... object field of A Software Development 1 // 2018W // 20

21 OVERWRITING METHODS Methods may be newly declared in sub classes, which is called overwriting: The new method replaces the overwritten method in all subclasses. Overwritten methods can still be called with the super keyword. Watch out: Overwrite (Überschreiben) Overload (Überladen) class A { int x; public void greetme() { System.out.println("A greets you."); class B extends A { int x; public void greetme() { System.out.println("B greets you."); super.greetme(); Call method A.greetMe(). Software Development 1 // 2018W // 21

22 OVERWRITING METHODS There is an important difference between overwritten methods and fields: Which field is accessed depends on the type of the reference. Which method is called depends on the type of the referenced object. If the reference is casted, different fields are accessed, but the same method is called. class A { int x; public void greetme() { System.out.println("A greets you."); class B extends A { int x; public void greetme() { System.out.println("B greets you."); A mya = new B(); mya.x = 1; // A.x = 1 ((A)myA).x = 2; // A.x = 2 ((B)myA).x = 3; // B.x = 3 mya.greetme(); // output: B greets you. ((A)myA).greetMe(); // output: B greets you. ((B)myA).greetMe(); // output: B greets you. Software Development 1 // 2018W // 22

23 METHOD SELECTION AND BINDING Each object has its method table with all declared methods, bound by one of the two following methods: Static binding (early binding) The method is bound by the compiler during compilation. Dynamic binding (late binding) If methods are overwritten in subclasses, the compiler can no longer decide during compilation, which method needs to be called. This depends on the referenced object (type unknown during compilation), not the reference (type known). Therefore the correct method (with the correct method signature) is chosen during runtime from the method table. Software Development 1 // 2018W // 23

24 SELECTION OF METHODS 1. step - static binding: Preparation during compilation 1.1 Search for the correct method declaration belonging to the method call (check method identifier and signature) 1.2 Check access permission (depends on access modifiers in declaration) 1.3 Decide on call method: nonvirtual (static binding), if private, static or final virtual (dynamic binding) otherwise 2. step - dynamic binding: Final binding during runtime 2.1 Find target object on which the method is called 2.2 Decide on the method that needs to be called if nonvirtual: there is only one method, use this one if virtual: search for the first method with matching signature start search at class of the target object if no method matches, continue with superclass... Software Development 1 // 2018W // 24

25 EXAMPLE: INHERITANCE Overload constructor subsidy() returns the amount of subsidy a person gets. Constructors are not inherited! They need to be redeclared in each subclass. Overwrite subsidy() Person firstname: String lastname: String birthdate: Date Person(firstName: String,...) Person(p: Person) age(): int subsidy(): int studentid: int branch: String Student Student(firstName: String,...) Student(p: Person) Student(s: Student) subsidy(): int Overwrite subsidy() again income: int Tutor Tutor(firstName: String,...) Tutor(s: Student, income: int) subsidy(): int

26 EXAMPLE :: INHERITANCE public class Person { public String firstname, lastname; // name of person public Date birthdate; // date of birth public Person(String firstname, String lastname, int day, int month, int year) { this.firstname = firstname; this.lastname = lastname; birthdate = new Date(day, month, year); public Person(Person p) { // alternative constructor this(p.firstname, p.lastname, p.birthdate.day, p.birthdate.month, p.birthdate.year); public int age() { // get age of person int thisyear = Calendar.getInstance().get(Calendar.YEAR); return thisyear - birthdate.year; Overload constructor (same name and class, but different signature) public int subsidy() { // usually no subsidy is granted return 0; SWE1.07 / at / jku / pervasive / swe1 / vo7 / Person.java Software Development 1 // 2018W // 26

27 EXAMPLE :: INHERITANCE public class Student extends Person { // unique id number for next student static private int nextstudentid = ; Static field (class field) public int studentid; // unique student id number (e.g. matrikelnummer) public String branch; // study branch (e.g. "computer science") public Student(String firstname, String lastname, int day, int month, int year, String branch) { super(firstname, lastname, day, month, year); // call super constr. studentid = nextstudentid++; // assign new student id this.branch = branch; public Student(Student s) { super(s); // call super constructor studentid = nextstudentid++; // assign new student id this.branch = s.branch; Overwrite method (same name and signature, but in subclass) public int subsidy() { // students get subsidy if younger than 26 return age() < 26? 150 : 0; SWE1.07 / at / jku / pervasive / swe1 / vo7 / Student.java Software Development 1 // 2018W // 27

28 EXAMPLE :: INHERITANCE public class Tutor extends Student { public int income; // income of tutor public Tutor(String firstname, String lastname, int day, int month, int year, String branch, int income) { super(firstname, lastname, day, month, year, branch); this.income = income; public Tutor(Student s, int income) { super(s); this.income = income; Call subsidy() method from superclass Student public int subsidy() { // a tutors subsidy is reduced by his income // (but never negative) return Math.max(0, super.subsidy() - income); SWE1.07 / at / jku / pervasive / swe1 / vo7 / Tutor.java Software Development 1 // 2018W // 28

29 EXAMPLE :: INHERITANCE // test operations public static void main(string[] args) { Person p; Student s; Tutor t; p = new Person("Theo", "Kopetzky", 18, 9, 1976); s = new Student("Julia", "Maus", 29, 2, 1990, "CS"); t = new Tutor("Monika", "Hecht", 27, 3, 1991, "CS", 100); t = new Tutor(s, 120); s = null; // student becomes tutor p is of type Person and references a Person-object ("Theo") System.out.println(p.firstName + " gets: " + p.subsidy()); p = t; System.out.println(p.firstName + " gets: " + p.subsidy()); p is of type Person and references a Tutor-object ( Monika"). System.out.println(t.income); The method Tutor.subsidy() is called! if (p instanceof Tutor) System.out.println(((Tutor)p).income); t = (Tutor)p; SWE1.07 / at / jku / pervasive / swe1 / vo7 / Tutor.java Software Development 1 // 2018W // 29

30 KEYWORD final To declare fields, methods or classes as being immutable / unchangeable, state the final modifier in the declaration. Global Variables / Static Fields: Values may be assigned only once, directly with the declaration or in a static block. After that the value can never be changed (constant). According to the Java naming conventions, constant names should be in upper case, with underscores (_) to separate words. final static double PI = 3.14; Typical constants final static String THE_ANSWER = "42"; final static String[] NUMBERS = {"Zero", "One", "Two";... NUMBERS[1] = "ONE"; Warning: It is allowed to declare constants with complex data types (arrays or objects). Constant is in this case only the reference, it is not allowed to assign a different object. The object fields are not final and may be changed anytime. This assignment is therefore valid! Software Development 1 // 2018W // 30

31 KEYWORD final Object fields, parameters or local variables: Value is assigned once with the declaration, in the constructor or in the current code block. It can not be changed afterwards as long as it is valid, but fields can be different for each object instance or local variables / parameters for each method call. Using final can prevent a lot of programming errors. class Circle { final double radius; final double area; Circle(double radius) { this.radius = radius; this.area = radius * radius * Math.PI; Values may be assigned directly with the declaration or in the constructor, like here. The value will stay constant for the full object life time. static double cf(final double r) { return 2 * r * Math.PI; Parameters and local variables can also be declared as final. They will stay constant for each method call. Software Development 1 // 2018W // 31

32 KEYWORD final Methods: Final methods can not be overwritten. public final int getbalance() {... Classes: Prevents any further subclasses. Extending a final class is prohibited. public final class CurrentAccount extends Account {... All methods and fields of a final class are implicitly also final (e.g. see java.lang.string). Use final methods and classes only if necessary. It is often difficult to predict in advance why and how a class is extended later on. Software Development 1 // 2018W // 32

33 ABSTRACT METHODS AND CLASSES Problem: 2 kinds of persons: workers and employees. From both we want to get their income through a uniform interface, but it is calculated differently: Member {abstract firstname: String lastname: String getincome(): int {abstract Worker workhours: int hourincome: int getincome(): int Employee baseincome: int locationbonus: int getincome(): int We introduce the superclass Member with the common fields and methods. But since there are no actual persons / objects of the class Member, implementing the method would not make sense. Solution: The method getincome() is declared as abstract Abstract methods only have a method signature, but no body. Software Development 1 // 2018W // 33

34 ABSTRACT METHODS AND CLASSES public abstract class Member { public String firstname, lastname; public abstract int getincome(); Abstract class with method signature public class Worker extends Member { public int workhours, hourincome; public int getincome() { return workhours * hourincome; public class Employee extends Member { public int baseincome, locationbonus; 2 different implementations of getincome() public int getincome() { return baseincome + locationbonus; Software Development 1 // 2018W // 34 SWE1.07 / at / jku / pervasive / swe1 / vo7 / Member.java SWE1.07 / at / jku / pervasive / swe1 / vo7 / Worker.java SWE1.07 / at / jku / pervasive / swe1 / vo7 / Employee.java

35 ABSTRACT METHODS AND CLASSES // test operations public static void main(string[] args) { Member[] department = new Member[4]; References of abstract superclass Member department[0] = new Worker(); // 1.Member department[1] = new Employee(); // 2.Member department[2] = new Employee(); // 3.Member department[3] = new Employee(); // 4.Member New instances of Worker and Employee objects. It is impossible to instantiate Member objects! int sum = 0; // sum up all incomes for (int i = 0; i < department.length; i++) sum += department[i].getincome(); Retrieve income through common interface. Software Development 1 // 2018W // 35

36 ABSTRACT METHODS AND CLASSES An abstract method is not implemented (has no method body), it is a blueprint for derived methods. A class has to be declared abstract if any of its methods is abstract. It is allowed to declare classes as abstract, although there are no abstract methods. An abstract class can have both abstract and actual (non-abstract) subclasses. It is not possible to instantiate an abstract class, to create new objects of this class. Only objects of non-abstract subclasses can be created. Abstract methods have to be implemented in non-abstract subclasses, or the subclass has to be declared abstract itself. Software Development 1 // 2018W // 36

37 THE JAVA-MAIN METHOD :: ENTRY-POINT FOR PROGRAM EXECUTION In the Java programming language, every application must contain a main method, arbitrary placed, whose signature is: class Program { //previous methods public static void main(string[] args) { // Code in the method //following methods Modifier Return type Argument public and static can be written in either order (public static or static public), but the convention is to use public static as shown above. void see next slide The argument can be named anything you want, but most programmers choose "args" or "argv". (Runtime System passes info to the Application: java MyApp arg1 arg2) Software Development 1 // 2018W // 37

38 THE JAVA-MAIN METHOD :: ENTRY-POINT FOR PROGRAM EXECUTION Return type void of main() (Java Specification): The method main must be declared public, static, and void. It must accept a single argument that is an array of strings. A program terminates all its activity and exits when one of two things happens: All the threads that are not daemon threads terminate. Some thread invokes the exit method of class Runtime or class System and the exit operation is not forbidden by the security manager. A Java program may exit before or after the main method finishes. A return value from main would therefore be meaningless. If you want the program to return a status code, call one of the following methods (note: all three methods never return normally): System.exit(int status),runtime.exit(int status),runtime.halt(int status) Software Development 1 // 2018W // 38

39 INTERFACES Interface can be seen as fully abstract classes: Contain only abstract methods or constants. There are no actual instructions. Specify only the behavior of an object, not how it is actually implemented. Interfaces can not be instantiated. Interfaces are declared with the keyword interface instead of class, and are included in a class with implements instead of extends. Interfaces allow multiple inheritance in Java: A class may implement several interfaces. They are not an inheritance mechanism in the OO sense. Example: interface Comparable { int compareto(object o); <<interface>> Comparable compareto(object o): int Software Development 1 // 2018W // 39

40 INTERFACES :: MOTIVATION Motivation for using interfaces: To separate specification and implementation. Allows multiple inheritance. Behavior is known, but the implementation is not: An interface just specifies what a method does, not how it is done. To allow multiple, competing implementations. The basic properties are defined through the method signatures. The method signature defines its input-/output behavior: the input parameters and the return type. Interfaces can be used without knowing anything about the actual implementation (encapsulation). Software Development 1 // 2018W // 40

41 INTERFACES :: MULTIPLE INHERITANCE Multiple inheritance = a class has several superclasses Person Athlete Student Sports Student Computer Science Student Problem: What to do if names conflict? Solution: Multiple inheritance in Java not allowed, a class may only extend exactly one superclass. But: Interfaces can be used instead. Software Development 1 // 2018W // 41

42 INTERFACES Declaration: interface InterfaceName { Constants&MethodDeclarations Interface can also inherit from other interfaces (but not classes!): interface InterfaceName extends SuperInterface {... Implementation of interfaces in a class: class ClassName extends SuperClass implements Interface1, Interface2,... {... If the class does not implement all of the methods in the interface, the class needs to be declared as abstract. Software Development 1 // 2018W // 42

43 INTERFACES class B extends A implements I {... References to objects of class B can have the following data types: Class B B myb = new B(); Class A, of which B inherits A mya = (A)myB; Interface I, that B implements I myi = (I)myB; Superclasses of A, I Object myo = (Object)myB; All interface-methods are implicitly public and abstract. public, because interface methods need to be known. abstract, because interfaces do not implement the methods. All interface-fields are implicitly public, static and final Since interface can not be instantiated, fields can only be constants (static and final). Software Development 1 // 2018W // 43

44 INTERFACES :: EXAMPLE Accounting application in a corner shop: Sells different kinds of goods, e.g. food, toys, books. All goods have a description and a price. Some wares have additional properties, e.g. food has a calories information, toys have a minimum age, books have an author. Value-added tax: Food is excluded, for toys and books there are taxes. For all goods with taxes we have a tax rate and a formula to calculate the tax. Software Development 1 // 2018W // 44

45 INTERFACES :: EXAMPLE Goods is the common superclass (could also be done as abstract class) Goods description: String price: double Goods(...) display() Taxable is an interface and defines the properties and methods of all taxable goods. <<interface>> Taxable taxrate: double = 0.06 calculatetax(): double Food calories: double Food(...) display() Toy minage: int Toy(...) display() Book author: String Book(...) display() Only Toy and Book implement the interface Taxable Software Development 1 // 2018W // 45

46 INTERFACES :: EXAMPLE public class Goods { String description; double price; Base class for all goods Goods(String description, double price) { this.description = description; this.price = price; void display() { System.out.println("item: " + description); System.out.println("price: " + price); SWE1.07 / at / jku / pervasive / swe1 / vo7 / Goods.java Software Development 1 // 2018W // 46

47 INTERFACES :: EXAMPLE public class Food extends Goods { double calories; Additional field. Food(String description, double price, double calories) { super(description, price); this.calories = calories; void display() { super.display(); System.out.println("calories: " + calories); Add more output details. SWE1.07 / at / jku / pervasive / swe1 / vo7 / Food.java Software Development 1 // 2018W // 47

48 INTERFACES :: EXAMPLE public interface Taxable { double taxrate = 0.06; double calculatetax(); Interface declaration taxrate is implicitly static and final Method declaration (no Implementation) SWE1.07 / at / jku / pervasive / swe1 / vo7 / Taxable.java Software Development 1 // 2018W // 48

49 INTERFACES :: EXAMPLE public class Toy extends Goods implements Taxable { int minimumage; public Toy(String description, double price, int minimumage) { super(description, price); this.minimumage = minimumage; void display() { super.display(); System.out.println("minimum Age: " + minimumage); public double calculatetax() { return price * taxrate; Implement the method calculatetax() taxrate is implicitly static and final SWE1.07 / at / jku / pervasive / swe1 / vo7 / Toy.java Software Development 1 // 2018W // 49

50 INTERFACES :: EXAMPLE public class Book extends Goods implements Taxable { String author; public Book(String description, double price, String author) { super(description, price); this.author = author; void display() { super.display(); System.out.println("Author: " + author); public double calculatetax() { return price * taxrate; Implementation of method calculatetax(). We could also implement a different formula here. SWE1.07 / at / jku / pervasive / swe1 / vo7 / Book.java Software Development 1 // 2018W // 50

51 INTERFACES :: EXAMPLE public static void main(string[] args) { Goods[] inventory = { new Goods("Bubble Bath", 1.40), new Food("Steak", 4.45, 1500), new Book("Frost", 24.95, "Bernhard"), new Toy("Lego", 54.45, 8), new Food("Banana", 1.20, 500), new Toy("Ball", 3.90, 0) ; Create an array with different goods. Output all our goods. for (int i = 0; i < inventory.length; i++) { inventory[i].display(); if (inventory[i] instanceof Taxable) { Taxable invtax = (Taxable)inventory[i]; System.out.println("Tax: " + invtax.calculatetax()); Software Development 1 // 2018W // 51 To avoid the additional reference invtax: System.out.println("Tax: " + ((Taxable)inventory[i]).calculateTax()); If it is a taxable item, show tax too. SWE1.07 / at / jku / pervasive / swe1 / vo7 / Goods.java

52 SOFTWARE DEVELOPMENT 1 Objects III 2018W (Institute of Pervasive Computing, JKU Linz)