CODEWITHSUNDEEP
javacollections
Eternal Learner
Eternal Learner

Reputation: 3870

How to create a class that implements java.util.collections

I am trying to create a class say MyStack that would implement a java.util.collections class. MyStack will override some methods of the collections class like add(similar to push), remove(similar to pop) etc.. I intend to model the class on the same lines as a Set or other interfaces of the collection class except that MyStack would not be an interface or abstract class and that we can create objects of type MyStack.

I have problems with the syntax as I am not sure if I am proceeding in the right direction.All I have so far is something like this - NOTE - None of the methods have been defined so far - I am trying to get teh skeleton right before proceeding to define the methods. 

import java.util.*;


public class MyStak implements java.util.Collection<E>{

    public boolean add(E o){

               return false;        
        }

       public boolean addAll(Collection c){
        return false; 

        }

       public void clear() {

       }

        public boolean contains(Object o){
          return false;

        }

        public boolean containsAll(Collection o){
          return false;

        }

        public boolean equals(Object c){
          return false; 
        }

        public int hashcode(){
          return 0; 
        }

        public boolean isEmpty(){
          return false; 
        }

        public Iterator iterator(){
          return null;

        }

        public boolean remove(Object o){
          return false; 
        }

        public boolean removeAll(Collection o){
          return false; 
        }

        public boolean retainAll(Collection o){
          return false; 
        }

        public int size(){
          return 1; 
        }

         public Object[] toArray(){
           return null;

         }

         public Object[] toArray(Object[] a){
           return null; 
         }

    }

I have a couple of compile time errors like - 

    +public class MyStak implements java.util.Collection<E>{
Multiple markers at this line
    - The type MyStak must implement the inherited abstract method 
     Collection<E>.add(E)
    - E cannot be resolved to a type

    +public boolean add(E o){
Multiple markers at this line
    - E cannot be resolved to a type
    - implements 
     java.util.Collection<E>.add

Any code modifications, examples , corrections to my code , links to tutorials etc will we highly appreciated.

Upvotes: 5

Views: 19442

Answers (6)

Alexandr
Alexandr

Reputation: 9505

And one recommendation, if you plan to implement your own collection interface consider extending corresponding abstract class, but not implementing interface itself, cause abstract classes implement methods general to the interface. Look at: AbstractCollection, AbstractSet, AbstractList

Upvotes: 2

Nowaker
Nowaker

Reputation: 12401

Is defining a stack what you really want to achieve? If so, then go ahead and define it without even implementing Collection interface - it will be OK for simple cases. Or use an existing class - java.util.Stack.

Upvotes: 0

John Kugelman
John Kugelman

Reputation: 361595

Make sure to throw on a <E> specification on your class as well:

public class MyStak<E> implements java.util.Collection<E>
                   ^^^

If you want to make life easier on yourself try sub-classing AbstractCollection instead of implementing Collection directly. It provides reasonable default implementations for most of the methods to minimize the amount of code you need to write.

java.util

Class AbstractCollection<E>

This class provides a skeletal implementation of the Collection interface, to minimize the effort required to implement this interface.

To implement an unmodifiable collection, the programmer needs only to extend this class and provide implementations for the iterator and size methods. (The iterator returned by the iterator method must implement hasNext and next.)

To implement a modifiable collection, the programmer must additionally override this class's add method (which otherwise throws an UnsupportedOperationException), and the iterator returned by the iterator method must additionally implement its remove method.

The programmer should generally provide a void (no argument) and Collection constructor, as per the recommendation in the Collection interface specification.

Upvotes: 16

Sandy
Sandy

Reputation: 6353

When we implement Collection along with we must implement Iterator<E> also. Which is use to iterate over the item on which you want.

Upvotes: 0

EboMike
EboMike

Reputation: 77732

You were VERY close!

You just need to define E in your subclass as well:

public class MyStak<E> implements java.util.Collection<E>

The idea is that you could have a subclass with, say, <E, F, G>, and you implement two different interfaces, one using E, one using F. That, or MyStak could be specialized and use a specific class for Collection, instead of a generic E.

Upvotes: 4

Laurence Gonsalves
Laurence Gonsalves

Reputation: 143144

Instead of:

public class MyStak implements java.util.Collection<E>{

try:

public class MyStak<E> implements java.util.Collection<E>{

Upvotes: 1

Related Questions