Classes Wrapper & primitivos

Programação Java
#1

E ae pessoal… vai uma classe que fiz ai, espero que sirva :wink:

/* Classe que cobre o objetivo 3.1 do Exame SCJP 5
 *  - Using Wrapper Classes
 * @author Wallas dos Santos Souza iwallas@gmail.com
 * @since 14 de Dezembro de 2006
*/

class WrapObjects {
	
	public static void main(String[] args) {
		//Criando objetos wrapper
		criaWrapperObjects();
		
		//convertendo uma String em Wrapper
		myValueOf();
		
		//convertendo um Wrapper num Primitivo
		xxxValue();
	}
	
	public static void criaWrapperObjects(){
		
		//criando objetos Boolean
		  Boolean b  = new Boolean(true);
	  	  Boolean b1 = new Boolean("true");
		  Boolean b2 = new Boolean("TrUe");
		  Boolean b3 = new Boolean("TRUE");
		
		//criando objetos Byte
		  Byte bt  = new Byte((byte)126);
		  Byte bt1 = new Byte("126");
		
		  //este código compila mas gera uma exception: NumberFormatException: Value out of range
		  //mesmo existindo o construtor String, o valor passado é maior que uma variável
		  //do tipo byte pode suportar: -127 até 127
		  //Byte bt2 = new Byte("1234");
		
		  //erro pois todos números inteiros são considerados do tipo int
		  //Byte bt  = new Byte(126);
				
		  //este código compila, mas gera uma exception: NumberFormatException
		  //porque ABC não é número
		  //Byte bt3 = new Byte("ABC");
		
		//criando objetos Long
		  Long l = new Long(1);
		  //o construtor Long aceita um valor inteiro, pois Long > Integer
		  //não há necessidade de cast.
		  Long l1 = new Long("1");
		
		//criando objetos Short
		  Short s = new Short((short)1);
		  //o construtor Short não aceita um valor inteiro, pois Short < Integer
		  Short s1 = new Short("1");
		  
		//criando objetos Integer
		  Integer i = new Integer(12345);
		  Integer i2 = new Integer("12345");
		
		//criando objeto Character
		  Character c = new Character('c');
	    
	    //criando objetos Float
		  Float f = new Float(12.1);
		  // quando não usamos wrapper classes não podemos
		  // atribuir pontos flutuantes para um float
		  // por exemplo: float fm = 12.1 > não compila
		  // devemos fazer a conversão: float fm = 12.1F
  		  
  		  Float f1 = new Float(12.1F);
	 	  Float f2 = new Float(12.1D);
	 	  Float f3 = new Float("12.1");
		
		//criando objetos Double
		  Double d = new Double(12.1F);
		  Double d1 = new Double(12.1);
		  Double d2 = new Double("12.1");
		  
		//O que é ilegal e não compila, pois nesse caso uma classe não pode instanciar outra
		  //Float il1 = new Double("12.1");
		  //Double il2 = new Float("12.1");
		  //Integer il3 = new Short("2");
		  //Short il4 = new Integer("2");
		  //Integer il5 = new Byte("2");
		  //Byte il6 = new Integer("2");
		  //String il7 = new Character('s');
	}	
		
	public static void myValueOf(){
		
		Integer i  = Integer.valueOf(1);
		Integer i1 = Integer.valueOf("1");
		
		Float f  = Float.valueOf(12.1F);
		Float f1 = Float.valueOf("12.1");
		
		String s = String.valueOf("Teste");
		
		Double d = Double.valueOf("13.1");
		Double d1 = Double.valueOf(13.1F);
		Double d2 = Double.valueOf(13.1);
		
		//usando radix
		//base binária, irá atribuir 9 à i2
		Integer i2 = Integer.valueOf("1001",2);
		  
		//base decimal, irá atribuir 1001 à i3
		Integer i3 = Integer.valueOf("1001",10);
		  
		//base octal, irá atribuir 513 à i4
		Integer i4 = Integer.valueOf("1001",8);
		  
		//Erro, usando radix devemos passar uma string
		//Integer i5 = Integer.valueOf(1001,2);
		  
	}
	
	public static void xxxValue(){
		Integer i = Integer.valueOf(1);
		Integer i2 = new Integer(128);
		Integer i3 = new Integer(2000);
		Double d = new Double(12.123456789);
		Float f = Float.valueOf(500.456F);
		
		//legal
		int ix = Integer.valueOf(4);
		
		//ilegal! Não compila, neste caso somente fazendo cast
		//byte bx = ix.byteValue();
		//byte bx1 = (byte)ix;
		// se atribuirmos o primitivo à um wrapper ok:
		Integer ixw = ix;
		byte bx = ixw.byteValue();
		
		//irá atribuir 1 à b
		byte b = i.byteValue();
		
		//irá atribuir -128 à b1, pois 128 > 127 limite de um tipo byte
		//quando passa do limite ele retorna números negativos.
		byte b1 = i2.byteValue();
		
		short s = i3.shortValue();
		
		//irá atribuir 2000.0 à f
		float f1 = i3.floatValue();
		
		//irá atribuir 12.123457 à f1, pois a capacidade do float é menor
		float f2 = d.floatValue();
		
		//irá atribuir 500.45599365234375 à d1, pois capacidade do double é maior	
		double d1 = f.doubleValue();
		System.out.println(d1);
		
		//erro de compilação 1: com primitivos essa operação não é possível
		  //int i3 = 2;
		  //byte b2 = i3.byteValue();
		
		//erro de compilação 2: se tentarmos usar cast
		  //Byte b = (byte)i;
		
		//erro de compilação 3: se tentarmos com primitivos
		  //int x = 2;
		  //byte b1 = x.intValue();
		  //- neste caso devemos usar cast: (byte)x
		  
	   //no geral, percebe-se que as operações de cast usadas em primitivos
	   // NÃO podem ser usadas com Wrapper e as operações usadas nestes
	   // como ex. byteValue ou valueOf não podem ser usadas com primitivos.
	}
}
#2