Wildcards und Generics Fehler

Question

Der folgende Code ist Wegwerf, eine gescheiterte Idee, eine Enumeration in der neuen foreach-Schleife zu arbeiten, aber ich würde es kompilieren lassen, da ich immer wieder auf ein Problem mit Generics und Joker stoßen. Aus welchen Gründen auch immer kann ich nicht sehen, wie man es repariert.

Also, welche Änderungen müssen vorgenommen werden, um diese Kompilierung zu machen?

import java.util.Enumeration; 
import java.util.HashSet; 
import java.util.Iterator; 
import java.util.Set; 
import java.util.zip.ZipEntry; 
import java.util.zip.ZipFile; 


public class Main 
{ 
    private ZipFile zipFile; 

    public Set<String> entries() 
    { 
     final Set<String>        names; 
     final Enumeration<? extends ZipEntry>   enumeration; 
     final IterableEnumeration<? extends ZipEntry> iteratable; 

     names = new HashSet<String>(); 

     // zipFile.entries() returns "Enumeration<? extends ZipEntry>" 
     enumeration = zipFile.entries(); 

     // this line won't compile 
     iteratable = new IterableEnumeration<? extends ZipEntry>(enumeration); 

     for(final ZipEntry entry : iteratable) 
     { 
      if(!(entry.isDirectory())) 
      { 
       names.add(entry.getName()); 
      } 
     } 

     return (names); 
    } 
} 

class IterableEnumeration<T> 
    implements Iterable<T> 
{ 
    private final Enumeration<T> enumeration; 

    public IterableEnumeration(final Enumeration<T> e) 
    { 
     enumeration = e; 
    } 

    public Iterator<T> iterator() 
    { 
     final EnumerationIterator<T> iterator; 

     // yeah cannot do this since an Iterable is supposed to work multiple times on the same object and Enumeration is descructive... 
     iterator = new EnumerationIterator<T>(enumeration); 

     return (iterator); 
    } 
} 

class EnumerationIterator<T> 
    implements Iterator<T> 
{ 
    private final Enumeration<T> enumeration; 

    public EnumerationIterator(final Enumeration<T> e) 
    { 
     enumeration = e; 
    } 

    public boolean hasNext() 
    { 
     return (enumeration.hasMoreElements()); 
    } 

    public T next() 
    { 
     return (enumeration.nextElement()); 
    } 

    public void remove() 
    { 
     throw new UnsupportedOperationException("Cannt remove via an Enumeration"); 
    } 
} 

Der Fehler ist:

Main.java:26: unexpected type 
found : ? extends java.util.zip.ZipEntry 
required: class or interface without bounds 
     iteratable = new IterableEnumeration<? extends ZipEntry>(enumeration); 
              ^
1 error 

Answer 1

Sie nicht einen Platzhalter angeben können, wenn eine parametrisierte Typ zu konstruieren. Dies ist die richtige Syntax:

iteratable = new IterableEnumeration<ZipEntry>(enumeration); 

Wie Sie bemerkt, gibt es Schwierigkeiten bei der Umsetzung Iterable mit einem Enumeration weil Enumeration ist die einmalige Gebrauch, während Code auf Iterable verlassen kann so viele frischen Iterator Objekte zu schaffen, wie es will. Sie könnten dies sicher in erweiterten For-Schleifen verwenden, aber es wäre unsicher, solch eine Iterable an eine andere Methode zu übergeben.

---

Oscar hat recht, die obige Änderung ist nicht ausreichend. Ich habe übersehen, dass der zugrunde liegende enumeration "? extends ZipEntry" ist. Darüber hinaus die folgenden Änderungen:

class IterableEnumeration<T> 
    implements Iterable<T> 
{ 

    private final Enumeration<? extends T> enumeration; 

    public IterableEnumeration(final Enumeration<? extends T> e) 
    { 
    enumeration = e; 
    } 

    ... 

und

class EnumerationIterator<T> 
    implements Iterator<T> 
{ 

    private final Enumeration<? extends T> enumeration; 

    public EnumerationIterator(final Enumeration<? extends T> e) 
    { 
    enumeration = e; 
    } 

    ... 

bedeuten diese Änderungen grundsätzlich „IterableEnumeration<T> mit einem Enumeration eines Teiltyp T zusammenarbeiten können“