Java Tutorial/Class Definition/Declare Object
Содержание
Demonstrates that all classes descend from the type java.lang.Object
/*
* file: ObjectIsGod.java
* package: oreilly.hcj.review
*
* This software is granted under the terms of the Common Public License,
* CPL, which may be found at the following URL:
* http://www-124.ibm.ru/developerworks/oss/CPLv1.0.htm
*
* Copyright(c) 2003-2005 by the authors indicated in the @author tags.
* All Rights are Reserved by the various authors.
*
########## DO NOT EDIT ABOVE THIS LINE ########## */
/**
* Demonstrates that all classes descend from the type <tt>java.lang.Object</tt>.
*
* @author
* @version $Revision: 1.3 $
*/
public class ObjectIsGod {
/**
* Main Method.
*
* @param args Command line arguments.
*/
public static final void main(final String[] args) {
System.out.println(SomeClass.class + " --|> " + SomeClass.class.getSuperclass());
System.out.println(SomeOtherClass.class + " --|> "
+ SomeOtherClass.class.getSuperclass());
}
/**
* Class with implicit java.lang.Object inheritance.
*/
public class SomeClass {
}
/**
* Class with explicit java.lang.Object inheritance.
*/
public class SomeOtherClass extends Object {
}
}
/* ########## End of File ########## */
Demonstration of the Pointers and References Concept
/*
* file: PointersAndReferences.java
* package: oreilly.hcj.review
*
* This software is granted under the terms of the Common Public License,
* CPL, which may be found at the following URL:
* http://www-124.ibm.ru/developerworks/oss/CPLv1.0.htm
*
* Copyright(c) 2003-2005 by the authors indicated in the @author tags.
* All Rights are Reserved by the various authors.
*
########## DO NOT EDIT ABOVE THIS LINE ########## */
import java.util.Vector;
/**
* Demonstration of the Pointers and References Concept.
*
* @author
* @version $Revision: 1.3 $
*/
public class PointersAndReferences {
/**
* Main method.
*
* @param args Command Line arguments.
*/
public static final void main(final String[] args) {
Vector source = new Vector();
source.add("O"Reilly");
source.add("XML");
source.add("Java");
System.out.println("Original Vector");
System.out.println(source.toString());
// -- Try the first method.
someMethod(source);
System.out.println("After first method.");
System.out.println(source.toString());
// -- Try the second method.
someOtherMethod(source);
System.out.println("After second method.");
System.out.println(source.toString());
}
/**
* Try using a vector without changing it.
*
* @param source The source Vector.
*/
public static void someMethod(Vector source) {
Vector target = source;
target.add("Swing");
}
/**
* Try using a vector without changing it with final parameter.
*
* @param source The source Vector.
*/
public static void someOtherMethod(final Vector source) {
Vector target = source;
target.add("JFC"); // ouch, still changes v.
// source = new Vector(); // compiler error.
}
}
/* ########## End of File ########## */
Implements a manager of lists that stores the lists by key
/*
* file: Inference.java
* package: oreilly.hcj.tiger
*
* This software is granted under the terms of the Common Public License,
* CPL, which may be found at the following URL:
* http://www-124.ibm.ru/developerworks/oss/CPLv1.0.htm
*
* Copyright(c) 2003-2005 by the authors indicated in the @author tags.
* All Rights are Reserved by the various authors.
*
########## DO NOT EDIT ABOVE THIS LINE ########## */
import java.util.ArrayList;
import java.util.List;
/**
* Implements a manager of lists that stores the lists by key.
*/
public class InferenceDemo {
static int callCount = 0;
/** Second. */
public static <Type extends Number> Type someMethod(final Type num) {
System.out.print("Second==> ");
return num;
}
/** Third. */
public static <Type> Type someMethod(final Type obj, List<Type> list) {
System.out.print("Third==> ");
return obj;
}
/** Fourth. */
public static <Type> List<Type> someMethod() {
System.out.print("Fourth==> ");
return new ArrayList<Type>();
}
/** Fifth. */
public static void someMethod(final Object obj) {
System.out.print("Fifth==> ");
}
/** Sixth. */
public static void someMethod(final String str) {
System.out.print("Sixth==> ");
}
/** Seventh. */
public static <Type> Type someOtherMethod(final Type obj, List<? extends Type> list) {
System.out.print("Seventh==> ");
return obj;
}
/** Demonstrate the rules. */
public final static void main(final String[] args) {
System.out.println();
// Picks Sixth
System.out.print("\n1) ");
someMethod("Hello");
// Ambiguous, wont compile.
// System.out.print("\n2) ");
// someMethod(new C());
// Ambiguous, wont compile.
// First and Fifth mask each other and can never be called.
// System.out.print("\n3) ");
// someMethod(new Object());
// Picks Second
System.out.print("\n5) ");
someMethod(new Integer(5));
// Picks Second
System.out.print("\n6) ");
someMethod(5);
// Picks Fourth
System.out.print("\n7) ");
List<Integer> listOne = someMethod();
listOne.add(new Integer(5));
System.out.print("\n7a) ");
List<String> listTwo = someMethod();
listTwo.add(new String("Hello"));
System.out.print("\n7b) ");
Object listThree = someMethod();
System.out.println(listThree.getClass());
// listThree.add( ... ); // Cant put anything into this list
// -- Make some lists --
List<A> listOfA = new ArrayList<A>();
listOfA.add(new A());
List<B> listOfB = new ArrayList<B>();
listOfB.add(new B());
// Picks
System.out.print("\n8) ");
someMethod(5, new ArrayList<Integer>());
// Wont compile: No such type. Since A can not necessarily be promoted to B.
// System.out.print("9) ");
// someMethod(new A(), listOfB);
// Picks Three: Works because B can be demoted to A
System.out.print("\n10) ");
someMethod(new B(), listOfA);
// Picks Seventh
System.out.print("\n11) ");
someOtherMethod(new A(), listOfB);
// Picks Seventh
// Works even though it probably shouldnt. The someOtherMethod() signature
// implies
// that the type of the component of the ist should be a subtype of the type
// used
// for obj. However, in this case first is a List<A> and A clearly isnt a
// subtype
// of B. Is this a bug?
System.out.print("\n12) ");
someOtherMethod(new B(), listOfA);
// Really weird as the two types arent even remotely related. This should
// probably
// be rejected by the compiler but it doesnt seem to be enforcing its
// bounds.
System.out.print("\n13) ");
List<String> listOfString = new ArrayList<String>();
listOfString.add("Hello");
someOtherMethod(new Integer(5), listOfString);
// Doesnt work even though the spec says it should:
// System.out.print(I"14)");
// A value = <A>someMethod(new B(), new ArrayList<A>());
// Picks Fourth: The type of the list returned by SomeMethod is
// List<Integer>
System.out.print("\n15) ");
someMethod(5, someMethod());
// Picks Fourth: The type of the list returned by SomeMethod is List<String>
System.out.print("\n16) ");
someMethod("Hello", someMethod());
}
private static class A {
}
private static class B extends A {
}
private static class C extends B {
}
}
/* ########## End of File ########## */
Using Objects
class Point {
double x;
double y;
Point(double xVal, double yVal) {
x = xVal;
y = yVal;
}
Point(final Point oldPoint) {
x = oldPoint.x;
y = oldPoint.y;
}
void move(double xDelta, double yDelta) {
x += xDelta;
y += yDelta;
}
double distance(final Point aPoint) {
return Math.sqrt((x - aPoint.x) * (x - aPoint.x) + (y - aPoint.y) * (y - aPoint.y));
}
public String toString() {
return Double.toString(x) + ", " + y;
}
}
// You can use Point objects in the definition of the class Line:
class Line {
Point start;
Point end;
Line(final Point start, final Point end) {
this.start = new Point(start);
this.end = new Point(end);
}
Line(double xStart, double yStart, double xEnd, double yEnd) {
start = new Point(xStart, yStart);
end = new Point(xEnd, yEnd);
}
double length() {
return start.distance(end);
}
public String toString() {
return "(" + start + "):(" + end + ")";
}
}
public class MainClass{
public static void main(String[] arg){
Line l1 = new Line(new Point(1,2), new Point(3,4));
System.out.println(l1);
}
}
(1.0, 2.0):(3.0, 4.0)
