Boa tarde galera!
Estou com uma dificudade com tipos génericos!
Esse código mostra bem o que quero fazer:
public class UmaClasse <tipo>{
tipo variavel;
public tipo funçãoQueSoma(tipo a,tipo b){
if(tipo == float || tipo == double){
return a+b;
}else{
throw new IllegalArgumentException("Operação invalida pra esse tipo de argumento");
}
}
}porem nao aceita as operações aritmética sem definir o tipo
alguem tem alguma ideia?
Nos seus estudos de generics… vc chegou a ver esse tipo de construção:
<TIPO extends Number>?
[quote=tabocu]Boa tarde galera!
Estou com uma dificudade com tipos génericos!
Esse código mostra bem o que quero fazer:
public class UmaClasse <tipo>{
tipo variavel;
public tipo funçãoQueSoma(tipo a,tipo b){
if(tipo == float || tipo == double){
return a+b;
}else{
throw new IllegalArgumentException("Operação invalida pra esse tipo de argumento");
}
}
}porem nao aceita as operações aritmética sem definir o tipo
alguem tem alguma ideia?[/quote]
Olá,
comecei a pouco com Java, mais ja me acostumei com algumas coisinhas, eu vou dar a minha opinião se o pessoal ver que ta errado por favor me perdoem
não sei se é isso que você realmente quer, mais praticamente um tipo (um Object) em java pode ser qualquer coisa, por isso você não consegue fazer operações aritiméticas sem saber exatamente o tipo, eu sugiro então que use a classe Number pai de todos os Wrappers em Java exceto por Boolean *se eu nao me engano,
por exemplo Todas as classes herdam de Object, porém Number tem como filhas as classes Wrappers, que representam numeros.
vou mudar o seu código e vc vê se serviu pro seu caso…
public class UmaClasse { //não preciso de Generics aqui
public Number funçãoQueSoma(Number a, Number b){
return a + b;
}
} graças ao Autoboxing você consegue colocar uma variavel primitiva no parametro do seu metodo,
qualquer duvida so avisar, abraços
*correção Number é uma interface e por isso não tem o metodo toString() sobrescrito,
fiz uns testes e mudei para
public Number funçãoQueSoma(Number a, Number b){
return a.intValue() + b.intValue();
}[quote=tabocu]Boa tarde galera!
Estou com uma dificudade com tipos génericos!
Esse código mostra bem o que quero fazer:
public class UmaClasse <tipo>{
tipo variavel;
public tipo funçãoQueSoma(tipo a,tipo b){
if(tipo == float || tipo == double){
return a+b;
}else{
throw new IllegalArgumentException("Operação invalida pra esse tipo de argumento");
}
}
}porem nao aceita as operações aritmética sem definir o tipo
alguem tem alguma ideia?[/quote]
Cara, acho que esse código aqui pode te ajudar:
public static void main(String[] args) {
// Lista que aceita Objetos do tipo Number
List<Number> numeros = new ArrayList<Number>();
int a = 1;
long b = 2;
byte c = 3;
// Adicionando int long e byte em uma lista de number
numeros.add(a);
numeros.add(b);
numeros.add(c);
// Não da erro pois ambos são number por herança
System.out.println(soma(numeros));
}
public static Number soma(List<Number> numeros)
{
int total = 0;
for (Number number : numeros) {
total = total + number.intValue();
}
// Só para mostrar que não há problema, retorno um int onde foi declarado Number
return total;
}Generics é vc trabalhar com abstração, ou seja, não ter q se preocupar com o tipo específico. No método soma, não faz diferença se na minha lista está int, byte, long.
Vc poderia usar por exemplo Eletronico. Definir métodos como estaLigado(), totalEnergiaConsumida() e depois instanciar esse cara como Eletronico eletro = new Eletronico(); e Pronto! Vc poderia acessar eletro.estaligado() sem problemas.
Generics necessita de muuuuuuito estudo.
Bom estudo ae! [=
Nada muito simples, garanto.
[code]
public class MinhaClasse {
public static void main(String[] args) {
MinhaClasse classe = new MinhaClasse();
System.out.println(classe.soma(5.5, 5.3));
System.out.println(classe.soma(5d, 5d));
System.out.println(classe.soma(5f, 5d));
System.out.println(classe.soma(5d, 5f));
System.out.println("O próximo dará erro!");
System.out.println(classe.soma(5D, 5)); // args inválidos
}
public Number soma(Number a, Number b){
if (checaNumeros(a, b)){
return a.doubleValue() + b.doubleValue();
}
throw new IllegalArgumentException("Args inválidos");
}
public boolean checaNumeros(Number... a){
for(Number n : a){
if (!(n instanceof Float || n instanceof Double )){
return false;
}
}
return true;
}
}[/code]
Oi gente! obrigado pela atenção!
no caso estou tentando trabalhar com generics mesmo.
A ideia é uma representação esparsa de matriz onde vc pode escolher qualquer tipo, ate mesmo um objeto complexo.
deem uma olhada neste codigo
public class matricial <tipo>{
static final double D_inf = Double.MAX_VALUE;
static final double D_eps = Double.MIN_VALUE;
static final double F_inf = Float.MAX_VALUE;
static final double F_eps = Float.MIN_VALUE;
static final double I_inf = Integer.MAX_VALUE;
Tab <tipo> matriz;
public matricial(int Dimensao, tipo esp){
matriz = new Tab<tipo>(Dimensao,esp);
}
public matricial(int Linhas, int Colunas, tipo esp){
matriz = new Tab<tipo>(Linhas,Colunas,esp);
}
public matricial(int Dimensao, Modo modo, tipo esp){
matriz = new Tab<tipo>(Dimensao,modo,esp);
}
public matricial(matricial<tipo> nova){
matriz = new Tab<tipo>(nova.matriz);
}
public matricial soma(matricial<tipo> a) {
matricial Z = new matricial(a);
for(int v_Cont_A = 0; v_Cont_A < a.matriz.numLinhas(); v_Cont_A++){
for(int v_Cont_B = 0; v_Cont_B < a.matriz.numColunas(); v_Cont_B++){
Z.matriz.valor(v_Cont_A,v_Cont_B,((Float) a.matriz.valor(v_Cont_A,v_Cont_B) + (Float) this.matriz.valor(v_Cont_A,v_Cont_B)));
}
}
return Z;
}
}ai eu preciso reconhecer o parametro para que eu possa realizar as operações. caso seja algum parametro que nao me interesse eu retorno um erro
[quote=renamed]Nada muito simples, garanto.
[code]
public class MinhaClasse {
public static void main(String[] args) {
MinhaClasse classe = new MinhaClasse();
System.out.println(classe.soma(5.5, 5.3));
System.out.println(classe.soma(5d, 5d));
System.out.println(classe.soma(5f, 5d));
System.out.println(classe.soma(5d, 5f));
System.out.println("O próximo dará erro!");
System.out.println(classe.soma(5D, 5)); // args inválidos
}
public Number soma(Number a, Number b){
if (checaNumeros(a, b)){
return a.doubleValue() + b.doubleValue();
}
throw new IllegalArgumentException("Args inválidos");
}
public boolean checaNumeros(Number... a){
for(Number n : a){
if (!(n instanceof Float || n instanceof Double )){
return false;
}
}
return true;
}
}[/code]
[/quote]
1 - Kd o generics?
2 - instanceof é considerado má pratica. http://www.guj.com.br/posts/list/100078.java
Pois é caro, se for fazer por generics, bom estudo. [=
Infelizmente, a implementação de generics do Java não é tão flexível e nem tão precisa quanto a do C++ ou do C#. No java, por exemplo, não é possível colocar como tipo genérico um tipo primitivo.
Nesse caso, com generics não é possível fazer o que você quer.
A não ser que ele saia do primitivo int e vá para Integer. [=
Ainda existe uma luz, mas como disse das outras duas vezes… Estude! [=
[quote=rogelgarcia]Nos seus estudos de generics… vc chegou a ver esse tipo de construção:
<TIPO extends Number>?[/quote]
A dez anos atras fiz tinha feito essa pergunta… hehehe
Mesmo com autoboxing, ele obterá uma performance desprezível. A aplicação dele é fortemente matemática, eu não recomendaria esse tipo de conversão implícita.
Oi gente,
A ideia da minha biblioteca e a seguinte:
eu criei uma representacao esparca de matriz pela classe tab.
Alem de ser esparca voce pode escolher o elemento esparco e ela é generica.
agora eu preciso criar operacoes padroes como multiplicacao de matrizes, soma, inversao etc.
para tal preciso verificar se tais operacoes sao possiveis com o tipo parametrizado e se foram eleas devem ser realizadas caso nao seja ela retorna um erro.
algo parecido com a ideia do matlab, porem sem a sobrecarga de operadores que nao é aceita em java.
se possivel me recomendem um link sobre generics para que eu possa estudar tambem.
muito obrigado
[quote=jakefrog][quote=renamed]Nada muito simples, garanto.
[code]
public class MinhaClasse {
public static void main(String[] args) {
MinhaClasse classe = new MinhaClasse();
System.out.println(classe.soma(5.5, 5.3));
System.out.println(classe.soma(5d, 5d));
System.out.println(classe.soma(5f, 5d));
System.out.println(classe.soma(5d, 5f));
System.out.println("O próximo dará erro!");
System.out.println(classe.soma(5D, 5)); // args inválidos
}
public Number soma(Number a, Number b){
if (checaNumeros(a, b)){
return a.doubleValue() + b.doubleValue();
}
throw new IllegalArgumentException("Args inválidos");
}
public boolean checaNumeros(Number... a){
for(Number n : a){
if (!(n instanceof Float || n instanceof Double )){
return false;
}
}
return true;
}
}[/code]
[/quote]
1 - Kd o generics?
2 - instanceof é considerado má pratica. http://www.guj.com.br/posts/list/100078.java
Pois é caro, se for fazer por generics, bom estudo. [=[/quote]
O problema do instanceof é que as pessoas acabam usando-o com certeza displicência, enquanto há outras formas mais elegantes de se resolver o problema. Beware of instanceof operator
Mas, no site da Oracle, não vi restrições quanto a sua utilização: The Type Comparison Operator instanceof
[quote=renamed][quote=jakefrog][quote=renamed]Nada muito simples, garanto.
[code]
public class MinhaClasse {
public static void main(String[] args) {
MinhaClasse classe = new MinhaClasse();
System.out.println(classe.soma(5.5, 5.3));
System.out.println(classe.soma(5d, 5d));
System.out.println(classe.soma(5f, 5d));
System.out.println(classe.soma(5d, 5f));
System.out.println("O próximo dará erro!");
System.out.println(classe.soma(5D, 5)); // args inválidos
}
public Number soma(Number a, Number b){
if (checaNumeros(a, b)){
return a.doubleValue() + b.doubleValue();
}
throw new IllegalArgumentException("Args inválidos");
}
public boolean checaNumeros(Number... a){
for(Number n : a){
if (!(n instanceof Float || n instanceof Double )){
return false;
}
}
return true;
}
}[/code]
[/quote]
1 - Kd o generics?
2 - instanceof é considerado má pratica. http://www.guj.com.br/posts/list/100078.java
Pois é caro, se for fazer por generics, bom estudo. [=[/quote]
O problema do instanceof é que as pessoas acabam usando-o com certeza displicência, enquanto há outras formas mais elegantes de se resolver o problema. Beware of instanceof operator
Mas, no site da Oracle, não vi restrições quanto a sua utilização: The Type Comparison Operator instanceof[/quote]
Realmente restringir só vão fazer quando dá um pau absurdo. Q eu me lembre agora, uma coisa que eu os vi aconselhar a não usar eh o SingleThreadModel.
Quando ao fato da displicência por parte dos outros, lembre-se que vc programa não só por vc, mas pelo outros da equipe também.
Se alguem tiver um conhecimento menor, concerteza fará coisa errada… Então, é melhor arquitetar de modo a não precisar usar! [=