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 EmployeeStudent 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 object Person kwame = new Student("Kwame", "CS"); Employee kojo = new Employee("Kojo", ); Student yaa = new Student("Yaa", "Math");  Description of an Employee and a Student returns: employee with a salary of ¢ 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", ); 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 Person kojo.description(); // method in Employee yaa.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 types Person 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", ); 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 $ 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 = ; // 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 $

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.