Achtung Spoiler:

foo, da Java eine statisch getypte Sprache ist.

Ich denke

Achtung Spoiler:
'foo'

, da Klassen wohl gegen Interface'e Vorrang haben.
Aber interessante Frage, eine genaue Erklärung ect. würde mich schon interessieren.

Hi,

ich tippe es wird "Foo" ausgegeben. Die übergebene Referenz ist vom Typ "Foo". Es verhält sich als würde "Foo" von "ActionListener" erben. Der Compiler prüft bei der überladenen Funktion erst ob Foo passt. Nur wenn das nicht passt, steigt er die Vererbungshierachie auf. Nicht auflösen könnte der Compiler dies:

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.io.Serializable;   public class Foo implements ActionListener, Serializable {     public Foo() {         new Foobar().a(this);     }     public static void main(String[] args) {         new Foo();     }     public void actionPerformed(ActionEvent e) {} }   class Foobar {     public void a(ActionListener a) {         System.out.println("actionlistener");     }     public void a(Serializable foo) {         System.out.println("Serializable");     } }

Gruß

Jo

Achtung Spoiler

Ich würde tippen, dass Foo ausgegeben wird.
Das warjm ist auch recht simpel. gehen wir davon aus die Klasse würde noch 5 weitere Interfaces implementieren, udn es gäbe nicht nur die Methode a mit einem ActionListener und Foo als Parameter, sondern auch noch die 5 weiteren Interfaces als Parameter. In diesem fall wäre es auf jeden Fall einfacher, wenn Foo genommen würde. Der einzige Knackpunkt der mir einfällt wäre, was dann passieren sollte wenn es die Methode mit Foo als Parameter nicht geben würde. Hier stehe ich dann auch auf dem Schlach. In diesem fall würde ich tippen entweder die Interfaces (mit Packageangabe!!) alphabetisch geordnet, oder in der Reihenfolge wie sie bei der Klassensignatur angegeben sind.

Edit:

Mir ist noch eingefallen, dass es auch sein könnte, dass danach geurteilt wird wie die Methoden im Quelltext auftauchen, in diesem fall, würde natürlich ActionListener ausgegeben, ich denke ich bleibe trotz dem bei meiner ersten Vermutung (siehe oben).

schade, dass dieser Thread schon wieder eingeschlafen ist. Ich hab jetzt alles mal durchgelesen und finde es sehr spannend

Hallo,

gegeben sei folgender Code:

Code java:

1 2 3 4 5 6 7 8

package de.tutorials;   public class WhatsGoingOn {   public static void main(String[] args) {     //?     System.out.println(new String("xxx"));   } }

Was kann man an Stelle von "?" schreiben damit das Programm folgende Ausgabe erzeugt?
Die Aufgabe ist auf mehrere verschiedene Arten lösbar.

Ausgabe:

Code :

1

huch?

Aufrufe von System.exit(...) / Reflection-Calls sowie Verwendung von AspectJ oder anderen AOP Frameworks sind nicht erlaubt!

Gruß Tom

Hier meine Lösung, die zumindest bei mir wunderbar funktioniert hat:

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13

Achtung Spoiler: [COLOR="whitesmoke"]package de.tutorials;   public class WhatsGoingOn {   public static void main(String[] args) {     System.setOut(new java.io.PrintStream(System.out) {                                                         public void println(String x) {                                                             super.println(x.equals("xxx") ?                                                             "huch?" : x);                                                         }});     System.out.println(new String("xxx"));   } }[/COLOR]

Noch ne Möglichkeit:

Achtung Spoiler:

public class WhatsGoingOn {
public static void main(String[] args) {
class String {

public String(java.lang.String s) {
}

@Override
public java.lang.String toString() {
return "huch?";
}
}
System.out.println(new String("xxx"));
}
}

So gehts auch:

Achtung Spoiler:

Code :

1 2 3 4 5 6 7

public class WhatsGoingOn {   public static void main(String[] args) {     System.out.println(new String("huch?"));     if (false)     System.out.println(new String("xxx"));   } }

/duck

*g* Auch nett

ich hätte auch noch einen.... Ähnliche Idee wie Zeja

Achtung Spoiler:

import java.io.PrintStream;

public class WhatsGoingOn {
public static void main(String[] args) {

System.setOut(new PrintStream(System.out){

@Override
public void println(String x) {

super.println("Huch");
}

});

System.out.println(new String("xxx"));
}
}

Ist zwar ähnlicher zu meiner Idee, aber dennoch gut

@technoblade

Stimmt, habe Deinen Beitrag leider übersehen....

Hallo,

da für das letzte Rätsel schon so ziemlich jede Lösungsvariante gepostet wurde gibts hiermit ein neues Rätsel:

Folgendes Programm läuft mit 48MB Heap (-Xmx48m) bricht kurz nach dem Start mit einem (java.lang.OutOfMemoryError: Java heap space) ab.

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

package de.tutorials;   import java.util.ArrayList; import java.util.List;   public class MemoryLeakExample {     public static void main(String[] args) {         List<List<?>> lists = new ArrayList<List<?>>();                 for(int i = 0; i < 100;i++){             List<Integer> list = new ArrayList<Integer>();                         for(int j = 0; j < 1000000;j++){                 list.add(j);             }             lists.add(list);                         System.out.println(i);             list.clear();  //+            ? //-         }                 System.out.println(lists);     } }

Was könnte man noch bei ? aufrufen um den OOME abzuwenden?

Regeln:
1) lists darf nicht null gesetzt / neu initialisiert oder mit clear() geleert werden.
2) Kein Thread Sleep
3) Kein System.gc() etc.
4) lists soll am Ende noch die ursprünglich hinzugefügten List Instanzen beinhalten
Edit:
5) -Xmx48m (Heap Size auf 48 MB beschränken)
6) Es dürfen nur beliebig viele Zeilen zwischen //+ und //- eingefügt werden

Gruß Tom

Also bei mir ist das Programm unter Java 6 32-bit version und Windows 7 64-bit Version durchgelaufen. Daraufhin habe ich den Heapsize auf 256 gesetzt um den Effekt zu bekommen.

Nachfolgende Lösung läuft dann bei mir durch:

Achtung Spoiler:

package de.tutorials;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class MemoryLeakExample {
public static void main(String[] args) {
List<List<?>> lists = new ArrayList<List<?>>();

for(int i = 0; i < 100;i++){
List<Integer> list = new ArrayList<Integer>();

for(int j = 0; j < 1000000;j++){
list.add(j);
}
lists.add(list);

System.out.println(i);
list.clear();
//?
lists.remove(list);
// lists.add(Collections.unmodifiableList(list));
lists.add(list);
}

System.out.println(lists);
}
}