Could someone explain this java practice to me 4

[pigsie]

Hi

I have been reading the latest JDC tech tip newsletter and i came across the following line:

Set sethash = new Hashset();

I'm assuming an object of class Set implements the Hashset interface but why not use
Set sethash = new Set();

Instead? What are the advantages (if any ) are there in creating a reference to an object in this way? I've seen this quite often but could never understand why its done.

I've always wondered about this.

Thanks

Kola

 

[MarsChelios]

Hi pigsie,
It's actually the reverse of what you said.

Set

is an interface and

HashSet

implements it. The

Set

reference

sethash

could refer to any object that implements Set.
One reason for doing this is that you may not know which type of

Set

implementation you want to use at compile time, some implementatons are thread-safe, others aren't, etc., so you program it to make the decision at runtime, choosing from

HashSet

,

TreeSet

, etc.
Hope this Helps,
MarsChelios

 

[pigsie]

Thanks for the reply. I'm still a bit confused are you saying that the sethash reference is presently of type Hashset but at run time this reference can be changed to point to any object which implements the HashSet interface?

Thanks

 

[MarsChelios]

Your confusion is understandable, this is getting into the harder concepts in Java, specifically Polymorphism.
First off,

Set

is the interface, not

HashSet

.

HashSet

implements

Set

and so

HashSet

has the methods of interface

Set

.
Some example code might make things clearer. Say we have an uninstantiated instance variable of type

Set

.

  private Set set;

Then later on, inside a constructor or method, we decide to instantiate it. At this point we may declare the reference

set

to refer to any class that implements the

Set

interface and is not abstract, so we could do:

  set = new HashSet ();

or

  set = new LinkedHashSet ();

or

  set = new TreeSet ();

set

can reference any of these classes because they implement the interface

Set

.
However, there's a trick; All of these classes have methods in addition to what

Set

says they must have, so how can a program that doesn't know what object

set

is call thjose methods?
The answer, they can't. Because the reference

set

was declared initialliy as type

Set

, only the methods in interface

Set

can be called by it and no others.
So for instance, if

set

referred to a

TreeSet

object, the code:

  set.subSet (from, to);

would give an error, since

subSet (Objec,t Object)

is defined in

TreeSet

and not

Set

.
Hope this clears that up, if it doesn't let me know.
MarsChelios

 

[sedj]

nice.

 

[pigsie]

are you saying that at run time we cannot be sure what methods a class has that implements an interface? so we instead make a reference specifying that class so we'll know what methods it supports. Also is it true you cant actually create an instance of an interface?

Thanks

 

[MarsChelios]

Are you saying that at run time we cannot be sure what methods a class has that implements an interface? So we instead make a reference specifying that class so we'll know what methods it supports?
No. I was trying to give an example for coding in this manner, this one is more in depth.
Say based on certain user input that we want to use a

TreeSet

to structure our data, and on other user input a

HashSet

, because structure is not important. So somewhere in our code, we might have a statement like this:

  if (userWantsStructure) {
    treeSet = new TreeSet ();
  }
  else {
    hashSet = new HashSet ();
  }

However, this makes the code twice as long, because whenever we want to add data, we have to see which type the user wants, because we have to use either the

treeSet

or

hashSet

. So code to add data would look like this:

  if (userWantsStructure) {
    treeSet.add (data);
  }
  else {
    hashSet.add ();
  }

This is where your question comes to the rescue. Both of these classes ,

TreeSet

and

HashSet

, implement

Set

. Also, most of the times we need to use these objects, we are using methods defined in

Set

.
By creating a variable of type

Set

, like so:

  private Set set;

and initializing it similar to the example above:

  if (userWantsStructure) {
    set = new TreeSet ();
  }
  else {
    set = new HashSet ();
  }

we can now do anything that

Set

defines, no matter whether

set

refers to a

TreeSet

or a

HashSet

. So the code to add data, no matter which object

set

references, would be:

  set.add (data);

If we wanted to do something specific with

TreeSet

or

HashSet

, then we would have to do the check for which type

set

references, cast

set

to that type, and then access the methods needed, shown below:

  if (set instanceof TreeSet) {
    TreeSet treeSet = (TreeSet) set;
    //Do something with treeSet here 
  }
  else {
    HashSet hashSet = (HashSet) set;
    //Do something with hashSet here 
  }

Also is it true you can't actually create an instance of an interface?
Technically yes. This is a little off topic, but anonymous classes are an exception to this. You can create an anonymous class that implements an interface and this violates direct instantiation of interfaces. Here is an example, using

ActionListener

, since that's how I use it most.

  ActionListener listener = new ActionListener () {
    public void actionPerformed (ActionEvent event) {
      //Code here for actionPerformed
    }
  };

I'm not quite sure what else to talk about, let me know if you have any further questions.

MarsChelios

 

[pigsie]

MarsChelios

Thank you for your patience, I understand it now.
by creating a variable in this way:

private Set set

it can be reference to any class which implements the set interface giving you more flexibility later on down the road!

Thanks

 

[MarsChelios]

Exactly!
MarsChelios