Dateiaufruf mit Strings

[andreas2505]

Hallo,

ich habe mal ne Frage. Ich möchte eine Datei folgendermaßen aufrufen.

String typ1
String typ2

typ1+In+typ2(....);

also aufrufen mit zwei variablen String werten.

Ist das möglich?
Gibst da irgendwie eine Umwandlung, so dass es den Aufruf erkennt?

 

[The_S]

Ich hab keine Ahnung, was du willst. Bitte noch einmal neu formulieren, so dass man es leichter verstehen kann, oder hoffen und warten, dass ein anderer dein Problem versteht.

 

[Murray]

Was soll denn "Aufrufen einer Datei" bedeuten? Eine Datei zum Lesen öffnen?

 

[faetzminator]

Ich glaube, dass er eine Methode einer Klasse/einer Instanz aufrufen will...
Wenn ja, müsstest du dir Reflection anschauen. Dort ist dies möglich, aber nicht üblich. Warum willst du das machen?

 

[B4RC0D3]

ich glaube er meint einen dateiaufruf.
da würde das gehen.
bsp.:

 String a="C:/", b="Windows/", c=a+b;
		System.out.println(c);
		File f=new File(c);
		try {
			FileInputStream fis=new FileInputStream(f);
		} catch (FileNotFoundException e) {
			e.printStackTrace();}

/edit
das muss noch ganz an den anfang vor die class

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

 

[andreas2505]

sorry,

habs ein bisschen falsch formuliert.
Ich möchte eine Methode einer anderen Klasse aufrufen.

ich will das so machen weil alle methoden dieser klasse die form typIntyp2 haben.
Und dann will ich mir Strings übergeben lassen und dann einfach einen befehl mit den strings, wo die passende methode aufgerufen wird.

Kann mir jetzt wer helfen?

 

[bygones]

geht ueber Reflection - siehe API Class & Method

 

[mvitz]

Wie schon gesagt, entweder Reflection, oder du teilst uns dein Problem etwas genauer mit (also den größeren Kontext), denn imho. deutet dein Problem häufig eher auf einen Designfehler hin.

 

[faetzminator]

Wenn ja, müsstest du dir Reflection anschauen. Dort ist dies möglich, aber nicht üblich. Warum willst du das machen?

Wie gesagt, folgendes kannst du machen. Aufruf einer Methode auf ein Objekt:

Object result = instance.getClass().getMethod(methodName, paramTypes).invoke(instance, params);

statische Methode:

Object result = SomeClass.class.getMethod(methodName, paramTypes).invoke(null, params);

Aber meistens hat man da ein Designproblem. Warum willst du das so machen?

 

[andreas2505]

also ich habe eine Klasse, die jeden bei mir vorkommenden Datentyp jeweils in den anderen umwandeln kann. Und das brauche ich dann in einer anderen Klasse.
Und es sind halt alle nach dem gleichen Schema benannt (typ1Intyp2), so dass ich nur die typen einsetzen möchte und es ruft die passende methode auf.

Das Objekt, dass die methode verwenden soll, soll allerdings nicht aus der gleichen methode stammen, wie die methoden. Muss ich das trotzdem so erzeugen.
Könntest du mir vlt. zu meinem Problem nen ausführlicheren Quelltext schreiben?

 

[faetzminator]

Wie wärs, wenn du uns die Methodendefinitionen und bisherigen Aufrufe zeigen würdest? Und warum überlädst du nicht gleich einen Methodennamen? Ist der Typ des jeweiligen Objekts zur Programmierzeit nicht bekannt?

 

[andreas2505]

ja genau der typ ist nicht bekannt, weil wir ja nicht wissen, was in was umgewandelt werden soll. das lass wir uns erst übergeben in form eines strings. deswegen der aufbau.

ich habe bisher kaum methoden geschrieben, weil ich ja allgemein erst ausprobieren muss , ob es funktioniert

 

[bygones]

klingt fuer mich sehr mysterioes und dass vll mehr gedanken bzgl Strategy / Double Dispatch oder sonstigen mustern gemacht werden sollte anstatt ueber sowas....

 

[faetzminator]

andreas2505, natürlich funktioniert das auf dem von mir beschriebenen Weg Aber eben, schön wären die Signaturen der umzuwandelnden Methoden, also irgendwie "static Foo bar2foo(Bar bar)" oder "void saveSome(String str)". Zusätzlich die exakten Variablen, in welcher die Infos stehen, dann kann ich dir diese 1, 2 Zeilen für den Aufruf natürlich schreiben.

 

[andreas2505]

Ok, also nehmen wir mal der Einfachheit halber die Methode:

public class umwandlung{

public String inInString(int a) {
     return "xxx" }   --> diese ist in der Klasse mit den ganzen Umwandlungsmethoden
}


so und dann habe ich zwei getMethoden in jeweils zwei verschiedenen Klassen:
 
public class Asym {
public String getKeyTyp1() {
     return typ1}
}

public class Sym {
public String getKeyTyp2() {
    return typ2}
}

und dann möchte ich in der Zentrale, also einer anderen Klasse die Methode aufrufen: ungefähr so:

public class zentrale{
Asym asym = new Asym();
Sym sym = new Sym();

String var1 = asym.getKeyTyp1();
String var2 = asym.getKeyTyp2();

und nun der Methodenaufruf, den ich halt nicht so weiß


Kannst du mir nun helfen???

 

[faetzminator]

wieso machst du nicht einfach [c]new umwandlung().inInString(deinInt)[/c]? Oder hab ich da was missverstanden :autsch: ?

 

[Noctarius]

Warum nicht einfach toString() überschreiben in den entsprechenden Klassen, oder habe ich das Problem falsch verstanden?

 

[bygones]

und wie beruecksichtigt ihr die "unmoeglichen" umwandlungen ? nicht jeder String laesst sich in int umwandeln oder boolean in int etc

 

[Michael...]

Ich tippe mal schwer auf Designfehler.
Ist allerdings aufgrund der ziemlich wagen Beschreibungen was überhaupt gemacht werden soll, wie gesagt nur ein Tipp.

 

[andreas2505]

also nochmal:

das int in string ist nur ein beispiel. Es kann auch heißen: byteArray in BigInteger oder irgendwas anderes.
Es geht nur darum, dass ich mit einem String typ1Intyp2 eine Methode aus einer anderen Klasse aufrufen will, siehe oben.
Geht das denn nun, mir hatte doch vorhin schon einer geschrieben wie es gehen könnte.
Nun bräuchte ich es mal für mein Beispiel.

 

[faetzminator]

Also für den Eingabetypen kannst du schon mal die Methoden überlagern. Wenn du jeweils pro Eingabetypen nur einen Rückgabetypen hast, hast du sowieso kein Problem. Ansonsten kannst du (int-)Konstanten definieren, welche den Rückgabewert definieren (dieser wär dann einfach Object)

 

[andreas2505]

sorry, aber könntest du wie gesagt mal bitte einen Code posten, weil ich halt nicht so umsetzen kann, was du mir beschreibst

 

[faetzminator]

Falls jeweils nur eine Möglichkeit in Frage kommt:

String convert(byte[] bytes) {
    return ...;
}
BigInteger convert(Integer integer) {
    return ...;
}

Falls mehrere:

public static final int TYPE_INT = 0;
public static final int TYPE_STRING = 1;
public static final int TYPE_BIGINT = 2;
Object convert(byte[] bytes, int type) {
    switch (type) {
    case TYPE_INT:
        return new Integer(...);
    case TYPE_STRING:
        return ...;
    ...
    }
}
Object convert(Integer integer, int type) {
    switch (type) {
    case TYPE_BIGINT:
        return new BigInteger(...);
    case TYPE_STRING:
        return ...;
    ...
    }
}

etc. etc.

So kannst du immer [c]Object result = convert(input)[/c] bzw [c]convert(input, TYPE_...)[/c] aufrufen.

 

[andreas2505]

ok so wollte ich das eigentlich nicht. Du hattest doch vorhin mal was von reflections erzählt
Da kann man doch den Methodenaufruf als String darstellen oder.
Eigentlich wäre mir das lieber.
Könntest du das vlt. auch nochmal zeigen?

 

[faetzminator]

Wie gesagt, folgendes kannst du machen. Aufruf einer Methode auf ein Objekt:

Object result = instance.getClass().getMethod(methodName, paramTypes).invoke(instance, params);

statische Methode:

Object result = SomeClass.class.getMethod(methodName, paramTypes).invoke(null, params);

da musst du nur result, instance, SomeClass, methodName, paramTypes und params durch deine Variablen ersetzen....:bahnhof:

 

[Shulyn]

// Wenn ich völlig daneben liege nicht schlagen

Also so wie ich es verstanden habe hast du x Methoden die jeweils 1 Umwandlungs ausführen, und 2 Klassen.

Klasse a :

a -> b //Methoden
a -> c
b -> a
usw

In Klasse b sieht es ähnlich aus. Nun bekommst du 2 Strings die die Typen für die umwandlung angeben. Daraus setzt du dir 1 String zusammen, der dem Methodennamen entspricht!

Und du suchst jetzt nach einer "einfachen" möglichkeit die entsprechende Methode aufzurufen.

Die 1. Idee die mir kommt ist ein Switch, in dem du dann die entsprechende Methode aufrufst. Da Switch mit String nicht geht, könntest du dir Z.b ein Enum basteln in dem die verschiedenen möglichkeiten stehen.

public enum moeglichkeiten {

aINb,
bINc,
// usw
dINw;

// nun die Methoden um die einträge umzuwandeln für den späteren vergleich

    // Saves the Enumnames in a List
    private static List<String> enumliste;
    
    // Returns the Enum entrys in a List<String>
    public static List<String> getValues() {
        if (enumliste == null) {
            moeglichkeiten[] array = values();
            List<String> list = new ArrayList<String>();
            for (moeglichkeiten mo : array) {
                list.add(mo.name());
            }
            enumliste = list;
        }
       
        
        return enumliste;
    }

}

// jetzt in der classe von der aus aufgerufen werden soll...

public void zuweisung(String text) {

   switch (moeglichkeiten.valueOf(text) {
                case aINb:
                    classe.aINB();
                    break;
                case bINc:
                    classe.bINc();
                    break;
                case dINw:
                    classe.dinW();
                    break;
                default:
                   // mache irgendwas
        }
}

So ungefähr stelle ich mir das vor. Nachteil ist das du das Enum "pflegen" musst und dort alle möglichkeiten drin stehen müssen/sollten. Aber über default könntest du gleich die NICHT Möglichen ausschließen wie " aINa ...

Shu!


//Edit -jetzt auch 2. Seite gelesen-
Sollte man Refectionen nicht nur benutzen wenn es keine andere möglichkeit gibt? Weil man verändert doch den Quelltext in/während der Laufzeit.... (oder verwecksel ich da etwas?!?)

 

[andreas2505]

ok danke, werds dann mal probieren!

 

[Landei]

Mein Versuch:

public class Converter {
  
  private static interface Conv<From,To> {
    public To convert(From from);
  }
  
  private static class FromTo {
    Class<?> fromClass;
    Class<?> toClass;
    public FromTo(Class<?> fromClass, Class<?> toClass) {
      this.fromClass = fromClass;
      this.toClass = toClass;
    }
    @Override
    public boolean equals(Object o) {
      if (o instanceof FromTo) {
        FromTo ft = (FromTo) o;
        return fromClass.equals(ft.fromClass) && toClass.equals(ft.toClass);
      }
      else return false;
    }
    @Override
    public int hashCode() { return fromClass.hashCode() + 17*toClass.hashCode(); }
  }
   
  private static Map<FromTo,Conv<?,?>> map = new HashMap<FromTo,Conv<?,?>>(); 
  
  static {
    map.put(new FromTo(Long.class, Date.class), new Conv<Long, Date>(){
      public Date convert(Long from) {
        return new Date(from);
      }});
    map.put(new FromTo(String.class, Integer.class), new Conv<String, Integer>(){
      public Integer convert(String from) {
        return Integer.parseInt(from);
      }});
  }
  
  
  public static <From, To> To convert(From from, Class<To> clazz) {
     Conv<From, To> conv = (Conv) map.get(new FromTo(from.getClass(), clazz));  
     if(conv == null) {
       throw new UnsupportedOperationException("Conversion from " + 
          from.getClass().getName() + " to " + clazz.getName() + " is not supported.");
     }
     return conv.convert(from);
  }
  
  public static void main(String... args) {
    Date date = convert(Long.valueOf(100000), Date.class);
    System.out.println(date);
    Integer integer = convert("42", Integer.class);
    System.out.println(integer);
    //System.out.println(convert("42", Date.class)); //throws UOE
  }
  
}

 

[andreas2505]

da musst du nur result, instance, SomeClass, methodName, paramTypes und params durch deine Variablen ersetzen....:bahnhof:

faetzminator, kannst du mir vlt. mal genau sagen, was die paramTypes sein sollen bei einer Methode die ich aufrufe, und was ich bei instance und params einsetzen muss?

 

[faetzminator]

Gehen wir davon aus, dass du von der Klasse [c]MeineKlasse[/c] eine Instanz [c]meineInstanz[/c] hast. dort hast du eine Methode mit der Definition [c]BigInteger getValue(String, Integer);[/c].
Du würdest "normal" folgendes aufrufen:

BigInteger value = meineInstanz.getValue("123.4", new Integer(45))

Mit Reflection sieht diese Zeile wie folgt aus:

BigInteger value = (BigInteger) meineInstanz.getClass()
        .getMethod("getValue", new Class[] {String.class, Integer.class})
        .invoke(meineInstanz, new Object[] {"123.4", new Integer(45)});

Oder bei statischer Variable (normal, Reflection):

BigInteger value = MeineKlasse.getValue("123.4", new Integer(45))

BigInteger value = (BigInteger) MeineKlasse.class
        .getMethod("getValue", new Class[] {String.class, Integer.class})
        .invoke(null, new Object[] {"123.4", new Integer(45)});

 

[andreas2505]

Problem: ich weiß nicht, was für ein Typ es sein muss (weil ich ja nicht weiß welche Methode aufgerufen wird), also kann ich nicht sagen BigInteger value =, geht das mit Object oder so?

 

[faetzminator]

Natürlich ist der Returntype grundsätzlich ein Object. Und die Typen der Parameter kannst du ja von [c]variable.getClass()[/c] holen. Aber irgendwann musst du ja den Typen des Returntypes wissen

 

[andreas2505]

na kann ich das nicht als Object auch wieder zurückgeben und der erkennt dann selber, ob es bigInt oder Int ist und rechnet damit weiter

 

[faetzminator]

Nein :autsch: !? Ich glaube immer noch, dass du einen Designfehler hast... Wie willst du etwas "in einen anderen Typen bringen", wenn du nicht weisst, welcher Typ du überhaupt willst?

 

[andreas2505]

also nochmal mein komplettes Problem:

ich habe zwei klasse k1,k2 ,eine zentrale Klasse zK und eine klasse convert.
convert kann jeden typ in jeden anderen umwandeln.

ich will nun eine methode schreiben, die die benötigte umwandlungsmethode aufruft.
ich habe also in meiner zentrale immer einen datentyp, wo ich nachfragen möchte bei k1 und k2, ob sie ihn umgewandelt bönötigen.
dazu habe ich in k1 und k2 eine methode, die einen String mit dem typ zurückliefert den sie benötigen. falls der nicht mit dem normalen übereinstimmt, soll es die entsprechende methode aus convert aufrufen.
deshalb heißen in convert alle methoden "gleich": typ1Intyp2
der typ in den das umgewandelt werden soll, den kann ich ja mit der methode aufrufen, die ich in k1 und k2 habe, allerdings ist dies ein String und außerdem soll die umwandlungsmethode in meiner zentrale ja variabel sein, für alle umwandlungen.

Ok haste ne lösung?

 

[faetzminator]

Na dann weisst du ja den Typen, welchen du willst (warum du das auch immer brauchst...). Dann kannst du spätestens in k1, k2 das Object zum gegebenen Typen casten. Und wenn die Methode sowieso <typ1>In<typ2> heisst, musst du mindestens typ2 kennen und kannst gleich casten.

 

[andreas2505]

was meinst du mit casten

 

[faetzminator]

:autsch::autsch::autsch:

Object getObj() {
    return new Foo();
}

void doSth() {
    Foo foo = (Foo) getObj();
}

 

[andreas2505]

als ich hab hier mal was geschrieben:

public Object umwandeln(Class c, String method, String s1, Object p1) {
    
    String s2 = (String) c.getMethod(method, new Class[] {String.class}).invoke(
    String s = s1+"In"+s2;
    if (! s1.equals(s2)) {
        Object p1 = (s2) con.getClass().getMethod(s, new Class[] {Object.s1}).invoke(
    }
    else {}
    
    return p1
    

}

Class c ist die Klasse, aus der die Methode aufgerufen werden soll, in was umgewandelt werden soll (also k1 oder k2),
String method soll die methode sein, die aus k1 bzw. k2 die methode aufruft, wo der String zurückgeliefert wird was umgewandelt wird.
String s1 ist der Typ, in dem sich die Variable im Moment vor der Umwandlung befindet
Object p1, ist die Variable, die umgewandelt werden soll.

Der if-Vergleich ist nur, damit nicht umgewandelt wird, wenn die Typen gleich sind.

bei invoke weiß ich nicht richtig was da hin kommt.

und das mit Object stimmt auch nicht richtig
vlt. kannste mir ja so helfen

 

[faetzminator]

also:

public Object umwandeln(Object ichWillAufgerufenWerden, String diesenTypenWillIch, Object dasHabIch) {
    String diesenTypenHabIch = dasHabIch.getClass().getSimpleName();
    if (!diesenTypenWillIch.equals(diesenTypenHabIch)) {
        String methodenName = diesenTypenHabIch.concat("In").concat(diesenTypenWillIch);
        return ichWillAufgerufenWerden.getClass().getMethod(methodenName, new Class[] {dasHabIch.getClass()})
                .invoke(ichWillAufgerufenWerden, new Object[] {dasHabIch});
    }
    return dasHabIch;
}

 

[andreas2505]

da kommt eine fehlermeldung: unreported exception java.lang.NOSuchElementException; must be caugth or declared to be thrown.

Wo muss ich die exception einfügen

 

[Shulyn]

da kommt eine fehlermeldung: unreported exception java.lang.NOSuchElementException; must be caugth or declared to be thrown.

Wo muss ich die exception einfügen

public Object umwandeln(Object ichWillAufgerufenWerden, String diesenTypenWillIch, Object dasHabIch) {
        String diesenTypenHabIch = dasHabIch.getClass().getSimpleName();
        if (!diesenTypenWillIch.equals(diesenTypenHabIch)) {
            String methodenName = diesenTypenHabIch.concat("In").concat(diesenTypenWillIch);
            try {
                return ichWillAufgerufenWerden.getClass().getMethod(methodenName, new Class[] {dasHabIch.getClass()})
                        .invoke(ichWillAufgerufenWerden, new Object[] {dasHabIch});
            }
            catch (IllegalArgumentException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            catch (SecurityException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            catch (IllegalAccessException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            catch (InvocationTargetException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            catch (NoSuchMethodException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return dasHabIch;
    }

Reflections sind BÖSE :hihi:

mfg Shu!

 

[andreas2505]

ok das Problem hab ich, aber noch ein anderes Problem:

diesenTypWillIch wird ja von einer Methode aus der Klasse k1 oder k2 aufgerufen.
Ich kann es zwar auch vorher aufrufen, aber geht es auch, dass wir das in die methode einbeziehen und dort den methodennamen als argument eingeben und uns in der methode den string ausgebn lassen?