Okay, im Prinzip hast du vollkommen Recht dass es ausschließlich Syntaxfehler sind
Vielleicht ist es als Rätsel etwas unsinnig, aber dennoch eine gute Frage, warum der Compiler reagiert, wie er reagiert

Gerade beim ersten und fünften Test reagiert der Compiler meiner Meinung nach einfach falsch. Und wenn es richtig wäre, mit welcher genauen Erklärung?

Viele Grüße,
MAN

Bei 5 vielleicht aus den selben Grund, warum byte a = 5; byte b = 3; byte c = (byte)(a + b); gecastet werden muss: Weil der Wert zur Kompilerzeit noch nicht eindeutig bekannt ist. Vielleicht will er deshalb auch final's, und kein Array, da dessen Felder ja auch zwischen Intialisation und Verwendung auch verändert werden können.

:/

Hallo,

hier noch ein neues Rätsel für euch:

Wie erstellt man eine Instanz der Klasse X ohne den Code der Klasse X zu ändern (weder auf Sourcecode noch auf Bytecode Ebene)?

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 28 29 30 31 32 33 34 35 36

package de.tutorials.training;   import java.lang.reflect.Constructor;   public class SneakyObjectConstruction {     public static void main(String[] args) throws Exception {       try {       System.out.println(X.class.newInstance());     } catch (Throwable t) {       System.out.println(t);     }       try {       Constructor<?> ctor = X.class.getDeclaredConstructor();       ctor.setAccessible(true);       System.out.println(ctor.newInstance());     } catch (Throwable t) {       System.out.println(t);     }         //TODO insert your approach here :)   }     static class X {         private int i = 1;         private X() {       if(i == 1){         throw new IllegalStateException("i is 1");       }     }   } }

Viel Spaß,
Gruß Tom

Hallo zusammen,

hier die Äuflösung des Java Rätsels:

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 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92

package de.tutorials.training;   import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException;     // Our test driver public class SneakyObjectConstruction {     public static void main(String[] args) throws Exception {       try {       System.out.println(X.class.newInstance());     } catch (Throwable t) {       System.out.println(t);     }       try {       Constructor<?> ctor = X.class.getDeclaredConstructor();       ctor.setAccessible(true);       System.out.println(ctor.newInstance());     } catch (Throwable t) {       System.out.println(((InvocationTargetException)t).getTargetException());     }       // Some working approaches :)       //ReflectionFactory     try {       sun.reflect.ReflectionFactory reflectionFactory = sun.reflect.ReflectionFactory.getReflectionFactory();       Constructor<X> ctor = reflectionFactory.newConstructorForSerialization(X.class, Object.class.getDeclaredConstructor());       System.out.println("ReflectionFactory: " + ctor.newInstance());     } catch (Throwable t) {       System.out.println(t);     }       //Unsafe     Field f = sun.misc.Unsafe.class.getDeclaredField("theUnsafe");     f.setAccessible(true);     sun.misc.Unsafe u = (sun.misc.Unsafe)f.get(null);     System.out.println("Unsafe: " +  u.allocateInstance(X.class));       //Method by Dr. Heinz Kabuts :)     //See [url]http://www.javaspecialists.eu/archive/Issue032.html[/url]     System.out.println("Heinz Kabutz: " + Y.make());   }     static class X {       private int i = 1;         private X() {        if(i == 1){        throw new IllegalStateException("i is 1");        }     }   }     static class Y extends X {     private static Y y;         static Y make() {       try {         new Y();       } catch (Exception ex) {         try {           synchronized (Y.class) {             while (y == null) {               System.gc();               Y.class.wait(100);             }           }         } catch (InterruptedException ie) {           return null;         }       }       return y;     }         @Override     protected void finalize() throws Throwable {       synchronized (Y.class) {         y = this;         Y.class.notify();       }     }   } }

Ausgabe:

Code :

1 2 3 4 5

java.lang.IllegalAccessException: Class de.tutorials.training.SneakyObjectConstruction can not access a member of class de.tutorials.training.SneakyObjectConstruction$X with modifiers "private" java.lang.IllegalStateException: i is 1 ReflectionFactory: de.tutorials.training.SneakyObjectConstruction$X@459189e1 Unsafe: de.tutorials.training.SneakyObjectConstruction$X@2f9ee1ac Heinz Kabutz: de.tutorials.training.SneakyObjectConstruction$Y@24c21495

Gruß Tom

"10, 20", da int ein atomarer Datentyp ist und byValue und nicht byReference der Funktion swap übergeben wird!

Da es hier schon lange kein Rätse mehr gab; hier ein kleines von meiner Seite,...

Es geht um die Berechnung einer Kreditkarten-Quersumme nach dem Module-10-Algorithmus. Wir hatten mal die Anforderung, eine Karte unseres Loyaltysystems zu validieren. Das war ja eher ein ge-copy-paste aus dem Internet. Die nächste Anforderung war, die nächste gültige Nummer zu bekommen.

Die Aufgabe darin besteht eine möglichst elegante/einfache Möglichkeit zur Berechnung der nächsten gültigen Nummer zu formulieren

Hier die Source:

Code :

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 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

package test;   public class CheckSum {     public static boolean validateCheckSum(String inData) {         char[] c = null;         char[] d = null;         int sum = 0;         int checksum = 0;         StringBuffer digits = new StringBuffer();           // isolate digits         c = inData.toCharArray();         for (int i = 0; i < c.length; i++) {             if (Character.isDigit(c[i])) {                 digits.append(c[i]);             }         }           // calculate sum         int nr = 0;         d = digits.toString().toCharArray();         for (int i = 0; i < d.length - 1; i++) {             nr = i + 1;             if (nr % 2 == 0) {                 sum += Character.digit(d[i], 10) * 3;             } else {                 sum += Character.digit(d[i], 10);             }         }           // validate check sum         if ((10 - (sum % 10)) == 10) {             checksum = 0;         } else {             checksum = 10 - (sum % 10);         }           if (checksum == Character.digit(c[(d.length - 1)], 10)) {             return true;         }           return false;     }       public static String getNextNumber(String inLatest) {         // your approach here         return null;     }       public static void main(String[] args) {         String latestNumber = "1009";         System.out.println("Is " + latestNumber + " valid? " + validateCheckSum(latestNumber));         System.out.println("Is 1018 the next number? " + "1018".equals(getNextNumber(latestNumber)));     } }

Ausgabe:
Is 1009 valid? true
Is 1018 the next number? false

Und wehe, es macht jemand einfach return "1018" :P

hf
slowy

Hallo,

danke für das Rätsel

Ich nehme mal an, dass die Aufgabe darin besteht eine möglichst elegante/einfache Möglichkeit zur Berechnung der nächsten gültigen Nummer zu formulieren, oder? Das steht leider nicht soooo explizit drin

Gruß Tom

kopf->tisch
ty, ge-edited.

Angenommen es gibt die Klassen Othello, welche das Interface Comparator wie folgt implementiert:

Code :

1 2 3 4 5

public class Othello implements Comparator<String> {     public int compare(String s1, String s2) {         return s2.compareTo(s1);     } }

Was ergibt demnach folgender System.out.println und weshalb:

Code :

1 2 3

String[] s = {"map", "pen", "marble", "key"};         Arrays.sort(s, new Othello());         System.out.println(Arrays.binarySearch(s, "key"));

Die Ausgabe lautet

Code :

1

-1

weil das Array falsch herum sortiert wurde.

Zitat von genodeftest

Die Ausgabe lautet

Code :

1

-1

weil das Array falsch herum sortiert wurde.

richtig analysiert!

Um eine richtige Antwort zu erhalten, müsste der Aufruf

System.out.println(Arrays.binarySearch(s, "key", new Othello()));

lauten.