JAVA INTERFACES
if a class extends a interface, what relationship do they have? what is the concept called?
"is-a" relationship; the class is-a interface. Polymorphism(a variable of the supertype can refer to a subtype object).
What is important to know about interface methods and interface references?
-BUT ONLY THE INTERFACE METHODS ARE ACCESSIBLE THROUGH THE INTERFACE REFERENCE -Even though a single class may implement many interfaces, if it is being accessed through an interface variable, the methods in the other interfaces are not avaliable -The interface masks the object such that only the interface methods are visible / callable -if other methods are attempted to be accessed, a compliation error will result
What is important if you decide to use interfaces for methods?
-In the class header we must declare that the interfaces are implemented public class Comedian implements Laughable, Booable { public void laugh() { System.out.println("ha ha ah");} public void boo() { System.out.println("you stink!");} }
How do you want to identity an object in multiple ways?
-One based on its inherent nature (i.e. its inheritance chain) Ex: A person -Classes are used to identity objects in this way -Others based on what it is capable of doing EX: A swimmer, A musician, A performer, so on and so forth -Interfaces are used to identify objects in this way
How do you implement an interface: i.e. how do you say in Java "this class is going to use XYZ interface"?
1. You use the "implements" keyword: public class DeskPhone implements ITelephone { 2. You actually implement ALL of the interface methods: The declaration line (ABOVE) will remained underlined in red (an error) until ALL the interface's methods are implemented.
What is an interface?
A java Interface is a named set of methods -However, no method bodies are given -- just the headers -Static constants are allowed, but no instance variables are allowed -Any Java class (no matter what its inheritance) can implement an interface by implementing the methods defined in it -Essentially an interface is stating an ABILITY of the class -A given class can implement any number of interfaces
Public is redundant for an interface because...
All the method signatures defined here HAVE to be used in a different class: Methods from an interface HAVE TO BE public to be used!
public class Gearbox { private boolean clutchIsIn; public void operateClutch(boolean inOrOut) { this.clutchIsIn = inOrOut; } } In this class and method, the code can be changed anytime; we haven't made any standard, any COMMITMENT that it won't be changed. An interface is...
An interface IS a commitment that the methods you have created will STAY THE SAME: it kind of "locks" them in. It is a "contract" that the method's signatures and variables in the interface's constants will NOT CHANGE. As long as you stick to what's in the interface that you've created- you WILL NOT be breaking code anywhere.
What can an interface variable do?
An interface variable can be used to reference any object that implements that interface./ -Note that the same method name (ex: laugh() below) may in fact represent different code segments in different class
what happens when there are default methods in the interface?
Any class that implements the interface will already have the method defined and usable.
Explain the example given about the Comparable interface.
Comparable interface contain one method : int compareTo(Object r); -Returns a negative number if the current object is less than r, 0 if the current object equals r and a positive number if the current object is greater than r -Consider what we need to know to sort data -is A[i] less than, equal to or greater than A[j] -Thus, we can sort Comparable Data without anything else about it -Polymorphism allows this to work!
Remember: you don't actually create the full methods in an interface. You simply...
Define the methods: You just create the method "signature" here (otherwise known as method "stubs"): public interface ITelephone { public void powerOn(); public void dial(int phoneNumber); public void answer(); public boolean callPhone(int phoneNumber); public boolean isRinging(); } The code itself is DEFINED in the actual class. What we have defined here now is the CONTRACT with the PARAMETERS that makes sure that the method signature will not change!
How do you instantiate an object that implements an interface (in the main method)?
EXAMPLE: ITelephone timsPhone; timsPhone = new DeskPhone(2385623); OR: DeskPhone timsPhone; timsPhone = new DeskPhone(2385623); THE IMPORTANT THING TO REMEMBER IS: You cannot instantiate an ITelephone object on it's own: REMEMBER: It just TELLS the other (actual) classes what methods to use/override
Example of using interface methods and interface references.
Ex: Laughable [] funny = new Laughable[3]; funny[0] = new Comedian(); funny[1] = new SitCom(); //implements laughable funny[2] = new Clown(); //implements laughable for(int i = 0; i < funny.length; i ++) funny [i].laugh(); funny[0].boo(); //illegal even though Comedian[0] it has the boo() method
In terms of classes and methods, what can interfaces allow programmers to do?
Ex: public interface Laughable { public void laugh();} public interface Booable { public void boo ();} -Bascially any Java class can implement Laughable by implementing the method laugh() -Same for method boo
Runnable
Example Lambda: () -> System.out.println("Doing stuff")
Supplier
Example Lambda: () -> new String("Hello ladies!')
Callable
Example Lambda: () -> {new Double(3.141597); throw new Exception(); }
Function
Example Lambda: (Integer num) -> num.toString()
BiFunction
Example Lambda: (Integer num1, Double num2) -> Double.toString(num1.doubleValue()/num2)
BiPredicate
Example Lambda: (Number num1, Number num2) -> num1.doubleValue() > num2.doubleValue()
Comparator
Example Lambda: (a, b) -> a-b
BinaryOperator
Example Lambda: (a,b) -> a + b
BiConsumer
Example Lambda: (key, value) -> System.out.println( "Key: " + key + "\t" + " Value: " + value )
Comparable
Example Lambda: b -> this.id - b.id
Predicate
Example Lambda: num -> num % 2 == 0
Consumer
Example Lambda: stuff -> System.out.print(stuff)
UnaryOperator
Example Lambda: x -> x*2
Function
Example Method Reference: Integer::toString
Predicate
Example Method Reference: List::isEmpty
BinaryOperator
Example Method Reference: String::concat
Supplier
Example Method Reference: String::new
UnaryOperator
Example Method Reference: String::toUpperCase
Consumer
Example Method Reference: System.out::print
static void filter(Collection<?> c) { for (Iterator<?> it = c.iterator(); it.hasNext(); ) if (!cond(it.next())) it.remove(); }
Go make a method that uses a Collection and an Iterator (flipside for example)
Interfaces are closely related to....?
Interfaces are closely related to inheritance and polymorphism. -The interface acts as a supercalss and the implementing classes implement the actual methods however they want -An interface variable can be used to reference any object that implements that interface -However, only the interface methods are accessible through the interface reference
what is an interface?
It is a reference type(similar to a class)
In Java, what is the restriction of using inheritance?
Java allows only single inheritance -A new class can be a subclass of ONLY ONE parent (super) class -There are several reasons for this, from both the implementation (i.e. how to do it in the complier and interpreter) point of view and the programmer (i.e. how to use it effectively) point of view -However, it is sometimes useful to be able to access an object through more than one superclass reference
Function
Method Signature: R apply(T t)
BiFunction
Method Signature: R apply(T t, U u)
UnaryOperator
Method Signature: T apply(T t)
BinaryOperator
Method Signature: T apply(T t1, T t2)
Supplier
Method Signature: T get()
Callable
Method Signature: V call() throws Exception
Predicate
Method Signature: boolean test(T t)
BiPredicate
Method Signature: boolean test(T t, U u)
Comparator
Method Signature: int compare(T t1, T t2)
Comparable
Method Signature: int compareTo(T t)
Consumer
Method Signature: void accept(T t)
BiConsumer
Method Signature: void accept(T t, U u)
Runnable
Method Signature: void run()
What is the common naming practice for interfaces?
Naming your interface class starting with I: ITelephone, IShoes, IBag, etc... NOTE: Tim later retracts this statement! It may be appropriate in some cases if you have other classes with similar names, but in general, it sounds like this isn't used much anymore.
Explain the note about static constants in a java interfaces.
Since Java 8 interfaces are allowed to have default methods. These are methods that are defined within the interface and that become part of any class that implements the interface. Interfaces may also have static methods. These are similar to static methods within classes.
How do you set up an interface in IntelliJ?
The same as setting up a class: - Go to the folder that you want, - right click - Select new, then class - UNDER the area where you name your class is a menu: Select INTERFACE - Name your interface class starting with an "i": ITelephone
what are the non-default or non-static methods in the interface called?
They are public abstract methods
In IntelliJ, how do we implement the methods from an interface (within the actual class we've created)?
Use the generate menu: Alt+insert (fn+Alt+insert on my laptop) NOTE: If not ALL of the methods from our interface have been implemented, it will NOT be a valid class! Using our telephone example: When we IMPLEMENT the interface we're saying "If you want to create a valid telephone object, it MUST contain/use all the methods we've defined; otherwise, it is NOT a valid telephone object." In our case- even though a desktop phone will always have the powerOn()- there's really no "power" button on a desktop phone- you MUST implement the method!
Runnable
Used by: Executor.execute(), new Thread( ),ExecutorService.submit()
Callable
Used by: ExecutorService.submit(), not by ExecutorService.execute()
Supplier
Used by: Stream.collect() Stream.generate()
Predicate
Used by: Stream.filter(), Stream.allMatch(), Collection.removeIf()
Consumer
Used by: Stream.forEach(), Stream.peek()
UnaryOperator
Used by: Stream.iterate(), List.replaceAll()
Function
Used by: Stream.map(), Stream.flatmap(), Comparator.comparing()
BinaryOperator
Used by: Stream.reduce() one argument version
What are interfaces? What does an interface do/allow us to do?
WHAT IS AN INTERFACE: An interface specifies methods that a particular class (which implements the interface) MUST use. The interface itself is ABSTRACT: this means there is no actual code for any of the methods IN the interface- you just provide the method names/parameters. The actual code still goes in the CLASS that you're creating. WHAT IT ALLOWS US TO DO: The idea is to use an interface to provide a common behavior that can be used by several classes by having them all implement the same interface. This is a way to STANDARDIZE the way a particular SET OF CLASSES is used.
The List class IS an interface class, meaning that it is abstract. What does this mean for, say, the LinkedList challenge (videos 69-71) where we (obviously) used LinkedLists for our playlist example (Hint: interfaces have a SET of classes)?
We can easily change all of the LinkedList<> declarations to List/Arraylist, and it will still work! Why? Because with an interface class (List), ALL "subclasses" MUST implement ALL of the methods of the interface class! (See video 73 "Interfaces Part 2" or "Interfaces LinkedList" file). You can see with this example, Java uses interfaces internally with A LOT of their code: it's a good way to make your code efficient, clean, etc ...
Comparable interface: Think of the objects we want to sort as "black boxes"
We know we can compare them because they implement Comparable -We know we can compare them because they implement Comparable -We don't know (or need ot know) anything else about them -Thus, a single sort method will work for any array of any Comparable class
where do we write the keyword to use the interface in the class? how do we write it?
We use the keyword 'implements' at the class header eg public class Class implements Implement1,Implement2 { variables, cstor, methods }
How does it benefit us to be able to access objects through interfaces?
_Sometimes we are only concerned about a given property of a class -The other attributes and methods still exist, but we don't care about them for what we want to do -For example: Sorting -We can sort a lot of different types of objects like:Various numbers;People based on their names alphabetically; Employees based on their salaries -Each of these classes can be very different; however, something about them all allows them to be sorted
How does it benefit us to be able to access object through interface? continue with sorting.
_They can be compared to each other -So we need some method that invokes this comparison -In order to sort them, we don't need to know or access anything else about any of these classes -Thus, if they all implement an interface that defines the comparison, we can sort them all with a single method that is defined in terms of that interface -Think about comparable interface
Collection
a List is a special kind of ___________
Collection
a Set is a special kind of ___________
Set
a SortedSet is a special kind of __________
a constructor that takes a Collection argument
by convention, what do general-purpose Collection implementations have?
public static <E> void swap(List<E> a, int i, int j) { E tmp = a.get(i); a.set(i, a.get(j)); a.set(j, tmp); }
create a function using the List interface and its operations, that swaps two indexed values of a List
listObj.size();
how do you return the number of elements in a List?
List<Type> list3 = new ArrayList<Type>(list1); list3.addAll(list2);
how would you add one list to the end of another? (non-destructive)
String[] x = y.toArray(new String[0]); //y is a Collection
how would you turn a Collection of String objects, into a String array?
Object[] x = y.toArray(); //y is a Collection
how would you turn a collection into an array?
What is the keyword required to use Interfaces(case sensitive)
implements
positional access; search; iteration; and range-view
in addition to the operations from Collection, what does the List interface add?
learn more...
interator COllceiotn
what are the modifiers of the methods in the interface set to?
public abstract
what modifiers do the data fields in an interface have?
public static final
how do interface inherit interfaces? if a class implements the interface what methods must it define?
the interface inherit other interfaces by extending them. If a class implements the interface, it would have to define all the abstract methods of all the interfaces.
Since interfaces cannot be instantiated, what can be done to them?
we can implement interfaces to classes or extend(inherit) them to other interfaces
myCollection.add(E element); //E being whatever type the Collection contains
what Collection method adds a new element?
myCollection.isEmpty();
what Collection method checks if the group is empty?
myCollection.contains(Object element);
what Collection method checks the group for a given object?
get, set, add, remove
what are the positional operations of the List interface?
a group of objects; known as elements
what does a Collection represent?
returns true if iteration has more lements
what does the Iterator method, hasNext(), do?
return next element in iteration
what does the Iterator method, next(), do?
removes the last element returned by next()
what does the Iterator method, remove(), do?
public interface Iterator<E> { boolean hasNext(); E next(); void remove(); //optional }
what interface does a Collection have that allows you to traverse through a collection and remove elements selectively?
for(Object o : collection){ System.out.println(o); }
what is the 'for' method for iterating over a collection?
to pass around objects where maximum generality is desired
what is the general rule for using Collection(s)?
obtaining a stream and performing aggregate operations on it
what is the preferred method of iterating over a collection?
list1.addAll(list2); //destructively means destroying both lists, and creating a new one
what would you do if you wanted to add one list to the end of another? (destructively)
removing the current element; iterating over multiple collections in parallel
when should you use Iterator over for-each, regarding Collections?