Entendendo um cÓdigo

Saudações a todos! Como um novo GUJnauta estou precisando ter uma visão panorâmica. Logo, venho solicitar uma explicação passo-a-passo (linha a linha) do que estes três códigos fazem. Se for possível citar um pouco da teoria aplica em cada passo… valeu!!! Seguem os três códigos:

[color=red]-----------------------------MEMÓRIA------------------------------
abstract class MemoriaS{
public static final int BYTE=1;
public static final int KB=2;
public static final int MB=3;
public static final int GB=4;

protected double total;
protected double utilizadoKB;
protected int unidade;

public MemoriaS(int newTotal,int newUnidade){
	this.total = newTotal;
	this.utilizadoKB = 0;
	this.unidade = newUnidade;
}
public MemoriaS(int newTotal){
	this(newTotal,KB);
	}
            public abstract double getEspacoDisponivelRealKB();
public abstract double getPerda();
   	
protected double getEspacoDisponivelKB(){
	return this.getConverteKB(this.total) - this.utilizadoKB;
}
public boolean GravaKB(int newTamanho){
	if ( (newTamanho<=this.getEspacoDisponivelRealKB()) ){
	 	this.utilizadoKB = this.utilizadoKB + newTamanho;
		 	return true;
	 }else{
	 	return false;
	 }
}
protected double getConverteKB(double valor){
	double tempValor=0;
		switch (unidade){
			 case MemoriaS.BYTE:
			        tempValor = valor/1204;
			        break;
			 case MemoriaS.KB:
			        tempValor = valor;
			        break;  
			 case MemoriaS.MB:
			        tempValor = valor*1024;
			        break;
			 case MemoriaS.GB:
			        tempValor = valor*1024*1024;       
		    	        break;			      
			 } 
		     return tempValor;
	}	
	public String getUnidade(){
		switch (unidade){
			 case BYTE:
			      return "BYTE";
			 case KB:
			      return "KB";  
			 case MB:
			      return "MB";  
			 case GB:
			      return "GB"; 
			} 
		return "";
	}
	
   public double getPercentualDisponivel(){
   	    return this.getEspacoDisponivelRealKB()/this.getConverteKB(this.total)*100;
	   }
   
   public String toString(){
   	      return " Percentual Disponivel " + this.getPercentualDisponivel() +
   	      "% Espaço Total " + this.getConverteKB(this.total) +
   	       "KB Espaço Disponivel Real " +this.getEspacoDisponivelRealKB()+
   	       "KB Perda "+this.getPerda() + "%"; 	
   }
   		
   public static void main(String args[ ]){
   	      MemoriaS hd = new HD("46327",10,MemoriaS.MB);
   	      System.out.println("Número  de Serie "+((HD)hd).getNumeroSerie()+ "Percentual de Perda"+ hd.getPerda());
   	   
   	      hd.GravaKB(10000);
   	      System.out.println(hd);
   	      
   	      MemoriaS cd = new CD(650,MemoriaS.MB);
   	      System.out.println(" Estado CD "+((CD)cd).getEstado());
   	      cd.GravaKB(10240);
   	      System.out.println(cd);
   	      
   	      cd.GravaKB(10240);
   	      System.out.println(cd);
	} 

}[/color]
[color=blue]---------------------------------HD-------------------------------
public class HD extends MemoriaS {
private String numeroSerie;
public HD (String newNumeroSerie,int newTotal,int newUnidade){
super(newTotal,newUnidade);
this.numeroSerie = newNumeroSerie;
}

public double getPerda(){
	return ((super.getConverteKB(super.total)/10240)/100);
}
public double getEspacoDisponivelRealKB(){
 	return super.getEspacoDisponivelKB()*(1-this.getPerda());
}

public String getNumeroSerie(){
	return this.numeroSerie;
}

public String toString(){
	return "HD Número de Serie " +this.numeroSerie+" " + super.toString(); 
}

}[/color]
[color=green]----------------------------------CD----------------------------------

public class CD extends MemoriaS {
public static final int ABERTO=1;
public static final int FECHADO=2;
public static final double PERCENTUALPERDA=0.98;

private int estado;

public CD (int newTotal,int newUnidade){
	super(newTotal,newUnidade);
	this.estado = CD.ABERTO;
}

public double getPerda(){
	return PERCENTUALPERDA;
}
public double getEspacoDisponivelRealKB(){
 		return super.getEspacoDisponivelKB()*this.getPerda();
}

public boolean GravaKB(int newTamanho){
		if ( (this.estado == this.ABERTO) && (super.GravaKB(newTamanho)) ){
		 	this.estado = this.FECHADO;
		 	return true;
		 }else{
		 	return false;
		 }
}

}[/color]

bem q pra iniciante estais com dúvidas até consideráveis, inclusive pedindo explicação passo a passo…
isso me parece mais exercicios de faculdade pra entregar na próxima aula!
não sabemos o seu nível de entendimento, portanto podemos gastar tempo explicando e no final vc não entender nada, porque ta querendo pular etapas…
Me responda: o que vc não entendeu no código?

if(resposta.equalsIgnoreCase(“Nada”) {
vai estudar os conceitos, orientação a objeto, Java SE do início…
}

para dúvidas estamos ai.

p.s. sem mágoas ok. :lol:

Você faz uma pergunta geral dessa, em caixa alta, quer que a gente comente linha a linha, nem se deu o trabalho de pesquisar, ou de como postar seu código adequadamente (entre as tags code).

É brincadeira né? Agora entendi…

Como colocar post com codigo-fonte no forum:
http://www.guj.com.br/posts/list/50115.java

Procedimentos antes de perguntar:
http://www.guj.com.br/posts/list/15777.java

Como fazer perguntas inteligentes:
http://www.linuxdicas.com.br/perguntas.html

Em relação às suas dúvidas, seja mais preciso nas dúvidas. Você não pode chegar e perguntar tudo de uma vez só. Isto economiza trabalho pra você, mas vai dar muito trabalho pra quem for responder.
A intenção do fórum é a reciprocidade de conhecimento, mas tudo tem um determinado limite.
Pense nisso :wink:

[quote=mfjeng]
É brincadeira né? Agora entendi…[/quote]

tmb acho :!:

Alô Javabuntu, mfjeng, francislon,…

Pelo desculpas pela…“má impressão”.

Sou realmente novo no Java, estou pegando essa disciplina na faculdade e estudando a parte teórica. Porém quando me debati com esse código fiquei na vontade de entendê-lo e poder associá-lo à teoria.

Ô Javabuntu, tem razão, vou tentar dar uma resumida e apontar apenas alguns trechos do código.

Mfjeng, não e brincadeira. Como me expliquei acima, é uma necessidade. Pra te dar uma idéia, é a primeira vez que participo de um fórum lingado a desenvolvimento. Mas vou me acostumar!

Francislon, você falou tudo. Mas estou começando a participar… vou pegar o jeito… Valeu pelos links!

Bom, seguindo algumas das dicas, vou perguntar:

1-O que é que esse código faz? Pega o que está na memória e grava no HD ou CD? É isso?

2-Esse trecho:

[color=red] protected double getEspacoDisponivelKB(){ return this.getConverteKB(this.total) - this.utilizadoKB; } [/color]

3-Por que nesta parte foi utilizado “MemoriaS.BYTE”, “MemoriaS.KB”… qual o entendimento disso em relação às constantes? Por que não colocou logo os valores das constantes? Ou para que definiu valores das constantes se está utilizando o nome delas?

[color=red] protected double getConverteKB(double valor){ double tempValor=0; switch (unidade){ case MemoriaS.BYTE: tempValor = valor/1204; break; case MemoriaS.KB: tempValor = valor; break; case MemoriaS.MB: tempValor = valor*1024; break; case MemoriaS.GB: tempValor = valor*1024*1024; break; } return tempValor; } public String getUnidade(){ switch (unidade){ case BYTE: return "BYTE"; case KB: return "KB"; case MB: return "MB"; case GB: return "GB"; } return ""; } [/color]

4-Só confirmando: Quando utilizo o “this” estou me referindo a um atributo ou método da própria classe né?
Se coloco o “super” a referência é a atributo ou método da superclasse,
E não posso referenciar a métodos e atributos de subclasses apenas indicar que há o vínculo.
É isso?

5-Dá uma explicada no código de HD que eu generalizo o entendimento então. Pode ser?

Falou pessoal, obrigado pela compreensão e apoio. Abraço

Respondendo a 1 e a 2(são as mesmas perguntas né?):

O método citado retorna a quantidade de espaço disponivel em KB do seu "HD".
Explicando o código:

protected -> modificador de acesso. Indica quem pode acessar o método. O modificador de acesso protected restringe o acesso ao método para membros da própria classe e de classes filhas desta.

double -> tipo de retorno. Indica qual tipo de dados será retornado pelo método. Como vc vai retornar a quantidade de espaço vazio em KB do seu HD, é necessário um numero de tipo ponto flutuante, pois pode ser que esteja faltando 2,6 KB(apenas um exemplo.) no seu HD.

getEspacoDisponivelKB() --> nome do método.

return --> palavra reservada da linguagem que retorna algo do tipo especificado pelo tipo de retorno do metodo.
Neste caso ele está retornando o valor do espaço disponivel em KB. Ele subtrai o espaço total do HD pelo espaço utilizado.

  • respondendo a pergunta 3: Você usa constantes em uma classe pra deixar o código mais organizado e mais fácil de entender. As constantes MemoriaS.XXXX são estaticas, por isso você chama com o nome da classe na frente, você poderia chamar estas constantes dentro de qualquer outra classe. Quando você chama somente pelo nome da constante, você está chamando a constante da própria classe(desta maneira você não consegue chamar de outra classe). Os dois casos não fazem diferença dentro da mesma classe.

5 - this você faz referencia ao objeto da classe atual. this.XXX você se refere a um atributo ou metodo do objeto atual.
O mesmo para super, mas fazendo referencia a classe Pai do objeto atual.

Fala Pessoal, é, tentei, tentei e não encontrei um local que me desse essa base inicial. Logo venho recorrer a vocês.
Quando eu aprender, vou publicar algo explicativo.
Passei meu final de semana tentando, estou precisando resolver outros códigos, mas o que me barra é o entendimento sobre a forma funcional do Java.
Respondendo:
P/ Francislon: A pergunta 1 (me expressei mal) é referente a todo o código. O que é que esse código faz? Esse código foi criado para resolver qual problema? O modo que você explicou o código, eu entendo, abaixo vou mostrar o que realmente preciso saber. Dá só uma olhada! Valeu!!!
P/ Marcosbrandao: Entendi! E a vantagem é eu poder fazer futuras alterações nas constantes de maneira prática né? Quando você fala que posso me referenciar às constantes em qualquer outra classe, é só num mesmo pacote né? Entendi o THIS tb! Valeu!!!

Abaixo vou comentando o código, se vocês puderem complementar o que AINDA não consigo… Marquei com: [color=red]>>>(?)<<<[/color]
Se eu estiver errado em algo, por favor, me corrijam.

//Problema: [color=red]>>>(?)<<<[/color]

abstract class MemoriaS{  /*Classe abstrata. Super classe. Como é abstrata não posso criar instâncias dela. Tem métodos abstatos.
Declarando Costantes estáticas. STATIC indica que as constantes são exclusivas da Classe MemoriaS. FINAL indica que elas são poderão ter seus valores alterados em outra parte do código.*/
public static final int BYTE=1; 
public static final int KB=2; 
public static final int MB=3; 
public static final int GB=4; 

/*Criando atributos PROTECTED que só podem ser utlizados nesta Classe MemoriaS e outras classes no mesmo pacote.*/
protected double total; 
protected double utilizadoKB; 
protected int unidade; 

//1º Construtor: 2 argumentos
public MemoriaS(int newTotal,int newUnidade){ 
/*Os atributos da Classe MemoriaS estão recebendo valores. Ou seja, os objetos criados através deste construtor terão os mesmos atributos da classe MemoriaS, e receberão os valores de algum local, fixando apenas o "utilizadoKB" em 0.*/
this.total = newTotal; 
this.utilizadoKB = 0; 
this.unidade = newUnidade; 
} 
//2º Construtor: 1 argumento
public MemoriaS(int newTotal){ 
>>>(?)<<< O que significa isso? >>>(?)<<<
this(newTotal,KB);
} 

/*Aqui acima há polimorfismo estático - sobrecarga: Métodos com mesmo nome mas argumentos diferentes.*/


public abstract double getEspacoDisponivelRealKB(); //Metodo abstrato: Implementados na(s) subclasse(s).
public abstract double getPerda(); //Metodo abstrato: Implementados na(s) subclasse(s).
//>>>(?)<<<Por que esses 2 métodos acima foram criados? E por que foram criados como abstratos?>>>(?)<<<

/*Metodo acessado somente por classes deste mesmo pacote.
Funcionamento: Ao ser chamado, passa o valor existente na variável "total" para o método getConverteKB e retorna o resultado, em double, da expressão de subtração.
O uso do THIS é para indicar que esses métodos e atributos estão declarados nesta Classe.*/
protected double getEspacoDisponivelKB(){ 
return this.getConverteKB(this.total) - this.utilizadoKB; 
} 

public boolean GravaKB(int newTamanho){ 
if ( (newTamanho<=this.getEspacoDisponivelRealKB()) ){ //[color=red]Espaço disponivel real(?)[/color]
this.utilizadoKB = this.utilizadoKB + newTamanho; 
return true; 
}else{ 
return false; 
} 
} 

//>>>(?)<<<Ele recebe um valor, mas como ele sabe a unidade deste valor?>>>(?)<<<
protected double getConverteKB(double valor){ 
double tempValor=0; 
switch (unidade){ 
case MemoriaS.BYTE: 
tempValor = valor/1204; 
break; 
case MemoriaS.KB: 
tempValor = valor; 
break; 
case MemoriaS.MB: 
tempValor = valor*1024; 
break; 
case MemoriaS.GB: 
tempValor = valor*1024*1024; 
break; 
} 
return tempValor; 
} 


//>>>(?)<<<Por que o método getTotal não foi definido? Somente os referentes aos outros 2 atributos. >>>(?)<<<


//>>>(?)<<<Por que esse método foi criado? Qual a sua utilidade em outras partes do código? >>>(?)<<<
public String getUnidade(){ 
switch (unidade){ 
case BYTE: 
return "BYTE"; 
case KB: 
return "KB"; 
case MB: 
return "MB"; 
case GB: 
return "GB"; 
} 
return ""; 
} 

public double getPercentualDisponivel(){ 
return this.getEspacoDisponivelRealKB()/this.getConverteKB(this.total)*100; 
} 

/*Metodo que estrutura uma String de saída
public String toString(){ 
return " Percentual Disponivel " + this.getPercentualDisponivel() + 
"% Espaço Total " + this.getConverteKB(this.total) + 
"KB Espaço Disponivel Real " +this.getEspacoDisponivelRealKB()+ 
"KB Perda "+this.getPerda() + "%"; 
} 

//Metodo principal. A execução das 3 classes inicia aqui. Durante o processo os métodos são chamados.
public static void main(String args[ ]){ 
//>>>(?)<<< É criado um objeto HD, mas não entendi ao pé da letra. >>>(?)<<<
MemoriaS hd = new HD("46327",10,MemoriaS.MB); 
System.out.println("Número de Serie "+((HD)hd).getNumeroSerie()+ "Percentual de Perda"+ hd.getPerda()); 

//>>>(?)<<<Ele está passando 10000 para onde? >>>(?)<<<
hd.GravaKB(10000); 
System.out.println(hd); 

//>>>(?)<<<Mesmas dúvidas acima>>>(?)<<<
MemoriaS cd = new CD(650,MemoriaS.MB); 
System.out.println(" Estado CD "+((CD)cd).getEstado()); 
cd.GravaKB(10240); 
System.out.println(cd); 
} 
} 
//Subclasse de MemoriaS (Herança: herda os atributos e métodos da superclasse.
public class HD extends MemoriaS { 
//mais um atributo
private String numeroSerie; 

//Metodo construtor: 3 argumentos
public HD (String newNumeroSerie,int newTotal,int newUnidade){ 
>>>(?)<<< O que significa isso? >>>(?)<<<
super(newTotal,newUnidade); 
this.numeroSerie = newNumeroSerie; 
} 

//Metodo que é abstrato na superclasse
public double getPerda(){ 
return ((super.getConverteKB(super.total)/10240)/100); /*>>>(?)<<<Ele está usando o método getConverteKB da superclasse, mas como isto está funcionando?>>>(?)<<<*/
} 

//Metodo que é abstrato na superclasse
public double getEspacoDisponivelRealKB(){ 
return super.getEspacoDisponivelKB()*(1-this.getPerda()); //getEspacoDisponivel da superclasse e getPerda desta subclasse.
} 

//Metodo get referente ao atributo desta subclasse
public String getNumeroSerie(){ 
return this.numeroSerie; 
} 

//Metodo toString desta subclasse. Texto de saída.
public String toString(){ 
return "HD Número de Serie " +this.numeroSerie+" " + super.toString(); 
} 
} 
//Subclasse de MemoriaS (Herança: herda os atributos e métodos da superclasse.
public class CD extends MemoriaS { 
//constantes exclusivas
public static final int ABERTO=1; 
public static final int FECHADO=2; 
public static final double PERCENTUALPERDA=0.98; 

//mais um atributo
private int estado; 

public CD (int newTotal,int newUnidade){ 
super(newTotal,newUnidade); 
this.estado = CD.ABERTO; 
} 

public double getPerda(){ 
return PERCENTUALPERDA; 
} 
public double getEspacoDisponivelRealKB(){ 
return super.getEspacoDisponivelKB()*this.getPerda(); 
} 

public boolean GravaKB(int newTamanho){ 
//>>>(?)<<< De onde vem o valor de estado? >>>(?)<<<
if ( (this.estado == this.ABERTO) && (super.GravaKB(newTamanho)) ){ 
this.estado = this.FECHADO; 
return true; 
}else{ 
return false; 
} 
} 
}

não.
Suas constantes são public, então poderão ser acessada de qualquer classe, dentro ou fora do pacote.

  • Você poderá acessar esta constante de qualquer lugar usando NomeDaClasse.NOME_DA_CONSTANTE. Se você usar somente NOME_DA_CONSTANTE poderá usar ela somente na propria classe ou nas filhas.

[code] //2º Construtor: 1 argumento
public MemoriaS(int newTotal){

(?)<<< O que significa isso? >>>(?)<<<
this(newTotal,KB);
}[/code]
Isso ignifica que você está acessando o construtor da propria classe, que tenha dois parametros, no seu caso o 1º construtor.

[code]# public abstract double getEspacoDisponivelRealKB(); //Metodo abstrato: Implementados na(s) subclasse(s).

public abstract double getPerda(); //Metodo abstrato: Implementados na(s) subclasse(s).

//>>>(?)<<<Por que esses 2 métodos acima foram criados? E por que foram criados como abstratos?>>>(?)<<<[/code]Esses métodos são abstratos porque não interessa a classe MomoriaS a sua implementção. Esses metodos serão implementados pelas classes que extenderem a classe MemoriaS(HD e CD, no seu caso). Provavelmente cada classe filha de MemoriaS vai ter um comportamento diferente para esses métodos.

//>>>(?)<<<Ele recebe um valor, mas como ele sabe a unidade deste valor?>>>(?)<<< protected double getConverteKB(double valor){ A unidade você atribui quando instanciou o Objeto. Lembra do construtor? Olhe lá em cima e veja que ele recebe uma unidade como parametro.

//>>>(?)<<< É criado um objeto HD, mas não entendi ao pé da letra. >>>(?)<<<O que exatamente você não entendeu?

//>>>(?)<<<Ele está passando 10000 para onde? >>>(?)<<< hd.GravaKB(10000);O objeto HD não possui um metodo gravaKB() declarado explicitamente, mas a sua classe Pai(MemoriaS) possui. Quando você extende uma classe, a classe filha herda todos os atributos e funcionalidades da classe pai. Então a classe HD além dos seus metodos, ela possue todos os métodos(public e protected) e atributos da classe MemoriaS.

por enquanto não posso mais te ajudar, pq meu tempo acabou. Mas continue estudando, logo vc vai entender todos esses conceitos.

Alô Marcos,
Demais! Demais!
Como foi de Páscoa?
Os conhecimentos estão fluíndo… Valeu mesmo!
Aqui vai mais uma dúvida: Linha 104 do código: O que significa? Em especial: ((HD)hd).

System.out.println("Número de Serie "+((HD)hd).getNumeroSerie()+ "Percentual de Perda"+ hd.getPerda());   

Estou comentando todo o código…
Fico no aguardo,
Forte abraço,

 MemoriaS hd = new HD("46327",10,MemoriaS.MB);   
 System.out.println("Número de Serie "+((HD)hd).getNumeroSerie()+ "Percentual de Perda"+ hd.getPerda());

Repare que quando você declara a variável hd, ela está como MemoriaS. Mas você sabe que é um HD, porque usou o construtor de HD. Então você dá um CAST para HD, e o programa passa a entender aquela MemoriaS como sendo um HD, e é possível utilizar os métodos da classe HD, mesmo ela sendo uma MemoriaS.

Complementando o thegoergen:

Um exemplo:

class Animal{
   String nome;
   public String getNome(){ return nome}
}

class Dog() extends Animal{
   String raca
   public String getRaca(){ return raca}
}
[/code][code]
Animal animal = new Dog();
animal.getNome();//OK, a classe Animal tem o método getNome;
animal.getRaca();//Erro, a classe Animal não tem um método getRaca

//precisa fazer um "cast" explicito para Dog que é a instância de "animal".
((Dog)animal).getRaca();