mit aiti 2004 – lecture 13 abstract classes and interfaces
TRANSCRIPT
MIT AITI 2004 – Lecture 13
Abstract Classes and Interfaces
What is an Abstract Class?
An abstract class is a class that cannot be instantiated—we cannot create instances of an abstract class.
One or more methods may be declared, but not defined. (The programmer has not yet written code for a few methods).
The declared methods and classes have the keyword abstract in their signature.
public class Employee { private String name; private double salary;
public Employee(String n, double s) { name = n; salary = s; }
public String getName() { return name; }
public double getSalary() { return salary; }
public String description() { return "employee with a salary of $ " + salary; }}
Employee Class
public class Student { private String name; private String course;
public Student(String n, String c) { name = n; course = c; }
public String getName() { return name; }
public String getCourse() { return course; }
public String description() { return "a student majoring in " + course; }}
Student Class
Common Functionality
Student and Employee may have common fields and methods. private String name;
getName()
Instead of repeating code, introduce a superclass
Example Hierarchy
Consider the following class structure:
Person
Employee Student
Superclass
Subclasses
public class Person {String name;
public Person(String n) {name = n;
}
public String getName() {return name;
}}
Person Class
public class Employee extends Person { // private String name; private double salary;
public Employee(String n, double s) { super(n); salary = s; }
// public String getName() { return name; }
public double getSalary() { return salary; }
public String description() { return "an employee with a salary of $" + salary; }}
Employee Subclass of Person
public class Student extends Person{// private String name;private String course;
public Student(String n, String c) {super(n);course = c; }
// public String getName() { return name; }
public String getCourse() {return course; }
public String description() {return "a student majoring in " + course; }
}
Revised Student
description() Method
Let’s create Person, Employee, and Student objectPerson kwame = new Student("Kwame", "CS");
Employee kojo = new Employee("Kojo", 200000);
Student yaa = new Student("Yaa", "Math");
Description of an Employee and a Student returns:employee with a salary of ¢200000
student majoring in Math
Can we say: kwame.description()
NO! the variable kwame is of type Person, which does not have a description() method defined
public class Person { String name;
public Person(String n) { name = n; }
public String getName() { return name; }
// add a method to return the // description of a Person}
Let's Revise Person
public class Person {String name;
public Person(String n) {name = n;
}
public String getName() {return name;
}
public String description() {return "person named " +
name;}
}
Revised Person
description() Revisited
Now we can call the description() method on Objects that are of type Person (instances of a Student, Employee, or Person)
Person kwame = new Person("Kwame"); Person kojo = new Employee("Kojo", 200000); Person yaa = new Student("Yaa", "Math");
kwame.description(); kojo.description(); yaa.description();
description Method Revisited
Now we can call the description() method on Objects that are of type Person (instances of a Student, Employee, or Person)Person kwame = new Person("Kwame");Person kojo = new Employee("Kojo", 20000);Person yaa = new Student("Yaa", "Math");
kwame.description(); // method in Personkojo.description(); // method in Employeeyaa.description(); // method in Student
PROBLEM: We don’t want to create instances of Person, just Students and Employee
Abstract Methods
• Solution: Use the keyword abstract
• A method labeled abstract is declared but not implemented
• Rule: An abstract class can have zero or more abstract methods
• Make description() an abstract method in the class Person
public abstract class Person { String name;
public Person(String n) { name = n; }
public String getName() { return name; }
public abstract String description();}
Abstract Person Class
Abstract Classes
Cannot instantiate or create an object of an abstract class
Person jacob = new Person("Jacob") // ERROR!!
An abstract class can have both abstract and non-abstract methods
Abstract methods need to be defined in concrete subclasses (classes that can be instantiated)
Using Abstract Classes
• Variables can be objects of abstract typesPerson p = new Student("Greg", "CS");
• Here p has the type Person, but references an instance of a non-abstract class, Student
Calls to Abstract Methods
Person[] people = new Person[2];
people[0] = new Employee("Evita", 2000000.0);
people[1] = new Student("Greg", "CS");
for (int i = 0; i < people.length; i++) {
Person p = people[i];
System.out.println(p.getName() + ", " +
p.description());
}
What is the output?Evita, an employee with a salary of $200000
Greg, a student majoring in CS
public abstract class Person { String name;
public Person(String n) { name = n; }
public String getName() { return name; }
// must declare in order to call // method on variable of type Person public abstract String description();}
Abstract Person Class
Advantages
• Classes can now be very general in a class/type hierarchy. – This allows more abstraction in object
oriented programming.
• Have more control over inheritance in a class/type hierarchy.– Make a class abstract even if there are no
abstract methods
Summary of Abstract Classes
• Partial implementation of a class
• Cannot be instantiated
• Use the abstract keyword in their signature.
• Abstract methods are defined in subclasses
Problem Situation
• Consider creating an Object that represents an Intern.
• An Intern behaves like both an Employee and a Student.
• Problem: a class can only extend ONE other class
Interfaces
• Solution: Use an interface, which is a set of requirements for a class
• A class can implement more than one interface
• Methods in an interface are automatically public and abstract
• Make Employee an interface
Interface Details
• An interface is a contract for a class.
• An interface specifies a set of methods a class must implement.
• An interface, similar to an abstract class, cannot be instantiated
• An interface has no constructors, only constants and method declarations.
• Classes implement interfaces using the keyword implements
Employee Interface
public interface Employee {
// fields are public static final constants double STARTING_SALARY = 200000.0;
// methods are automatically public and // abstract; must be overridden in // classes that implement the interface String description();
double getSalary();}
public class Student { private String name; private String course;
public Student(String n, String c) { name = n; course = c; }
public String getName() { return name; }
public String getCourse() { return course; }
public String description() { return "a student majoring in " + course; }}
Student Class Revisted
class Intern extends Student implements Employee { private double income;
public Intern(String n, String c) { super(n, c); income = STARTING_SALARY; }
public double getSalary() { return income; }
public String description() { return "intern majoring in "+ super.getCourse() + "with an income of $" + income; }}
Intern Class
Using Intern Class
public static void main(String[] args) {
Intern irish = new Intern("Conor", "Math");
System.out.println(irish.getName() + " ," + irish.description());}
Output: Conor, intern majoring in Math
with an income of $200000.0
Variable Types
• A variable may have the type of an abstract class, an interface, or a concrete class (a non-abstract class).
• Because only a concrete class can be instantiated, an object may only have the type of a concrete class.
• All of these are valid variable declarations: Intern a = new Intern("Conor", "Math"); Student b = new Intern("Conor", "Math"); Employee c = new Intern("Conor", "Math");
Variable vs Object Types (Again)
Intern a = new Intern("Conor", "Math"); Student b = new Intern("Conor", "Math"); Employee c = new Intern("Conor", "Math");
• These expressions will not compile: b.getSalary() // Student does not have getSalary
c.getCourse() // Employee does not have getCourse
• But all of these will: ((Employee)b).getSalary()
((Intern)b).getSalary()
((Student)c).getCourse()
((Intern)c).getCourse()
Interface Rules
• Interfaces may specify but do not implement methods.
• A class that implements the interface must implement all its methods.
• Interfaces cannot be instantiated.
• Interfaces may contain constants.