Arquivo Discussoes de Programacao e Tecnologia 
package capitulo01;
import java.util.*;
public class Mae {
public void metodo(Integer integer){
System.out.println("Integer Method Called");
}
public void metodo(Byte b){
System.out.println("Byte Method Called");
}
}
public class Main {
public static void main(String[] args) throws Exception {
byte b = 10;
byte c = 15;
new Mae().metodo((byte) b+c);
new Mae().metodo(b += c);
new Mae().metodo(c++);
new Mae().metodo(b+c);
}
}
Vai depender muito do que voce passa como parametro, pois voce tem um metodo que recebe um Integer e outro um Byte,
Então o proprio programa vai saber para qual metodo direcionar, se ele recebe um tipo de parametro vai para um, se for outro para outro,
new Mae().metodo((byte) b+c);
Voce poderia te no seu metodo ou um proprio metodo que fize-se esse Cast, um metodo que valida-se se ele receber algum outro tipo de parametro para ele transformar o valor fazer um cast
Abçs
Em Java qualquer operação envolvendo int ou tipos menores, (byte, short, char) vai resultar em um int.
Nas linhas 08 e 09 da classe Main a versão Byte será invocada pois os operadores compostos ++ e += fazem o cast por debaixo dos panos
se quiser que a primeira ou última invocação seja a versão Byte, então coloque a operação matemática dentro de parênteses.
Caro, realmente é curioso este exercício. No meu caso, como faço muitas operações binárias, fiquei até preocupado de um dia cair nesta pegadinha num cenário errado.
Pelo que pude analisar, em ordem foram chamados:
1.o) Integer Method Called
2.o) Byte Method Called
3.o) Byte Method Called
4.o) Integer Method Called
Analise por chamada:
Primeira chamada: O bytecode do seu algoritimo está chamando Integer.valueOf para expressão (byte) b+c porque está predefinido ser a forma mais ágil de execução neste tipo de invocação. Por isso chamou o método com a assinatura Integer. A minha primeira impressão foi de que você estivesse fazendo um parse da expressão [b+c] para byte, mas na verdade você converteu desnecessariamente b. A conversão da expressão é assim: (byte) (b+c).
Segunda chamada: Por se tratar de uma atribuição (b += c) antes de chamada do método, quando invocado o método, é passado não uma expressão e sim um primitivo byte. Neste caso o compilador decidiu pelo método de assinatura Byte.
Terceira chamada: Por se tratar de um parâmetro incrementado antes (c++), quando invocado o método, é passado não uma expressão e sim um primitivo byte. Neste caso o compilador também decidiu pelo método de assinatura Byte.
Quarto chamada: A primeira chamada compreende esta situação em seu esclarecimento.
Segue a pilha de chamadas de main:
public static void main(java.lang.String[]);
Code:
Stack=4, Locals=3, Args_size=1
0: bipush 10
2: istore_1
3: bipush 15
5: istore_2
6: new #6; //class Mae
9: dup
10: invokespecial #7; //Method "<init>":()V
13: iload_1
14: iload_2
15: iadd
16: invokestatic #8; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
19: invokevirtual #9; //Method metodo:(Ljava/lang/Integer;)V
22: new #6; //class Mae
25: dup
26: invokespecial #7; //Method "<init>":()V
29: iload_1
30: iload_2
31: iadd
32: i2b
33: dup
34: istore_1
35: invokestatic #10; //Method java/lang/Byte.valueOf:(B)Ljava/lang/Byte;
38: invokevirtual #11; //Method metodo:(Ljava/lang/Byte;)V
41: new #6; //class Mae
44: dup
45: invokespecial #7; //Method "<init>":()V
48: iload_2
49: iload_2
50: iconst_1
51: iadd
52: i2b
53: istore_2
54: invokestatic #10; //Method java/lang/Byte.valueOf:(B)Ljava/lang/Byte;
57: invokevirtual #11; //Method metodo:(Ljava/lang/Byte;)V
60: new #6; //class Mae
63: dup
64: invokespecial #7; //Method "<init>":()V
67: iload_1
68: iload_2
69: iadd
70: invokestatic #8; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
73: invokevirtual #9; //Method metodo:(Ljava/lang/Integer;)V
76: return
LineNumberTable:
line 14: 0
line 15: 3
line 17: 6
line 18: 22
line 19: 41
line 20: 60
line 22: 76
}
wiliamps
Em Java qualquer operação envolvendo int ou tipos menores, (byte, short, char) vai resultar em um int.Nas linhas 08 e 09 da classe Main a versão Byte será invocada pois os operadores compostos ++ e += fazem o cast por debaixo dos panos
Conforme simplificou o Kaesar, as expressões de tipos menores do que int, retornam basicamente int. Esta é a predefinição adotada no compilador.
Segue teste:
public static void main(String[] args) {
byte a = 10;
byte b = 15;
short c = 10;
short d = 15;
char e = 10;
char f = 15;
System.out.println("Teste sem converter tipo da expressão:");
System.out.println(String.format("- tipo da expressão (a + b): %s", ((Object) (a + b)).getClass().getName()));
System.out.println(String.format("- tipo da expressão (c + d): %s", ((Object) (c + d)).getClass().getName()));
System.out.println(String.format("- tipo da expressão (e + f): %s", ((Object) (e + f)).getClass().getName()));
System.out.println("");
System.out.println("Teste com a conversão do tipo da expressão:");
System.out.println(String.format("- tipo da expressão (byte) (a + b): %s", ((Object) (byte) (a + b)).getClass().getName()));
System.out.println(String.format("- tipo da expressão (short) (c + d): %s", ((Object) (short) (c + d)).getClass().getName()));
System.out.println(String.format("- tipo da expressão (char) (e + f): %s", ((Object) (char) (e + f)).getClass().getName()));
}
Resultado:
Teste sem converter tipo da expressão:
- tipo da expressão (a + b): java.lang.Integer
- tipo da expressão (c + d): java.lang.Integer
- tipo da expressão (e + f): java.lang.Integer
Teste com a conversão do tipo da expressão:
- tipo da expressão (byte) (a + b): java.lang.Byte
- tipo da expressão (short) (c + d): java.lang.Short
- tipo da expressão (char) (e + f): java.lang.Character
wiliamps