Java/Class/class object

A changeable wrapper class

// : appendixa:MutableInteger.java
// A changeable wrapper class.
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
import java.util.ArrayList;
import java.util.List;
class IntValue {
  private int n;
  public IntValue(int x) {
    n = x;
  }
  public int getValue() {
    return n;
  }
  public void setValue(int n) {
    this.n = n;
  }
  public void increment() {
    n++;
  }
  public String toString() {
    return Integer.toString(n);
  }
}
public class MutableInteger {
  public static void main(String[] args) {
    List v = new ArrayList();
    for (int i = 0; i < 10; i++)
      v.add(new IntValue(i));
    System.out.println(v);
    for (int i = 0; i < v.size(); i++)
      ((IntValue) v.get(i)).increment();
    System.out.println(v);
  }
} ///:~

A companion class to modify immutable objects

// : appendixa:Immutable2.java
// A companion class to modify immutable objects.
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
class Mutable {
  private int data;
  public Mutable(int initVal) {
    data = initVal;
  }
  public Mutable add(int x) {
    data += x;
    return this;
  }
  public Mutable multiply(int x) {
    data *= x;
    return this;
  }
  public Immutable2 makeImmutable2() {
    return new Immutable2(data);
  }
}
public class Immutable2 {
  private int data;
  public Immutable2(int initVal) {
    data = initVal;
  }
  public int read() {
    return data;
  }
  public boolean nonzero() {
    return data != 0;
  }
  public Immutable2 add(int x) {
    return new Immutable2(data + x);
  }
  public Immutable2 multiply(int x) {
    return new Immutable2(data * x);
  }
  public Mutable makeMutable() {
    return new Mutable(data);
  }
  public static Immutable2 modify1(Immutable2 y) {
    Immutable2 val = y.add(12);
    val = val.multiply(3);
    val = val.add(11);
    val = val.multiply(2);
    return val;
  }
  // This produces the same result:
  public static Immutable2 modify2(Immutable2 y) {
    Mutable m = y.makeMutable();
    m.add(12).multiply(3).add(11).multiply(2);
    return m.makeImmutable2();
  }
  public static void main(String[] args) {
    Immutable2 i2 = new Immutable2(47);
    Immutable2 r1 = modify1(i2);
    Immutable2 r2 = modify2(i2);
    System.out.println("i2 = " + i2.read());
    System.out.println("r1 = " + r1.read());
    System.out.println("r2 = " + r2.read());
  }
} ///:~

Create Object Demo

/* From http://java.sun.ru/docs/books/tutorial/index.html */
/*
 * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * -Redistribution of source code must retain the above copyright notice, this
 *  list of conditions and the following disclaimer.
 *
 * -Redistribution in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *
 * Neither the name of Sun Microsystems, Inc. or the names of contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 *
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
 * ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
 * OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN")
 * AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE
 * AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
 * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
 * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
 * INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY
 * OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 *
 * You acknowledge that this software is not designed, licensed or intended
 * for use in the design, construction, operation or maintenance of any
 * nuclear facility.
 */
public class CreateObjectDemo {
  public static void main(String[] args) {
    // create a point object and two rectangle objects
    Point origin_one = new Point(23, 94);
    Rectangle rect_one = new Rectangle(origin_one, 100, 200);
    Rectangle rect_two = new Rectangle(50, 100);
    // display rect_one"s width, height, and area
    System.out.println("Width of rect_one: " + rect_one.width);
    System.out.println("Height of rect_one: " + rect_one.height);
    System.out.println("Area of rect_one: " + rect_one.area());
    // set rect_two"s position
    rect_two.origin = origin_one;
    // display rect_two"s position
    System.out.println("X Position of rect_two: " + rect_two.origin.x);
    System.out.println("Y Position of rect_two: " + rect_two.origin.y);
    // move rect_two and display its new position
    rect_two.move(40, 72);
    System.out.println("X Position of rect_two: " + rect_two.origin.x);
    System.out.println("Y Position of rect_two: " + rect_two.origin.y);
  }
}
class Point {
  public int x = 0;
  public int y = 0;
  // a constructor!
  public Point(int x, int y) {
    this.x = x;
    this.y = y;
  }
}
class Rectangle {
  public int width = 0;
  public int height = 0;
  public Point origin;
  // four constructors
  public Rectangle() {
    origin = new Point(0, 0);
  }
  public Rectangle(Point p) {
    origin = p;
  }
  public Rectangle(int w, int h) {
    this(new Point(0, 0), w, h);
  }
  public Rectangle(Point p, int w, int h) {
    origin = p;
    width = w;
    height = h;
  }
  // a method for moving the rectangle
  public void move(int x, int y) {
    origin.x = x;
    origin.y = y;
  }
  // a method for computing the area of the rectangle
  public int area() {
    return width * height;
  }
}

Demonstrates Reference objects

// : c11:References.java
// Demonstrates Reference objects
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
class VeryBig {
  private static final int SZ = 10000;
  private double[] d = new double[SZ];
  private String ident;
  public VeryBig(String id) {
    ident = id;
  }
  public String toString() {
    return ident;
  }
  public void finalize() {
    System.out.println("Finalizing " + ident);
  }
}
public class References {
  private static ReferenceQueue rq = new ReferenceQueue();
  public static void checkQueue() {
    Object inq = rq.poll();
    if (inq != null)
      System.out
          .println("In queue: " + (VeryBig) ((Reference) inq).get());
  }
  public static void main(String[] args) {
    int size = 10;
    // Or, choose size via the command line:
    if (args.length > 0)
      size = Integer.parseInt(args[0]);
    SoftReference[] sa = new SoftReference[size];
    for (int i = 0; i < sa.length; i++) {
      sa[i] = new SoftReference(new VeryBig("Soft " + i), rq);
      System.out.println("Just created: " + (VeryBig) sa[i].get());
      checkQueue();
    }
    WeakReference[] wa = new WeakReference[size];
    for (int i = 0; i < wa.length; i++) {
      wa[i] = new WeakReference(new VeryBig("Weak " + i), rq);
      System.out.println("Just created: " + (VeryBig) wa[i].get());
      checkQueue();
    }
    SoftReference s = new SoftReference(new VeryBig("Soft"));
    WeakReference w = new WeakReference(new VeryBig("Weak"));
    System.gc();
    PhantomReference[] pa = new PhantomReference[size];
    for (int i = 0; i < pa.length; i++) {
      pa[i] = new PhantomReference(new VeryBig("Phantom " + i), rq);
      System.out.println("Just created: " + (VeryBig) pa[i].get());
      checkQueue();
    }
  }
} ///:~

Examination of the way the class loader works

// : c10:SweetShop.java
// Examination of the way the class loader works.
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
class Candy {
  static {
    System.out.println("Loading Candy");
  }
}
class Gum {
  static {
    System.out.println("Loading Gum");
  }
}
class Cookie {
  static {
    System.out.println("Loading Cookie");
  }
}
public class SweetShop {
  public static void main(String[] args) {
    System.out.println("inside main");
    new Candy();
    System.out.println("After creating Candy");
    try {
      Class.forName("Gum");
    } catch (ClassNotFoundException e) {
      System.out.println("Couldn"t find Gum");
    }
    System.out.println("After Class.forName(\"Gum\")");
    new Cookie();
    System.out.println("After creating Cookie");
  }
} ///:~

Objects that cannot be modified are immune to aliasing

// : appendixa:Immutable1.java
// Objects that cannot be modified are immune to aliasing.
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
public class Immutable1 {
  private int data;
  public Immutable1(int initVal) {
    data = initVal;
  }
  public int read() {
    return data;
  }
  public boolean nonzero() {
    return data != 0;
  }
  public Immutable1 multiply(int multiplier) {
    return new Immutable1(data * multiplier);
  }
  public static void f(Immutable1 i1) {
    Immutable1 quad = i1.multiply(4);
    System.out.println("i1 = " + i1.read());
    System.out.println("quad = " + quad.read());
  }
  public static void main(String[] args) {
    Immutable1 x = new Immutable1(47);
    System.out.println("x = " + x.read());
    f(x);
    System.out.println("x = " + x.read());
  }
} ///:~

Passing objects to methods may not be what you"re used to.

//: c03:PassObject.java
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
class Letter {
  char c;
}
public class PassObject {
  static void f(Letter y) {
    y.c = "z";
  }
  public static void main(String[] args) {
    Letter x = new Letter();
    x.c = "a";
    System.out.println("1: x.c: " + x.c);
    f(x);
    System.out.println("2: x.c: " + x.c);
  }
} ///:~