From e109d16f8c56fa61f9b4c15a2426ad07ac88cbd6 Mon Sep 17 00:00:00 2001 From: Tom Tromey Date: Mon, 23 Jul 2001 20:01:29 +0000 Subject: javaprims.h: Rebuilt class list. * gcj/javaprims.h: Rebuilt class list. * Makefile.in: Rebuilt. * Makefile.am (core_java_source_files): Added VMClassLoader. * java/lang/VMClassLoader.java: New file. * java/lang/Boolean.java: Merged with Classpath. * java/lang/Byte.java: Merged with Classpath. * java/lang/Integer.java: Merged with Classpath. * java/lang/Long.java: Merged with Classpath. * java/lang/Number.java: Merged with Classpath. * java/lang/Short.java: Merged with Classpath. From-SVN: r44274 --- libjava/java/lang/Byte.java | 303 +++++++++++++++++++++++++++++++++----------- 1 file changed, 231 insertions(+), 72 deletions(-) (limited to 'libjava/java/lang/Byte.java') diff --git a/libjava/java/lang/Byte.java b/libjava/java/lang/Byte.java index 347e2524fae..964e073b735 100644 --- a/libjava/java/lang/Byte.java +++ b/libjava/java/lang/Byte.java @@ -1,88 +1,193 @@ -/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation +/* Byte.java -- object wrapper for byte + Copyright (C) 1998, 2001 Free Software Foundation, Inc. - This file is part of libgcj. +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +As a special exception, if you link this library with other files to +produce an executable, this library does not by itself cause the +resulting executable to be covered by the GNU General Public License. +This exception does not however invalidate any other reasons why the +executable file might be covered by the GNU General Public License. */ -This software is copyrighted work licensed under the terms of the -Libgcj License. Please consult the file "LIBGCJ_LICENSE" for -details. */ package java.lang; /** - * @author Per Bothner - * @date April 17, 1998. + * Instances of class Byte represent primitive byte + * values. + * + * Additionally, this class provides various helper functions and variables + * useful to bytes. + * + * @author Paul Fisher + * @author John Keiser + * @author Per Bothner + * @since JDK 1.0 */ -/* Written using "Java Class Libraries", 2nd edition, plus online - * API docs for JDK 1.2 beta from http://www.javasoft.com. - * Status: Believed complete and correct. - * Includes JDK 1.2 methods. - */ - -public final class Byte extends Number implements Comparable +public final class Byte extends Number implements Comparable { - byte value; + static final long serialVersionUID = -7183698231559129828L; - public final static byte MIN_VALUE = -128; - public final static byte MAX_VALUE = 127; + /** + * The minimum value a byte can represent is -128. + */ + public static final byte MIN_VALUE = -128; - // This initialization is seemingly circular, but it is accepted - // by javac, and is handled specially by gcc. - public static final Class TYPE = byte.class; + /** + * The maximum value a byte can represent is 127. + */ + public static final byte MAX_VALUE = 127; - private static final long serialVersionUID = -7183698231559129828L; + /** + * The primitive type byte is represented by this + * Class object. + */ + public static final Class TYPE = VMClassLoader.getPrimitiveClass("byte"); - public Byte(byte value) + /** + * The immutable value of this Byte. + */ + private final byte value; + + /** + * Create a Byte object representing the value of the + * byte argument. + * + * @param value the value to use + */ + public Byte(byte value) { this.value = value; } - public Byte(String str) - throws NumberFormatException + /** + * Create a Byte object representing the value specified + * by the String argument. + * + * @param s the string to convert. + */ + public Byte(String s) throws NumberFormatException { - this.value = parseByte(str, 10); + value = parseByte(s, 10); } - public byte byteValue() + /** + * Return a hashcode representing this Object. + * + * Byte's hash code is calculated by simply returning its + * value. + * + * @return this Object's hash code. + */ + public int hashCode() { return value; } - public short shortValue() + /** + * Returns true if obj is an instance of + * Byte and represents the same byte value. + * @return whether these Objects are semantically equal. + */ + public boolean equals(Object obj) { - return value; + return ((obj instanceof Byte) && (value == ((Byte)obj).byteValue())); } - public int intValue() + /** + * Converts the byte to a String and assumes + * a radix of 10. + * @param i the byte to convert to String + * @return the String representation of the argument. + */ + public static String toString(byte i) { - return value; + return Integer.toString ((int) i); } - public long longValue () + /** + * Converts the Byte value to a String and + * assumes a radix of 10. + * @return the String representation of this Byte. + */ + public String toString() { - return value; + return Integer.toString ((int) value); } - - public float floatValue () + + /** + * Creates a new Byte object using the String, + * assuming a radix of 10. + * @param s the String to convert. + * @return the new Byte. + * @see #Byte(java.lang.String) + * @see #parseByte(java.lang.String) + * @exception NumberFormatException thrown if the String + * cannot be parsed as a byte. + */ + public static Byte valueOf(String s) throws NumberFormatException { - return (float) value; + return new Byte(parseByte(s)); } - public double doubleValue () + /** + * Creates a new Byte object using the String + * and specified radix (base). + * @param s the String to convert. + * @param radix the radix (base) to convert with. + * @return the new Byte. + * @see #parseByte(java.lang.String,int) + * @exception NumberFormatException thrown if the String + * cannot be parsed as a byte. + */ + public static Byte valueOf(String s, int radix) + throws NumberFormatException { - return (double) value; + return new Byte(parseByte(s, radix)); } - public static Byte decode(String str) - throws NumberFormatException + /** + * Converts the specified String into a byte. + * This function assumes a radix of 10. + * + * @param s the String to convert + * @return the byte value of the String + * argument. + * @exception NumberFormatException thrown if the String + * cannot be parsed as a byte. + */ + public static byte parseByte(String s) throws NumberFormatException { - int i = (Integer.decode(str)).intValue(); - if (i < MIN_VALUE || i > MAX_VALUE) - throw new NumberFormatException(); - return new Byte((byte) i); + return parseByte(s, 10); } - public static byte parseByte(String str, int radix) - throws NumberFormatException + /** + * Converts the specified String into a byte + * using the specified radix (base). + * + * @param str the String to convert + * @param radix the radix (base) to use in the conversion + * @return the String argument converted to byte. + * @exception NumberFormatException thrown if the String + * cannot be parsed as a byte. + */ + public static byte parseByte(String str, int radix) + throws NumberFormatException { int i = Integer.parseInt(str, radix); if (i < MIN_VALUE || i > MAX_VALUE) @@ -90,55 +195,109 @@ public final class Byte extends Number implements Comparable return (byte) i; } - public static byte parseByte(String str) - throws NumberFormatException + /** + * Convert the specified String into a Byte. + * The String may represent decimal, hexadecimal, or + * octal numbers. + * + * The String argument is interpreted based on the leading + * characters. Depending on what the String begins with, the base will be + * interpreted differently: + * + * + * + * + * + * + * + * + *
Leading
Characters		Base
#16
0x16
0X16
08
Anything
Else		10
+ * + * @param str the String to interpret. + * @return the value of the String as a Byte. + * @exception NumberFormatException thrown if the String + * cannot be parsed as a byte. + */ + public static Byte decode(String str) throws NumberFormatException { - return parseByte(str, 10); + int i = (Integer.decode(str)).intValue(); + if (i < MIN_VALUE || i > MAX_VALUE) + throw new NumberFormatException(); + return new Byte((byte) i); } - - public static Byte valueOf(String str, int radix) - throws NumberFormatException + + /** Return the value of this Byte as an short. + ** @return the value of this Byte as an short. + **/ + public byte byteValue() { - return new Byte(parseByte(str, radix)); + return value; } - public static Byte valueOf(String str) - throws NumberFormatException + /** Return the value of this Byte as an short. + ** @return the value of this Byte as an short. + **/ + public short shortValue() { - return valueOf(str, 10); + return value; } - // Added in JDK 1.2 - public int compareTo(Byte anotherByte) + /** Return the value of this Byte as an int. + ** @return the value of this Byte as an int. + **/ + public int intValue() { - return this.value - anotherByte.value; + return value; } - // Added in JDK 1.2 - /** @throws ClassCastException */ - public int compareTo(Object o) + /** Return the value of this Byte as a long. + ** @return the value of this Byte as a long. + **/ + public long longValue() { - return this.value - ((Byte) o).value; + return value; } - public boolean equals(Object obj) + /** Return the value of this Byte as a float. + ** @return the value of this Byte as a float. + **/ + public float floatValue() { - return (obj instanceof Byte) && ((Byte)obj).value == value; + return value; } - // Verified that hashCode is returns plain value (see Boolean_1 test). - public int hashCode() + /** Return the value of this Byte as a double. + ** @return the value of this Byte as a double. + **/ + public double doubleValue() { return value; } - - public String toString() + + /** + * Compare two Bytes numerically by comparing their + * byte values. + * @return a positive value if this Byte is greater + * in value than the argument Byte; a negative value + * if this Byte is smaller in value than the argument + * Byte; and 0, zero, if this + * Byte is equal in value to the argument + * Byte. + */ + public int compareTo(Byte b) { - return Integer.toString((int) value); + return (int)(value - b.byteValue()); } - - public static String toString(byte value) + + /** + * Behaves like compareTo(java.lang.Byte) unless the Object + * is not a Byte. Then it throws a + * ClassCastException. + * @exception ClassCastException if the argument is not a + * Byte. + */ + public int compareTo(Object o) { - return Integer.toString((int) value); + return compareTo((Byte)o); } } -- cgit v1.2.1