Interfaces CSC 123 Fall 2018 Howard Rosenthal

Size: px

Start display at page:

Download "Interfaces CSC 123 Fall 2018 Howard Rosenthal"

Samantha Hicks
5 years ago
Views:

1 Interfaces CSC 123 Fall 2018 Howard Rosenthal

2 Lesson Goals Defining an Interface How a class implements an interface Using an interface as a data type Default interfaces Implementing multiple interfaces Extending an interface Functional interfaces and lambda expressions Much of the information in this section is adapted from: Java Illuminated 5 TH Edition, Anderson, Julie and Franceschi Herve, Jones and Bartlett, 2019 Starting Out With Objects From Control Structures Through Objects, Gaddis, Tony, Pearson Publishing,

3 Why Interfaces As we have discussed, Java has single inheritance, only. This means that a child class inherits from only one parent class and usually this is all you need. However, sometimes multiple inheritance would be convenient, where a child class inherits characteristics from several parent classes. But this can be confusing. What happens when two parents have different versions of the same method? With object oriented programming, you define software objects that mimic "real world" objects. This makes programs easier to think about and more reliable. In the real world, you often think about an object in several different ways. You can think of your car as a vehicle or as taxable property. It would be convenient if software objects, also, could be thought of in several ways. But a Java object belongs to just one class. Interfaces give Java some of the advantages of multiple inheritance without the disadvantages. The use of interfaces is especially useful with graphics applications. 3

4 What Is An interface In Java (1) An interface describes aspects of a class other than those that it inherits from its parent. An interface is a set of requirements that the class must implement. An interface is a list of constants and method headers. The methods are not implemented in the interface (there is no method body). A class that implements an interface must implement all of the methods listed in the interface. 4

5 What Is An interface In Java (2) As we have said, a class can extend one parent class to inherit the methods and instance variables of that parent. A class can also implement an interface to gain additional methods and constants. However, the methods in the interface must be implemented (explicitly written) as part of the importing class definition. The interface is a list of requirements that the class definition must explicitly meet (through written code, not through inheritance). For example, a class Car might extend the Vehicle class. Inheritance then gives it all the methods and instance variables of Vehicle. If Car also implements the Taxable interface, then its definition must contain code for all the methods listed in Taxable. 5

6 Defining An interface (1) An interface has the following form: interface InterfaceName { constant definitions method headers (without implementations). } As previously described, a A method header is an access modifier, a return type, the method name, a parameter list followed by a semicolon. You can put an interface in its own source file or include it with other classes in a source file. In either case, the source file ends with the extension.java The methods in an interface are public by default, so you can omit public from the method headers. The methods cannot be private and cannot be protected prior to Java 9 An interface looks somewhat like a class definition. But no objects can be constructed from it. However, you can define a class that implements an interface, and once you have done that you can construct objects of that class. 6

7 Defining An interface (2) A class implements an interface by doing this: class SomeClass extends SomeParent implements InterfaceName1, InterfaceName2,. { } Rules A class extends just one parent, but may implement multiple interfaces. A method in an interface cannot be made private. A method in an interface is public by default. The constants in an interface are public static final by default. Recall that final means that the value cannot change as the program is running. 7

8 Defining An interface Look at these two examples: Example 1: interface MyInterface { public static final int ACONSTANT = 32; // a constant public static final double PI = ; // a constant public void methoda( int x ); // a method header public double methodb(); // a method header } Example 2: interface MyInterface { int ACONSTANT = 32; // a constant (public static final, by default) double PI = ; // a constant (public static final, by default) void methoda( int x ); // a method header (public, by default) double methodb(); // a method header (public, by default) } The second interface (above) is the preferred way to define an interface. The defaults are assumed and not explicitly coded. 8

9 Snap Check What is wrong with the following interface? interface SomeInterface { public final int x = 32; public double y; public double addup( ); } 9

10 Rules For Implementing An interface A class that implements an interface must implement each method in the interface. Methods from the interface must be declared public in the class. This is changed in Java v9, but most computers at CSUDH are still running Java 8, so we will stick with public interfaces Constants from the interface can be used as if they had been defined in the class. Constants should not be redefined in the class. Any number of classes can implement the same interface. The implementations of the methods listed in the interface can be different in each class. 10

11 A Recent Change In interface Before Java 8, interfaces could have only abstract methods. The implementation of these methods has to be provided in a separate class. So, if a new method is to be added in an interface, then its implementation code has to be provided in the class implementing the same interface. To overcome this issue, Java 8 has introduced the concept of default methods which allow the interfaces to have methods with implementation without affecting the classes that implement the interface. The default methods were introduced to provide backward compatibility so that existing interfaces can use the lambda expressions without implementing the methods in the implementation class. default is used as a modifier of the method A default method can still be overridden Default methods are also known as defender methods or virtual extension methods. 11

12 Static Methods In Interfaces Another feature that was added in JDK 8 is that we can now define static methods in interfaces which can be called independently without an object. Note: these methods are not inherited. 12

13 An interface Is A Contract When a class implements an interface, it is agreeing to provide all of the methods that are specified by the interface. It is often said that an interface is like a contract, and when a class implements an interface it must adhere to the contract. 13

14 Sample Problem Taxing Goods In A Store Let us create a database program for a store. The store sells: Goods, each of which has the attributes: description price The types of goods are: Food with an attribute calories. Food objects are not taxable. Toy with an attribute minimumage. Toy objects are taxable. Book with an attribute author. Book objects are taxable. There are many things that are taxable that are not goods, such as services or entertainment. Also, not all goods are taxable. So we want to have the concept taxable as a separate concept, not part of the concept of Goods, since not all Goods are taxed. Here is what the concept Taxable looks like: A Taxable item, has a taxrate of 6 percent, has a calculatetax() method. When implemented in Java, these concepts will appear as a class hierarchy and as an interface. 14

15 Snap Check Fill in this chart: Concept Goods Food Toy Book Taxable Parent Class, Child Class, or Interface? 15

16 Snap Check Answers Concept Parent Class, Child Class, or Interface? Goods Parent Food Child Toy Child Book Child Taxable Interface 16

17 An Example Using interface Look at the files Goods.java, Food.java, Taxable.java (an interface) Book.java, Toy.java, TestStore.java TestStoreArray.java and TestStoreArrayList.java also exhibit rules of polymorphism 17

18 Interface As A Type Just as with classes, an interface can be used as a data type for a reference variable. Since Toy and Book implement Taxable, they can both be used with a reference variable of type Taxable The Taxable interface tells the compiler that all Taxable objects will have a calculatetax() method, so that method can be used with these variables. public class TestStore2 { public static void main ( String[] args ) { Taxable item1 = new Book ( "Emma", 24.95, "Austen" ); Taxable item2 = new Toy ( "Legos", 54.45, 8 ); } System.out.printf("Tax is: %.2f\n", item1.calculatetax()); System.out.printf("Tax is: %.2f\n", item2.calculatetax()); } See TestStore2.java 18

19 Type Casting With Classes We have already used type casting in our equals() methods If you executed the following program you will get an error: public class TestStore3 { public static void main ( String[] args ) { Taxable item1 = new Book ( "Emma", 24.95, "Austen" ); System.out.printf( "Tax on item 1 %.2f\n, item1.calculatetax() ); System.out.printf( "Author: %s\n", item1.getauthor() ); } } Why? Not all taxable items test the term author. If you want item1 to act like a Book you need to cast it System.out.printf( "Author: %s\n", ((Book)item1).getAuthor() ); See TestStore3.java TestStore4.java shows another example of casting 19

20 Hierarchies Of Interfaces An interface can be an extension of another interface (but not an extension of a class): public interface ExciseTaxable extends Taxable { double extratax = 0.02; double calculateextra(); } A complex hierarchy of interfaces can be constructed using this feature. 20

21 Functional Interfaces A functional interface is an interface that has one abstract method. You can use a special type of expression, known as a lambda expression, to create an object that implements a functional interface. Both the functional interface and lambda expression are new in Java 8. interface IntCalculator { int calculate(int number); } 21

22 Lambda Expressions Because IntCalculator is a functional interface, we do not have to go to the trouble of defining a class that implements the interface. Instead, we can use a lambda expression to create an object that implements the interface, and overrides its abstract method. Note: To use a lambda expression the interface file must be there. It actually get compiled into a class when we compile the main class or another class that uses it. You can think of a lambda expression as an anonymous method, or a method with no name. Like regular methods, lambda expressions can accept arguments and return values. Here is the general format of a simple lambda expression that accepts one argument, and returns a value: parameter -> expression In this general format, the lambda expression begins with a parameter variable, followed by the lambda operator (->), followed by an expression that has a value. Here is an example: x -> x * x See LambdaDemo.java, LambdaDemo2.java, IntCalculator.java 22

23 Rules When Using Lambda Expressions (1) Lambda Expressions That Do Not Return a Value If a functional interface s abstract method is void (does not return a value), any lambda expression that you use with the interface should also be void. Here is an example: x -> System.out.printf( %s\n, x); This lambda expression has a parameter, x. When the expression is invoked, it displays the value of x. Lambda Expressions with Multiple Parameters If a functional interface s abstract method has multiple parameters, any lambda expression that you use with the interface must also have multiple parameters. To use more than one parameter in a lambda expression, simply write a comma-separated list and enclose the list in parentheses. Here is an example: (a, b) -> a + b; This lambda expression has two parameters, a and b. The expression returns the value of a + b. 23

24 Rules When Using Lambda Expressions (2) Lambda Expressions with No Parameters If a functional interface s abstract method has no parameters, any lambda expression that you use with the interface must also have no parameters. Simply write a set of empty parentheses as the parameter list, as shown here: () -> System.out.printf(); When this lambda expression is invoked, it simply prints a blank line. Explicitly Declaring a Parameter s Data Type You do not have to specify the data type of a lambda expression s parameter because the compiler will determine it from the interface s abstract method header. However, you can explicitly declare the data type of a parameter, if you wish. Here is an example: (int x) -> x * x; Note that the parameter declaration (on the left side of the -> operator) must be enclosed in parentheses. Here is another example, involving two parameters: (int a, int b) -> a + b; 24

25 Rules When Using Lambda Expressions (3) Using Multiple Statements in the Body of a Lambda Expression You can write multiple statements in the body of a lambda expression, but if you do, you must enclose the statements in a set of curly braces, and you must write a return statement if the expression returns a value. Here is an example: (int x) -> { int a = x * 2; return a; }; Accessing Variables Within a Lambda Expression A lambda expression can access variables that are declared in the enclosing scope, as long as those variables are final, or effectively final. An effectively final variable is a variable whose value is never changed, but it isn t declared with the final key word. 25

26 Programming Exercise 1 Adding More interfaces Adding more interfaces Copy Goods.java, Food.java, Book.java, Toy.java and Taxable.java Create a new interface called Returnable with a boolean method canreturn: boolean canreturn(double threshold); Implement Returnable in Book and in Toy to return true if the value of the Book is greater than a threshold Modify a version of TestStore.java to check this feature for each of the two classes obtaining both true and false features. Read in a threshold for each class. 26

Abstract Classes and Polymorphism CSC 123 Fall 2018 Howard Rosenthal

Abstract Classes and Polymorphism CSC 123 Fall 2018 Howard Rosenthal Lesson Goals Define and discuss abstract classes Define and discuss abstract methods Introduce polymorphism Much of the information