Abstract Classes
● No creating instances of abstract classes with new but they still have
constructors (even with parameters)
○ Note in java if a superclass ONLY has a constructor that takes arguments
(meaning no default constructor is made), the subclass must call
Super(arguments) in the subclass constructor (even if the subclass
constructor takes no arguments). But if both a default constructor and a
constructor that takes arguments OR there is no constructor declared (in
which case Java makes a default constructor) then there is no need to
explicitly type Super(...) since Java will automatically do it.
● Syntax of of abstract methods:
public abstract class Shape {
...
}
public class Circle extends Shape {
...
}
● If a subclass of an abstract superclass does not implement all abstract methods it
must be declared as abstract
● A non-abstract class cant have abstract methods
○ An Abstract class can have no abstract methods
● An instance of an abstract class is not possible but you can use it as a data type:
Shape[ ] circles = new Shape[10];
circles[0] = new Circle(5);
● Not that ONLY abstract methods can have no bodies. Any other method must
have a body.
● Abstract methods are not static
● A subclass method can override a superclass method and make it abstract
● You cannot cast siblings classes
● This throws an error because Number does not implement
Comparable<Number>”:
Number x = new Integer(10);
system.out.println(x.compareTo(new Integer(5)));
● An abstract class can implement an interface
Interfaces
● An interface only has constants and abstract methods
● No making instances but for an interface A you can declare:
A x; //It must be assigned to an instance of a class that extends A
public interface Edible {
}
class chicken extends Animal implements Edible {
}
● When a class implements an interface it must implement all the methods
declared in the interface with the SAME signatures and return types
○ Also interface methods are public by default thus when implementing them
in subclasses they MUST be set to public
● If the class implementing an interface does not implement all its methods it must
be declared abstract
● Let n be an Integer object. The following are true:
1. n instanceof Integer
2. n instanceof Object
3. n instanceof Comparable
//Note Comparable is an interface implemented by Integer
● A class that implements Comparable expects its compareTo to take an argument
the same as the class’ type. This would be wrong:
public int compareTo (Object o) { //should be String o
}
●
● A Java class can extend only one superclass but can implement multiple
interfaces
public class dog extends Animal implements notEdible, animalToys, furry {
….
}
● An interface can extend (NOT implement) multiple interface
public interface newInterface extends Inter1, inter2, inter3 {
...
}
● Note an interface extending another interface simply inherits the interfaces
methods, no implementing them.
●
● Unlike classes which share a root, the Object class, interfaces dont have this.
● A variable can be of an interface type and refer to an instance of any class that
implements it.
Interface Animal {
void makeSound();
}
public class Dog implements Animal {
public void makeSound() {
system.out.println(“Woof”);
}
…..main {
Animal o = new Dog();
o.makeSound();
● You can cast interface objects and classes that implement it the same way as
other classes:
Animal a = new Dog();
Dog d = (Dog)a;
