Várias respostas sobre JAVA
30 pág.

Várias respostas sobre JAVA


DisciplinaAlgoritmos e Programação 2141 materiais3.785 seguidores
Pré-visualização8 páginas
após subtração com atribuição => \u201c+x); 
 x *= 5; 
 System.out.println(\u201cValor após multiplicação com atribuição => \u201c+x); 
 x /= 5; 
 System.out.println(\u201cValor após divisão com atribuição => \u201c+x); 
 } 
 
 public static void main (String args[]) 
 { 
 Operacoes o = new Operacoes(); 
 o.calculos(); 
 o.operadoresUnarios(); 
 o.operadoresRelacionais(); 
 o.operacoesAtribuicao(); 
 } 
} 
 
 
Fluxo.java 
public class Fluxo extends Object 
{ 
 public static void main(String args[]) 
 { 
 int x = 5; 
 int k = 0; 
 
 if (x > 10) 
 { 
 x = 50; 
 } 
 else 
 { 
 x = 40; 
 } 
 
 switch (x) 
 { 
 case 10: { 
 System.out.println(\u201cDEZ\u201d); 
 break; 
 } 
 case 40: { 
 System.out.println(\u201cQUARENTA\u201d); 
 break; 
 } 
 case 50: { 
 System.out.println(\u201cCINQÜENTA\u201d); 
 break; 
 } 
 } 
 
 for (k = 0; k < 10; k++) 
 { 
 if (k > 5) 
 { 
 // volta para o for 
 continue; 
 } 
 System.out.println(\u201cvalor => \u201c+k); 
 } 
 while (k > 0) 
 { 
 System.out.println(\u201cvalor do while => \u201c+k); 
 k~W; 
 } 
 
 do { 
 System.out.println(\u201cvalor no do-while => \u201c+k); 
 k++; 
 } while (k < 5); 
 
 // tratamento de exceções tenta executar o código se não funcionar trata o 
erro 
 // com (catch) ou executa um finally (executa no final do trecho de código) 
 try { 
 System.out.println(\u201cdentro do try\u201d); 
 } 
 catch(Exception e) 
 { 
 
 System.out.println(\u201cSe não funcionar por algum motivo entra aqui!\u201d); 
 } 
} 
Tabela 3.8 
Operadores pós-fixados [] . (params) expr++ expr- 
Operadores unários ++expr -expr +expr -expr ~ ! 
Cast ou criação new (type)expr 
Multiplicação * / % 
Adição + - 
Rotação << >> >>> 
Relacional < > <= >= instanceof 
Igualdade = = != 
Operador de bits AND & 
Operador de bits OR exclusivo ^ 
Operador de bits OR inclusivo | 
AND lógico && 
OR lógico || 
Condicional ?:: 
Atribuição = += -= *= /= %= &= ^= |= <<= >>= 
>>>= 
 
Tabela 3.8 - Tabela de expressões na linguagem Java 
Tabela 3.9 
Tipo do Fluxo Palavra-chave 
Tomada de decisão If-else, switch-case 
Laços (loops) for, while, do-while 
Tratamento de exceções try-catch-finally, throw 
Outros break, continue, label:, return 
 
Tabela 3.9 - Tabela de fluxo de execução na linguagem Java 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
O Geek que sabia Java Parte III 
Na terceira parte de nosso curso de Java, abordamos o conceito de hierarquia 
entre classes. Esta é uma aula essencialmente prática, portanto preste muita 
atenção ao código fonte e aos blocos de comentário entre ele, que dão dicas do 
que está sendo feito. 
Código fonte: http://www.revistadolinux.com.br/ed/039/RdL39-Curso_de_Java.tar.gz 
Exemplo de uma Hierarquia de Classes 
Compile o exemplo a seguir da seguinte forma: 
$ javac Livro.java 
$ javac LivroTecnico.java 
$ javac LivroInfantil.java 
As classes LivroTecnico e LivroInfantil apresentam o método main. Esse método define 
que uma classe pode ser acessada pela Máquina Virtual Java para iniciar a execução de 
uma aplicação. Toda a classe que tem declarada esse método pode ser passada como 
parâmetro para o executável java, tal como a seguir: 
$ java LivroTecnico 
$ java LivroInfantil 
Livro.java 
class Livro extends Object 
{ 
 // atributos acessados somente 
 // dentro da classe 
 private int codigo = 0; 
 
 // atributo acessado dentro da classe 
 // e pelas classes 
 // que herdam desta classe 
 protected String nome = null; 
 
 // acessível por outros objetos diretamente 
 public String editora = null; 
 
 // acessível por classes pertencentes 
 // a este pacote 
 int ano = 0; 
 
 public Livro() 
 { 
 codigo = 0; 
 nome = \u201cdefault\u201d; 
 editora = \u201cdefault\u201d; 
 ano = 2001; 
 } 
 
 public Livro(int codigo, String nome) 
 { 
 this.codigo = codigo; 
 this.nome = nome; 
 editora = \u201cdefault\u201d; 
 ano = 2001; 
 } 
 
 public Livro(String nome, int codigo) 
 { 
 this.codigo = codigo; 
 this.nome = nome; 
 } 
 
 public Livro(int codigo, String nome, String editora, int ano) 
 { 
 this.codigo = codigo; 
 this.nome = nome; 
 this.editora = editora; 
 this.ano = ano; 
 } 
 
 public void setCodigo(int codigo) 
 { 
 this.codigo = codigo; 
 } 
 
 public void setNome(String nome) 
 { 
 this.nome = nome; 
 } 
 
 public void setEditora(String editora) 
 { 
 this.editora = editora; 
 } 
 
 public void setAno(int ano) 
 { 
 this.ano = ano; 
 } 
 
 public int getCodigo() 
 { 
 return codigo; 
 } 
 
 public String getNome() 
 { 
 return nome; 
 } 
 
 public String getEditora() 
 { 
 return editora; 
 } 
 
 public int getAno() 
 { 
 return ano; 
 } 
 
 public void imprime() 
 { 
 System.out.println(\u201cLivro => \u201c+codigo+\u201d, \u201c+nome+\u201d, \u201c+editora+\u201d, \u201c+ano); 
 } 
} 
 
LivroTecnico.java 
{ 
 protected String palavras_chave = null; 
 public LivroTecnico() 
 { 
 // chama o construtor da classe 
 // pai (superclasse)sem parâmetros 
 super(); 
 palavras_chave = \u201csem palavras-chave\u201d; 
 } 
 
 public LivroTecnico(int codigo, String nome, String editora, int ano, String 
palavras_chave) 
 { 
 super(codigo, nome, editora, ano); 
 this.palavras_chave = palavras_chave; 
 } 
 
 public void testeMensagens() 
 { 
 
Comentário: acessar private int código da classe-pai gera erros, pois um 
atributo private somente é acessível pela própria classe. Mesmo herdando da 
classe que tem o atributo private, não é possível acessá-lo diretamente. Todo 
atributo protected é acessível pela própria classe e pelas classes que herdarem 
da classe que os contém. 
 
System.out.println(\u201cvalor de protected String nome -> \u201c+nome); 
 
Comentário: acessando public String editora. Quando um atributo ou método é 
public ele pode ser acessado diretamente por qualquer objeto. 
 
System.out.println(\u201cvalor de public String editora -> \u201c+editora); 
 
Comentário: acessando int ano. Neste caso não há modificadores, qualquer classe-
filha ou pertencente ao mesmo pacote pode acessá-la. 
 
System.out.println(\u201cvalor de int ano-> \u201c+ano); 
 
 // acessando protected String palavras_chave 
 
 System.out.println(\u201cprotected String palavras_chave -> 
\u201c+palavras_chave); 
 } 
 
 public void imprime() 
 { 
 System.out.println(\u201cLivroTecnico\u201d); 
 System.out.println(nome+\u201d, \u201c+editora+\u201d, \u201c+ano+\u201d, \u201c+palavras_chave); 
 } 
 
 public static void main(String args[]) 
 { 
 LivroTecnico lt = new LivroTecnico(1, \u201cLinguagens\u201d, \u201cNovatec\u201d, 2001, \u201cc, 
c++, java, orientação a objetos\u201d); 
 lt.testeMensagens(); 
 
 Livro lv = new Livro(5, \u201cO Livro Externo\u201d, \u201cA Editora\u201d, 1930); 
 
Comentário: acessando de forma externa, ou seja, o envio da mensagem para o 
objeto não é feito dentro da classe System.out.println(\u201cAcessando o atributo 
private int codigo => \u201c+lv.codigo); Isto não funciona, pois private somente é 
acessível dentro da classe