Abstract Classes and Interfaces

howToEat() method in an interface and let it serve as a common supertype for other classes.

For example,

public static void main(String[] args) {

Edible stuff = new Chicken();

eat(stuff);

stuff = new Duck();

eat(stuff);

stuff = new Broccoli();

eat(stuff);

public static void eat(Edible stuff) {

stuff.howToEat();

interface Edible {

class Chicken implements Edible {

return "Fry it";

class Duck implements Edible {

public String howToEat()

return "Roast it";

class Broccoli implements Edible {

return "Stir-fry it";

To define a class that represents edible objects, simply let the class implement the Edible

interface. The class is now a subtype of the Edible type. Any Edible object can be passed

to invoke the eat method.

why wrapper class?

Boolean

java.lang.Number

java.lang.Integer

+byteValue(): byte

-value: int

+shortValue(): short

+MAX_VALUE: int

+intValue(): int

+MIN_VALUE: int

+longValue(): long

+floatValue(): float

+Integer(value: int)

+doubleValue(): double

+Integer(s: String)

+valueOf(s: String): Integer

+valueOf(s: String, radix: int): Integer

«interface»

+parseInt(s: String): int

java.lang.Comparable

+parseInt(s: String, radix: int): int

+compareTo(o: Object): int

java.lang.Double

-value: double

+MAX_VALUE: double

+MIN_VALUE: double

+Double(value: double)

+Double(s: String)

+valueOf(s: String): Double

+valueOf(s: String, radix: int): Double

+parseDouble(s: String): double

+parseDouble(s: String, radix: int): double

Abstract Classes and Interfaces

You can construct a wrapper object either from a primitive data type value or from a string

representing the numeric value—for example, new Double(5.0), new Double("5.0"),

new Integer(5), and new Integer("5").

The wrapper classes do not have no-arg constructors. The instances of all wrapper classes

are immutable; this means that, once the objects are created, their internal values cannot be

changed.

Each numeric wrapper class has the constants MAX_VALUE and MIN_VALUE. MAX_VALUE

represents the maximum value of the corresponding primitive data type. For Byte, Short,

Integer, and Long, MIN_VALUE represents the minimum byte, short, int, and long val-

ues. For Float and Double, MIN_VALUE represents the minimum positive float and

double values. The following statements display the maximum integer (2,147,483,647), the

minimum positive float 11.4E -452, and the maximum double floating-point number

11.79769313486231570e + 308d2.

System.out.println("The maximum integer is " + Integer.MAX_VALUE);

System.out.println("The minimum positive float is " +

Float.MIN_VALUE);

System.out.println(

"The maximum double-precision floating-point number is " +

Double.MAX_VALUE);

Each numeric wrapper class implements the abstract methods doubleValue(),

floatValue(), intValue(), longValue(), and shortValue(), which are defined in

the Number class. These methods return a double, float, int, long, or short value for

the wrapper object.

The numeric wrapper classes have a useful static method, valueOf(String s). This

method creates a new object initialized to the value represented by the specified string. For

example,

Double doubleObject = Double.valueOf("12.4");

Integer integerObject = Integer.valueOf("12");

You have used the parseInt method in the Integer class to parse a numeric string into an

int value and the parseDouble method in the Double class to parse a numeric string into

a double value. Each numeric wrapper class has two overloaded parsing methods to parse a

numeric string into an appropriate numeric value based on 10 (decimal) or any specified

radix (e.g., 2 for binary, 8 for octal, and 16 for hexadecimal). These methods are shown

below:

// These two methods are in the Byte class

public static byte parseByte(String s)

public static byte parseByte(String s, int radix)

// These two methods are in the Short class

public static short parseShort(String s)

public static short parseShort(String s, int radix)

// These two methods are in the Integer class

public static int parseInt(String s)

public static int parseInt(String s, int radix)

// These two methods are in the Long class

public static long parseLong(String s)

public static long parseLong(String s, int radix)

// These two methods are in the Float class

public static float parseFloat(String s)

public static float parseFloat(String s, int radix)

/** Sort an array of comparable objects */

public static void sort(Comparable[] list)

Comparable currentMin;

int currentMinIndex;

for (int i = 0; i < list.length - 1; i++) {

// Find the maximum in the list[0..i]

currentMin = list[i];

currentMinIndex = i;

for (int j = i + 1; j < list.length; j++) {

if (currentMin.compareTo(list[j]) > 0) {

currentMin = list[j];

currentMinIndex = j;

// Swap list[i] with list[currentMinIndex] if necessary;

if (currentMinIndex != i) {

list[currentMinIndex] = list[i];

list[i] = currentMin;