Upload
others
View
8
Download
0
Embed Size (px)
Citation preview
CSCI-142 Computer Science 2
Recitation
03InterfacesGenerics
2
Java Interfaces
● An interface is a bit like a class, but can only contain method signatures (and static fields)
public interface Animal { double run(int seconds); String speak();}
● As a consequence, an interface cannot be instantiated
Animal a = new Animal();
Error. Animal is abstract and cannot be instantiated
3
Implementing an Interface
● When a class implements an interface it agrees to implement all of its methods
public class Camel implements Animal { ... @Override public double run(int seconds) { return (seconds * RUN_SPEED_MS) / this.numHumps; }
@Override public String speak() { return toString() + " says, \"grunt!, grunt!\""; }
4
Relationship: A Camel is-an Animal
● When an Animal reference points to a Camel instance, it may only call on the Animal behaviors
Camel joe = new Camel(2);joe.run(10); // OKjoe.speak(); // OKjoe.milk(5); // OK
Animal animal = joe; // OKanimal.run(7); // OKanimal.speak(); // OKanimal.milk(2); // ERROR
5
UML Class Diagram: Animal Farm
6
Relationship: A Penguin is-an Animal and is-a Swimmer
public class Penguin implements Animal, Swimmer { ... @Override public double run(int seconds) {
... } @Override public String speak() {
... } @Override public double dive(int minutes) { ... }
7
public class AnimalFarm { private ArrayList<Animal> animals; ... public AnimalFarm() {
... this.animals.add(new Camel(1)); this.animals.add(new Penguin(10)); this.animals.add(new Camel(2)); this.animals.add(new Penguin(20)); }
for (Animal anim : animals) { anim.speak();}
Camel Penguin Camel Penguin
animals
anim
Camel{numHumps=1, litersMilked=0.0} says, "grunt!, grunt!"Penguin{beakLength=10, fishEaten=0} says, "gak!, gak!"Camel{numHumps=2, litersMilked=0.0} says, "grunt!, grunt!"Penguin{beakLength=20, fishEaten=0} says, "gak!, gak!"
output
8
Java Generics
● Java’s type system is extended by generics – Allows a type or method to operate on objects of
various types– Provides compile-time safety
ArrayList<String> strings = new ArrayList<>();strings.add("hello");strings.add(10); // Error: add(String) cannot be applied to int
ArrayList<Integer> ints = new ArrayList<>();ints.add(10);String s = ints.get(0); // Error: incompatible types // requires Integer, found String
9
Generics: Type Omission
● When the generic type is omitted Object is used as the default type– In order to work with legacy code prior to Java 5
when generics were introduced
ArrayList strings = new ArrayList(); // generic type is Objectstrings.add("10"); // Warning: unchecked call to add(E)String s1 = strings.get(0); // Error: incompatible types // requires Object, found String
String s2 = (String) strings.get(0); // typecasting works (ugly!)int i = (int) strings.get(0); // Runtime Error: ClassCastException // String can't be cast to Integer
10
Python: BTNode dataclass
@dataclassclass BTNode: value: Any # node can hold any value left: Union[None, 'BTNode'] # the left child right: Union[None, 'BTNode'] # the right child
def mk_btnode_leaf(value): return BTNode(value, None, None)
def mk_btnode(value, left, right): return BTNode(value, left, right)
root = mk_btnode('A', # root mk_btnode_leaf('B'), # root's left mk_btnode_leaf('C')) # root's right
root.value # 'A'root.left # BTNode(value='B', left=None, right=None)root.left.value # 'B'root.left.right # None
A
B C
root
None None None None
left right
left leftright right
11
From: Python AnyTo: Java Generic Type E
@dataclassclass BTNode: value: Any # node can hold any value left: Union[None, 'BTNode'] # the left child right: Union[None, 'BTNode'] # the right child
public class BTNode<E> { /** node can hold any value */ private E value; /** the left child */ private BTNode<E> left; /** the right child */ private BTNode<E> right;
● Our Java generic class is BTNode<E>
Python
Java
12
From: Python NoneTo: Java null
def mk_btnode_leaf(value): return BTNode(value, None, None)
def mk_btnode(value, left, right): return BTNode(value, left, right)
Python/** * Create a new leaf node (no children). * * @param value value for the node */public BTNode(E value) { this(value, null, null);}
/** * Create a new non-leaf node. * @param value value for the node * @param left the left child * @param right the right child */public BTNode(E value, BTNode<E> left, BTNode<E> right) { this.value = value; this.left = left; this.right = right;}
Java
● In Java we link the leaf node constructor to the non-leaf constructor with this and use null for no child
13
BTNode.java: Accessors and toString
public class BTNode<E> { private E value; private BTNode<E> left; private BTNode<E> right;
… /** * Get the value in the node. * * @return node's value */ public E getValue() { return this.value; }
/** * Get the left child of the node. * * @return node's left child */ public BTNode<E> getLeft() { return this.left; }
/** * Get the right child of the node. * @return node's right child */public BTNode<E> getRight() { return this.right;}
/** * Return a string representation e.g.: * "rootA: BTNode{value=A, left=null, * right=null}" * @return the string representation */@Overridepublic String toString() { return "BTNode{" + "value=" + this.value + ", left=" + this.left + ", right=" + this.right + '}';}
14
BTNode<E> Usage
public static void main(String[] args) { BTNode<String> rootA = new BTNode<>("A"); System.out.println("rootA: " + rootA); System.out.println("rootA value: " + rootA.getValue());
BTNode<String> rootB = new BTNode<>("B", new BTNode<>("C"), new BTNode<>("D")); System.out.println("rootB: " + rootB); System.out.println("rootB left: " + rootB.getLeft()); System.out.println("rootB right: " + rootB.getRight());}
rootA: BTNode{value=A, left=null, right=null}rootA value: ArootB: BTNode{value=B, left=BTNode{value=C, left=null, right=null}, right=BTNode{value=D, left=null, right=null}}rootB left: BTNode{value=C, left=null, right=null}rootB right: BTNode{value=D, left=null, right=null}
output
15
Presentation Code
● Interfaces: Animal Farm– https://www.cs.rit.edu/~csci142/Recitations/03/Code/Animal.java
– https://www.cs.rit.edu/~csci142/Recitations/03/Code/AnimalFarm.java
– https://www.cs.rit.edu/~csci142/Recitations/03/Code/Camel.java
– https://www.cs.rit.edu/~csci142/Recitations/03/Code/Penguin.java
– https://www.cs.rit.edu/~csci142/Recitations/03/Code/Swimmer.java
● Generics: BTNode– https://www.cs.rit.edu/~csci142/Recitations/03/Code/BTNode.java
– https://www.cs.rit.edu/~csci142/Recitations/03/Code/btnode.py