Programação em Java

09
 Descrição do módulo

Reconhecer os princípios fundamentais da linguagem de programação

orientada por objectos.
Elaborar páginas para a web, em JAVA, com recurso a applets.
Reconhecer as estruturas complexas da programação em JAVA.

Objectivos

 Programação orientada por objectos

 Conceitos, objectos, classes, atributos e procedimentos
 Criação de uma classe
 Herança, interface e packages
 Subclasse
 Princípios da linguagem JAVA
 Variáveis e tipos de dados
 Literais
 Expressões e operadores
 Operadores aritméticos e lógicos
 Precedência dos operadores nas expressões
 Cadeias de caracteres
 Objectos
 Novos objectos
 Parâmetros em applets
 Acesso
 Conversão e comparação de objectos
 Classe de um objecto
 Livraria de classes do JAVA
 Estruturas de dados matriciais
 Definição e declaração de matrizes
 Objectos matriz
 Acesso a elementos da matriz
 Matrizes multidimensionais
 Estruturas lógicas condicionais
 Operador condicional
 Instrução IF e Switch
 Estruturas lógicas repetitivas
 Instrução for, while e do while
 Ciclos e quebras de ciclo
 Erros comuns em ciclos
 Classes e métodos
 Definição de classes
 Criação de instâncias e variáveis classe
 Criação de métodos e passagem de argumentos em métodos
 Criação de métodos com diferentes argumentos
 Método construtor e finalizar
 Applets – princípios gerais
 Applets e aplicações
 Criação de applets
 Applet em página web
 Passagem de parâmetros para applets
 Gráficos, fontes e cores
 Classe Graphics
 Desenho
 Texto e fontes de caracteres e cor
 Animação gráfica
 Introdução aos Threads
 Applets com Theards
 Animação com imagens e som
 Leitura e modificação de imagens
 Animação com imagens
 Leitura e utilização de ficheiros de som
 Applet animator
 Introdução aos eventos e à interactividade
 Toques e movimentos do rato
 Toques no teclado
 Chaves definidas por defeito
 Gestor de eventos
 Interfaces de utilizador
 Componentes das interfaces
 Painéis e sub painéis
 Gestão das acções e dos eventos sobre a interface
 Janelas
 Janelas, menus e caixas de diálogo
 Eventos sobre as janelas
 Comunicação em rede
 Linguagem JAVA e comunicação em rede
 Links em applets
 Comunicação entre applets
 Modificadores
 Controlo de acesso a métodos e variáveis
 Modificador final
 Métodos e classes abstract
 Packages
 Programas
 Escrita do código
 Excepções em JAVA
 Limitações colocadas na programação
 Clausula finally
 Multithreading
 Paralelismo
 Sincronismo
 Criação, utilização e paragem de threads
 Partilha
 Streams
  Input e output - streams
 Classes relativas a streams

Trabalho

Não se aplica.

O que aprendi

Neste módulo aprendi os Fundamentos da linguagem java.

Foi em 1991, que foi iniciado o Green Project, na Sun Microsystems, que
consiste no desenvolvimento de uma linguagem de programação orientada a
objectos. Com este projecto, o objectivo não era a criação de uma nova
linguagem de programação, mas tentar antecipar e planejar o futuro do mundo
digital.

A linguagem Java foi projectada tendo em vista os

seguintes objectivos:
 Orientação a objectos;
 Portabilidade - Independência de plataforma - "write once, run
anywhere";
 Recursos de Rede - Possui uma extensa biblioteca de rotinas que
facilitam a cooperação com protocolos TCP/IP, como HTTP e FTP;
 Segurança - Pode executar programas via rede com restrições de
execução;

Além disso, podem-se destacar outras vantagens

apresentadas pela linguagem:
 Sintaxe similar a Linguagem C/C++ e principalmente, a C#.
 Facilidades de Internacionalização - Suporta nativamente caracteres
Unicode;
 Simplicidade na especificação, tanto da linguagem como do "ambiente"
de execução (JVM);
 É distribuída com um vasto conjunto de bibliotecas (ou APIs);
  Possui facilidades para criação de programas distribuídos e multitarefa
(múltiplas linhas de execução num mesmo programa);
 Desalocação de memória automática por processo de colector de lixo
(garbage collector);
 Carga Dinâmica de Código – Os programas em Java, são formados por
uma colecção de classes armazenadas independentemente e que
podem ser carregadas em qualquer momento da sua utilização.

Método main
O método main é onde o programa inicia. Pode estar presente em qualquer
classe. Os parâmetros de linha de comando são enviados para a array args[],
do tipo String.

public class OlaMundo {

/**
* Método que executa o programa
* public = É visto em qualquer lugar da aplicação
* static = é iniciado automaticamente pela JVM, sem precisar de uma
instância
* void = Método sem retorno (retorno vazio)
* main = Nome do método, que é obrigatório ser este. Recebe como
parâmetro um array de String.
* String[] args = Array de argumentos que podem ser repassados na
chamada do programa.
*/
public static void main(String[] args) {
System.out.println("Olá, Mundo!"); //Imprime no ecrã a frase
}
}

Pseudocódigo: é uma forma genérica de escrever um algoritmo, utilizando uma

linguagem simples (nativa a quem o escreve, de forma a ser entendida por
qualquer pessoa) sem necessidade de conhecer a sintaxe de nenhuma
linguagem de programação. É, como o nome indica, um Pseudocódigo e,
portanto, não pode ser executado num sistema real (computador).

Os livros sobre a ciência de computação utilizam frequentemente o

Pseudocódigo para ilustrar os seus exemplos, de forma que todos os
programadores possam entendê-los (independentemente da linguagem que
utilizem).

Estrutura de controlo:

IF:
if(condição){
Acção caso seja verdadeira
}
IF – ELSE:
if(condição){
Acção caso seja verdadeira
}
else {
Acção alternativa
}

Switch:
switch(variavel){
case 'sejaqualquerCoisa':{
Acção;
}
default: acção por defeito
}

While:
while(Condicão){
Acção
}

Do – While:
do{
Acção

}while(Condicão)

For:
for(atribuição da Variável; Teste de comparação; incremento){
Acção; }

Classes
As classes de uma forma muito simples, é onde se vai fazer o programa. Ou
seja, vai ser o ficheiro, regra geral de extensão, java, onde se escreve o código
pretendido.

Formas simples de um programa em java:

public class qwerty {

//Lugar onde é definido entre outras coisas, métodos, variáveis estáticas,

etc..

public static void main(String[] args) {

// Lugar onde é feito todo o código necessário a ser corrido na

classe mãe, "public static void main"

Package é um conjunto de interfaces e classes, geralmente relacionadas.

Se um ficheiro, contendo classes e interfaces, for iniciado por uma declaração
do género package games.monsters; então todas as classes e interfaces
incluídas nesse ficheiro são declaradas como fazendo parte do package
referido. No entanto a instalação das classes e interfaces não é automática:
estas têm de ser arrumadas manualmente dentro das directorias correctas.

Modificadores de classe
Os principais são três:
public -- Indica que a classe pode ser acedida fora do package à qual pertence.
Este modificador também se aplica a interfaces.
abstract -- Indica que a classe é abstracta, ou seja, que pode conter métodos
abstractos. Uma classe abstracta também não admite instâncias.
final -- Indica que não é possível herdar a partir da classe.

Há cinco espécies de componentes de classes:

Variáveis de instância -- Caracterizam a estrutura das instâncias da classe.
Métodos de instância -- Caracterizam o comportamento das instâncias da
classe.
Variáveis de classe -- Pertencem à classe e são acessíveis a todas as suas
instâncias. Também são acessíveis do exterior, se forem declaradas públicas.
Exemplo: A classe System contém uma variável de classe pública chamada
out, usada por exemplo em System.out.println("ola") ;.
Métodos de classe -- Pertencem à classe e são acessíveis a todas as suas
instâncias. Também são acessíveis do exterior, se forem declarados públicos.
Construtores -- São métodos de classe especiais que servem para inicializar
as instâncias da classe, no momento da criação.

Durante este módulo de Linguagem Java utilizamos o pacote útil, existem

outros. Para usarmos este pacote, temos que o importar, usando a sintaxe:
Import java.util.*;
Sendo um objecto, ele tem que ser iniciado, isto faz-se com a sintaxe:
Scanner nomeObjecto= new Scanner(System.in);
Depois conforme o dado a ser obtido, varia a sintaxe:
* next() : para ler textos
* nextInt() : para ler números inteiros
* nextFloat() : para ler números reais - ou números de ponto flutuante.
* nextDouble() : para ler números reais - ou números de ponto flutuante com
dupla precisão

Exemplo:
System.out.println("Digite seu nome: ");
String nome = entrada.next();

Ambientes gráficos:
Abordamos neste tópico o conceito de janelas, neste caso falamos do pacote
swing, da classe java.

Demos dois tipos do método JOptionPane:

JOptionPane.showInputDialog(null,"introduza o valor de 'a'");
O “.showInputDialog” – recebe uma variável atrás para onde vai ser carregada
o valor introduzido n a caixa de combinação que vai aparecer no ecrã.

JOptionPane.showMessageDialog(null, "Não é possível dividir por

0","Erro",0);
O “.showMessageDialog” – é uma caixa que apresenta uma mensagem, tem
como curiosidade, a possibilidade de configurar o texto em cima e qual o sinal
gráfico que queremos que apareça no caso.

Strings
Métodos usados:

charAt():
Char.charAt(Casa do vector);

equalsIgnoreCase():
if(s.equalsIgnoreCase("qwerty")){
acção;
}

lenght()
s.length();
s.replace(oldChar, newChar)
s.replace('s', 'S');

toLowerCase()
s.toLowerCase()

Estruturas de captura e tratamentos de erros

Excepção representa uma situação não esperada ocorrida na execução de

algum segmento de código. Uma excepção deve ser vista como um retorno
alternativo da execução de algum método. O processo de gerar uma excepção
é chamado de “lançamento de excepção” e o processo de processar uma
excepção é chamado de “capturar a excepção”. A excepção pode ser
capturada por uma função dentro da sequência de funções chamadas.
Agora veremos abaixo a estrutura de como tratar um erro ou excepção:

try - é usada para indicar um bloco de código que possa ocorrer uma excepção.
catch – serve para manipular as excepções, ou seja, tratar o erro;
finally – sempre será executado depois do bloco try/catch. O importante é saber
que esse bloco será sempre executado (excepto nos casos de encerramento
da java System.exit ()).

Classes e métodos
Terminologia básica: a classe define um tipo de objecto.
Especifica os dados que qualquer objecto da classe tem.
Providencia métodos especificando as acções que um objecto da classe pode
fazer.
Um objecto que satisfaz a definição da classe é uma instância da classe.
Os dados e os métodos são referidos como membros da classe.
Os dados associados com um objecto da classe denominam-se variáveis de
instância.

Sintaxe simplificada da definição de classe:

public class Nome_classe {
declaração_variável_instância_1;
 declaração_variável_instância_2;
...
definição_método_1
definição_método_2

Constantes
As constante não são nada mais do que variáveis, que pelas suas
características, ou seja por terem valores fixos, são por convenção, escritas em
letra grande.

Exemplo:
final float PI=3.14f;

Métodos
Toda a definição de um método pertence a alguma classe.
As definições dos métodos estão dentro da definição de uma classe ao qual os
métodos pertencem.
Há métodos que:
 retornam um valor (e.g. nextInt)
 executam uma acção mas não retornam valores (e.g. println),
denominados métodos void .

Passagem de parâmetros
Ao criar uma classe podemos definir, quais os tipos de parâmetros que ela vai
receber para tratamento e depois mais tarde no código invocar essa classe
para lhos passar.
Por exemplo:
public class qwerty {
public static void qwerty(int numero, char letra){
}

public static void main(String[] args) {

int n=1;
char l='e';

qwerty(n,l);
 }
}

Objectos

Os objectos em java podem ser entendidos como os objectos na vida real, com
atributos:
Exemplo como exemplo temos o objecto carro em que os atributos serão, a
cilindrada, a cor, modelo, etc.
Exemplo:
NomeClasse nomeObjecto=new NomeClasse (Argumentos);
nomeObjecto.variável;
Podem também ser chamados métodos que existam dentro dessas classes, a
sintaxe é idêntica, mas acabando com ().

Java – applets
Applets são pequenos programas em Java destinados a correr a partir de um
documento na Internet.
Os Applets correm dentro de um documento HTML
HTML: Hypertext Markup Language (Linguagem usada para criar documentos
para a Internet)

Os documentos HTML são executados por um ‘web browser’.

 Netscape Navigator
 Microsoft Internet Explorer
 Firefox

Criação de applet
A applet pode ser entendida como uma função, como tal obedece a certas
regras, tais como:

Iniciação:
init();
Começar:
start();

Parar:
stop();

Destruir:
destroy();

Imprimir na Applet
Paint():

Para criar um applet, é preciso desenvolver uma classe que estenda a classe
Applet:
import java.applet.*;
public class MeuApplet extends Applet {
...
}
O Java inclui duas bibliotecas úteis para a criação de applets
java.awt - contém a classe Graphics que possui
Métodos para a produção de gráficos.
java.applet - suporta a criação de applets
A classe JApplet está na biblioteca applet

Para criar applets é necessário incluir a linha

import java.applet.*
Exemplos de um programa em applet simples:
// Importar as bibliotecas
import java.awt.*;
import java.applet.Applet;
// Indicar que se trata de um applet
public class linha extends Applet
{
public void paint(Graphics g)
{
//g representa a área do desenho
// Desenha uma linha entre os pontos (0,0) e (90,100)
g.drawLine(0,0,90,100);
//...
g.drawLine(90,100,90,60);
g.drawLine(90,60,150,60);
}
}

import java.awt.*;
import java.applet.Applet;
// indicar que se trata de um applet
public class HelloApplet extends Applet
{
public void paint(Graphics g){
g.drawString("Hello out there!", 10, 20);
}
}
Uma das formas de usar gráficos em Java é através do desenho de figuras:
tais como linhas, ovais, rectângulos e polígonos diversos.
O método paint desenha figuras no ecrã e está pré-definido na maioria das
componentes Swing .
Para desenhar figuras básicas temos de redefinir o método paint.
Este método é chamado automaticamente, não necessita de ser invocado no
código do programa.
A classe Graphics contém os métodos usados para desenhar formas básicas
e linhas. Faz parte da biblioteca AWT por isso o seu uso tem de ser antecedido
por uma linha com a respectiva importação:
import java.awt.*;
A maioria dos métodos para desenhar formas tem duas versões:
A versão draw que apenas desenha a linha exterior da forma ( e.g. drawOval )
A versão fill que preenche o interior da forma (e.g. fillOval )

Exemplo: triangulo
import java.applet.Applet;
import java.awt.*;
import java.awt.geom.*;

public class triangulo extends Applet {

public void init()
{

public void paint(Graphics g){

Graphics2D g2d=(Graphics2D) g;
GeneralPath triangulo=new GeneralPath(GeneralPath.WIND_EVEN_ODD);
triangulo.moveTo(10f, 10f);
triangulo.lineTo(100f, 10f);
triangulo.lineTo(50f,100f);
triangulo.closePath();

g2d.setColor(Color.green);
g2d.setStroke(new BasicStroke(4f));
g2d.draw(triangulo);
g2d.setColor(Color.blue);
g2d.drawString("TRIANGULO",30,40);

}}

drawPolygon permite desenhar formas com qualquer número de lados.

Public void drawPolygon(int[] x, int[] y, int point)

Cada ponto do polígono terá uma coordenada x do primeiro parâmetro e uma

coordenada y que é o correspondente elemento no segundo

Parâmetro.
O terceiro parâmetro diz-nos quantos pontos o polígono terá.
É desenhado sempre um polígono (fechado).
drawPolyline é semelhante mas permite desenhar figuras abertas.
fillPolygon é semelhante mas preenche a figura com cor.
O comando clearRect() pinta um rectângulo com a cor em uso. Aplicado com a
cor do fundo de um applet provoca o apagar de uma área rectangular.

Desenhos com acção e repaint

A modificação só será visível se o método repaint for chamado.
O método repaint faz com que o paint actualize a figura.
O método paint não deve ser chamado directamente.

Cores
Os métodos draw e fill como o fillOval irão usar a cor corrente.
Podemos usar o método setColor de um objecto Graphics para alterar a cor
corrente.
Também podemos personalizar a cor do fundo do applet com a instrução
setBackground:
setBackground(Color.blue)

Existem várias cores pré-definidas:

>> black >> blue
>> cyan >> darkGray
>> gray >> green
>> lightGray >> magenta
>> orange >> pink
>> red >> white
>> yellow

A classe Color mistura, em diferentes proporções, quantidades de vermelho

(red), verde (green) e azul (blue) para produzir outras cores.
Como as cores são obtidas por combinação de vermelho (red), verde (green) e
azul (blue), este sistema de cores é designado por RGB.
Os parâmetros do constructor Color têm de ser do tipo int ou float.
Quando os parâmetros do constructor Color são inteiros podem tomar valores
entre 0 e 255.
Quando os parâmetros de Color são floats podem tomar valores entre 0.0 e
1.0.
O construtor Font serve para especificar o nome da fonte, o estilo e o tamanho.
Font f = new Font(“Serif”, Font.BOLD|Font.ITALIC,POINT_SIZE); g.setFont(f);

Em resumo, podemos desenhar figuras como linhas, ovais e rectângulos

usando métodos da classe Graphics.
Podemos especificar a cor de cada figura usando o método setColor da classe
Graphics.
Podemos definir cores personalizadas usando a classe Color.
As cores são definidas usando o sistema RGB (Red/Green/Blue).
Podemos adicionar texto aos gráficos desenhados usando o método
drawString da classe Graphics.
Podemos definir a fonte e o tamanho do texto a escrever usando drawString
com o método setFont da classe Graphics.

Eventos da interface gráfica

Um componente gráfico qualquer pode reconhecer alguma acção do utilizador
e a partir dela disparar um evento — indicando, por exemplo: o botão do rato
foi pressionado ou que um texto foi modificado — que será capturado por um
objecto registado especificamente para registar aquele tipo de evento ocorrido
naquele componente.

O pacote java.awt.event define as diversas classes de eventos que podem

ocorrer através das interfaces gráficas. Eventos gráficos são objectos
derivados da classe AWTEvent, que por sua vez são derivados de objectos de
evento genéricos definidos pela classe EventObject. Destes, eventos gráficos
herdam o método getSource(), que permite identificar o objecto que deu origem
ao evento.
Eventos gráficos genéricos são especializados de acordo com o tipo de evento
sob consideração.
— Por exemplo, pressionar o botão do rato gera um objecto da classe
MouseEvent.
A mesma acção sobre um botão, no entanto, gera também um ActionEvent,
enquanto que sobre o botão de minimizar na barra de título de um frame um
WindowEvent seria ao invés adicionalmente gerado.
Outros eventos de interesse definidos em java.awt.event incluem ItemEvent,
indicando que um item de uma lista de opções foi seleccionado; TextEvent,
quando o conteúdo de um componente de texto foi modificado; e KeyEvent,
quando alguma tecla foi pressionada no teclado.
A resposta que uma aplicação dá a qualquer evento que ocorre em algum
componente gráfico é determinada por métodos específicos, registados para
responder a cada evento. O nome e a assinatura de cada um desses métodos
é determinada por uma interface Java do tipo listener. Assim, para responder a
um ActionEvent será utilizado o método definido na interface ActionListener.
Para responder a um WindowEvent, os métodos de WindowListener.
Similarmente, há interfaces ItemListener, TextListener e KeyListener. Os
eventos do rato são manipulados através de métodos especificados em duas
interfaces, MouseListener (para acções sobre o rato) e MouseMotionListener
(para tratar movimentos realizados com o rato).
Apesar de existir um grande número de eventos e possibilidades de resposta
que a aplicação poderia dar a cada um deles, cada aplicação pode especificar
apenas aqueles para os quais há interesse que sejam tratados.
Para os eventos que o programador da aplicação tem interesse de oferecer
uma reacção, ele deve definir classes manipuladoras de eventos (handlers),
implementações de cada listener correspondente ao tipo de evento de
interesse.
Para interfaces listener que especificam diversos métodos, classes
adaptadoras são definidas.
Essas classes adaptadoras são classes abstractas definidas no pacote de
eventos AWT, com nome XX- XAdapter, onde XXX seria o prefixo
correspondente ao tipo de evento de interesse. Assim, para que a aplicação
use uma classe adaptadora para tratar os eventos do tipo WindowEvent, por
exemplo, uma classe que estende a classe WindowAdapter pode ser definida.
Nessa classe derivada, os métodos relacionados aos eventos de interesse são
redefinidos (pelo mecanismo de overriding). Como a classe adaptadora
implementa a interface correspondente WindowListener, assim o fará a classe
derivada. Os métodos não redefinidos herdarão a definição original, que
simplesmente ignora os demais eventos.
A API de eventos AWT de Java define, além de WindowAdapter, as classes
adaptadoras MouseAdapter, MouseMotionAdapter e KeyAdapter.

Manipuladores de eventos de baixo nível

Eventos do rato que são tratados pelos métodos definidos em dois listeners
distintos definidos em java.awt.event. A interface MouseListener específica os
métodos para os eventos de maior destaquem na interacção do utilizador com
o rato. A classe abstracta MouseAdapter oferece implementações vazias para
todos esses métodos.
Um objecto associado a um evento do rato descreve eventos notáveis
ocorridos com o rato, como o facto de ter entrado ou saído na área de interesse
(uma janela, tipicamente), um “clique” ocorrido, se alguma tecla de modificação
(ALT, SHIFT ou CONTROL) estava pressionada e a posição na qual o evento
ocorreu.
A interface MouseMotionListener especifica métodos para manipular eventos
de movimentação do rato. A classe abstracta MouseMotionAdapter é uma
classe adaptadora para esse listener. Nesse caso, qualquer movimentação do
rato é relatada, diferenciando entre eventos da forma MOUSE_MOVED, para
movimentos com o rato livre, e MOUSE_DRAGGED, para movimentos do rato
com algum botão pressionado.

A interface KeyListener especifica os métodos necessários para detectar e

tratar eventos de teclado. São eles: keyPressed(), para indicar que a tecla foi
pressionada; keyReleased(),para indicar que a tecla foi solta; e keyTyped(),
para indicar que uma tecla que não de controle foi pressionada e solta. Todos
os métodos recebem um objecto KeyEvent como parâmetro. Esse objecto
indica o tipo de evento ocorrido (KEY_PRESSED, KEY_TYPED ou
KEY_RELEASED), o código da tecla e se havia modificadores associados.
Como essa interface listener especifica mais de um método, uma classe
adaptadora, KeyAdapter, é oferecida.

Manipuladores de eventos de alto nível

Raramente uma aplicação está preocupada em tratar eventos no nível tão
básico como qualquer movimento do rato ou tecla pressionada.
O Java oferece um conjunto de funcionalidades que filtram esses eventos para
outros mais próximos da visão da aplicação, como o pressionar de um botão ou
entrar texto em um campo.
A interface ActionListener especifica o método actionPerformed() para tratar
eventos do tipo acção. Objectos da classe ActionEvent representam eventos
associados a uma acção aplicada a algum componente AWT.
Uma descrição (na forma de uma string) da acção pode ser obtida através do
método getActionCommand(). Dessa forma, se mais de um componente
compartilha um mesmo listener, esse método permite diferenciar qual
componente foi o gerador da acção.
Outro atributo que está representado em um objecto evento diz respeito aos
modificadores, teclas que podem estar apertadas simultaneamente à
ocorrência do evento para requisitar um tratamento alternativo. A classe
ActionEvent define o método getModifiers(), que retorna um valor inteiro que
pode ser analisado em relação a quatro constantes da classe, ALT_MASK,
CTRL_MASK, META_MASK e SHIFT_MASK.
Um objecto de uma classe que implemente ActionListener deve ser associado
a um componente através do método addActionListener(), que é definido para
componentes do tipo botão, listas e campos de texto.
Quando um evento desse tipo ocorre, o objecto registado é notificado. O
método actionPerformed() é então invocado, recebendo como argumento o
objecto que representa o evento.

Eventos associados à manipulação de janelas são definidos na interface

WindowListener. Essa interface específica os seguintes métodos:
 windowOpened(): trata-se um evento que é apenas gerado quando a
janela é criada e aberta pela primeira vez.
 windowClosing(): o utilizador solicitou que a janela fosse fechada, seja
através de um menu do sistema ou através de um botão da barra de
títulos ou através de uma sequência de teclas do sistema.
 windowClosed(): trata evento que indica que a janela foi fechada.
 windowIconified(): trata evento que indica que janela foi iconificada.
  windowDeiconified(): trata evento indicando que o ícone da janela foi
aberto.
 windowActivated(): trata evento que indica que a janela ganhou o foco
do teclado e tornou-se a janela activa.

Conclusão

Tudo o que aprendi neste módulo ajudou-me a compreender um pouco da

linguagem Java.
Já tinha umas bases da linguagem de programação C. Mas achei a linguagem
Java mais complexa, mas mais fácil de entender.