home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1998 February / VPR9802A.ISO / APP_DEMO / VC / MAIN.BIN / Byte.java < prev    next >
Text File  |  1997-10-27  |  7KB  |  268 lines
  1. /*
  2.  * @(#)Byte.java    1.7 97/01/20
  3.  * 
  4.  * Copyright (c) 1995, 1996 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  * CopyrightVersion 1.1_beta
  20.  * 
  21.  */
  22.  
  23. package java.lang;
  24.  
  25. /**
  26.  *
  27.  * The Byte class is the standard wrapper for byte values.
  28.  *
  29.  * @author  Nakul Saraiya
  30.  * @version 1.7, 01/20/97
  31.  * @see     java.lang.Number
  32.  * @since   JDK1.1
  33.  */
  34. public final
  35. class Byte extends Number {
  36.  
  37.     /**
  38.      * The minimum value a Byte can have.
  39.      *
  40.      * @since   JDK1.1
  41.      */
  42.     public static final byte   MIN_VALUE = -128;
  43.  
  44.     /**
  45.      * The maximum value a Byte can have.
  46.      *
  47.      * @since   JDK1.1
  48.      */
  49.     public static final byte   MAX_VALUE = 127;
  50.  
  51.     /**
  52.      * The Class object representing the primitive type byte.
  53.      *
  54.      * @since   JDK1.1
  55.      */
  56.     public static final Class    TYPE = Class.getPrimitiveClass("byte");
  57.  
  58.     /**
  59.      * Returns a new String object representing the specified Byte. The radix
  60.      * is assumed to be 10.
  61.      *
  62.      * @param b    the byte to be converted
  63.      * @since   JDK1.1
  64.      */
  65.     public static String toString(byte b) {
  66.     return Integer.toString((int)b, 10);
  67.     }
  68.  
  69.     /**
  70.      * Assuming the specified String represents a byte, returns
  71.      * that byte's value. Throws an exception if the String cannot
  72.      * be parsed as a byte.  The radix is assumed to be 10.
  73.      *
  74.      * @param s        the String containing the byte
  75.      * @exception    NumberFormatException If the string does not
  76.      *            contain a parsable byte.
  77.      * @since   JDK1.1
  78.      */
  79.     public static byte parseByte(String s) throws NumberFormatException {
  80.     return parseByte(s, 10);
  81.     }
  82.  
  83.     /**
  84.      * Assuming the specified String represents a byte, returns
  85.      * that byte's value. Throws an exception if the String cannot
  86.      * be parsed as a byte.
  87.      *
  88.      * @param s        the String containing the byte
  89.      * @param radix    the radix to be used
  90.      * @exception    NumberFormatException If the String does not
  91.      *            contain a parsable byte.
  92.      * @since   JDK1.1
  93.      */
  94.     public static byte parseByte(String s, int radix)
  95.     throws NumberFormatException {
  96.     int i = Integer.parseInt(s, radix);
  97.     if (i < MIN_VALUE || i > MAX_VALUE)
  98.         throw new NumberFormatException();
  99.     return (byte)i;
  100.     }
  101.  
  102.     /**
  103.      * Assuming the specified String represents a byte, returns a
  104.      * new Byte object initialized to that value.  Throws an
  105.      * exception if the String cannot be parsed as a byte.
  106.      *
  107.      * @param s        the String containing the integer
  108.      * @param radix     the radix to be used
  109.      * @exception    NumberFormatException If the String does not
  110.      *            contain a parsable byte.
  111.      * @since   JDK1.1
  112.      */
  113.     public static Byte valueOf(String s, int radix)
  114.     throws NumberFormatException {
  115.     return new Byte(parseByte(s, radix));
  116.     }
  117.  
  118.     /**
  119.      * Assuming the specified String represents a byte, returns a
  120.      * new Byte object initialized to that value.  Throws an
  121.      * exception if the String cannot be parsed as a byte.
  122.      * The radix is assumed to be 10.
  123.      *
  124.      * @param s        the String containing the integer
  125.      * @exception    NumberFormatException If the String does not
  126.      *            contain a parsable byte.
  127.      * @since   JDK1.1
  128.      */
  129.     public static Byte valueOf(String s) throws NumberFormatException {
  130.     return valueOf(s, 10);
  131.     }
  132.  
  133.     /**
  134.      * Decodes a String into a Byte.  The String may represent
  135.      * decimal, hexadecimal, and octal numbers.
  136.      *
  137.      * @param nm the string to decode
  138.      * @since   JDK1.1
  139.      */
  140.     public static Byte decode(String nm) throws NumberFormatException {
  141.     if (nm.startsWith("0x")) {
  142.         return Byte.valueOf(nm.substring(2), 16);
  143.     }
  144.     if (nm.startsWith("#")) {
  145.         return Byte.valueOf(nm.substring(1), 16);
  146.     }
  147.     if (nm.startsWith("0") && nm.length() > 1) {
  148.         return Byte.valueOf(nm.substring(1), 8);
  149.     }
  150.  
  151.     return Byte.valueOf(nm);
  152.     }
  153.  
  154.     /**
  155.      * The value of the Byte.
  156.      */
  157.     private byte value;
  158.  
  159.     /**
  160.      * Constructs a Byte object initialized to the specified byte value.
  161.      *
  162.      * @param value    the initial value of the Byte
  163.      * @since   JDK1.1
  164.      */
  165.     public Byte(byte value) {
  166.     this.value = value;
  167.     }
  168.  
  169.     /**
  170.      * Constructs a Byte object initialized to the value specified by the
  171.      * String parameter.  The radix is assumed to be 10.
  172.      *
  173.      * @param s        the String to be converted to a Byte
  174.      * @exception    NumberFormatException If the String does not
  175.      *            contain a parsable byte.
  176.      * @since   JDK1.1
  177.      */
  178.     public Byte(String s) throws NumberFormatException {
  179.     this.value = parseByte(s);
  180.     }
  181.  
  182.     /**
  183.      * Returns the value of this Byte as a byte.
  184.      *
  185.      * @since   JDK1.1
  186.      */
  187.     public byte byteValue() {
  188.     return value;
  189.     }
  190.  
  191.     /**
  192.      * Returns the value of this Byte as a short.
  193.      *
  194.      * @since   JDK1.1
  195.      */
  196.     public short shortValue() {
  197.     return (short)value;
  198.     }
  199.  
  200.     /**
  201.      * Returns the value of this Byte as an int.
  202.      *
  203.      * @since   JDK1.1
  204.      */
  205.     public int intValue() {
  206.     return (int)value;
  207.     }
  208.  
  209.     /**
  210.      * Returns the value of this Byte as a long.
  211.      *
  212.      * @since   JDK1.1
  213.      */
  214.     public long longValue() {
  215.     return (long)value;
  216.     }
  217.  
  218.     /**
  219.      * Returns the value of this Byte as a float.
  220.      *
  221.      * @since   JDK1.1
  222.      */
  223.     public float floatValue() {
  224.     return (float)value;
  225.     }
  226.  
  227.     /**
  228.      * Returns the value of this Byte as a double.
  229.      *
  230.      * @since   JDK1.1
  231.      */
  232.     public double doubleValue() {
  233.     return (double)value;
  234.     }
  235.  
  236.     /**
  237.      * Returns a String object representing this Byte's value.
  238.      *
  239.      * @since   JDK1.1
  240.      */
  241.     public String toString() {
  242.     return String.valueOf((int)value);
  243.     }
  244.  
  245.     /**
  246.      * Returns a hashcode for this Byte.
  247.      *
  248.      * @since   JDK1.1
  249.      */
  250.     public int hashCode() {
  251.     return (int)value;
  252.     }
  253.  
  254.     /**
  255.      * Compares this object to the specified object.
  256.      *
  257.      * @param obj    the object to compare with
  258.      * @return         true if the objects are the same; false otherwise.
  259.      * @since   JDK1.1
  260.      */
  261.     public boolean equals(Object obj) {
  262.     if ((obj != null) && (obj instanceof Byte)) {
  263.         return value == ((Byte)obj).byteValue();
  264.     }
  265.     return false;
  266.     }
  267. }
  268.