Interface List nicht als Collection an erkannt.

[eclipseworker]

Ich habe folgenden Construktor:

public A(String name, Collection<B> collB){
//...
}

Ich möchte auch diesen verwenden:

public A(String name, B[] arrB){
List<Feature> bal=Arrays.asList(arrB);
       PacketFeature(name, bal);
}

Aber Eclipse sagt mir, dass A(String, List) nicht definiert ist , warum eigentlich? Ich dachte eigentlich, dass List eine Erweiterung von Collection ist.

 

[mrBrown]

Der gezeigte Konstruktor ist A(String, Collection<B>, die einzig aufgerufene Methode ist PacketFeature mit String, List<Feature>?


Ja, List erweitert Collection. Sind beide Interfaces passend importiert?

 

[stg]

Poste doch bitte ein MCVE. Dein Problem ist mit dem geposteten Schnipsel nicht verständlich.

der einzig aufgerufene ist PacketFeature

Ich sehe da gar keinen Konstruktor-Aufruf

 

[mrBrown]

Ich sehe da gar keinen Konstruktor-Aufruf

Oh, stimmt...von dem UpperCase verwirren lassen -.-

 

[stg]

Das hier funktioniert jedenfalls:

public class Main {
  public static void main(String[] args) {
    new A<String>("Foo", new ArrayList<String>());
  }
}

public class A<B> {
  public A(String name, Collection<B> collB){ 
  }
}

...vielleicht beantwortet das ja schon deine Frage.

 

[eclipseworker]

Der gezeigte Konstruktor ist A(String, Collection<B>, die einzig aufgerufene Methode ist PacketFeature mit String, List<Feature>?


Ja, List erweitert Collection. Sind beide Interfaces passend importiert?

Stimmt ich habe es irgendwie verabsäumt meinen Code um zu ändern. PacketFeature=A und Feature=B. Der gesamt Code der Klasse PacketFeature sieht so aus (was das Interface und die Klasse SimpleFeature machen glaube ich kann man sich denken):

package aufgabe_2;

import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class PacketFeature implements Feature {
  
   private static final long serialVersionUID = 1L;
   private String name;
   private Set<Feature> subFeatures;
   private Map<SimpleFeature, Long> simpleFeatures;
   private Set<PacketFeature> subPacketFeatures;

   public PacketFeature(String name, Collection<Feature> subFeatures) throws Exception {
       this.name=name;
       this.subFeatures=new HashSet<>();
       this.subFeatures.addAll(subFeatures);
       this.simpleFeatures=new HashMap<>();
       this.subPacketFeatures=new HashSet<>();
       for(Feature s:subFeatures){
           if(this.equals(s)) continue;
           if(s.getKind()==FeatureKind.SIMPLE){
               simpleFeatures.put(((SimpleFeature) s), 1L);
           }else{
               for(SimpleFeature sf:((PacketFeature) s).getSimpleFeatures()){
                   simpleFeatures.put(sf, 1L);
               }
               subPacketFeatures.add(((PacketFeature) s));
           }
       }
   }
  
   public PacketFeature(String name, Feature[] subFeatures) throws Exception {
       List<Feature> sfal=Arrays.asList(subFeatures);
       PacketFeature(name, sfal);
   }
  
   public PacketFeature(String name){
       this.name=name;
       this.subFeatures=new HashSet<>();
       this.simpleFeatures=new HashMap<>();
       this.subPacketFeatures=new HashSet<>();
   }
  
  
   /* (non-Javadoc)
    * @see java.lang.Object#hashCode()
    */
   @Override
   public int hashCode() {
       final int prime = 31;
       int result = 1;
       result = prime * result + ((name == null) ? 0 : name.hashCode());
       return result;
   }

   /* (non-Javadoc)
    * @see java.lang.Object#equals(java.lang.Object)
    */
   @Override
   public boolean equals(Object obj) {
       if (this == obj) {
           return true;
       }
       if (obj == null) {
           return false;
       }
       if (!(obj instanceof PacketFeature)) {
           return false;
       }
       PacketFeature other = (PacketFeature) obj;
       if (name == null) {
           if (other.name != null) {
               return false;
           }
       } else if (!name.equals(other.name)) {
           return false;
       }
       return true;
   }
  

   public void addFeature(Feature fe) throws Exception{
       subFeatures.add(fe);
       if(fe.getKind()==FeatureKind.SIMPLE){
           SimpleFeature sf=((SimpleFeature) fe);
           if(!simpleFeatures.containsKey(sf)){
               simpleFeatures.put(sf, 1L);
           }
       }else{
           PacketFeature pf=((PacketFeature) fe);
           if(this.equals(pf)) throw new Exception("can't be my own subfeature.");
           for(SimpleFeature sf:pf.getSimpleFeatures()){
               if(simpleFeatures.containsKey(sf)){
                   simpleFeatures.put(sf, simpleFeatures.get(sf)+1);
               }else{
                   simpleFeatures.put(sf, 1L);
               }
           }
           subPacketFeatures.add(pf);
       }
   }
  
   /* (non-Javadoc)
    * @see java.lang.Object#toString()
    */
   @Override
   public String toString() {
       StringBuilder builder = new StringBuilder();
       builder.append("PacketFeature [");
       if (name != null) {
           builder.append("name=");
           builder.append(name);
           builder.append(", ");
       }
       if (subFeatures != null) {
           builder.append("subFeatures=");
           builder.append(subFeatures);
           builder.append(", ");
       }
       if (simpleFeatures != null) {
           builder.append("simpleFeatures=");
           builder.append(simpleFeatures);
           builder.append(", ");
       }
       if (subPacketFeatures != null) {
           builder.append("subPacketFeatures=");
           builder.append(subPacketFeatures);
           builder.append(", ");
       }
       builder.append("getPrice()=");
       builder.append(getPrice());
       builder.append("]");
       return builder.toString();
   }

   public void addMultipleFeatures(Collection<Feature> featureCollection) throws Exception{
       for(Feature fe:featureCollection){
           addFeature(fe);
       }
   }
  

   public void addMultipleFeatures(Feature[] featureArray) throws Exception{
       addMultipleFeatures(Arrays.asList(featureArray));
   }
   /**
    * @return the serialversionuid
    */
   public static long getSerialversionuid() {
       return serialVersionUID;
   }

   /**
    * @return the subFeatures
    */
   public Set<Feature> getSubFeatures() {
       return subFeatures;
   }

   /**
    * @return the simpleFeatures
    */
   public Set<SimpleFeature> getSimpleFeatures() {
       return simpleFeatures.keySet();
   }
  
   public Map<SimpleFeature, Long> getSimpleFeaturesCounted(){
       return simpleFeatures;
   }
  
   public void removeFeature(Feature rf){
       if(rf.getKind()==FeatureKind.SIMPLE){
           SimpleFeature sf=((SimpleFeature) rf);
           if(simpleFeatures.containsKey(sf)){
               if(simpleFeatures.get(sf)>1){
                   simpleFeatures.put(sf, simpleFeatures.get(sf)-1);
               }else{
                   simpleFeatures.remove(sf);
                   subFeatures.remove(sf);
               }
           }
       }else{
           PacketFeature pf=((PacketFeature) rf);
           subFeatures.remove(pf);
           for(SimpleFeature scpf:pf.getSimpleFeatures()){
               if(simpleFeatures.containsKey(scpf)){
                   if(simpleFeatures.get(scpf)>1){
                       simpleFeatures.put(scpf, simpleFeatures.get(scpf)-1);
                   }else{
                       simpleFeatures.remove(scpf);
                       subFeatures.remove(scpf);
                   }
               }
           }
       }
   }
  
   public void removeMultipleFeatures(Collection<Feature> featureCollection) {
       for(Feature fe:featureCollection){
           removeFeature(fe);
       }
   }
  
   public void removeMultipleFeatures(Feature[] featureArray) {
       removeMultipleFeatures(Arrays.asList(featureArray));
   }
  

   /**
    * @param name the name to set
    */
   public void setName(String name) {
       this.name = name;
   }

   @Override
   public int compareTo(Feature o) {
       return new Long(this.getPrice()).compareTo(o.getPrice());
   }

   @Override
   public String getName() {
       return name;
   }

   /**
    * @return the subPacketFeatures
    */
   public Set<PacketFeature> getSubPacketFeatures() {
       return subPacketFeatures;
   }

   @Override
   public long getPrice() {
       long price=0;
       for(SimpleFeature sf:getSimpleFeatures()){
           price+=sf.getPrice();
       }
       return price;
   }

   @Override
   public FeatureKind getKind() {
       return FeatureKind.COMPOSED;
   }
  

}

Mich wunderts halt um so mehr da addMultipleFeatures(Feature[] featureArray) throws Exception und removeMultipleFeatures(Feature[] featureArray) akzeptiert werden.

 

[stg]

Poste doch bitte ein MCVE.

Um mich einfach mal selbst zu zitieren....

 

[mrBrown]

Guck dir noch mal an, wie man Konstruktoren aufruft...

 

[eclipseworker]

Um mich einfach mal selbst zu zitieren....

Ok das hier das MCV:

import java.util.*;

public class A {
 
    private String name;
    private Set<String> subFeatures;

    public A(String name, Collection<String> strs) {
        this.name=name;
        this.subFeatures=new HashSet<>();
        this.subFeatures.addAll(strs);
    }
  
    public A(String name, String[] strs) throws Exception {
        List<String> sfal=Arrays.asList(strs);
        A(name, sfal);
    }
}

 

[mihe7]

@eclipseworker Konstruktoren werden nicht über den Klassennamen aufgerufen, mach ein this draus.

 

[eclipseworker]

Guck dir noch mal an, wie man Konstruktoren aufruft...

Oh es hat tatsächlich nur new gefehlt, ich habe jetzt nicht bedacht, dass das auch Konstruktor zu Konstruktor Aufruf nötig ist.

 

[eclipseworker]

@eclipseworker Konstruktoren werden nicht über den Klassennamen aufgerufen, mach ein this draus.

Ok was ist jetzt besser?

public A(String[] arr){
    this(Arrays.asList(arr));
}

oder

public A(String[] arr){
    new A(Arrays.asList(arr));
}

 

[stg]

Die Frage ist nicht, was besser ist, sondern was du haben willst.
Vermutlich ersteres.

 

[eclipseworker]

Die Frage ist nicht, was besser ist, sondern was du haben willst.
Vermutlich ersteres.

Aber macht es einen Unterschied? Nein, oder etwa doch?

 

[mihe7]

Schon. Im new-Fall erzeugst Du während der Initialisierung des aktuellen Objekts (this) ein neues Objekt (new A(...)). Im this-Fall initialisierst Du das aktuelle Objekt.