EVGD: Códigos Toscos

Assuntos Gerais
#367

[quote=danieldestro]Emo Code Convention???[/quote]2 :slight_smile: :slight_smile: :slight_smile:

#368

é mixugol!!!

#369 
public class MiguxesException extends LinguaPortuguesaException {}
#370

Com toda certeza alguém fez as devidas referências a POG certo?

#371

Acabei de ver aqui…

Um método recebendo 21 parâmetros:

public void render(Component c){
   boolean isAlgumaCoisa = c.getX() == 0;
   render(c.getId(), c.getWidth(), isAlgumaCoisa, ... ); //+ 19 (!!!!!) parâmetros (todos utilizando o component)
}

private void render(... 21 parâmetros...){
  // renderiza o componente
}

Porque já não refatorou tudo para um método só ou pelo menos passasse o objeto para o método seguinte?

Falando com uns colegas aqui, descobri que esse método iniciou a sua grandiosa vida recebendo já 8 parâmetros.

Nada como o gambi-pattern Mega Zord!!! :twisted:

#372

[quote=peczenyj]Um dia veremos isso:

pubLIc KlAXX ExXxeMPlU ExXxteNdxXx OTrAclaXXi{ pRIvaTI int iDADI; // kONStrUtoR pUbLIc exXxemPLU(){ ThixXx......iDaDi = 0;} PuBLIC gETIdaDI(){ rETUrN THixXx......iDaDI; } PuBLic SeTIdaDI(iNT idAdI){ ThixXx......IDAdi = idadI; } }

qro morre…

Fonte: http://www.coisinha.com.br/miguxeitor/[/quote]

hahahahahahahahahahahahahahahahahahahahahahahahahahahahahaha…
quase morrendo de rir aqui… hahhahahahahahaahaha…

essa foi boa! :lol:

#373

List<String> lista = populalista(); String a = "teste"; for (String b : lista) { a += a + b; // 800 megas de memória e estouro da heap }

#374

Agora sim eu entendi um uso “adequado” de enums.

[code]public enum StatusMovimento {

/** The P. */
P("P"),
/** The S. */
S("S"),
/** The E. */
E("E"),
/** The A. */
A("A"),
/** The C. */
C("C"),
/** The R. */
R("R"),
/** The V. */
V("V"),
/** The D. */
D("D"),
/** The T. */
T("T"),
/** The F. */
F("F");

/** The status. */
private final String status;

private StatusMovimento(String status) {
    this.status = status;
}

public String getValue() {
    return this.status;
}

public String toString() {
    return this.status;
}

}[/code]

Ainda bem que tem comentários, senão eu não entenderia.

#375

[quote=danieldestro]Agora sim eu entendi um uso “adequado” de enums.

[code]public enum StatusMovimento {

/** The P. */
P("P"),
/** The S. */
S("S"),
/** The E. */
E("E"),
/** The A. */
A("A"),
/** The C. */
C("C"),
/** The R. */
R("R"),
/** The V. */
V("V"),
/** The D. */
D("D"),
/** The T. */
T("T"),
/** The F. */
F("F");

/** The status. */
private final String status;

private StatusMovimento(String status) {
    this.status = status;
}

public String getValue() {
    return this.status;
}

public String toString() {
    return this.status;
}

}[/code]

Ainda bem que tem comentários, senão eu não entenderia.[/quote]

Podia ser pior:

[code]public class StatusMovimento {

/** The P. */
public static String P = "P";
/** The S. */
public static String S = "S";
/** The E. */
public static String E = "E";
/** The A. */
public static String A = "A";
/** The C. */
public static String C = "C";
/** The R. */
public static String R = "R";
/** The V. */
public static String V = "V";
/** The D. */
public static String D = "D";
/** The T. */
public static String T = "T";
/** The F. */
public static String F = "F";

}[/code]

#376

o pior são os comentarios… hauhauhauha comico…

#377

Fora que o cara nem sabe que o “toString()” do enum já faz o que ele implementou.

#378

Podia ser pior, já vi gente fazendo consulta no BD e criando componentes swing dentro do método toString().

#379

Olha só o que eu achei, o troço está em produção:

[code]/**
*
*/

/**

  • @author

*/
public class Xxx extends Thread {

/**
 * 
 */
public Xxx() {
	// TODO Auto-generated constructor stub
}

/**
 * @param arg0
 */
public Xxx(Runnable arg0) {
	super(arg0);
	// TODO Auto-generated constructor stub
}

/**
 * @param arg0
 */
public Xxx(String arg0) {
	super(arg0);
	// TODO Auto-generated constructor stub
}

/**
 * @param arg0
 * @param arg1
 */
public Xxx(ThreadGroup arg0, Runnable arg1) {
	super(arg0, arg1);
	// TODO Auto-generated constructor stub
}

/**
 * @param arg0
 * @param arg1
 */
public Xxx(ThreadGroup arg0, String arg1) {
	super(arg0, arg1);
	// TODO Auto-generated constructor stub
}

/**
 * @param arg0
 * @param arg1
 */
public Xxx(Runnable arg0, String arg1) {
	super(arg0, arg1);
	// TODO Auto-generated constructor stub
}

/**
 * @param arg0
 * @param arg1
 * @param arg2
 */
public Xxx(ThreadGroup arg0, Runnable arg1, String arg2) {
	super(arg0, arg1, arg2);
	// TODO Auto-generated constructor stub
}

/**
 * @param arg0
 * @param arg1
 * @param arg2
 * @param arg3
 */
public Xxx(ThreadGroup arg0, Runnable arg1, String arg2, long arg3) {
	super(arg0, arg1, arg2, arg3);
	// TODO Auto-generated constructor stub
}

}[/code]

#380

É o padrão MUCO: “Multiple Useless Constructor Overload”.

#381

Por favor, matem-lo!!!

[quote]
diego_sl wrote:

    Thiagosc wrote:

        giulianocosta wrote:hhehehe...

        Essa é classica:


        if(isAlgumaCoisa == true){
        //sfkljsdklfjklsdfkl
        }



    Acho que isso se encaixa mais no "estilo de código" do que código burro. O "true" é desnecesssário mas não faz mal algum.

    Seria o mesmo que implicar com indentação do código de alguém ou algo parecido, tipo o indivídio que usa tab tirando uma onda de quem usa espaço, e o que usa a formatação automática da IDE tirando sarro dos dois.



Eu ainda não vi ninguém que achasse melhor usar "== true". Sempre era falta de conhecimento.

depende, esse caso não é tão desastroso assim, pois tem gente que vem de outras linguagens, onde não tem esse recurso e acaba fazendo isso, concordo que seria uma forma desnecessária de representar uma expressão booleana,sao alguns bits a mais. Mas também não é uma forma errada, as vezes pra quem ta começando expressa mais facilmente.

Tem casos piores… como if (true)… [/quote]

E o Thiagosc tambem!!! HUAuhAUHHUAuhauhAUHaUHuhAuha

Realmente o Thiagosc e o Fabrício Cozer Martins estão no topico certo hein… hahahahahhaa…

apropósito… você tambem fazem isso:

if ( objeto.envia() ) { return true; } else { return false; }

??? huahuahuahua, não mintam hein!!! :wink:

huauhahuahuuha. por favor né…

return objeto.envia();
#382

Correção: MATEM-NO.

kkkkkk… só pra alegrar o dia!!! :slight_smile:

#383

É o padrão MUCO: “Multiple Useless Constructor Overload”.[/quote]

Sem falar da excelente documentação. E o perfeito nome da classe que descreve perfeitamente a sua importância no sistema.

#384

[code] public String performAction(HttpServletRequest request, HttpServletResponse response) {

    String operation = request.getParameter("operation");
    request.setAttribute("operation",operation);
    try{
        switch (operation.charAt(0)) {        
        case 'A':{
            return doShowAll(request);
        }
        case 'C':{
            return doShowAll(request);
        }                    
        case 'E':{
            return doShowAll(request);
        }        
        case 'I':{            
            return doShowAll(request);
        }
        case 'S':{
            return doShowAll(request);
        }        
        case 'X':{
            return doShowAll(request);            
        }        
        }
    }catch (Exception e) {
        e.printStackTrace();
    }
    
    return null;
}[/code]
#385 

if (coisa != null) {
 if(coisa == null) {
   //mais coidigo aqui
 }
 else if (coisa != null) {
   //mais coidigo aqui
 }
 else if(coisa == null) {
   //mais codigo aqui
 }
 else {
   //não faz nada
 }
}
else if (coisa == null) {
  //mais codigo aqui
} 
else if (coisa != null) {
  //o cara fumou uma!!!
}
else {
   coisa = new Coisa();
}

coisa = new Coisa();

Acreditem um dia eu vi algo bem parecido com este tipo de coisa… acho que o cara deve ter fumado umas…

#386

Acho que você que fumou um… hahaahaha… brincadeirinha!!!