ANOTAÇÕES DE JAVA

 Você tem uma classe que contêm o método principal (main).

 Dentro desse método vamos criar um objeto com o modelo da classe que está acima da
classe que contém o método principal.
 Através desse objeto vamos chamar os métodos (que já estão criados) da classe de cima.

Classe conta

Método_1 da classe conta

Método_2 da classe conta

Método_3 da classe conta

Classe principal

Método main

Criação do objeto do tipo conta: (Conta c = new Conta)

Chamando objetos da classe conta acima:

c.deposita(1000);

c.saca(100);

c.imprimeExtrato();

------------------------------------------------------------------------------------------------------------------------------

Na criação de um objeto com o comando new, os argumentos passados devem ser

compatíveis com a lista de parâmetros de algum construtor definido na classe que está sendo
instanciada. Caso contrário, um erro de compilação ocorrerá para avisar o desenvolvedor dos
valores obrigatórios que devem ser passados para criar um objeto.

_____________________________________________________________________

HERANÇA EM JAVA

 O super é para ter acesso aos métodos e atributos privados.

CONSTRUTORES

 É um método especial da classe, responsável exclusivamente por inicializar um objeto.

 Os construtores servem para atribuir valores iniciais aos atributos de uma classe.
 Devemos utilizar o construtor quando queremos atribuir valores aos atributos de um objeto no
momento de sua criação:

 Obse
rve
que

acima estou inicializando os atributos x e y da classe Ponto.

 Quando temos uma construção de objeto: Carro cobalt = new Cobalt( ), esse último Cobalt()
é o construtor do objeto cobalt. Essa linha de código vai estar na classe principal. Se houver
argumentos no construtor Cobalt(67), lá na classe Carro, o construtor da mesma vai receber
parâmetros se não vai dá erro em Carro cobalt = new Cobalt() na classe principal. Logo deve
ficar assim: public Cobalt (double quilometragem). E a partir daí iniciar o objeto cobalt da
classe Carro com atributos.

 Um construtor quando quer invocar outro ele utiliza a linha de código: this(name,endereco,0); //
Primeira linha do construtor

CLASSES E ATRIBUTOS PÚBLICOS, DEFALTS E PRIVADOS

 Atributos, métodos e classes públicos, consegue-se ver de qualquer classe de qualquer pacote.
Se forem defalt só serão vistos nas classes dos pacote. E se forem privados só serão vistos na
própria classe

METODOS GET E SET

 Esses métodos são utilizados para acessar atributos privados de uma classe. Sendo que atributos
privados são acessados somente dentro da classe.

 Usamos get para obter informações. Esse tipo de método sempre retorna um valor.

 Usamos set para definir valores. Esse tipo de método geralmente não retorna valores.
 METODO STATIC

 Através do método static, podemos invocar métodos e atributos de uma classe sem precisar ser
através do objeto.

 Ex: MinhaCalculadora.soma (2, 3); // Estou invocando o método soma diretamente da classe
MinhaCalculadora.

 Veja abaixo como é declarado um método static.

 Dentro de métodos static somente é possível poder acessar outros métodos e variáveis que
também sejam static.

 Dentro do método pode-se definir qualquer tipo de variável, static ou não.

 Caso seja necessário acessar algum método ou membro não-static, é necessário criar uma
instância da classe e então chamar o que quiser. Já o contrário é um pouco diferente: dentro de
membros não-static, é possível acessar tanto propriedades static quanto as não-static.

 Declarando alguma coisa como static, todos os objetos da classe irão compartilhar a mesma
cópia da variável ou método.

CLASSE FINAL JAVA

 Uma classe final java não pode ser herdada, dará um erro de compilação.

 Esse método getContentPene() diz o que vai ser feito no conteúdo do painel, ou seja, no local
onde não tem barra de título, botões etc. OBS: O objeto Painel, não pode ser acessado
 diretamente por isso ele é recuperado pelo método getContentPane(). Logo esse método é um
intermediário entre o objeto do painel e outros métodos.

GridBagConstraint

 GridBagConstraints contém vários campos que são utilizados para especificar a geometria de
cada componente e a relação com os outros componentes no GridBaglayout.

 Você deve definir os campos GridBagConstraints para cada componente no GridBagLayout

 Aplica-los ao layout utilizando o método setConstraints do GridBagLayout

 Após isso, o objeto será adicionado ao container com o método add.

 Continuar testando os outros parâmetros apostila “Programação Básica em Java” pg 65 no

programa do eclipse.

Relacionamento entre Classes

Para eu estabelecer um relacionamento entre classes

Classes Abstratas

São classes que não servem para ser instanciadas, ou seja, criar objetos a partir delas, só servem
para serem estendidas, ou seja, que uma classe herde seus atributos e métodos. Exemplo: no sistema
com as classes: Principal, Pessoa, Funcionário e Cliente, a classe Pessoa seria abstrata.

Interface

Nas interfaces declaramos métodos que serão implementados por outras classes.

Polimorfismo

Vamos entender com um exemplo: digamos que tenhamos a classe aluno que tem o método
calcularMedia ( ). E que tenhamos subclasses alunoTecnico e alunoConvencional. O aluno
técnico tem 3 disciplinas e o aluno convencional tem 5 disciplinas. Podemos usar o mesmo método
calcularMedia ( ) tanto pela subclasse alunoTecnico como pela subclasse alunoConvencional podem
usar calcularMedia ( ). O exemplo Polimorfismo_2 está ótimo.
 Try e Catch

try{ //em português significa “tente”, ou seja, tente executar esse código

// Bloco que é monitorado para erros

}catch (TipoDaExcessao variavelDoTipoExcessao){

// Bloco para tratamento de erros

- como parâmetro do catch temos uma Exceção e uma Variável do tipo exceção. Lembrando que
tanto a Exceção quanto a Variável são tipos de objetos. Ali teríamos a Classe e sua variável.

- Não tratar os erros fazem a execução do programa terminar.

- Após tratar os erros o programa continua a ser executado.

INTERFACE GRÁFICA

- Tratamento de eventos: A interface gráfica em JAVA é orientada a eventos, ou seja, cada vez que
um usuário clica em um botão, seleciona um item em uma lista, ou pressiona uma tecla, o sistema
operacional gera um evento.

– Se uma aplicação está interessada em um evento específico (por exemplo, clique em um botão),
deve solicitar ao sistema para “escutar” o evento.

- Para que um componente ou container possa “escutar” eventos, é preciso instalar um listener.

- Listeners são classes criadas especificamente para o tratamento de eventos.

RESUMINDO: temos um componente ao qual está associado um ouvinte, por exemplo assim:

Elemento.addActionListener(this). Que normalmente é a mesma classe na qual esta o componente

que está gerando o evento. Depois vem o método actionPerformed() que tem um parâmetro objeto
do tipo evento: ActionEvent evento, no qual vem descriminado que tipo de evento foi gerado. E
quando se faz evento.getSource() == nomeDoBotaoPressionado. Estar-se tentando identificar a
fonte geradora do evento.
 Interface Gráfica

 Os componentes ficam distribuídos da seguinte forma: FRAMES <= PANEL<= LABEL, onde as
vezes podemos ter os componentes diretos no PANEL, mas também podemos colocar os mesmos
dentro dos LABELS.

Super
 Coloca-se os parâmetros dentro da cláusula super na subclasse e essas mandam como parâmetro
para o construtor da superclasse e esses vão para os atributos da superclasse.

 Na classe principal cria-se um objeto e esse objeto através do ponto acessa os atributos da
superclasse