Abstract Classes and Interfaces Chapter 9 CSCI 1302

Abstract Classes and Interfaces

Chapter 9CSCI 1302

CSCI 1302 – Abstract Classes and Interfaces 2

Outline

• Introduction• Abstract Classes• Interfaces

– Implementing Interfaces– Interfaces vs. Abstract Classes– Creating Custom Interfaces

• Processing Primitive Data Type Values as Objects– Numeric Wrapper Class Constructors


Outline

• Processing Primitive Data Type Values as Objects (cont.)– Numeric Wrapper Class Constants– Conversion Methods– The Static valueOf Methods– The Methods for Parsing Strings into

Numbers

• Automatic Conversion Between Primitive and Wrapper Class Types


Introduction

• Recall specificity chain• Superclasses should contain common

features of its subclasses• Superclass so general it does not have

specific instances is an abstract class• Java classes can have only one

superclass (single inheritance)• Can emulate multiple inheritance with

interfaces


Abstract Classes

• Concrete classes vs. abstract classes• Classes that are derived from the same

superclass have common properties and behaviors

• Often the superclass will have methods (behaviors) that it cannot and should not implement for its subclasses

• These methods are abstract methods, method signature in the superclass, but only implemented in the subclass


Abstract Classes

• A class that contains abstract methods should be declared abstract

• Cannot declare new instances of this class

• Provides common features (data and methods)

• Declares subclass implementation-specific methods as abstract


Abstract Classes

• Abstract methods must be in abstract classes

• If a subclass does not implement all abstract superclass methods, the subclass must be abstract

• Abstract classes cannot be instantiated, but can still have constructors for its subclasses


Abstract Classes

• See GeometricObject code packet

Circle -radius: double +getRadius(): double +setRadius(radius: double): void

Cylinder

-length: double +getLength(): double +setLength(length: double): void +findVolume(): double

GeometricObject -color: String -filled: boolean +getColor(): String +setColor(String color): void +isFilled(): boolean +setFilled(boolean filled): void +findArea(): double +findPerimeter(): double

Object

Rectangle -width: double -length: double +getWidth(): double +setWidth(width: double): void +getLength(): double +setLength(length: double): void

UML Notation: The abstract class name and the abstract method names are italicized.


Interfaces

• Classlike construct that contains only constants and abstract methods

• Declared with interface keywordpublic interface InterfaceName {/** Constants *//** Method signatures */

}

• Provides a generic framework for common operations

• Best example: java.lang.Comparable


Interfaces

• Interface can define generic compareTo methodpackage java.lang;public interface Comparable {public int compareTo(Object o);

}

• Defined behavior: Returns 0 if equal, negative number if calling object is less than o, positive number if calling object is greater than o


Interfaces

• Can now create generic max methodpublic Object max(Object o1, Object o2) {if(((Comparable)o1).compareTo(o2) > 0)

return o1;else

return o2;}


Implementing Interfaces

• Use keyword implements when forming class

• Inherits all constants in the interface and implements all the methods

• Another form of generic programming


Implementing Interfaces

• Create a ComparableRectangle class that implements Comparable

• See ComparableRectangle.java

Rectangle -

GeometricObject -

java.lang.Comparable +compareTo(o: Object):int

Notation: The interface name and the method names are italicized. The dashed lines and hollow triangles are used to point to the interface.

ComparableRectangle -


Interface vs. Abstract Classes

• Interfaces and abstract classes can be used in similar ways, but are defined differently

• In an interface, the data must be constants, abstract classes can have non-constant data fields (variables)

• Interface methods have only a signature, abstract classes can have concrete methods


Interface vs. Abstract Classes

• Classes can only inherit from one class, but can implement manypublic class NewClass extends BaseClassimplements Interface1, … , InterfaceN

• Both model common features, when do you use one over the other?

• Use inheritance when modeling strong is-a relationships. Use interfaces when modeling weak is-a relationships

• Interfaces are adjectives or nouns


Primitive Data Types as Objects

• Primitive data types exist for performance issues

• Some methods only take objects, use wrapper classes to wrap primitive data types into forms useful for generic programming

• Boolean, Character, Double, Float, Byte, Short, Integer, and Long in java.lang

• All extend the abstract Number class and implement the Comparable interface


Wrapper Class Constructors

• Construct from primitive type or stringInteger intObj = new Integer(5);Integer intObj = new Integer(“5”);Double dblObj = new Double(5.0);Double dblObj = new Double(“5.0”);


Wrapper Class Constants

• All wrapper classes have MAX_VALUE and MIN_VALUE

System.out.println(Integer.MAX_VALUE);System.out.println(Float.MIN_VALUE);


Conversion Methods• doubleValue, floatValue, intValue, longValue, and shortValue methods are available in all wrapper classes

long l = doubleObject.longValue();int i = integerObject.intValue();

double a = 5.9;Double doubleObject = new Double(a);String s = doubleObject.toString();


Static valueOf Methods

• Convert string into object of wrapper type

Double a = Double.valueOf(“12”);Integer b = Integer.valueOf(“4”);


Parsing Strings into Numbers

• Parse strings into with parseType methods

Integer.parseInt(“10”);Long.parseLong(“12”);Byte.parseByte(“14”);


Sort Arrays of Objects

• See GenericSort.java

Documents

Abstract Classes and Interfaces Chapter 9 CSCI 1302