Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Capítulo 1
Java
Java é uma linguagem de programação orientada a objetos desenvolvida na
década de 90 por uma equipe de programadores chefiada por James Gosling, na
empresa Sun Microsystems. Diferentemente das linguagens convencionais, que são
compiladas para código nativo, a linguagem Java é compilada para um "bytecode"
que é executado por uma máquina virtual. A linguagem de programação Java é a
linguagem convencional da Plataforma Java, mas não sua única linguagem.
Histórico
Em 1991, na Sun Microsystems, foi iniciado o GreenProject, o berço do Java,
uma linguagem de programação orientada a objetos. Os mentores do projeto eram
Patrick Naughton, Mike Sheridan, e James Gosling. O objetivo do projeto não era a
criação de uma nova linguagem de programação, mas antecipar e planejar a
“próxima onda” do mundo digital. Eles acreditavam que, em algum tempo, haveria
uma convergência dos computadores com os equipamentos e eletrodomésticos
comumente usados pelas pessoas no seu dia-a-dia.
O próximo passo era encontrar um mercado para o *7. A equipe achava que
uma boa idéia seria controlar televisões e vídeo por demanda com o equipamento.
Eles construíram um demo chamado Movie Wood, mas infelizmente era muito
cedo para que o vídeo por demanda bem como as empresas de TV a cabo
pudessem viabilizar o negócio. A idéia que o *7 tentava vender, hoje já é realidade
em programas interativos e também na televisão digital. Permitir ao telespectador
interagir com a emissora e com a programação em uma grande rede cabos, era algo
muito visionário e estava muito longe do que as empresas de TV a cabo tinham
capacidade de entender e comprar. A idéia certa, na época errada.
Desde seu lançamento, em maio de 1995, a plataforma Java foi adotada mais
rapidamente do que qualquer outra linguagem de programação na história da
computação .Em 2003 Java atingiu a marca de 4 milhões de desenvolvedores em
todo mundo. Java continuou crescendo e hoje é uma referência no mercado de
desenvolvimento de software. Java tornou-se popular pelo seu uso na Internet e
hoje possui seu ambiente de execução presente em web browsers, mainframes,
SOs, celulares, palmtop se cartões inteligentes, entre outros.
Padronização
Em 1997 a Sun Microsystems tentou submeter a linguagem a padronização
pelos orgãos ISO/IEC e ECMA, mas acabou desistindo. Java ainda é um standard de
fato, que é controlada através da JCP Java Community Process. Em 13 de Novembro
de 2006, a Sun lançou a maior parte do Java como Software Livre sob os termos da
GNU General Public License(GPL). Em 8 de Maio de 2007 a Sun finalizou o
processo, tornando praticamente todo o código Java como software de código
aberto, menos uma pequena porção que a Sun não possui copyright.
Extensões
Extensões em Java:
• J2SE (Standard Edition)
• J2EE (Enterprise Edition)
• J2ME (Micro-Edition for PDAs and cellular phones)
• JCE (Java Cryptography Extension)
• JMF (Java Media Framework)
• JNDI (Java Naming and Directory Interface)
• JSML (Java Speech API Markup Language)
• JDBC (Java Database Connectivity)
• JMS (Java Message Service)
• JAAS (Java Authentication and Authorization Service)
• JDO (Java Data Objects)
• JAIN (Java API for Integrated Networks)
• JDMK (Java Dynamic Management Kit)
• Jini (a network architecture for the construction of distributed systems)
• Jiro
• JXTA (open source-based peer-to-peer infrastructure)
• Java Card
• JavaSpaces
• JMI (Java Metadata Interface)
• JMX (Java Management Extensions)
• JSP (JavaServer Pages)
• JSF (JavaServer Faces)
• JNI (Java Native Interface)
• J3D (A high level API for 3D graphics programming)
• JOGL (A low level API for 3D graphics programming, using OpenGL)
• OSGi (Dynamic Service Management and Remote Maintenance)
• SuperWaba (JavaVMs for handhelds)
• MARF (Modular Audio Recognition Framework)
• JavaFX
Frameworks
É possível utilizar frameworks parafacilitar o desenvolvimento de aplicações.
Dentreos mais utilizados pode-se destacar:
• Hibernate ferramenta para ORM;
• Spring ferramenta que auxilia principalmente implementação de injeção de
dependências e inversão de controle;
• Log4j ferramenta para facilitar a criação de logs na aplicação;
• Junit ferramenta para auxiliar na criação de testes unitários;
• Struts controlador MVC (Model 2) web.
Ambientes de desenvolvimento
É possível desenvolver aplicações sem Java através de vários ambientes de
desenvolvimento integrado (IDE's). Dentre as opções mais utilizadas pode-se
destacar:
Certificações
Existem 8 tipos de certificações da Sun Microsystems para Java:
Comunidade
A comunidade de desenvolvedores Java reúne-se em grupo denominados
JUGs (Java User Groups). No Brasil o movimento de grupos de usuários expandiu-
se bastante e tem formado alguns dos maiores grupos de usuários Java do mundo,
como, por exemplo, o Portal Java e o GUJ.
Licença
A Sun disponibiliza a maioria das distribuições Java gratuitamente e obtém
receita com programas mais especializados como o Java Enterprise System. Em 13
de novembro de 2006, Sun liberou partes de Java como software livre, sob a
licença GNU General Public License(GPL). A liberação completa dos programas
fonte sob a GPL é esperada para o primeiro trimestre de 2007.
Capítulo 2
O que é necessário para programar em JAVA
Para programar em Java, não é necessário ter programado antes. Porém,
ficaria mais fácil se tiver conhecimento em linguagem Orientada a Objeto, porque
Java é totalmente estruturada em objetos (Classes, métodos, abstração, etc).
(String[ ] args)
(String[] args) é o argumento passado ao método main. Qualquer programa
pode ser iniciado ou não com argumentos que modificam sua execução, trataremos
futuramente de argumentos com programas.
{}
As chaves são usadas para marcar o bloco de dados. No caso deste
algorítmo, ele marca o código que será executado na classe MeuPrimeiroPrograma
e também todo o código que será executado quando o método main for chamado.
System.out.println
System.out.println é a saída padrão de Java. É este método que indica o que
deve aparecer na tela.
É muito provável que quem não tenha experiência com programação sinta
dificuldade de identificar todos os termos utilizados neste artigo, mas garantimos
que tudo que será visto aqui será detalhado mais adiante, embora que este artigo
se torna trivial a medida que programamos. Portanto, quem já conhece
programação em algum outro tipo de linguagem (como Delphi ou C++)
aconselhamos que prossiga para a próxima página. Porém, se nunca programou
antes, com certeza, este artigo será didático o suficiente para que entenda essas
regras.
Nome de Classes
Por convenção, toda classe deve começar com uma letra maiúscula e, de
preferência, não pode conter letras não ASCII (caracteres de língua de origem
latina, como caracteres acentuados). Portanto, não é possível declarar uma classe
com qualquer caracter especial (@, #, $, %, &, *, _, etc...) ou número.
Caso o nome de uma classe seja composto por mais de uma palavra, a
primeira letra de cada palavra deve ser em maiúscula.
O nome da classe deve ser exatamente o mesmo nome de seu arquivo fonte
( .java ).
Nome de Pacotes
Os pacotes devem começar com uma letra minúscula e podem usar letras
não ASCII. Jamais poderemos iniciar o nome de um pacote com caracteres
especiais (@, #, $, %, &, *, _, etc...) ou número.
var1 = 20;
var2 = var1;
A variável var1 recebe o número 20, depois a variável var2 recebe o valor
de var1 (que é 20). Pronto! Agora, temos duas variáveis guardando o mesmo
número (20).
Char deve ser inicializado com uma letra entre aspas simples. O importante
é entender que em uma variável do tipo char só pode ser colocada uma letra, não
uma frase. Além do mais, neste caso há diferença entre maiúsculas e minúsculas.
Exemplo:
char var1 = 'a';
char var2 = 'A';
Com exceção da inexistente, toda string deve estar dentro de aspas duplas (
" " ). Se por acaso, precisarmos digitar uma aspas dentro de uma string, estas aspas
devem vir precedidas de uma barra invertida (\). Exemplo:
O tipo booleano possui apenas dois valores: verdadeiro e falso. True para
verdadeiro e False para falso. Exemplo:
O método println faz parte da classe System que controla a maioria das
funcionalidades do computador, e se tratando de uma saída, mais especificamente
de out.
Uma outra forma de saída padrão é o print. A única diferença entre println e
print é que ao final de seu argumento ele não irá pular nenhuma linha. Dessa forma
podemos criar uma linha contínua com vários print em linhas diferentes.
Controle de Texto
Outra possibilidade interessante nos métodos de saída são os controles de
texto. Os controles de texto são dados por caracteres chaves que são indicados com
uma barra invertida antes dele. Veja a lista abaixo:
Concatenação
Concatenação é o ato de unir duas ou mais cadeias de caracteres (strings).
Dessa forma, com apenas este símbolo, podemos unir duas cadeias de
caracteres diferentes em apenas uma.
Veja este exemplo, que apesar de bobo, ilustra exatamente o que acontece
na concatenação:
O melhor da concatenação é que não precisa ser uma palavra que faça
sentido porque o computador não verifica se faz sentido, ele simplesmente junta a
cadeia de caracteres. Portanto, poderíamos muito bem fazer isso:
01.public class ConcatenacaoComposta {
02. public static void main(String[] args) {
03. String part1 = "De";
04. String part2 = "se";
05. String part3 = "nc";
06. String part4 = "or";
07. String part5 = "aj";
08. String part6 = "ad";
09. String part7 = "o";
10. System.out.println(part1+part2+part3+part4+part5+part6+part7);
11. }
12.}
Cuidados ao concatenar
Apesar da concatenação ser algo bem simples de ser feito, devemos ter
alguns cuidados. Pois como podemos perceber, ele também é o símbolo utilizado
para fazer operações de adição. O que queremos dizer é que, se por exemplo,
quisermos marcar um número de telefone em uma única string e tivermos na
verdade dois números inteiros distintos, o resultado será desastroso. Veja:
Exemplificando: Se (IF) for tal coisa, faça isso! Caso contrário (ELSE), faça
aquilo!
Usando IF
Para usar o IF basta digitar entre parênteses o que deve ser comparado.
Se o if tiver que executar várias linhas, todas as linhas que devem ser
enquadradas dentro do bloco de dados - as chaves ({}).
Usando ELSE
O ELSE só existe se tiver um IF. O else só será executado se o IF for falso.
Else executará só a primeira linha abaixo dele. Se o else tiver que executar
várias linhas, vale a mesma regra de if. Todas as linhas a ser executadas deverão
estar contidas dentro do bloco de dados ({}).
Para que IF chegue a uma decisão de falso e verdadeiro são necessários
operadores lógicos. Dos quais destacam-se 6:
Importante
O operador lógico ! (negação) server para inverter o valor, ou seja, se algo
for falso, irá se tornar verdadeiro e vice-e-versa.
Uma construção sem comparação entre duas variáveis será entendida como
false se usarmos o operador de negação antes da variável. Ex.: if (!var1) -> entenda
como: se var1 for falso.
WHILE
While é uma estrutura de repetição.
WHILE (comparação)
DO WHILE
DO WHILE é uma estrutura de repetição, tal como o próprio while. A
principal diferença entre os dois é que DO WHILE irá fazer a comparação apenas
no final do bloco de código, sendo representado da seguinte forma:
Neste caso, devemos ter as mesmas precauções quanto while, no que diz
respeito a looping infinito. Mas não é necessário inicializar a variável antes do
bloco de código como acontece com while, pois a comparação só será feita após
todo o código ter sido executado.
FOR
FOR é uma estrutura de repetição que exerce a mesma função que WHILE e
DO WHILE.
A principal diferença entre eles é a sintaxe e também a forma de trabalhar.
Em um código ficaria:
A estrutura do Switch é:
SWITCH (variável) {
CASE valor :
Código a ser executado caso o valor de case seja o mesmo da variável de switch
}
Default
Como switch pode receber várias possibilidades, pode ocorrer de algum
caso estar fora do alcance ou não definido. Nesse momento, default faz seu papel.
Default pega qualquer resultado que não esteja definido no case. Ou seja, ele é o
bloco de código padrão que deve ser executado quando nenhum case for satisfeito.
Podemos colocá-lo onde quisermos dentro de switch, mas, geralmente, o
colocamos no final.
Break e Continue
Break e Continue são dois comandos de controle de estruturas largamente
utilizados em loops (repetições) como for e while.
Break
O comando break serve para determinar uma quebra de estrutura, ou seja,
ele faz com que, por exemplo, um loop (repetição) pare. No comando switch, por
exemplo, ele determina que não pode ser executado o case seguinte, e assim por
diante.
Continue
Continue também é muito utilizado em estruturas e repetição e sua função
é ignorar o código, e não sair como acontece com o break.
Como um array pode guardar vários valores temos que definir quantos
valores ele deve guardar para que seja reservado o espaço necessário em memória.
Agora que já declaramos o array, devemos dar um tamanho a ele, para que
seja reservado espaço suficiente em memória. Para fazermos isso, utilizaremos um
instanciador chamado new.
Uma única variável com 4 espaços nos quais podem ser guardados números
inteiros.
Acessando uma posição no Array
Agora, para acessarmos um local específico dessa memória devemos indicar
entre colchetes a posição desejada no array que chamamos de index. O importante
mesmo é saber que não importa o tamanho do array, o index (número que indica a
posição) sempre começa em 0. Ou seja, um array de tamanho 20 vai da posição 0 a
19, um array de tamanho 180 vai da posição 0 a 179. Portanto, um array de
tamanho 4 vai da posição 0 a 3.
Não podemos nunca nos esquecer que o limite do array é sempre seu
tamanho menos 1. Usando o exemplo: array de tamanho 4, posição máxima é 3
(pois 4-1=3). Então, se atribuirmos um valor a posição 4 ocorrerá um erro.
Resumidamente, jamais poderíamos fazer meuArray [4]=200.
Matrizes
Matrizes são arrays multidimensionais, ou seja, eles não são totalmente
lineares, e sim, geométricos.
Enquanto um array tem apenas uma linha com vários valores, uma matriz
pode, por exemplo, tem várias linhas com vários valores, que comumente
chamamos de linhas e colunas.
Isso também pode ser feito para adquirirmos o formato de matriz que
quisermos. Ou seja, se fosse uma matriz tridimensional, bastaria ter três
dimensionadores, se fosse 4D, então, 4 dimensionadores, se fosse 5D (apesar de
geometricamente difícil de imaginar) seriam 5 dimensionadores. E assim por
diante...
Entendendo Static
Sempre que programamos devemos levar em conta como nosso próprio
programa irá acessar os dados que ele mesmo produz. Isso é o simples
entendimento e visualização da diferença entre o que é local e o que é global.
Local é qualquer tipo de dado que só pode ser acessado em seu próprio
contexto. Por exemplo, uma variável dentro da função principal (main) só pode ser
acessada pela função main.
As funções mais básicas são aquelas que apenas executam uma rotina,
portanto, não recebem nenhum argumento. No código, digitaríamos dentro da
classe, mas fora da função main o seguinte:
Static porque pode ser acessado globalmente; void porque não retorna
nenhum valor; mesmo não tendo argumentos, é necessário ter parênteses.
Uma função pode ter um ou vários argumentos desde que separados por
vírgula (,). Cada argumento deve ter seu tipo de dado declarado. Então, todos os
exemplos abaixo são funções válidas:
Para demonstrar este tipo de função criaremos uma função que mostra na
tela o resultado fatorial de um número. Além disso, colocaremos esta função
dentro de um loop que irá de 1 a 10 para ele mostrar cada um desses fatoriais.
Simplificando, x que está sendo passado pelo main para fatorar() será o
valor int numero da função fatorar.
Vamos imaginar que três funções, sendo que a primeira irá retornar um inteiro, a
segunda um double e a terceira uma string. Então, as criaríamos da seguinte
maneira:
No exemplo abaixo, nós criaremos uma função que irá retornar um valor
booleano (verdadeiro ou falso). Usando este retorno, determinaremos o que fazer
dentro de uma estrutura seletiva (if).
Para criar uma classe usamos a palavra chave class, e após a definição do
nome de nossa classe, nós definimos seus atributos. Para exemplificar, criaremos
uma classe que terá as características mais simples de uma televisão.
1.class TV{
2. int tamanho;
3. int canal;
4. boolean ligada;
5.}
Pronto, esses são os atributos de uma classe, ou seja, nós definimos que
existe um objeto chamado TV e que ele tem três características: uma dessas
características é o tamanho, outra é um valor inteiro identificado por canal e mais
outra característica que determina se ele está ligado ou não.
Método Construtor
Vimos anteriormente que é simples criar uma classe. Mas, para realmente
conseguirmos utilizar a classe, ela deve conter pelo menos um método construtor.
O método construtor é desenvolvido da mesma forma que uma função, a
única diferença é que ele tem o mesmo nome da classe.
Isso se deve ao fato de que um objeto deve ser construído cada vez que
chamamos a classe. E a responsabilidade de fazer isso é do construtor. Isso parte
do princípio que podemos ter dois objetos com a mesma característica, mas que
não são os mesmos objetos.
Ou seja, nós podemos ter uma TV de 29" ligada no canal 15 e nosso amigo
tem uma outra TV que também é de 29" e está ligada no canal 15. Perceba que
ambas as TVs têm as mesmas características, mas continuam sendo duas TVs
diferentes.
Então, vamos imaginar que sempre que uma TV é construída, o seu padrão é
tamanho 21", desligada e no canal 0. Então, podemos definí-lo como:
01.class TV {
02. int tamanho;
03. int canal;
04. boolean ligada;
05.
06. TV(){
07. tamanho=21;
08. canal=0;
09. ligada=false;
10. }
11.}
Instanciar Objetos
Objetos são estruturas de dados definidas e agrupas dentro de uma classe.
Sempre que utilizamos um objeto ou classe devemos reservar espaço em memória
para que aquele objeto seja manipulado sem maiores problemas.
Além do mais, também podemos utilizar a mesma classe (com todos os seus
métodos e atributos) para manipular outros objetos que serão tratados de forma
diferente (mesmo se tiverem as mesmas características do objeto anterior), pois
serão dois endereços de memória diferentes.
A vantagem de Java é nos possibilitar uma instanciação rápida e simples,
sem termos que nos preocupar com referência a endereços e alocação dinâmica de
memória, pois quem trata de manipular a memória é o próprio Java. Sem contar
que, se um objeto não é mais referenciado dentro do programa, o próprio Java
trata de liberar os recursos de memória consumidos pelo objeto usando o Garbage
Colletor - Coletor de Lixo.
01.public class TV {
02. int tamanho;
03. int canal;
04. boolean ligada;
05.
06. TV() {
07. tamanho = 21;
08. canal = 0;
09. ligada = false;
10. }
11.
12. public static void main(String[] args) {
13. TV objeto1 = new TV();
14. TV objeto2;
15. objeto2 = new TV();
16. }
17.}
This
This é usado para fazer auto-referência ao próprio contexto em que se
encontra. Resumidamente, this sempre será a própria classe ou o objeto já
instanciado.
01.public class TV {
02. //atributos
03. int tamanho;
04. int canal;
05. boolean ligada;
06.
07. // método contrutor com parâmetro
08. TV(boolean ligada) {
09. this.ligada = ligada;
10. /**
11. * Onde this.ligada é o atributo
12. * e ligada é o valor do parâmetro
13. */
14. }
15.}
Sobrecarga de métodos
Java nos permite criar vários métodos com o mesmo nome desde que tenham
parâmetros diferentes. Isso é o que chamamos de sobrecarga de métodos.
1.public TV {
2. int canal;
3. int volume;
4. boolean ligada;
5. int tamanho;
6.}
Agora, vamos personalizar este método para que ele mude o atributo ligada
de acordo com o parâmetro.
Porém, o mesmo não pode ser aplicado aos atributos canal e volume.
Porque não é possível criar um método que recebe um inteiro e criar um outro
método com o mesmo nome que também recebe um inteiro, mesmo que estes dois
inteiros sejam totalmente diferentes. Se visualizarmos como Java interpreta o
método, veríamos:
void ligar (boolean ligada, int canal) l void ligar (int canal, boolean ligada)
void ligar (boolean, int) l void ligar (int, boolean)
01.public class TV {
02. int canal;
03. int volume;
04. boolean ligada;
05. int tamanho;
06.
07. void ligar() {
08. this.ligar(3, 25, true);
09. }
10.
11. void ligar(boolean ligada) {
12. this.ligar(3, 25, ligada);
13. }
14.
15. void ligar(int canal, int volume) {
16. this.ligar(canal, volume, true);
17. }
18.
19. void ligar(int canal, int volume, boolean ligada) {
20. this.canal = canal;
21. this.volume = volume;
22. this.ligada = ligada;
23. }
24.}
01.public class TV {
02. int canal;
03. int volume;
04. boolean ligada;
05. int tamanho;
06.
07. public TV(){
08. this.tamanho = 21;
09. this.ligada = true;
10. }
11.
12. public static void main (String args []){
13. TV minhaTV = new TV();
14. minhaTV.canal = 3;
15. minhaTV.volume = 25;
16. }
17.}
01.public class TV {
02. int canal;
03. int volume;
04. boolean ligada;
05. int tamanho;
06.
07. public TV(){
08. this.tamanho = 21;
09. this.ligada = true;
10. this.canal = 3;
11. this.volume = 25;
12. }
13.
14. public void aumentarVolume(){
15. this.volume += 5;
16. }
17.
18. public static void main (String args []){
19. TV minhaTV = new TV();
20. minhaTV.aumentarVolume();
21. }
22.}
01.public class TV {
02. int canal;
03. int volume;
04. boolean ligada;
05. int tamanho;
06.
07. public TV(){
08. this.tamanho = 21;
09. this.ligada = false;
10. this.canal = 0;
11. this.volume = 0;
12. }
13.
14. // método da classe
15. public void ligar(boolean ligada){
16. this.ligada = ligada;
17. }
18.
19. // função
20. public static void estahLigada (TV objeto){
21. if (objeto.ligada)
22. System.out.println ("está ligada");
23. else
24. System.out.println ("não está ligada");
25. }
26.
27. public static void main (String args []){
28. TV televisao1 = new TV();
29. TV televisao2 = new TV();
30. // chamando o método ligar
31. televisao1.ligar(true);
32. televisao2.ligar(false);
33. System.out.print ("A televisão 1 ");
34. // chamando a função estahLigada
35. estahLigada (televisao1);
36. System.out.print ("A televisão 2 ");
37. estahLigada (televisao2);
38. }
39.}
Criar Pacotes
Muitos compiladores criam automaticamente os pacotes como uma forma
eficaz de organização, mas a criação de pacote pode ser feita diretamente no
sistema operacional. Basta que criemos uma pasta e lhe demos um nome. Após
isso, devemos gravar todos os arquivos fonte de java dentro desta pasta.
Definir Pacotes
Agora que já possuímos a pasta que será nosso pacote, devemos definir em
nossa classe a qual pacote ela pertence. Isso é feito pela palavra reservada package.
Importar Pacotes
Java possui vários pacotes com outros pacotes internos e várias classes já
prontas para serem utilizadas.
Para consolidar o que foi visto até aqui, o código abaixo ilustra o uso de
pacotes.
01.package tiexpert;
02.
03.import javax.swing.JOptionPane;
04.
05.public class Mensagem {
06. public static void main (String args[]){
07. JOptionPane.showMessageDialog(null,
08. "Bem vindo ao mundo de Java!");
09. }
10.}
Usamos o nível de acesso mais restritivo que faça sentido para um membro
particular. Sempre usamos private, a menos que tenhamos um bom motivo para
deixá-lo com outro nível de acesso.
Não devemos permitir o acesso público aos membros, exceto em caso de ser
constantes. Isso porque membros públicos tendem a nos ligar a uma
implementação em particular e limita a nossa flexibilidade em mudar o código.
Exemplo:
Public
O modificador public deixará visível a classe ou membro para todas as
outras classes, subclasses e pacotes do projeto Java.
Private
O modificador private deixará visível o atributo apenas para a classe em que
este atributo se encontra.
Protected
O modificador protected deixará visível o atributo para todas as outras
classes e subclasses que pertencem ao mesmo pacote. A principal diferença é que
apenas as classes do mesmo pacote tem acesso ao membro. O pacote da subclasse
não tem acesso ao membro.
Set
Nomeamos um método acessor com set toda vez que este método for
modificar algum campo ou atributo de uma classe, ou seja, se não criarmos um
método acessor set para algum atributo, isso quer dizer que este atributo não deve
ser modificado.
Get
Nomeamos um método acessor com get toda vez que este método for
verificar algum campo ou atributo de uma classe.
Como este método irá verificar um valor, ele sempre terá um retorno como
String, int, float, etc. Mas não terá nenhum argumento.
Is
Nomeamos um método acessor com is toda vez que este método for
verificar algum campo ou atributo de uma classe que tenha retorno do tipo
boolean.
01.public class TV {
02. private int tamanho;
03. private int canal;
04. private int volume;
05. private boolean ligada;
06.
07. public TV(int tamanho, int canal, int volume, boolean ligada) {
08. this.tamanho = tamanho;
09. this.canal = canal;
10. this.volume = volume;
11. this.ligada = ligada;
12. }
13.
14. public int getTamanho() {
15. return tamanho;
16. }
17.
18. public void setTamanho(int tamanho) {
19. this.tamanho = tamanho;
20. }
21.
22. public int getCanal() {
23. return canal;
24. }
25.
26. public void setCanal(int canal) {
27. this.canal = canal;
28. }
29.
30. public int getVolume() {
31. return volume;
32. }
33.
34. public void setVolume(int volume) {
35. this.volume = volume;
36. }
37.
38. public boolean isLigada() {
39. return ligada;
40. }
41.
42. public void setLigada(boolean ligada) {
43. this.ligada = ligada;
44. }
45.}
Capítulo 1M
Herança
Enquanto programamos em Java, há a necessidade de trabalharmos com
várias classes. Muitas vezes, classes diferentes tem características comuns, então,
ao invés de criarmos uma nova classe com todas essas características usamos as
características de um objeto ou classe já existente.
Extends e Super
Para fazermos uma classe herdar as características de uma outra, usamos a
palavra reservada extends logo após a definicação do nome da classe. Dessa forma:
Como estamos tratando de herança de classes, toda classe tem seu método
construtor. Portanto, se estamos trabalhando com duas classes, temos dois
métodos construtores. Para acessarmos o método construtor da classe que está
sendo herdada usamos o super().
Podemos usar o super para qualquer construtor da classe pai, pois o Java
consegue diferenciar os construtores por causa da sobrecarga de métodos.
Classe 1: Eletrodomestico
01.package tiexpert;
02.
03.public class Eletrodomestico {
04. private boolean ligado;
05. private int voltagem;
06. private int consumo;
07.
08. public Eletrodomestico(boolean ligado, int voltagem, int consumo) {
09. this.ligado = ligado;
10. this.voltagem = voltagem;
11. this.consumo = consumo;
12. }
13. // (...)
14.}
Classe 2: TV
01.package tiexpert;
02.
03.public class TV extends Eletrodomestico {
04. private int canal;
05. private int volume;
06. private int tamanho;
07.
08. public TV(int voltagem, int consumo, int canal, int volume, int tamanho) {
09. super(false, voltagem, consumo);
10. this.canal = canal;
11. this.volume = volume;
12. this.tamanho = tamanho;
13. }
14. //(...)
15.}
01.package tiexpert;
02.
03.public class ExemploHeranca {
04. public static void mostrarCaracteristicas(TV obj) {
05. System.out.print("Esta TV tem as seguintes características:\n"
06. + "Tamanho: " + obj.getTamanho() + "\"\n"
07. + "Voltagem Atual: "+ obj.getVoltagem() + "V\n"
08. + "Consumo/h: " + obj.getConsumo() + "W\n");
09. if (obj.isLigado()) {
10. System.out.println("Ligado: Sim\n"
11. + "Canal: " + obj.getCanal() + "\n"
12. + "Volume: " + obj.getVolume()+"\n");
13. } else {
14. System.out.println("Ligado: Não\n");
15. }
16. }
17.
18. public static void main(String args[]) {
19. TV tv1 = new TV(110, 95, 0, 0, 21);
20. TV tv2 = new TV(220, 127, 0, 0, 29);
21. tv2.setLigado(true);
22. tv2.setCanal(3);
23. tv2.setVolume(25);
24. mostrarCaracteristicas(tv1);
25. mostrarCaracteristicas(tv2);
26. }
27.}