Interfaces

Interfaces

• Specify behavior of objects

• Used for existing classes to create “contracts” with certain behavior (methods)

Interfaces

• _{Can only contain constants and abstract}

methods

– _{All methods are assumed to be “public abstract”}

• _{Do not need to explicitly state these key words}

– _{All data fields are “public static final”}

• _{Do not need to explicitly state these key words}

When to Use Interfaces

• _{When you want to specify a set of behavior}

• _{When this behavior can be shared among several}

classes

• _{Abstract class}

– When your class is a sub-type of the abstract class • _Interface

– _{When your class uses common methods of the} interface

When to Use Interfaces

• _{Start with functions in a class}

• If you notice this functionality can be shared

• Consider abstracting this functionality from the class to an interface

• Have the class(es) implement this interface

Interface Examples

• Comparable

– Used when an object can be compared to another object

– Used by sorting libraries of the Collections class – https://

docs.oracle.com/javase/8/docs/api/java/lang/Compara ble.html

• Serializable

– Used when your object can be serialized and written to disk

– https://

docs.oracle.com/javase/8/docs/api/java/io/Serializable .html

Interface Examples

• _Runnable

– _{Used by any classes that are executed by a thread} – The run method acts like a main method and is

where the execution of threads start

– _https://

docs.oracle.com/javase/8/docs/api/java/lang/Runna ble.html

• _Iterable

– _{Used by objects (lists) which can be iterated over} – _https://

docs.oracle.com/javase/8/docs/api/java/lang/Iterabl e.html

How to Make an Interface

• _{Use the “interface” keyword in front of the}

interface name

• Example:

– _{“public interface Edible”}

How to Use an Interface

• _{Several useful interfaces already exist in java} • To use these interfaces, use the key word

“implements” after the class name

• Examples

– “public class Food implements Edible”

– “public class Card implements Comparable<Card>”

• Implementing classes must define the methods in the interface

– This ensures the contract between the class and the

Using Interface Variables

• _{Is the following code valid?}

– _{List<Integer> someList = new ArrayList<Integer>();} • List is an interface

• ArrayList is a class

Using Interface Variables

• _{Is the following code valid?}

– _{List<Integer> someList = new ArrayList<Integer>();} • List is an interface

• ArrayList is a class

• Yes

– Why?

Using Interface Variables

List<Integer> someList = new ArrayList<Integer>();

– _{This is very common syntax when using interfaces} – Often preferred over using the class name

– _{Can use this to call methds of the interface} – Cannot use this to call methods of the class

Using Interface Variables

List<Integer> someList = new ArrayList<Integer>();

13

We are creating a variable of type “ArrayList<Integer>”

Using Interface Variables

List<Integer> someList = new ArrayList<Integer>();

14

Using Interface Variables

List<Integer> someList = new ArrayList<Integer>();

15

someList can use any methods defined in the List interface

Using Interface Variables

List<Integer> someList = new ArrayList<Integer>();

16

Interface Rules

• Cannot create an instance of an interface

• Can have an inheritance hierarchy

– _{One interface can inherit (extend) from another} – _{An interface cannot extend from classes}

• _{A class can implement any number of}

interfaces

– _{A class can only extend one class}

• _{Interfaces are the solution to this}

Example – Interface Example

• _Oxygen.java • TextFile.java

• Compressable.java

• Main.java

Abstract Classes

• _{Classes that cannot be instantiated}

• An object cannot be created from an Abstract class

• _{Classes can inherit from abstract classes} • Not very popular

– _{Can be replaced by regular classes and interfaces}

When to Use Abstract Classes

• Sometimes there will be classes that should exist but should not be instantiated

• _Example

– _{An animal Animal}

• _{If I asked you to make an animal, you would typically}

respond with “what type of animal?”.

• This question indicated that an animal cannot be created without knowing the type of animal

• _{Therefore an Animal class cannot be instantiated, but}

subclasses can

When to Use Abstract Classes

• _{Start with normal classes}

• If you notice common variables

• Consider making an abstract to hold these common variables

– _{Include set/get methods too}

• If there is common functionality without variables

– Consider using an interface

Abstract Class Examples

• Typically found at the top of the inheritance chain of your favorite classes

• _Shape

– _{https://docs.oracle.com/javafx/2/api/javafx/scene/s}

hape/Shape.html

• InputStream – _https://

docs.oracle.com/javase/8/docs/api/java/io/InputStr eam.html

Abstract Class Examples

• _{AbstractCollection}

– _https://

docs.oracle.com/javase/8/docs/api/java/util/Abstra ctCollection.html

• Clock – _https://

docs.oracle.com/javase/8/docs/api/java/time/Clock .html

How to Make an Abstract Class

• _{Use the “abstract” keyword in front of the}

class name

• Example:

– _{“public abstract class Animal”}

Abstract Methods

• _{Abstract classes can have abstract methods} • An abstract method is an unimplemented

method of an abstract class

• _{A regular class cannot have an abstract method} • Example

– _{AbstractCollection class}

• public abstract int size()

Abstract Class Rules

• An abstract class can have any number of abstract methods (including none)

– _{All non-abstract subclasses must implement these}

methods

• _{An abstract class can extend another abstract}

class

• _{An abstract class can extend a regular class} • Abstract classes still have constructors

– _{Called via subclasses}

Example - Abstract Example

• _Animal.java

• _{RealAnimal.java}

• _{MythicalAnimal.java} • _Edible.java

• _Donkey.java • _Dragon.java • _Ogre.java • _Main.java