Várias respostas sobre JAVA
30 pág.

Várias respostas sobre JAVA


DisciplinaAlgoritmos e Programação 2145 materiais3.831 seguidores
Pré-visualização8 páginas
A herança torna possível a reutilização de funcionalidades previamente definidas em uma classe. A 
finalidade é que a subclasse (aquela que herda as características de determinada classe) inclua o 
comportamento da superclasse (aquela que contém o comportamento a ser herdado) e adicione mais 
funcionalidades. Não seria interessante a herança, se não houvesse a possibilidade de adicionar 
funcionalidades à subclasse. 
Existem construções de hierarquia de classes que apresentam erros. A figura anterior apresenta um 
exemplo de hierarquia onde a superclasse Carro tem as subclasses Porta e Pneu. Essa técnica não 
expressa corretamente o conceito de hierarquia, onde as subclasses especializam, ou seja, afunilam 
o conceito da superclasse. Caso utilize o mesmo questionamento realizado anteriormente para essa 
hierarquia como: \u201cUma Porta é um Carro?\u201d, a resposta é não. Portanto, o correto é definir uma 
subclasse que tenha a ver com a superclasse, onde a subclasse seja o conceito da superclasse, 
adicionando algum conteúdo que possa representar de forma mais específica o conceito apresentado 
pela superclasse. 
A herança pode ser múltipla onde uma subclasse herda características de diversas superclasses. A 
linguagem C++ suporta esse tipo de herança, enquanto a linguagem Java suporta somente a herança 
de uma única classe. 
A seguir, um exemplo de herança em Java: 
/*declaração da superclasse*/ 
class madeira { 
 // atributo da classe madeira 
 String cor; 
 
 // métodos da classe madeira 
 public String getCor() 
 { 
 return cor; 
 } 
 public void setCor(String nova_cor) 
 { 
 cor = nova_cor; 
 } 
} // fim da declaração da superclasse 
/*declaração da subclasse*/ 
class cadeira extends madeira 
{ 
 // atributos adicionais à superclasse 
 int peso; 
 // métodos adicionais à superclasse 
 public void escreve_tela() 
 { 
 System.out.println(this.getCor()); 
 } 
} // fim da declaração da subclasse 
O que é Sobrecarga de Métodos e de Operadores? 
Sobrecarregar um método ou operador é permitir que se utilize o mesmo nome de chamada para 
operar sobre uma variedade de tipos de dados. A seguir, um exemplo de classe em Java que tem o 
método setValor sobrecarregado: 
// declaração da classe vetor 
public class vetor 
{ 
 // atributos da classe vetor 
 private float X; 
 private float Y; 
 // métodos da classe vetor 
 // ocorre sobrecarga no método setValor, pois 
 // ele manipula uma ou duas variáveis do 
 // tipo float 
 public void setValor(float novo_x) 
 { 
 X = novo_x; 
 } 
 public void setValor(float novo_x, float novo_y) 
 { 
 X = novo_x; 
 Y = novo_y; 
 } 
} // fim da declaração da classe vetor 
A sobrecarga de operadores é oferecida para classes que desejem manipular adição, subtração e 
outras operações. A seguir, um exemplo na linguagem C++ onde existe a sobrecarga do operador 
adição (+) para que manipule objetos do tipo Vetor2D. 
// declaração da classe em C++ 
class Vetor2D 
{ 
 // atributos 
 float x, y; 
 public: 
 // construtor 
 Vetor2D(Vetor2D v2); 
 // métodos 
 void EscreveVideo(char texto[]); 
 Vetor2D operator + (Vetor2D v2); 
} // fim da classe Vetor2D 
No exemplo anterior, é declarado um método: Vetor2D operator + (Vetor2D v2). 
Existe nesse método a sobrecarga do operador + (adição). Esta sobrecarga torna possível a soma de 
dois objetos do tipo Vetor2D, como abaixo: 
Vetor2D v1 = new Vetor2D; 
Vetor2D v2 = new Vetor2D; 
 
// uso do operador adição entre instâncias 
// do tipo Vetor2D 
Vetor2D v3 = v2 + v1; 
No caso apresentado acima, o objeto v2 é responsável por executar de forma implícita uma 
chamada para o operador adição sobrecarregado (+), o qual executa uma determinada função sobre 
os dados. Na chamada para execução do operador sobrecarregado, o objeto v1 é enviado como 
parâmetro. Na declaração da classe Vetor2D, observa-se que o operador adição sobrecarregado 
recebe somente um parâmetro, que é do mesmo tipo da classe. 
O que é Polimorfismo? 
É a troca de mensagens entre métodos de uma subclasse com sua superclasse, e assim 
sucessivamente. O polimorfismo pode ser observado através de métodos virtuais de uma classe 
como representado a seguir: 
/*declaração da superclasse*/ 
class Madeira 
{ 
 // atributo da classe Madeira 
 String cor; 
 // métodos da classe madeira 
 public void escreve_na_tela() 
 { 
 escreve(); 
 } 
 public void escreve() 
 { 
 System.out.println(\u201cestou na classe Madeira!\u201d); 
 } 
} // fim da declaração da superclasse 
/*declaração da subclasse*/ 
class Cadeira extends Madeira 
{ 
 // métodos adicionais à superclasse 
 public void escreve() 
 { 
 System.out.println(\u201cestou na classe Cadeira!\u201d); 
 } 
} // fim da declaração da subclasse 
Na prática, o que acontece é que cada classe procura os métodos sempre da classe cujas chamadas 
estão sendo feitas em direção às superclasses. Na linguagem Java, todos os métodos são virtuais, 
portanto, suportam polimorfismo. Basta serem redeclarados nas subclasses. Em C++, o mesmo não 
ocorre, a superclasse deve permitir que determinado método seja reescrito nas subclasses. 
O que são Construtores e Destrutores? 
Construtores são métodos especiais que são chamados no processo de instanciação de um objeto no 
sistema. A execução de tais métodos garante que os identificadores serão inicializados de forma 
correta. Todo construtor tem o mesmo nome que a classe. O exemplo a seguir tem dois 
construtores, um que não recebe parâmetro algum e outro que recebe o nome de um cliente. 
Observe o exemplo em Java abaixo: 
// declaração inicial da classe cliente 
public class cliente 
{ 
 // atributos da classe cliente 
 private String nome; 
 private String endereco; 
 
 // construtores 
 public cliente() 
 { 
 nome = \u201c\u201d; 
 endereco = \u201c\u201d; 
 } 
 public cliente(String novo_nome) 
 { 
 nome = novo_nome; 
 endereco = \u201c\u201d; 
 } 
 // métodos da classe cliente 
 public void setNome (String novo_nome) 
 { 
 nome = novo_nome; 
 } 
 public void setEndereco (String novo_endereco) 
 { 
 endereco = novo_endereco; 
 } 
 public String getNome() 
 { 
 return nome; 
 } 
 public String getEndereco() 
 { 
 return endereco; 
 } 
} // fim da declaração da classe Cliente 
Todo construtor recebe o mesmo nome da classe. No exemplo anterior, existem dois construtores 
sobrecarregados, um que não recebe nenhum parâmetro e outro que recebe uma string novo_nome. 
Quando um objeto do tipo classe cliente é criado, isto pode ser feito de duas formas, pois existem 
dois construtores. Primeira forma: 
// utilizando o construtor sem parâmetros que 
// inicia o objeto do tipo cliente. É executado o 
// código contido nesse construtor 
cliente c1 = new cliente(); 
Segunda Forma: 
// utilizando o construtor que recebe como parâmetro 
// uma string que identifica o nome do cliente. É 
// executado o código contido nesse construtor. 
cliente c2 = new cliente(\u201co cliente\u201d); 
O construtor é chamado somente durante o processo de instanciação do objeto. Nos construtores, 
são definidos comportamentos de início do objeto. Quando um objeto, por exemplo,