Abstract Classes in Object-Oriented Programming
Abstract Classes
•
We often define classes as subclasses of other classes
–
First, define the superclass
–
In some cases, a superclass may not have enough
specificity to allow for an implementation of one or more
methods
•
a GeometricObject class might be the parent for Circle and
Rectangle
•
computeArea and computePerimeter are two useful methods for
these subclasses but GeometricObject is too generic of a class to
be able to implement these methods on
•
yet we want to define these methods in GeometricObject so they
are inherited by Circle and Rectangle
•
recall we did something similar when implement Vehicle so that
other Vehicle subclasses could inherit getBattleUtility
•
An
abstract method
is a definition for a method
without an implementation
•
An
abstract class
is a class that contains at least one
abstract method
Abstract Classes
•
You cannot instantiate an object of an abstract class
(although you can declare a variable to be of that type
for polymorphism)
–
Here we see obj is a GeometricObject
–
We cannot instantiate obj to be a GeometricObject but we
can instantiate it to be a Circle or a Rectangle
•
GeometricObject obj;
•
obj = new Circle(10);
•
…
•
obj = new Rectangle(5,10);
•
The reason for having abstract classes is first to
provide a “placeholder” that informs programmers of
what needs to be implemented in a subclass and
second to provide a common basis for all subclasses
of this superclass
Defining an Abstract Class
•
Add the word
abstract
to the class header
–
public abstract class
Name
•
You can define instance data, constants and methods as
normal
–
You can also implement at least one abstract method (you do not
have to have abstract methods in an abstract class)
•
To declare an abstract method
–
Place the word
abstract
in the method header
–
In place of the method’s implementation
{…}just put a
;
•
public abstract void foo(…);
–
The method’s profile (return type, parameters) must be exactly
as you expect subclasses to implement them
•
you must override an abstract method, it can not be overloaded
•
you cannot make an abstract method static
•
The example that follows is the UML for GeometricObject,
Circle and Rectangle
Some Comments
•
Abstract methods cannot be placed in non-abstract classes
–
If a class extends an abstract class, it must either implement all
inherited abstract methods or itself also be abstract
–
Recall that you cannot instantiate an object of an abstract class
•
An abstract class does not need to contain abstract methods
–
You would only do this if the superclass was merely a base for
other classes to inherit from
•
A subclass can override a parent class’ method and make it
abstract – in which case the subclass would have to be
abstract
–
Here the superclass is not [necessarily] abstract while the
subclass is
–
This is unusual but allows you to “shut off” inheritance of a
superclass implementation of a method
Example: Revising Vehicle
public abstract class Vehicle
{protected String type;
protected boolean heavilyArmored;
protected int capacity;
protected int speed;
protected int armament;
public Vehicle(String t) { ... }public String getType() {...}public boolean getHeavilyArmored() {...}public int getCapcity() {...}public int getSpeed() {...}public int getArmament() {...}public String toString() {...}public abstract int getBattleUtility
(boolean night, boolean roughTerrain,
boolean needGroundSupport, boolean needHeavyArms,
boolean antiAircraftGuns, boolean equipment,
int distance);
}
As before
abstract and no implementation
Another Example
•
We want to define a deck of cards
–
There are different types of cards
•
Ordinary cards which are shuffled randomly
•
Magic cards which are not shuffled randomly
•
Stacked decks
•
We will define CardClass to represent an abstract deck of
cards
–
This class will create instance data of the deck itself (an array
of ints which indicate the order of the cards currently) and
whether a particular card has been dealt yet (a boolean array)
–
Non-abstract methods will be a constructor and accessors to get
a card and determine if a card has been dealt
–
But the shuffle method will be abstract based on the subclass
•
We will then implement a subclass, PlayingCards to be a
deck of ordinary playing cards
–
The shuffle method is implemented as a simple random
generation of the sequence of cards (numbers 0-51)
public abstract class CardClass {protected int[] deck;
protected boolean[] dealt;
public CardClass() {deck=new int[52];
dealt=new boolean[52];
for(int i=0;i<52;i++) dealt[i]=false;
}
public boolean dealtYet(int index) throws
IndexOutOfBoundsException
{if(index<52) return dealt[index];
else throw new IndexOutOfBoundsException(index +
" is too large for the size of this deck");
}
public int getCard(int index) throws
IndexOutOfBoundsException {if(index<52) return deck[index];
else throw new IndexOutOfBoundsException(index +
" is too large for the size of this deck");
}
public abstract void shuffle();
}
import java.util.*;
public class PlayingCards extends CardClass {protected Random g;
public PlayingCards() {super();
g=new Random();
}
public void shuffle() {boolean[] order=new boolean[52];
int i, temp;
for(i=0;i<52;i++) order[i]=false;
for(i=0;i<52;i++) {do
{temp=g.nextInt(52);
}while(order[temp]);
order[temp]=true;
deck[i]=temp;
}
}
}
Arrays of an Abstract Class
•
You cannot instantiate an abstract class
•
But you can create an array of an abstract class
and instantiate the individual array elements to be
subclasses
–
Assume we have our previously described
GeometricShape, Circle and Rectangle classes
–
GeometricShape[ ] shapes = new
GeometricShape[10];
•
This is legal
–
shapes[0] = new Circle(10);
–
shapes[1] = new Rectangle(5, 10);
•
These are legal
–
Shapes[2] = new GeometricShape( );
•
This is illegal because GeometricShape is abstract
Interfaces
•
Java does not permit
multiple inheritance
(inheriting
from multiple classes) but it does provide interfaces
–
In a way, interfaces are a form of multiple inheritance
•
An interface is like an abstract class in that it defines
a portion of a class but does not implement it
–
The interface class contains constants and abstract methods
only, no implemented methods and no instance data
–
By
implementing
an interface, like extending an abstract
class, you are completing the class
–
The advantage of implementing an interface is that you are
stating that the given class will act a certain way so that
other classes can expect a particular functionality
•
for instance, you might implement Comparable indicating that the
class will implement comparesTo
Implementing an Interface
•
You add to the class header
implements
InterfaceName
•
Now you must override the abstract method(s)
defined in the Interface
–
If you do not override
all
of the abstract methods, you
will receive compilation errors
–
You cannot instantiate an object of a type of Interface
class because of the abstract methods (just as you cannot
instantiate the object of an abstract class), all you can do
is implement the Interface class in your own class
•
One of the most significant types of Interfaces is the
class of GUI handlers that will respond when a GUI
component, mouse, or keyboard action occurs
–
We will look at this later in the semester
–
Here, we will concentrate on two of the most significant
interfaces: Comparable and Cloneable
Implementing Comparable
•
Comparable is an interface class meaning that as a class, it
is defined as an interface which means that you cannot
instantiate an object of this type
•
You also will (most likely) not extend Comparable but
instead implement Comparable
•
The reason for the Comparable interface is to indicate that
a class that you are implementing will have the ability to
directly compare two instances of this type
–
recall that the relational operators (<, >, etc) are not available
for objects, only for primitive types
–
so instead, we will implement Comparable which requires that
we implement a method called compareTo (recall Strings have
this method, the reason being that Strings implement
Comparable requiring this method be implemented)
•
How do you compare two objects? Depends on the type
of object – we look at a couple of examples coming up
Continued
•
To implement Comparable, do the following
–
Add
implements Comparable
to the class header
•
As in
public class MyClass extends YourClass
implements Comparable
–
Add a compareTo method with the following profile
•
public int compareTo(Object o) {…}•
Notice that your compareTo is receiving an Object, not a MyClass
object, why? Because this is how compareTo appears as an abstract
method in the Comparable class
•
If you do not match this profile exactly then you are not overriding
the abstract compareTo but instead overloading it, and so
compilation will fail
•
compareTo will return an int value: negative if this object is less
than the object passed to compareTo, positive if this object is greater
and 0 if the two objects are deemed equivalent
Examples
•
Here, we make the Circle class (introduced earlier
in the semester) Comparable
–
Circles will be compared based on their radius
•
As an alternative to using (Object o) and
downcasting as shown above, we can implement
Comparable<Circle> employing generics
–
see the next example
public class Circle extends GeometricObject
implements Comparable {... // as before
public int compareTo(Object o)
{ if(radius>((Circle)o).getRadius( )) return 1; else if(radius<((Circle)o).getRadius( )) return -1;
else return 0;
}
}
Another Example: Comparing Names
public class Name implements Comparable<Name> {private String first, middle, last;
public Name(String f, String m, String l) {first=f;middle=m;last=l;
}
public String getFirst() {return first;}public String getMiddle() {return middle;}public String getLast() {return last;}public int compareTo(Name n) {if(last.compareTo(n.getLast())>0) return 1;
else if(last.compareTo(n.getLast())<0) return -1;
else if(first.compareTo(n.getFirst())>0) return 1;
else if(first.compareTo(n.getFirst())<0) return -1;
else if(middle.compareTo(n.getMiddle())>0) return 1;
else if(middle.compareTo(n.getMiddle())<0) return -1;
else return 0;
}
}
Creating An Interface Class
•
You can create your own interface classes by substituting
the modifier
interface
in place of class
–
public interface InterfaceName
•
The Interface’s definition will consist solely of constants
and abstract method definitions
–
The abstract methods have no body (no {…}) and end with a ;•
Example: we have a class called Instrument to define
various types of musical instruments
–
We want to define an interface class called Playable which, if
implemented, will indicate how to play that instrument
–
public interface Playable {public abstract String howToPlay( ); }
–
Now, if we implement Playable, we have to define a howToPlay
method which returns a String
Implementing Playable
public class Drums extends Instrument implements Playable {private int numDrums;
public Drums(int size) {super(“Drums”);
// assume Instrument’s constructor assigns
numDrums=size;
// the var type to this String
}
public Drums( ) {super(“Drums”);
numDrums=0;
}
public String howToPlay( ) {return “Strike drums with drumsticks or mallets”;
}
}
public class Guitar extends Instrument implements Playable {private int numStrings;
// constructors similar to Drums
public String howToPlay( ) {return “Strum strings with pick or fingers”;
}
}
Implementing Cloneable
•
Consider the following code
–
SomeObject o1, o2;
–
o1=new SomeObject(…);
–
o2=o1;
•
In this code, o1 points at an object in heap memory that has
been instantiated with the new operator, but what about o2?
–
Is o2 another object with the same values as o1 or is it the same
object? It is the same
•
If we instead want to “clone” o1 into o2 we would create
another object, have o2 point at the new object in the heap,
and set all of its values to be the same as o1
•
In this way, we have two different objects which are
equivalent rather than two reference variables which are
equal in that they are pointing at the same object
•
We accomplish this by implementing Cloneable which
requires implementing a clone method
Cloneable Interface
•
Unlike Comparable, the Cloneable interface is empty
– there is no abstract method defined
–
You must still implement the clone method
•
According to the textbook, the abstract method for
clone is defined as follows
–
protected native Object clone( ) throws
CloneNotSupportedException;
–
native
means that the actual implementation for copying
data is left up to the JVM, not the compiler
–
Notice that clone returns an Object so you will have to cast
the returned object appropriately
–
You must either add the “throws Clone…” to your method
header or handle it in a try-catch block when you attempt to
clone an object of the class you have implemented as
cloneable
Example: Person Class
public class Person implements Cloneable
{private String name;
private int age, height, weight;
private boolean isMarried;
private Person spouse;
public Person() {age=0;
name="unknown";
isMarried=false;
spouse=null;
}
public Person(String n, int a, int h, int w) {age=a;
name=n;
height=h;
weight=w;
isMarried=false;
spouse=null;
}
public Person(String n, int a, int h, int w, Person s) {age=a;
name=n;
height=h;
weight=w;
isMarried=true;
spouse=s;
}
public void getsMarried(Person s) { if(!isMarried) {isMarried=true;
spouse=s;
}
else System.out.println(name + " cannot marry " +
s.getName() + " until " + name + " gets a divorce!");
}
public String getName() {return name;}public int getAge() {return age;}public int getHeight() {return height;}public int getWeight() {return weight;}public String getSpouseName() {if(isMarried) return spouse.getName(); else return "not married";}
public void setName(String n) { if(name==null) name=n;}public void setAge(int a) { if(age==0) age=a;}public void setHeight(int h) { if(height==0) height=h;}public void setWeight(int w) { if(weight==0) weight=w;}public void setMarried(Person s) {if(!isMarried)
{isMarried=true;
spouse=s;
}
}
public Object clone() throws CloneNotSupportedException
{Person p=(Person)super.clone();
p.setName(name);
p.setAge(age);
p.setHeight(height);
p.setWeight(weight);
p.setMarried(spouse);
return p;
}
} // ends the class
People Class
public class People
{public static void main(String[] args) throws
CloneNotSupportedException
{Person p1=new Person();
Person p2=new Person("Frank Zappa", 53, 69, 158);Person p3=new Person("Gail Sloatman", 50, 63, 110);p2.getsMarried(p3);
p3.getsMarried(p2);
p1=(Person)p2.clone();
System.out.println(p1.getName() + " " + p1.getAge()
+ " " + p1.getHeight() + " " + p1.getWeight() +
" " + p1.getSpouseName());
}
}
An alternative implementation is to remove the throws statement from main
and insert the
p1=(Person)p2.clone();
statement in a try block with
a catch block that can catch
CloneNotSupportedException
Interfaces vs Abstract Classes
•
Both types provide a basis for the programmer to build upon
–
Abstract classes support single inheritance
–
Interfaces offer a form of multiple inheritance
–
Abstract classes can contain instance data and non-abstract
methods
–
Interfaces cannot contain instance data and non-abstract
methods (and can even be empty), the only variables must be
constants (
public static final
) and the only methods
must be
public abstract
–
Abstract classes can have constructors, interfaces will not
–
Objects of either type can be declared but not instantiated
•
An interface class can itself extend other interfaces in which
case implementing that interface requires implementing all
of the methods of that interface and its superclasses
–
A naming convention: class names are usually nouns but
interface names can be nouns or adjectives (particularly if they
end with “able” or “ible” such as “Comparable” or “Cloneable”)
Abstract classes serve as blueprints for subclasses in object-oriented programming, allowing for shared functionality while ensuring specific methods are implemented in subclasses. By defining abstract methods and classes, programmers create a foundation for inheritance, polymorphism, and structured design. This article explores the concept of abstract classes in Java, highlighting their importance, usage, and implementation through examples like GeometricObject, Circle, and Rectangle.
Download Presentation
Please find below an Image/Link to download the presentation.
The content on the website is provided AS IS for your information and personal use only. It may not be sold, licensed, or shared on other websites without obtaining consent from the author. Download presentation by click this link. If you encounter any issues during the download, it is possible that the publisher has removed the file from their server.
E N D
Presentation Transcript
Abstract Classes We often define classes as subclasses of other classes First, define the superclass In some cases, a superclass may not have enough specificity to allow for an implementation of one or more methods a GeometricObject class might be the parent for Circle and Rectangle computeArea and computePerimeter are two useful methods for these subclasses but GeometricObject is too generic of a class to be able to implement these methods on yet we want to define these methods in GeometricObject so they are inherited by Circle and Rectangle recall we did something similar when implement Vehicle so that other Vehicle subclasses could inherit getBattleUtility An abstract method is a definition for a method without an implementation An abstract class is a class that contains at least one abstract method
Abstract Classes You cannot instantiate an object of an abstract class (although you can declare a variable to be of that type for polymorphism) Here we see obj is a GeometricObject We cannot instantiate obj to be a GeometricObject but we can instantiate it to be a Circle or a Rectangle GeometricObject obj; obj = new Circle(10); obj = new Rectangle(5,10); The reason for having abstract classes is first to provide a placeholder that informs programmers of what needs to be implemented in a subclass and second to provide a common basis for all subclasses of this superclass
Defining an Abstract Class Add the word abstract to the class header public abstract class Name You can define instance data, constants and methods as normal You can also implement at least one abstract method (you do not have to have abstract methods in an abstract class) To declare an abstract method Place the word abstract in the method header In place of the method s implementation { } just put a ; public abstract void foo( ); The method s profile (return type, parameters) must be exactly as you expect subclasses to implement them you must override an abstract method, it can not be overloaded you cannot make an abstract method static The example that follows is the UML for GeometricObject, Circle and Rectangle
GeometricObject Abstract class -color: String -filled: boolean -dateCreated: java.util.Date The # sign indicates protected modifier #GeometricObject() #GeometricObject(color: string, filled: boolean) +getColor(): String +setColor(color: String): void +isFilled(): boolean +setFilled(filled: boolean): void +getDateCreated(): java.util.Date +toString(): String +getArea(): double Abstract methods are italicized +getPerimeter(): double Methods getArea and getPerimeter are overridden in Circle and Rectangle. Superclass methods are generally omitted in the UML diagram for subclasses. Rectangle Circle -width: double -radius: double -height: double +Circle() +Rectangle() +Circle(radius: double) +Rectangle(width: double, height: double) +Circle(radius: double, color: string, filled: boolean) +Rectangle(width: double, height: double, color: string, filled: boolean) +getRadius(): double +getWidth(): double +setRadius(radius: double): void +setWidth(width: double): void +getDiameter(): double +getHeight(): double +setHeight(height: double): void
Some Comments Abstract methods cannot be placed in non-abstract classes If a class extends an abstract class, it must either implement all inherited abstract methods or itself also be abstract Recall that you cannot instantiate an object of an abstract class An abstract class does not need to contain abstract methods You would only do this if the superclass was merely a base for other classes to inherit from A subclass can override a parent class method and make it abstract in which case the subclass would have to be abstract Here the superclass is not [necessarily] abstract while the subclass is This is unusual but allows you to shut off inheritance of a superclass implementation of a method
Example: Revising Vehicle public abstract class Vehicle { protected String type; protected boolean heavilyArmored; protected int capacity; protected int speed; protected int armament; public Vehicle(String t) { ... } public String getType() {...} public boolean getHeavilyArmored() {...} public int getCapcity() {...} public int getSpeed() {...} public int getArmament() {...} public String toString() {...} public abstract int getBattleUtility (boolean night, boolean roughTerrain, boolean needGroundSupport, boolean needHeavyArms, boolean antiAircraftGuns, boolean equipment, int distance); } As before abstract and no implementation
Another Example We want to define a deck of cards There are different types of cards Ordinary cards which are shuffled randomly Magic cards which are not shuffled randomly Stacked decks We will define CardClass to represent an abstract deck of cards This class will create instance data of the deck itself (an array of ints which indicate the order of the cards currently) and whether a particular card has been dealt yet (a boolean array) Non-abstract methods will be a constructor and accessors to get a card and determine if a card has been dealt But the shuffle method will be abstract based on the subclass We will then implement a subclass, PlayingCards to be a deck of ordinary playing cards The shuffle method is implemented as a simple random generation of the sequence of cards (numbers 0-51)
public abstract class CardClass { protected int[] deck; protected boolean[] dealt; public CardClass() { deck=new int[52]; dealt=new boolean[52]; for(int i=0;i<52;i++) dealt[i]=false; } public boolean dealtYet(int index) throws IndexOutOfBoundsException { if(index<52) return dealt[index]; else throw new IndexOutOfBoundsException(index + " is too large for the size of this deck"); } public int getCard(int index) throws IndexOutOfBoundsException { if(index<52) return deck[index]; else throw new IndexOutOfBoundsException(index + " is too large for the size of this deck"); } public abstract void shuffle(); }
import java.util.*; public class PlayingCards extends CardClass { protected Random g; public PlayingCards() { super(); g=new Random(); } public void shuffle() { boolean[] order=new boolean[52]; int i, temp; for(i=0;i<52;i++) order[i]=false; for(i=0;i<52;i++) { do { }while(order[temp]); order[temp]=true; deck[i]=temp; } } } temp=g.nextInt(52);
Arrays of an Abstract Class You cannot instantiate an abstract class But you can create an array of an abstract class and instantiate the individual array elements to be subclasses Assume we have our previously described GeometricShape, Circle and Rectangle classes GeometricShape[ ] shapes = new GeometricShape[10]; This is legal shapes[0] = new Circle(10); shapes[1] = new Rectangle(5, 10); These are legal Shapes[2] = new GeometricShape( ); This is illegal because GeometricShape is abstract
Interfaces Java does not permit multiple inheritance (inheriting from multiple classes) but it does provide interfaces In a way, interfaces are a form of multiple inheritance An interface is like an abstract class in that it defines a portion of a class but does not implement it The interface class contains constants and abstract methods only, no implemented methods and no instance data By implementing an interface, like extending an abstract class, you are completing the class The advantage of implementing an interface is that you are stating that the given class will act a certain way so that other classes can expect a particular functionality for instance, you might implement Comparable indicating that the class will implement comparesTo
Implementing an Interface You add to the class header implements InterfaceName Now you must override the abstract method(s) defined in the Interface If you do not override all of the abstract methods, you will receive compilation errors You cannot instantiate an object of a type of Interface class because of the abstract methods (just as you cannot instantiate the object of an abstract class), all you can do is implement the Interface class in your own class One of the most significant types of Interfaces is the class of GUI handlers that will respond when a GUI component, mouse, or keyboard action occurs We will look at this later in the semester Here, we will concentrate on two of the most significant interfaces: Comparable and Cloneable
Implementing Comparable Comparable is an interface class meaning that as a class, it is defined as an interface which means that you cannot instantiate an object of this type You also will (most likely) not extend Comparable but instead implement Comparable The reason for the Comparable interface is to indicate that a class that you are implementing will have the ability to directly compare two instances of this type recall that the relational operators (<, >, etc) are not available for objects, only for primitive types so instead, we will implement Comparable which requires that we implement a method called compareTo (recall Strings have this method, the reason being that Strings implement Comparable requiring this method be implemented) How do you compare two objects? Depends on the type of object we look at a couple of examples coming up
Continued To implement Comparable, do the following Add implements Comparable to the class header As in public class MyClass extends YourClass implements Comparable Add a compareTo method with the following profile public int compareTo(Object o) { } Notice that your compareTo is receiving an Object, not a MyClass object, why? Because this is how compareTo appears as an abstract method in the Comparable class If you do not match this profile exactly then you are not overriding the abstract compareTo but instead overloading it, and so compilation will fail compareTo will return an int value: negative if this object is less than the object passed to compareTo, positive if this object is greater and 0 if the two objects are deemed equivalent
Examples Here, we make the Circle class (introduced earlier in the semester) Comparable Circles will be compared based on their radius public class Circle extends GeometricObject implements Comparable { ... // as before public int compareTo(Object o) { if(radius>((Circle)o).getRadius( )) return 1; else if(radius<((Circle)o).getRadius( )) return -1; else return 0; } } As an alternative to using (Object o) and downcasting as shown above, we can implement Comparable<Circle> employing generics see the next example
Another Example: Comparing Names public class Name implements Comparable<Name> { private String first, middle, last; public Name(String f, String m, String l) { first=f;middle=m;last=l; } public String getFirst() {return first;} public String getMiddle() {return middle;} public String getLast() {return last;} } public int compareTo(Name n) { if(last.compareTo(n.getLast())>0) return 1; else if(last.compareTo(n.getLast())<0) return -1; else if(first.compareTo(n.getFirst())>0) return 1; else if(first.compareTo(n.getFirst())<0) return -1; else if(middle.compareTo(n.getMiddle())>0) return 1; else if(middle.compareTo(n.getMiddle())<0) return -1; else return 0; }
Creating An Interface Class You can create your own interface classes by substituting the modifier interface in place of class public interface InterfaceName The Interface s definition will consist solely of constants and abstract method definitions The abstract methods have no body (no { }) and end with a ; Example: we have a class called Instrument to define various types of musical instruments We want to define an interface class called Playable which, if implemented, will indicate how to play that instrument public interface Playable { public abstract String howToPlay( ); } Now, if we implement Playable, we have to define a howToPlay method which returns a String
Implementing Playable public class Drums extends Instrument implements Playable { private int numDrums; public Drums(int size) { super( Drums );// assume Instrument s constructor assigns numDrums=size; // the var type to this String } public Drums( ) { super( Drums ); numDrums=0; } public String howToPlay( ) { return Strike drums with drumsticks or mallets ; } } public class Guitar extends Instrument implements Playable { private int numStrings; // constructors similar to Drums public String howToPlay( ) { return Strum strings with pick or fingers ; } }
Implementing Cloneable Consider the following code SomeObject o1, o2; o1=new SomeObject( ); o2=o1; In this code, o1 points at an object in heap memory that has been instantiated with the new operator, but what about o2? Is o2 another object with the same values as o1 or is it the same object? It is the same If we instead want to clone o1 into o2 we would create another object, have o2 point at the new object in the heap, and set all of its values to be the same as o1 In this way, we have two different objects which are equivalent rather than two reference variables which are equal in that they are pointing at the same object We accomplish this by implementing Cloneable which requires implementing a clone method
Cloneable Interface Unlike Comparable, the Cloneable interface is empty there is no abstract method defined You must still implement the clone method According to the textbook, the abstract method for clone is defined as follows protected native Object clone( ) throws CloneNotSupportedException; native means that the actual implementation for copying data is left up to the JVM, not the compiler Notice that clone returns an Object so you will have to cast the returned object appropriately You must either add the throws Clone to your method header or handle it in a try-catch block when you attempt to clone an object of the class you have implemented as cloneable
Example: Person Class public class Person implements Cloneable { private String name; private int age, height, weight; private boolean isMarried; private Person spouse; public Person() { age=0; name="unknown"; isMarried=false; spouse=null; } public Person(String n, int a, int h, int w) { age=a; name=n; height=h; weight=w; isMarried=false; spouse=null; }
public Person(String n, int a, int h, int w, Person s) { age=a; name=n; height=h; weight=w; isMarried=true; spouse=s; } public void getsMarried(Person s) { if(!isMarried) { isMarried=true; spouse=s; } else System.out.println(name + " cannot marry " + s.getName() + " until " + name + " gets a divorce!"); } public String getName() {return name;} public int getAge() {return age;} public int getHeight() {return height;} public int getWeight() {return weight;} public String getSpouseName() {if(isMarried) return spouse.getName(); else return "not married";}
public void setName(String n) { if(name==null) name=n;} public void setAge(int a) { if(age==0) age=a;} public void setHeight(int h) { if(height==0) height=h;} public void setWeight(int w) { if(weight==0) weight=w;} public void setMarried(Person s) { if(!isMarried) { isMarried=true; spouse=s; } } } // ends the class public Object clone() throws CloneNotSupportedException { Person p=(Person)super.clone(); p.setName(name); p.setAge(age); p.setHeight(height); p.setWeight(weight); p.setMarried(spouse); return p; }
People Class public class People { public static void main(String[] args) throws CloneNotSupportedException { Person p1=new Person(); Person p2=new Person("Frank Zappa", 53, 69, 158); Person p3=new Person("Gail Sloatman", 50, 63, 110); p2.getsMarried(p3); p3.getsMarried(p2); p1=(Person)p2.clone(); System.out.println(p1.getName() + " " + p1.getAge() + " " + p1.getHeight() + " " + p1.getWeight() + " " + p1.getSpouseName()); } } An alternative implementation is to remove the throws statement from main and insert the p1=(Person)p2.clone(); statement in a try block with a catch block that can catch CloneNotSupportedException
Interfaces vs Abstract Classes Both types provide a basis for the programmer to build upon Abstract classes support single inheritance Interfaces offer a form of multiple inheritance Abstract classes can contain instance data and non-abstract methods Interfaces cannot contain instance data and non-abstract methods (and can even be empty), the only variables must be constants (public static final) and the only methods must be public abstract Abstract classes can have constructors, interfaces will not Objects of either type can be declared but not instantiated An interface class can itself extend other interfaces in which case implementing that interface requires implementing all of the methods of that interface and its superclasses A naming convention: class names are usually nouns but interface names can be nouns or adjectives (particularly if they end with able or ible such as Comparable or Cloneable )
