1. Question of the Day  Write valid mathematical equation using: 2 3 4 5 one addition operator (‘+’) one equality operator (‘=’)  Should have equal values on both sides of equals sign  Not limited to what is possible in Java

2. Question of the Day  Write valid mathematical equation using: 2 3 4 5 one addition operator (‘+’) one equality operator (‘=’)  Should have equal values on both sides of equals sign  Not limited to what is possible in Java 5 + 4 = 3 2

4. Announcement

5. Inheritance Issues  Multiple inheritance causes many problems  What if there are multiple superclasses declare field?  Which constructor will super() chain to?  Since classes extend only 1 class, Java avoids problem  Often mix multiple ideas within class, however

6. Inheritance Issues  Multiple inheritance causes many problems  What if there are multiple superclasses declare field?  Which constructor will super() chain to?  Since classes extend only 1 class, Java avoids problem  Often mix multiple ideas within class, however public class Mammal { … } public class Bird { … } public class Platypus extends

7. Inheritance Issues  Multiple inheritance causes many problems  What if there are multiple superclasses declare field?  Which constructor will super() chain to?  Since classes extend only 1 class, Java avoids problem  Often mix multiple ideas within class, however public class Mammal { … } public class Bird { … } public class Platypus extends

8. abstract  Can declare methods as abstract  Methods cannot be defined; promise functionality  Methods can have parameters, return type, etc.  Bodies are illegal; declaration only lists signature public abstract void foo(int i); public abstract Beer bar(String o);

9. abstract class  If we have a class containing abstract methods  Class considered abstract no matter how declared  abstract  abstract classes similar to regular classes…  static & non- static fields allowed in class  Class will always extend exactly 1 other class  Mix of abstract & normal methods can be included  May use default one or may define a constructor  Can be extended by other classes

10. abstract class

12. Interfaces in Real World

13. Interfaces  Can only declare important constant fields  public static final must be used for fields  Interface declares public abstract methods  Methods callable anywhere by any class  But method’s body cannot be defined in interface

14. Adding to an Interface  Interfaces have sub-interfaces  Sub-interface extends super-interface  Super-interface’s methods inherited by sub-interface  Methods from super-super-interface also inherited  Sub-interface can extend multiple interfaces  Methods not defined so does not cause problems

15. Declaring Interfaces public interface Drawable { public void setColor(Color c); public Color getColor(); public void draw(Graphics g); } public interface TranDraw extends Drawable{ public void setTransparency(int tLevel); } public interface MoveDraw extends Drawable{ public void setPosition(int x, int y); }

16. Interfaces implement  Classes implement interfaces  Implementing classes define interface’s methods  Any number of interfaces may be implemented  Multiple inheritance issues ignored -- methods empty  Unrelated to superclass chosen or used by a class  Classes must implement all interface’s methods  Includes methods inherited from super-interface

17. Implementing Interfaces public class Square implements Drawable { private Color c; private int x, y, side; public Square(Color col, int len) { c = col; side = len; } public void setColor(Color col){ c=col; } public Color getColor() { return c; } public void draw(Graphics g) { g.drawRect(x, y, side, side, c); } }

18. Implementing Interfaces public class Oval implements Drawable { private Color c; private int x, y, majRad, minRad; public Oval(Color co, int maj, int min){ c = co; majRad = maj; minRad = min; } public void setColor(Color col){ c=col; } public Color getColor() { return c; } public void draw(Graphics g) { g.drawOval(x, y, majRad, minRad, c); } }

19. Using Interfaces

22. Interface vs. Abstract Class  Both concepts serve similar purposes  Cannot instantiate either of these types  But can be used for variable, field, & parameter types  Used in other classes to identify important features  But very important differences define when each used

23. Interface vs. Abstract Class  Can extend classes & implement interfaces instances  Both used to mark instances have methods defined  Fields, params, & locals can use either as their type  Use abstract class when…  …classes should use common method or private field  …place in object hierarchy as subclass of existing class  Otherwise use interface for abstract methods  More flexible: class can implement many interfaces  Can mark classes; do not have to declare methods

24. Typecasting int i = 13; Square s = ((Square)i);  Only exist to “assist” compiler with code  Changes variable’s type so compilation continues  Not in *.class file – does not affect instance at all  Only when KNOW instance & variables types differ  Errors at runtime instead of during compilation  Illegal code will compile, but still illegal

25. Typecasting int i = 13; Square s = ((Square)i);  Only exist to “assist” compiler with code  Changes variable’s type so compilation continues  Not in *.class file – does not affect instance at all  Only when KNOW instance & variables types differ  Errors at runtime instead of during compilation  Illegal code will compile, but still illegal

26. Narrowing Conversions  Java cannot compile narrowing conversions  Assigns superclass/interface to lower variable  Compiler will not allow it, but could be legal  Typecasting required for these assignments Object obj = new String(“bye”);

27. Narrowing Conversions  Java cannot compile narrowing conversions  Assigns superclass/interface to lower variable  Compiler will not allow it, but could be legal  Typecasting required for these assignments Object obj = new String(“bye”); String sad = obj; //  Does not work

28. Narrowing Conversions  Java cannot compile narrowing conversions  Assigns superclass/interface to lower variable  Compiler will not allow it, but could be legal  Typecasting required for these assignments Object obj = new String(“bye”); String sad = obj; //  Does not work String glad = (String)obj; // works!

29. Your Turn  Get into your groups and complete activity

30. For Next Lecture  Read GT2.5 for Mon. and be ready to discuss  What is a generic type?  Why are they going to save our wrists this year?  How can they be used correctly?  As usual, there is weekly assignment on Angel Tuesday  Due by 5PM Tuesday via Assignment Submitter  Each problem graded using provided JUnit tests