public class PoisonParen {
/*
* Add a declaration that initializes a field to some expression and
* compile the program. It must compile without error. Now add a pair
* of parentheses around a subexpression that serves merely to reinforce
* the order of evaluation that was performed before you inserted the
* parentheses. Recompile the program. If it no longer compiles, then
* you've solved the puzzle!
*/
}
public class Reflexive {
public static void main(String[] args) throws Exception {
/*
* If you can come up with a primitive type and value
* that causes this program to print "false", then
* you have proven that the == operator is not reflexive.
*/
<typeX> x = <valueX>;
System.out.println(x == x);
}
}
public class Symmetric {
public static void main(String[] args) throws Exception {
/*
* If you can come up with a set of primitive types and values
* that causes this program to print "true false", then
* you have proven that the == operator is not symmetric.
*/
<typeX> x = <valueX>;
<typeY> y = <valueY>;
System.out.print ((x == y) + " ");
System.out.println(y == x);
}
}
public class Transitive {
public static void main(String[] args) throws Exception {
/*
* If you can come up with a set of primitive types and values
* that causes this program to print "true true false", then
* you have proven that the == operator is not transitive.
*/
<typeX> x = <valueX>;
<typeY> y = <valueY>;
<typeZ> z = <valueZ>;
System.out.print ((x == y) + " ");
System.out.print ((y == z) + " ");
System.out.println(x == z);
}
}
import java.util.*;
public class Pair<T> {
private final T first;
private final T second;
public Pair(T first, T second) {
this.first = first;
this.second = second;
}
public T first() {
return first;
}
public T second() {
return second;
}
public List<String> stringList() {
return Arrays.asList(String.valueOf(first),
String.valueOf(second));
}
public static void main(String[] args) {
Pair p = new Pair<Object>(23, "skidoo");
System.out.println(p.first() + " " + p.second());
for (String s : p.stringList())
System.out.print(s + " ");
}
}
public class LinkedList<E> {
private Node<E> head = null;
private class Node<E> {
E value;
Node<E> next;
// Node constructor links the node as a new head
Node(E value) {
this.value = value;
this.next = head;
head = this;
}
}
public void add(E e) {
new Node<E>(e);
// Link node as new head
}
public void dump() {
for (Node<E> n = head; n != null; n = n.next)
System.out.println(n.value + " ");
}
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<String>();
list.add("world");
list.add("Hello");
list.dump();
}
}
public class Outer {
class Inner1 extends Outer {}
class Inner2 extends Inner1 {}
}
import java.util.*;
import java.io.*;
public class SerialKiller {
public static void main(String[] args) {
Sub sub = new Sub(666);
sub.checkInvariant();
Sub copy = (Sub) deepCopy(sub);
copy.checkInvariant();
}
// Copies its argument via serialization (See Puzzle 80)
static public Object deepCopy(Object obj) {
try {
ByteArrayOutputStream bos =
new ByteArrayOutputStream();
new ObjectOutputStream(bos).writeObject(obj);
ByteArrayInputStream bin =
new ByteArrayInputStream(bos.toByteArray());
return new ObjectInputStream(bin).readObject();
} catch(Exception e) {
throw new IllegalArgumentException(e);
}
}
}
class Super implements Serializable {
final Set<Super> set = new HashSet<Super>();
}
final class Sub extends Super {
private int id;
public Sub(int id) {
this.id = id;
set.add(this); // Establish invariant
}
public void checkInvariant() {
if (!set.contains(this))
throw new AssertionError("invariant violated");
}
public int hashCode() {
return id;
}
public boolean equals(Object o) {
return (o instanceof Sub) && (id == ((Sub)o).id);
}
}
public class Twisted {
private final String name;
Twisted(String name) {
this.name = name;
}
private String name() {
return name;
}
private void reproduce() {
new Twisted("reproduce") {
void printName() {
System.out.println(name());
}
}.printName();
}
public static void main(String[] args) {
new Twisted("main").reproduce();
}
}
public class PrintWords {
public static void main(String[] args) {
System.out.println(Words.FIRST + " " +
Words.SECOND + " " +
Words.THIRD);
}
}
public class Words {
private Words() { }; // Uninstantiable
public static final String FIRST = "the";
public static final String SECOND = null;
public static final String THIRD = "set";
}
// The second version of the Words class appears below (commented out)
//
// public class Words {
// private Words() { }; // Uninstantiable
//
// public static final String FIRST = "physics";
// public static final String SECOND = "chemistry";
// public static final String THIRD = "biology";
// }
import java.util.Random;
public class Shuffle {
private static Random rnd = new Random();
public static void shuffle(Object[] a) {
for (int i = 0; i < a.length; i++)
swap(a, i, rnd.nextInt(a.length));
}
private static void swap(Object[] a, int i, int j) {
Object tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
}
public class ApplePie {
public static void main(String[] args) {
int count = 0;
for (int i = 0; i < 100; i++); {
count++;
}
System.out.println(count);
}
}
import java.util.*;
public class BananaBread {
public static void main(String[] args) {
Integer[] array = { 3, 1, 4, 1, 5, 9 };
Arrays.sort(array, new Comparator<Integer>() {
public int compare(Integer i1, Integer i2) {
return i1 < i2 ? -1 : (i2 > i1 ? 1 : 0);
}
});
System.out.println(Arrays.toString(array));
}
}
public class ChocolateCake {
public static void main(String[] args) {
System.out.println(true?false:true == true?false:true);
}
}
No comments:
Post a Comment