Vejam se estou programando bem e falem como acham que eu devia ter feito

Está programando muito mal. Não usa sequer a tag [code] para postar código.
Quem sabe depois de formatar adequadamente o tópico, alguém consiga ler e entender o que você quis fazer.

credo q lixo de codigo, use as tags Code pra postar codigo !!
Ta programando mto mal cara.

Por que não mostrar uma solução melhor pro manolo ao invés de apenas criticar seu codigo?

drsmachado:

Está programando muito mal. Não usa sequer a tag [code] para postar código. Quem sabe depois de formatar adequadamente o tópico, alguém consiga ler e entender o que você quis fazer.

pronto ve la sw vc entende, foi mal comecei faz bem pouco tempo, e sou novo no guj entrei antes de ontem XD nunca tinha postado um código.

lgweb:

credo q lixo de codigo, use as tags Code pra postar codigo !!
Ta programando mto mal cara.

pronto le la de novo mano ta com o code XD

poise e olha que eu comecei a programar faz menos de um mês contando com os nove dias que eu fui viajar XD, para esse tempo não está bom não gente?

Agora que você formatou adequadamente, vamos as considerações
1 - Tente não misturar métodos e declarações de variáveis. Normalmente, os atributos são os primeiros elementos dentro da classe.
2 - Java code, coloque comentário em tudo, para facilitar a leitura por alguém que venha a ler
3 - Creio que ValidacaoPremio poderia ser um atributo da classe Funcionario e não a representação do mesmo
4 - Ao invés de quantosPassaPonto = quantosPassaPonto + 1;
use quantosPassaPonto++;
5 - O nome quantosPassaPonto faz algum sentido para ti, isolado do contexto? talvez numPassaPonto ou totalPassaPonto
6 - Já ouviu falar em laço de repetição? Um for ali no main ajudaria demais e limparia o código.

Acho que é isso.

Começando com dicas simples de boas práticas:

1. coloque os atributos da classe logo em seguida a declaração da mesma.
2. utilize variável inteira ao invés de “double” já que está simplesmente incrementando 1.
3. Se estiver seguindo a Orientação a Objetos totalmente, crie getters e setters para TODOS os campos da classe.

Foram dicas simples para melhorar seu código, para quem está aprendendo, siga em frente que vc somente evoluirá!

Pessoal, postem mais dicas para ajudar o rapaz aí…

drsmachado:

Agora que você formatou adequadamente, vamos as considerações
1 - Tente não misturar métodos e declarações de variáveis. Normalmente, os atributos são os primeiros elementos dentro da classe.
2 - Java code, coloque comentário em tudo, para facilitar a leitura por alguém que venha a ler
3 - Creio que ValidacaoPremio poderia ser um atributo da classe Funcionario e não a representação do mesmo
4 - Ao invés de quantosPassaPonto = quantosPassaPonto + 1;
use quantosPassaPonto++;
5 - O nome quantosPassaPonto faz algum sentido para ti, isolado do contexto? talvez numPassaPonto ou totalPassaPonto
6 - Já ouviu falar em laço de repetição? Um for ali no main ajudaria demais e limparia o código.

Acho que é isso.

muito obrigado me ajuda muito :), bom o lgweb esta me enviando mensagens com insulto, o que fasso quando a isso?

platinijow:

Começando com dicas simples de boas práticas:

1. coloque os atributos da classe logo em seguida a declaração da mesma.
2. utilize variável inteira ao invés de “double” já que está simplesmente incrementando 1.
3. Se estiver seguindo a Orientação a Objetos totalmente, crie getters e setters para TODOS os campos da classe.

Foram dicas simples para melhorar seu código, para quem está aprendendo, siga em frente que vc somente evoluirá!

Pessoal, postem mais dicas para ajudar o rapaz aí…

Eu discordo no 3º e me baseio em cima disso daqui: http://blog.caelum.com.br/nao-aprender-oo-getters-e-setters/

Aqui estão algumas sugestões minhas

public class ValidacaoPremio {

// DECLARAR AS VARIAVEIS EM UM UNICO LOCAL, POIS SERÁ MAIS FACIL DE PROCURA-LAS DEPOIS 
 private double quantosPassaPonto;
 private String premio;
 private String notificacao;

// UMA DICA PARA DEIXAR MAIS CURTO: quantosPassaPonto++ EQUIVALE A ESSA PARTE DO CODIGO  quantosPassaPonto  = quantosPassaPonto + 1;   
   public void passaPonto() {

       quantosPassaPonto++;
   }
   
   public void chequeParaPremio () {
       if (quantosPassaPonto == 10) {
           premio = "carro";
           notificacao = "Parabéns você recebeu o premio!";
       } else {
           notificacao = "você ainda tera de trabalhar ";
           premio = "trabalhe mais";
       }
   }
   
// PARTICULARMENTE PREFIRO DEIXA OS GETTERS AND SETTERS POR ULTIMO, QUANDO NÃO FAÇO NENHUMA RESTRIÇÃO/REGRA DE NEGOCIO DENTRO DESSES METODOS 
   public String getNotificacao() {
        return notificacao;
    }

    public String getPremio() {
        return premio;
    }

    public double getQuantosPassaPonto() {
        return quantosPassaPonto;
    }
}

Sem_Nome:

platinijow:

Começando com dicas simples de boas práticas:

1. coloque os atributos da classe logo em seguida a declaração da mesma.
2. utilize variável inteira ao invés de “double” já que está simplesmente incrementando 1.
3. Se estiver seguindo a Orientação a Objetos totalmente, crie getters e setters para TODOS os campos da classe.

Foram dicas simples para melhorar seu código, para quem está aprendendo, siga em frente que vc somente evoluirá!

Pessoal, postem mais dicas para ajudar o rapaz aí…

Eu discordo no 3º e me baseio em cima disso daqui: http://blog.caelum.com.br/nao-aprender-oo-getters-e-setters/

Sim eu coloquei apenas getter porque eu li exatamente essa matéria, e o código saiu com um erro os getters ficaram em cima das variáveis, mais eu não queria isso XD foi um erro de atenção.

alepsilva14:

Aqui estão algumas sugestões minhas

public class ValidacaoPremio {

// DECLARAR AS VARIAVEIS EM UM UNICO LOCAL, POIS SERÁ MAIS FACIL DE PROCURA-LAS DEPOIS 
 private double quantosPassaPonto;
 private String premio;
 private String notificacao;

// UMA DICA PARA DEIXAR MAIS CURTO: quantosPassaPonto++ EQUIVALE A ESSA PARTE DO CODIGO  quantosPassaPonto  = quantosPassaPonto + 1;   
   public void passaPonto() {

       quantosPassaPonto++;
   }
   
   public void chequeParaPremio () {
       if (quantosPassaPonto == 10) {
           premio = "carro";
           notificacao = "Parabéns você recebeu o premio!";
       } else {
           notificacao = "você ainda tera de trabalhar ";
           premio = "trabalhe mais";
       }
   }
   
// PARTICULARMENTE PREFIRO DEIXA OS GETTERS AND SETTERS POR ULTIMO, QUANDO NÃO FAÇO NENHUMA RESTRIÇÃO/REGRA DE NEGOCIO DENTRO DESSES METODOS 
   public String getNotificacao() {
        return notificacao;
    }

    public String getPremio() {
        return premio;
    }

    public double getQuantosPassaPonto() {
        return quantosPassaPonto;
    }
}

Hehe preferi fazer assim:

public class Premiacao {

	public static String premio = "um carro";

	public static boolean verifica(Funcionario f) {
		if (f.getPontos() >= 10) {
			return true;
		}
		return false;
	}

	public static void main(String[] args) {
		Funcionario f = new Funcionario();
		for (int i = 0; i < 5; i++) {
			f.passaPonto();
		}
		if(Premiacao.verifica(f)) {
			System.out.println("Parabéns! O seu premio é " + Premiacao.premio + "!");
		}
		else {
			System.out.println("Precisa trabalhar mais!");
		}
	}

}

class Funcionario {
	private int pontos;

	public void passaPonto() {
		pontos++;
	}

	public int getPontos() {
		return pontos;
	}

}

Ali é só você controlar quantas vezes ele passo o ponto pelo for.

alepsilva14:

Aqui estão algumas sugestões minhas

public class ValidacaoPremio {

// DECLARAR AS VARIAVEIS EM UM UNICO LOCAL, POIS SERÁ MAIS FACIL DE PROCURA-LAS DEPOIS 
 private double quantosPassaPonto;
 private String premio;
 private String notificacao;

// UMA DICA PARA DEIXAR MAIS CURTO: quantosPassaPonto++ EQUIVALE A ESSA PARTE DO CODIGO  quantosPassaPonto  = quantosPassaPonto + 1;   
   public void passaPonto() {

       quantosPassaPonto++;
   }
   
   public void chequeParaPremio () {
       if (quantosPassaPonto == 10) {
           premio = "carro";
           notificacao = "Parabéns você recebeu o premio!";
       } else {
           notificacao = "você ainda tera de trabalhar ";
           premio = "trabalhe mais";
       }
   }
   
// PARTICULARMENTE PREFIRO DEIXA OS GETTERS AND SETTERS POR ULTIMO, QUANDO NÃO FAÇO NENHUMA RESTRIÇÃO/REGRA DE NEGOCIO DENTRO DESSES METODOS 
   public String getNotificacao() {
        return notificacao;
    }

    public String getPremio() {
        return premio;
    }

    public double getQuantosPassaPonto() {
        return quantosPassaPonto;
    }
}

na apostila da caelum não ensina sobre o ++ obrigado e vou passar a utilizar! E sobre as variáveis foi um erro eu sempre as deixo em cima mas obrigado por falar, e eu concordo em colocar o get e set em baixo fica mais organizado, mais também acho organizado em cima XD eu vou continuar a programa e ver qual o melhor!

Sem_Nome:

alepsilva14:

Aqui estão algumas sugestões minhas

public class ValidacaoPremio {

// DECLARAR AS VARIAVEIS EM UM UNICO LOCAL, POIS SERÁ MAIS FACIL DE PROCURA-LAS DEPOIS 
 private double quantosPassaPonto;
 private String premio;
 private String notificacao;

// UMA DICA PARA DEIXAR MAIS CURTO: quantosPassaPonto++ EQUIVALE A ESSA PARTE DO CODIGO  quantosPassaPonto  = quantosPassaPonto + 1;   
   public void passaPonto() {

       quantosPassaPonto++;
   }
   
   public void chequeParaPremio () {
       if (quantosPassaPonto == 10) {
           premio = "carro";
           notificacao = "Parabéns você recebeu o premio!";
       } else {
           notificacao = "você ainda tera de trabalhar ";
           premio = "trabalhe mais";
       }
   }
   
// PARTICULARMENTE PREFIRO DEIXA OS GETTERS AND SETTERS POR ULTIMO, QUANDO NÃO FAÇO NENHUMA RESTRIÇÃO/REGRA DE NEGOCIO DENTRO DESSES METODOS 
   public String getNotificacao() {
        return notificacao;
    }

    public String getPremio() {
        return premio;
    }

    public double getQuantosPassaPonto() {
        return quantosPassaPonto;
    }
}

Hehe preferi fazer assim:

public class Premiacao {

	public static String premio = "um carro";

	public static boolean verifica(Funcionario f) {
		if (f.getPontos() >= 10) {
			return true;
		}
		return false;
	}

	public static void main(String[] args) {
		Funcionario f = new Funcionario();
		for (int i = 0; i < 5; i++) {
			f.passaPonto();
		}
		if(Premiacao.verifica(f)) {
			System.out.println("Parabéns! O seu premio é " + Premiacao.premio + "!");
		}
		else {
			System.out.println("Precisa trabalhar mais!");
		}
	}

}

class Funcionario {
	private int pontos;

	public void passaPonto() {
		pontos++;
	}

	public int getPontos() {
		return pontos;
	}

}

Ali é só você controlar quantas vezes ele passo o ponto pelo for.

u.u não aprendi a utilizar o for assim ainda se puder me ensinar :)

Cara eu organizo dessa forma minhas classes:

public class MinhaClasse {
	
	//Atributos
	private String Atributo;
	
	//Blocos
	static {
		
	}
	
	{
		
	}
	
	//Construtores
	public MinhaClasse() {

	}
	
	//Métodos publicos
	public void metodo(){
		
	}
	
	//Métodos privados
	private void outroMetodo() {
		
	}

	//Getter e Setters
	public String getAtributo() {
		return Atributo;
	}

	public void setAtributo(String atributo) {
		Atributo = atributo;
	}

}

O for funciona assim:

for(inicializacao; condicao para a repeticao; incrementação /<em>a incrementação é opcional</em>/) {

//o codigo a ser repetido

}

No caso

for (int i = 0/*Inicializacao*/; i < 10/*Condição para a repeticao*/; i++/*Incrementacao*/) {
			f.passaPonto();
			System.out.println("O for passou aqui pela vez de numero " + i);
		}

Note que não precisa ser necessariamente uma incrementação. Poderia ser algo como i = i = i * 2 e coisas do tipo.

Obs: Caso não saiba /* */ // são comentarios, o compilador ignora eles na hora de compilar.

gabrielfrios:

Cara eu organizo dessa forma minhas classes:

public class MinhaClasse {
	
	//Atributos
	private String Atributo;
	
	//Blocos
	static {
		
	}
	
	{
		
	}
	
	//Construtores
	public MinhaClasse() {

	}
	
	//Métodos publicos
	public void metodo(){
		
	}
	
	//Métodos privados
	private void outroMetodo() {
		
	}

	//Getter e Setters
	public String getAtributo() {
		return Atributo;
	}

	public void setAtributo(String atributo) {
		Atributo = atributo;
	}

}

é, eu só acho um pouco confuso porque os construtores estão lá em cima e eu não estou acostumado costumo escrever em baixo XD , mas acho ótima a organização.

Sem_Nome:

O for funciona assim:

for(inicializacao; condicao para a repeticao; incrementação /<em>a incrementação é opcional</em>/) {

//o codigo a ser repetido

}

No caso

for (int i = 0/*Inicializacao*/; i < 10/*Condição para a repeticao*/; i++/*Incrementacao*/) {
			f.passaPonto();
			System.out.println("O for passou aqui pela vez de numero " + i);
		}

Note que não precisa ser necessariamente uma incrementação. Poderia ser algo como i = i = i * 2 e coisas do tipo.

Obs: Caso não saiba /* */ // são comentarios, o compilador ignora eles na hora de compilar.

sobre os comentários eu sei, obrigado, não sabia como funcionava o for :), eu até pensei nisso mais o no for esta escrito menor ou igual a 5 então pensei que nao foce repetição de código

Sem_Nome:

O for funciona assim:

for(inicializacao; condicao para a repeticao; incrementação /<em>a incrementação é opcional</em>/) {

//o codigo a ser repetido

}

Na verdade qualquer um deles é opcional

for(;;) {

}

E o ultimo não é necessariamente para incremento, vc pode chamar um método que retorne algo, por exemplo.

gabriel-java:

Sem_Nome:

O for funciona assim:

for(inicializacao; condicao para a repeticao; incrementação /<em>a incrementação é opcional</em>/) {

//o codigo a ser repetido

}

No caso

for (int i = 0/*Inicializacao*/; i < 10/*Condição para a repeticao*/; i++/*Incrementacao*/) {
			f.passaPonto();
			System.out.println("O for passou aqui pela vez de numero " + i);
		}

Note que não precisa ser necessariamente uma incrementação. Poderia ser algo como i = i = i * 2 e coisas do tipo.

Obs: Caso não saiba /* */ // são comentarios, o compilador ignora eles na hora de compilar.

sobre os comentários eu sei, obrigado, não sabia como funcionava o for :), eu até pensei nisso mais o no for esta escrito menor ou igual a 5 então pensei que nao foce repetição de código :)

O for funciona até com boolean (nem sabia disso, acabei de testar hehe).

gabrielfrios:

Sem_Nome:

O for funciona assim:

for(inicializacao; condicao para a repeticao; incrementação /<em>a incrementação é opcional</em>/) {

//o codigo a ser repetido

}

Na verdade qualquer um deles é opcional

for(;;) {

}

E o ultimo não é necessariamente para incremento, vc pode chamar um método que retorne algo, por exemplo.

Essa ai é nova (em relação ao for com 2 ; ) para mim.

Em relação ao incremento, eu só usei incremento porque é mais comum (mas não exclusivo) mas disse a ele que poderia colocar qualquer expressão aritmetica.

Sem_Nome, eu também já li esse artigo há muito tempo atrás e concordo plenamente com o mesmo. Mas se vc ler atentamente verá que deixei bem explicito para nosso amigo que “SE ele estiver usando OO pura” deveria colocar getters e setters em todos os campos. Como vc deve ser um programador avançado e de mercado sabe que em ambientes de produção é impossível colocar um sistema utilizando todos os padrões sugeridos pelos criadores da teoria de orientação a objetos, por questões de performance e tempo de desenvolvimento, além do fato de nem todos os padrões serem aceitos universalmente por todos pesquisadores. Mas isso já é para outro tópico, deixe que nosso amigo escolha seu próprio estilo de programação. Abraço.

Mesmo que ele esteja usando OO pura, não deveria colocar getters and setters para tudo.
Abstração e encapsulamento são dois dos principais tópicos da OO pura, e isso implica em esconder dados.

Não é nem questão de “estilo de programação”, e o motivo para isso também não é “performance” ou “otimizar o tempo de desenvolvimento”. Todas essas alegações não são motivos para fazer um código porco. Aliás, perde-se mais tempo de desenvolvimento corrigindo bugs causados por más interfaces, do que o eventual ganho que essa prática possa parecer dar a princípio.

Muitas vezes, getters e setters feitos da maneira errada ferem o encapsulamento:

E podem ser tão prejudiciais quanto simplesmente deixar os métodos públicos.

ViniGodoy, entendo seu ponto de vista e concordo que não devemos colocar getters/setters em todos os campos, até pq nem todos necessitam desse tratamento. Mas já li em livros bem teóricos sobre essa “obrigatoriedade”. E sobre qualidade do código não influenciar na performance da aplicação eu tenho que discordar de vc, por princípio básico da computação, quanto mais chamadas eu tenho que fazer a métodos diferentes para realizar uma tarefa é menor a velocidade de acesso caso eu fosse direto no dado que desejo manipular. Aqui estamos falando de stack e seu funcionamento, sem mencionar as referências do heap. Já sobre não ser justificável fazer um código “porco”, concordo plenamente com vc, trabalhei em uma multinacional onde a equipe de dev passou 1 semana somente atendendo chamado de bugs em sistemas, simplesmente não produzimos nada naquela semana. Obrigado por ter exposto seu pensamento, o conhecimento surge do embate de ideias. Abraço.

Pode citar os livros, por favor?
Eu posso citar vários que dizem o contrário, desde o Refatoração, do Martin Fowler, até um dos primeiros livros sobre o assunto, do Grady Booch.
Gostaria muito de ver um autor que defendesse que devemos colocar gets e sets para tudo.

E você despreza a evolução dos últimos 50 anos dos compiladores? Uma das capacidades mais básicas chama-se inlining de invocações. O compilador é capaz de reconher um get ou um set e simplesmente eliminá-lo, se seu código for muito básico. Assim como invocações em cascata (uma função que simplesmente chama outra). Além disso, eu estava falando da performance geral do software. O custo de uma chamada de método é tão ínfimo, que em casos muitíssimos raros ele se torna um gargalo considerável (eu mesmo nunca vi acontecer). Seu código provavelmente vai estar aguardando o banco de dados, a memória ou leituras em arquivos.

Finalmente, jamais deve-se abrir mão da qualidade do código para “otimiza-lo” sem ter em mãos um problema real. Otimizações prematuras geram código caro e difícil de manter, sem falar que geralmente, não resolvem problema nenhum. O ideal é mesmo usar um profiler, identificar os gargalos reais, entende-los e aí sim, abrir mão de legibilidade do código. Em boa parte das vezes, perdas de performance são causadas por E/S, bugs, ou por estruturas de dados mau escolhidas.
Nesse post, explico um pouco sobre performance: http://www.guj.com.br/java/31346-regras-de-programacao/2#989991

Há vários artigos interessantes do Brian Goetz sobre performance em Java. Procure por Java Theory and Practice e dê uma lida. Ele explica melhor as otimizações da linguagem e fala bastante sobre mitos.

Acho que o platinijow está tentando se referir aos clássicos POJOs (Plain Old Java Objects), com construtor default e getter e setters.

Pode citar os livros, por favor?
Eu posso citar vários que dizem o contrário, desde o Refatoração, do Martin Fowler, até um dos primeiros livros sobre o assunto, do Grady Booch.
Gostaria muito de ver um autor que defendesse que devemos colocar gets e sets para tudo.

E você despreza a evolução dos últimos 50 anos dos compiladores? Uma das capacidades mais básicas chama-se inlining de invocações. O compilador é capaz de reconher um get ou um set e simplesmente eliminá-lo, se seu código for muito básico. Assim como invocações em cascata (uma função que simplesmente chama outra). Além disso, eu estava falando da performance geral do software. O custo de uma chamada de método é tão ínfimo, que em casos muitíssimos raros ele se torna um gargalo considerável (eu mesmo nunca vi acontecer). Seu código provavelmente vai estar aguardando o banco de dados, a memória ou leituras em arquivos.

Finalmente, jamais deve-se abrir mão da qualidade do código para “otimiza-lo” sem ter em mãos um problema real. Otimizações prematuras geram código caro e difícil de manter, sem falar que geralmente, não resolvem problema nenhum. O ideal é mesmo usar um profiler, identificar os gargalos reais, entende-los e aí sim, abrir mão de legibilidade do código. Em boa parte das vezes, perdas de performance são causadas por E/S, bugs, ou por estruturas de dados mau escolhidas.
Nesse post, explico um pouco sobre performance: http://www.guj.com.br/java/31346-regras-de-programacao/2#989991

Há vários artigos interessantes do Brian Goetz sobre performance em Java. Procure por Java Theory and Practice e dê uma lida. Ele explica melhor as otimizações da linguagem e fala bastante sobre mitos.
Bom e para jogos como isso fica gente? Pois nos jogos o mais importante é velocidade! E eles também precisam de muito suporte e etc… Eu devo ou não usar getters e setters em tudo? Bom eu pelo menos acho como iniciante que quanto menos cogido mais rápido o código fica, certo? Então creio eu que para jogos é melhor usar só o preciso, se você só precisa pegar, ou se você só precisa mudar o valor, bom acho que é isso, ai depende do que você quer fazer não?

ViniGodoy, também li o livro Refatoração de Martin Fowler, e citando o mesmo, lhe digo que no início de 2000 o próprio autor ajudou a definir os POJO’s (Plain Old Java Object) que eram padrões rígidos de como deveriam ser estruturados objetos e pela definição entram os gets/sets e construtor default. Com a evolução dos processos de desenvolvimento, inclusive “ágeis”, mudou-se para colocar somente em campos que realmente necessitam, assim como o artigo da Caelum sobre o mesmo explicita de forma clara.

Sobre performance, continuo firme em minha ideia que com o aumento de chamadas a métodos, o heap aumenta, logo baixando o desempenho da aplicação. Concordo com você sobre o desempenho/evolução dos compiladores e até a “inteligência da JVM” está impressionante, mas de todo caso, não podemos negar a queda de performance. Para encerrar esse assunto sobre performance, eu pessoalmente acredito que é melhor fazer um código limpo seguindo padrões do que um código “gambiarrado” com a desculpa de que “vamos otimizar toda a aplicação”. Devemos sempre separar a teoria pura da aplicação de software em produção.

Abraço e obrigado por contribuir com seus argumentos.

Para deixar um código mais legível é melhor comentar o que está fazendo, e inicializar todas as variáveis no começo para não se perder. Sendo o “quantosPassaPonto” uma variável que só vai incrementar +1 seria melhor cria-la como “int”. Para incrementa-la use “quantosPassaPonto++”, deixa o programa mais eficiente. Dê pelo menos um espaço entre cada método para facilitar na leitura. Só isso acho que de mais relevante. Boa sorte na aprendizagem.

ok sobre o ++ eu conheço mais normalmente só uso no for : (i = 0; i <5; i++) XD, é verdade tem que da espaço mais as vezes eu não me ligo nisso, é dês de quando eu comecei a aprender eu achei bastante importante isso sobre variáveis, de utilizar a variável certa! Pois se você não vai fazer uma conta para que colocar um double e deixar seu programa mais pesado, fazer isso só uma vez não da tanto problema mais se você se acostumar sua programação vai ficar um lixo