INSTITUTO TECNOLÓGICO SUPERIOR DE IRAPUATO

ENGENHARIA EM SISTEMAS COMPUTACIONAIS

INTRODUÇÃO À ENGENHARIA EM SISTEMAS

COMPUTACIONAIS

TEMA: PROGRAMACIÓN JAVA

RIVERA MUÑOZ JESÚS RAMÓN IS09110255

MAESTRA: MARIANA RICO CHAGOLLAN

IRAPUATO, GTO. 13 DE SEPTIEMBRE DE 2010

Conteúdo
Contenido............................................................................................................i
Historia del lenguaje Java...................................................................................3
Programação Java..............................................................................................5
Comentarios.......................................................................................................6
Identificadores....................................................................................................6
Palavras-chave....................................................................................................7
Literales..............................................................................................................7
Matrizes.................................................................................................8
Operadores.........................................................................................................9
Separadores.....................................................................................................10
Clases y objetos...............................................................................................10
Atributos...........................................................................................................11
Comportamiento..............................................................................................11
O projeto.......................................................................................................11
A aula............................................................................................................12
Os membros dado...........................................................................................12
As funções membro....................................................................................13
Os construtores.............................................................................................16
Os objetos.......................................................................................................17
Acesso aos membros.....................................................................................18
A vida de um objeto.........................................................................................19
Identificadores..................................................................................................21
BIBLIOGRAFIA...................................................................................................22

eu
PROGRAMACÃO EM JAVA
História da linguagem Java

Java é uma linguagem de programação orientada a objetos desenvolvida pela Sun

Microsistemas no início dos anos 90.

Em dezembro de 1950, Patrick Naughton, engenheiro da Sun Microsystems, recrutou

a vários colegas entre eles James Gosling e Mike Sheridan para trabalhar sobre um
nuevo proyecto conocido como"El proyecto verde".
Com a ajuda de outros engenheiros, começaram a trabalhar em um pequeno escritório
en Sand Hill Road em Menlo Park, Califórnia. E assim interrompeu todas as
comunicações regulares com a Sun e trabalhou sem descanso durante 18 meses.

Tentavam desenvolver uma nova tecnologia para programar o próximo

geração de dispositivos inteligentes, nos quais via um novo campo a
explorar. Criar uma linguagem de programação fácil de aprender e de usar.
No início, considerava-se C++ como a linguagem a ser utilizada, mas tanto Gosling
como Bill Joy o encontraron inadecuado. Gosling tentou primeiro extender e
modificarC++resultando o linguagemC++ ++ -(++ - porque se adicionavam e
eliminavam características do C++), mas abandonou para criar uma nova linguagem
desde cero ao que chamo Oak (carvalho em inglês, segundo a versão mais aceita, por
o carvalho que via através da janela de seu escritório).

O resultado foi uma linguagem que tinha semelhanças com C, C++ e Objective C que
não estava ligado a um tipo concreto de CPU.
Mais tarde, o nome de Oak seria mudado para Java, por questões de propriedade.
intelectual, ao já existir uma linguagem com o nome de Oak. Supõe-se que lhe
puseram esse nome enquanto tomavam café (Java é o nome de um tipo de café,
originario de Asia), aunque otros afirman que el nombre deriva de las siglas de
James Gosling, Arthur Van Hoff e Andy Bechtolsheim.

Em agosto de 1991, a Oakya executava seus primeiros programas.

Para 1992, a equipe já havia desenvolvido um sistema em um protótipo chamado

Star7 (*7), dispositivo parecido a uma PDA, cujo nome vinha da combinação
de teclas do telefone do escritório do Projeto Green que permitia aos usuários
atender o telefone de qualquer lugar.

Por su parte, el presidente de la compañía Sun,Scott McNealy, se dio cuenta de

forma oportuna e estabeleceu o Projeto Verde como uma subsidiária da Sun.

Depois de mostrar a Scott McNealy e Bill Joy os protótipos de baixo nível do

sistema, continuam com o desenvolvimento, incluindo sistema operativo, Green OS; o
linguagem Oak, as bibliotecas, alguma aplicação básica e o hardware, até que o3
de setembro de 1992 termina o desenvolvimento e com isso o Projeto Verde.

De 1993 a 1994, o time de Naughton se lançou em busca de novas

oportunidades no mercado, as quais foram surgindo através do sistema
operativo base.

3
A subsidiária incipiente fracassou em suas tentativas de ganhar uma oferta com a Time-
Warner, no entanto, a equipe concluiu que o mercado para consumidores
eletrônicos inteligentes e as caixas Set-Up em particular, não eram totalmente eficazes. A
subsidiaria Proyecto verde fue amortizada por la compañía Sun a mediados de
1994.

Felizmente, o término do Projeto Verde coincidiu com o nascimento do

fenómeno mundialWEB. Ao examinar as dinâmicas da Internet, o que foi feito pelo
o ex equipe verde se adequava a este novo ambiente.

Patrick Naughton iniciou a construção da linguagem de programação Java

que se acionava com um navegador protótipo. Em 29 de setembro de 1994 se
finaliza o desenvolvimento do protótipo do HotJava. Quando a demonstração é feita a
os executivos da Sun, desta vez, reconhecem o potencial do Java e aceitam o
projeto.

Com o passar do tempo, o HotJava se tornou um conceito prático dentro do

linguagem Java e demonstrou que poderia fornecer multiplataformas para que o
código possa ser baixado e executado do Host da Rede Mundial de Computadores e que de outra
forma no são seguros.
Uma das características do HotJava foi seu suporte para os "applets", que são
as partes do Java que podem ser carregadas através de uma rede de trabalho para
depois executá-lo localmente e assim alcançar soluções dinâmicas em computação
acordes ao rápido crescimento do ambiente WEB.

Em 23 de maio de 1995, na conferência SunWorld `95, John Gage, da Sun

Microsistemas, yMarc Andreessen, cofundador e vice-presidente do Netscape,
anunciaban la versión alpha de Java, que en ese momento solo corría en Solaris,
e o fato de que o Java iria ser incorporado no Netscape Navigator, o
navegador mais utilizado da Internet.

Com a segunda alfa do Java em Julho, é adicionado o suporte para Windows NT.
na terceira, em Agosto, para Windows 95.
Em janeiro de 1995, a Sun forma a empresa Java Soft para se dedicar ao desenvolvimento de
produtos baseados nas tecnologias Java, e assim trabalhar com terceiros
para criar aplicações, ferramentas, sistemas de plataforma e serviços para
aumentar as capacidades da linguagem. Nesse mesmo mês aparece a versão 1.0
do JDK.

A Netscape Communications decide apoiar os applets Java no Netscape Navigator

2.0. Esse foi o fator chave que lançou o Java para ser conhecido e famoso.
E como parte de sua estratégia de crescimento global e para favorecer a
promoción de la nueva tecnología, Java Soft otorgó permisos para otras
companhias para que pudessem ter acesso ao código-fonte e ao mesmo tempo
melhorar seus navegadores.
Também permitia criar ferramentas de desenvolvimento para programação Java e
os facultava para acondicionar máquinas virtuais Java (JVM), a vários sistemas
operativos.

4
Muito em breve, as licenças ou permissões contemplavam firmas prestigiadas como: IBM,
Microsoft, Symantec, Silicon Graphics, Oracle, Toshiba y Novell.

Os applets Java (baseados no JDK 1.02) são suportados pelos dois mais populares
navegadores web(Nestcape Navigator 3.0 y Microsoft Internet Explorer 3.0.
I.B.M./Lotus, Computer Associados, Symantec, Informix, Oracle, Sybase e outros
poderosas empresas de software estão construindo Software 100% puro JAVA,
por exemplo o Corel Office que atualmente está na versão Beta.

Os novos projetos de Javason co-patrocinados por centenas de milhões de

dólares en capital disponible de recursos tales como laFundación Java, un fondo
comum de capital formado no verão passado por 11 companhias, incluindo a Cisco
Sistemas, IBM, Netscape e Oracle.

Hoje em dia, você pode encontrar a tecnologia Java em redes e dispositivos que
comprendem desde a Internet e supercomputadores científicos até notebooks e
celulares; desde simuladores de mercado em Wall Street até jogos de
uso doméstico e cartões de crédito: Java está em todo lugar.

Programação Java

A linguagem para a programação em Java é uma linguagem orientada a objetos,

uma plataforma independente.

A linguagem para programação em Java foi desenvolvida pela empresa Sun.

Microssistemas, com a ideia original de usá-lo para a criação de páginas WEB.

Esta programação Java tem muitas semelhanças com a linguagem C e C++, assim
que se tiver conhecimento deste idioma, o aprendizado da programação
Java será de fácil compreensão por um programador que tenha realizado
programas nesses idiomas.

Com a programação em Java, é possível realizar diferentes aplicativos, como são

applets, que são aplicações especiais, que são executadas dentro de um
navegador ao ser carregada uma página HTML em um servidor WEB, Por geral
os applets são programas pequenos e de propósitos específicos.

Otra de las utilidades de la programación en Java es el desarrollo de aplicaciones,

que son programas que se ejecutan en forma independiente, es decir con la
programação Java, podem ser criadas aplicações como um processador de
palavras, uma folha que sirva para cálculos, uma aplicação gráfica, etc. em
resumo qualquer tipo de aplicação pode ser realizado com ela. Java permite a
modularidade, pois podem ser feitas rotinas individuais que sejam usadas por
mais de uma aplicação, por exemplo, temos uma rotina de impressão que pode
servir para o processador de palavras, como para a folha de cálculo.

5
A programação em Java permite o desenvolvimento de aplicações sob o esquema
de Cliente Servidor, como de aplicações distribuídas, o que o torna capaz de
conectar dois ou mais computadores, executando tarefas
simultaneamente, e desta forma consegue distribuir o trabalho a ser realizado.

Comentarios

Em Java, existem três tipos de comentários:

// comentarios para una sola línea

/* comentários de uma o */
mais linhas
*/

/** comentário de documentação, de uma ou mais linhas */

*/

Os dois primeiros tipos de comentários são os que todo programador conhece e se

utilizam da mesma forma. Os comentários de documentação, colocados
imediatamente antes de uma declaração (de variável ou função), indicam que esse
comentario ha de ser colocado en la documentación que se genera
automaticamente quando se utiliza a ferramenta de Java, javadoc. Ditios
comentarios sirven como descripción del elemento declarado permitiendo generar
una documentación de nuestras clases escrita al mismo tiempo que se genera el
código.

En este tipo de comentario para documentación, se permite la introducción de

alguns tokens ou palavras-chave, que farão com que a informação que se segue
apareça de forma diferente ao resto na documentação.

Identificadores
Os identificadores nomeiam variáveis, funções, classes e objetos; qualquer coisa que o
programador precisa identificar ou usar.

Em Java, um identificador começa com uma letra, um sublinhado (_) ou um símbolo

de dólar ($). Os seguintes caracteres podem ser letras ou dígitos. Eles são distintos.
as maiúsculas das minúsculas e não há comprimento máximo.

Serían identificadores válidos:

identificador
nombre_usuario
Nombre_Usuario
_variável_do_sistema
$transaccion

6
e seu uso seria, por exemplo:

int contador_principal;
char _lista_de_ficheiros;
float $quantidade_em_Ptas;

Palavras-chave

As seguintes são as palavras-chave que estão definidas em Java e que não são
podem ser utilizados como identificadores:

resumo continua para novo interruptor

booleano padrão ir null síncrono
quebrar faça se embalar isso
byte duplo implementa privado seguro para threads
por valor senão importar protegido lançar
caso estende instância de pública transiente
pegar falso int retornar verdadeiro
caracterefinal interface curta tentar
classe finalmente longo estático vazio
const flutuante nativo super enquanto

Palabras Reservadas
Além disso, a linguagem reserva algumas palavras a mais, mas que até agora
não têm um cometido específico. São:

elenco futuro genérico interno

operador externo rest var

Literais

Um valor constante em Java é criado utilizando uma representação literal dele.

Java utiliza cinco tipos de elementos: inteiros, reais em ponto flutuante, booleanos,
caracteres e strings, que podem ser colocados em qualquer lugar do código fonte
de Java. Cada um desses literais tem um tipo correspondente associado com
ele.

Enteros:

byte 8 bits complemento a dos

curto 16 bits complemento a dos
int 32 bits complemento a dois
longo 64 bits complemento a dos
For example: 21 077 0xDC00

Reais em ponto flutuante:

7
 flutuar 32 bits IEEE 754
duplo 64 bits IEEE 754
Por ejemplo: 3.14 2e12 3.1E12

Booleanos:

verdadeiro
falso

Caracteres:

For example: a \t ???? [????] é um número unicode

Cadenas:

Por ejemplo: Isto é uma cadeia literal

Arrays
Em Java, é possível declarar arrays de qualquer tipo:

char s[];
int iArray[];

Incluso se pueden construir arrays de arrays:

int tabla[][] = new int[4][5];

Los límites de los arrays se comprueban en tiempo de ejecución para evitar

desbordamentos e a corrupção da memória.

Em Java, um array é realmente um objeto, pois o operador [] está redefinido.

Tem uma função membro: length. Este método pode ser utilizado para conhecer a
longitud de cualquier array.

int a[][] = new int[10][3];

[Link]; /* 10 */
a[0].comprimento; /* 3 */

Para criar um array em Java, existem dois métodos básicos. Criar um array vazio:

int lista[] = new int[50];

ou pode-se criar já o array com seus valores iniciais:

String nombres[] = {
"Juan","Pepe","Pedro","Maria"
};

Isso que é equivalente a:

String nomes[];

8
 nombres = new String[4];
nombres[0] = new String( "Juan" );
nombres[1] = new String( "Pepe" );
nombres[2] = new String( "Pedro" );
nombres[3] = new String( "Maria" );

Não é possível criar arrays estáticos em tempo de compilação:

int lista[50]; // gerará um erro em tempo de compilação

Tampoco não se pode preencher um array sem declarar o tamanho com o operador new:

int lista[];
para( int i=0; i < 9; i++ )
lista[i] = i;

Es decir, todos los arrays en Java son estáticos. Para convertir un array en el
equivalente a um array dinâmico em C/C++, usa-se a classe vector, que permite
operaciones de inserción, borrado, etc. en el array.

Operadores
Os operadores de Java são muito semelhantes em estilo e funcionamento aos de C. Na
na tabela a seguir aparecem os operadores que são utilizados em Java, por ordem de
precedencia:

. [] ()
++ --
! ~ instância de
* / %
+ -
<< >> >>>
< > <= >= == !=
& ^ |
&& ||
? :
= op= (*= /= %= += -= etc.) ,

Los operadores numéricos se comportan como esperamos:

int + int = int

Os operadores relacionais retornam um valor booleano.

Para as cadeias, podem-se usar os operadores relacionais para

comparaciones además de + y += para la concatenación:

String nombre = "nombre" + "Apellido";

9
O operador = sempre faz cópias de objetos, marcando os antigos para
apagá-los, e o coletor de lixo se encarregará de devolver ao sistema a
memória ocupada pelo objeto eliminado.

Separadores
Sólo há um par de sequências com outros caracteres que podem aparecer no código
Java; são os separadores simples, que vão definir a forma e função do código. Os
separadores admitidos em Java são:

() - parênteses. Para conter listas de parâmetros na definição e chamada a

métodos. También se utiliza para definir precedencia en expresiones, contener
expressões para controle de fluxo e cercar as conversões de tipo.

{} - chaves. Para conter os valores de matrizes inicializadas automaticamente.

Também é utilizado para definir um bloco de código, para classes, métodos e
ámbitos locais.

[]- colchetes. Para declarar tipos matriz. Também é utilizado quando se

referenciam valores de matriz.

;- ponto e vírgula. Separa sentenças.

,- coma. Separa identificadores consecutivos em uma declaração de variáveis.

Também é utilizado para encadear sentenças dentro de uma sentença for.

.- ponto. Para separar nomes de pacote de subpacotes e classes. Também se

utiliza para separar uma variável ou método de uma variável de referência.

Classes e objetos

Quando se escreve um programa em uma linguagem orientada a objetos, definimos

uma plantilla ou classe que descreve as características e o comportamento de um
conjunto de objetos similares. A classe automóvel descreve as características
comuns de todos os automóveis: seus atributos e seu comportamento. Os
atributos ou propriedades referem-se à marca ou fabricante, à cor, às
dimensões, se têm duas, três, quatro ou mais portas, a potência, se utiliza como
combustível a gasolina ou gasóleo, etc. O comportamento refere-se à possibilidade
deslocar-se por uma estrada, frear, acelerar, mudar de marcha, virar, etc.

Depois, temos automóveis concretos, por exemplo, o automóvel próprio de uma

determinada marca, cor, potência, etc., o automóvel do vizinho de outra marca,
de outra cor, etc., o automóvel de um amigo, etc.

10
Uma classe é, portanto, um template implementado em software que descreve um
conjunto de objetos com atributos e comportamentos semelhantes.

Una instancia u objeto de una clase es una representación concreta y específica

de uma classe e que reside na memória do computador.

Atributos

Os atributos são as características individuais que diferenciam um objeto do outro

e determinam sua aparência, estado ou outras qualidades. Os atributos são armazenados
em variáveis denominadas de instância, e cada objeto particular pode ter
valores distintos para estas variáveis.

As variáveis de instância, também chamadas de membros de dados, são declaradas

na classe, mas seus valores são fixados e alterados no objeto.

Além das variáveis de instância, existem variáveis de classe, as quais se aplicam

à classe e a todas as suas instâncias. Por exemplo, o número de rodas de um
o automóvel é o mesmo quatro, para todos os automóveis.

Comportamento

O comportamento dos objetos de uma classe é implementado por meio de funções

membro ou métodos. Um método é um conjunto de instruções que realizam uma
tarefa determinada e são similares às funções das linguagens estruturadas.

Da mesma forma que existem variáveis de instância e de classe, também existem métodos
de instância e de classe. No primeiro caso, um objeto chama um método para
realizar uma determinada tarefa, no segundo, o método é chamado a partir do próprio
classe.

El proyecto

O projeto consiste em dois arquivos, o primeiro contém a classe Retângulo que

se guarda no arquivo [Link] e não tem o métodomain. A última
caixa do assistente de criação de classes Novo Arquivo Java deve estar
desativada.

A outra classe é a que descreve a aplicaçãoRectanguloApp1 e é salva no

archivo [Link], esta clase tiene que tener el métodomain, por lo

11
tanto, a última caixa do assistente de criação de classes New Java File deve de
estar ativada.

Un proyecto puede constar de varias clases (normalmente se sitúa cada clase en

um arquivo) mas apenas um tem o métodomainy representa a aplicação.
Para distinguir a classe que descreve a aplicação das demais, adicionamos-lhe
el sufijoApp.

rectangulo1: [Link], [Link]

A classe

Para criar uma classe, utiliza-se a palavra reservada class e a seguir o

nombre de la clase. La definición de la clase se pone entre las llaves de apertura
e fechamento. O nome da classe começa com letra maiúscula.

classe Retangulo{
//membros dado
//funciones miembro
}

Os membros dado

Os valores dos atributos são armazenados nos membros de dados ou variáveis de

instância. Os nomes dessas variáveis começam com letra minúscula.

Vamos criar uma classe chamada Retangulo, que descreva as

características comuns a estas figuras planas que são as seguintes:

• El origen del rectángulo: el origen o posición de la esquina superior izquierda del

retângulo no plano determinado por dois números inteiros x e y.
• Las dimensiones del rectángulo:anchoyalto, otros dos números enteros.

classe Rectangulo{
int x;

12
 int y;
int largura;
int alto;
//faltam as funções membro
}

As funções membro

Em C++, as funções membro são declaradas, definidas e chamadas. Em

o linguagem Java, as funções membro ou métodos somente são definidos e são
chamam.

O nome das funções membro ou métodos começa com letra minúscula e

devem sugerir ações (mover, calcular, etc.). A definição de uma função tem
o seguinte formato:

tipo nomeFuncao (tipo parm1, tipo parm2, tipo parm3){

//...sentenças
}

Entre as chaves de abertura e fechamento se coloca a definição da função. Tipo

indica o tipo de dado que pode ser predefinido int, double, etc., ou definido pelo
usuário, uma classe qualquer.

Para chamar uma função membro ou método, escreve-se

retorno=[Link](arg1, arg2, arg3);

Quando a função é chamada, os argumentos arg1, arg2, arg3 são copiados nos
parâmetros parm1, parm2, parm3 e as instruções são executadas dentro da
função. A função termina quando se chega ao final do seu bloco de definição ou
quando encontra uma instrução return.

Quando a função é chamada, o valor retornado pela instrução return é

atribua à variavelretorno.

Quando uma função não retorna nada, diz-se que é do tipo void. Para chamar a
função, se escreve

[Link](arg1, arg2, arg3);

Estudaremos mais adiante com mais detalhes como as funções são definidas.

Uma função geralmente termina quando chega ao final do bloco de sua definição

void funcao(....){
//sentencias...
}

13
Uma função pode finalizar antes de chegar ao final de sua definição

void funcao(....){
//sentenças...
se(condicion) retornar;
//sentenças..
}

Una función puede devolver un valor (un tipo de dato primitivo o un objeto).

double funcao(....){
double soma=0.0;
//sentenças...
retornar soma;
}

Qualquer variável declarada dentro da função tem uma vida útil temporária,
existindo na memória, enquanto a função estiver ativa. Trata-se de variáveis
locais para a função. Por exemplo:

void nomeFuncao(int parm){

//...
int i=5;
//...
}

A variável parm existe desde o início até o final da função. A variável

locali, existe desde o ponto de sua declaração até o final do bloco da
função.

Deve-se ter em mente que as funções membro têm acesso aos

membros dados, portanto, é importante no design de uma classe decidir o que
as variáveis são membros de dados, quais variáveis são locais às funções membro,
e que valores passamos a essas funções. Os exemplos nos ajudarão a
entender esta distinção.

Definimos os atributos ou membros de dados da classe Retangulo, agora lhe

vamos añadir un comportamiento: los objetos de la claseRectanguloo
retângulos saberão calcular sua área, terão capacidade para se deslocar para outro
punto del plano, sabrán si contienen en su interior un punto determinado del
plano.

A função que calcula a área realizará a seguinte tarefa, calculará o produto

do largura pela altura do retângulo e retornará o resultado. A função retorna
Um inteiro é, portanto, do tipo int. Não é necessário passar dados para ele, pois tem
acesso aos membros dadoanchoaltoque guardam a largura e a altura de um
retângulo concreto.

classe Retangulo{
int x;
int y;
int largura;
int alto;
int calcularArea(){

14
 retornar (largura * altura);
}
}

A função que desloca o retângulo horizontalmente endx e verticalmente em

dy, le passamos dichos deslocamentos, e a partir destes dados atualizará os
valores que guardam seus membros datoxey. A função não retorna nada é de
tipovoid.

classe Retangulo{
int x;
int y;
int largura;
int alto;
void desplazar(int dx, int dy){
x += dx;
y += dy;
}
}

A função que determina se um ponto está ou não dentro do retângulo,

devolverá verdadeiro se o ponto estiver dentro do retângulo e devolverá
falsesi não se encontra, ou seja, será uma função do tipo booleano. A função
você precisará conhecer as coordenadas desse ponto. Para que um ponto de
coordenadasx1ey1está dentro de um retângulo cujo origen éxey, e cujas
dimensões sonanchoyalto, deverá cumprir ao mesmo tempo quatro condições

x1>xy ao mesmo tempo x1<x+largura

Também deve ser cumprido

y1>yy ao mesmo tempo y1<y+alto

Como se têm que cumprir as quatro condições ao mesmo tempo, elas se unem mediante o
operador lógico AND simbolizado por&&.

classe Retângulo{
int x;
int y;
int largura;
int alto;
boolean estaDentro(int x1, int y1){
se((x1>x)&&(x1<x+ancho)&&(y1>y)&&(y1<y+ancho)){
retornar verdadeiro;

}
retornar falso;
}
}

Na linguagem Java, se a primeira condição for falsa, as restantes não são avaliadas.
expresiones ya que el resultado esfalse. Ahora bien, si la primera es verdadera
verdadeiro, passa-se a avaliar a segunda, se esta for falsa o resultado é falso, e assim por diante
sucessivamente.

15
Os construtores

Um objeto de uma classe é criado chamando uma função especial denominada

construtor da classe. O construtor é chamado automaticamente quando se
crea un objeto, para situarlo en memoria e inicializar los miembros dato
declarados na classe. O construtor tem o mesmo nome que a classe. O
específico do construtor é que não tem tipo de retorno.

classe Retângulo{
int x;
int y;
int largura;
int alto;
Retangulo(int x1, int y1, int w, int h){
x=x1;
y=y1;
ancho=w;
alto=h;
}
}

O construtor recebe quatro números que guardam os parâmetros x1, y1, wyh, e
com eles inicializa os membros datox,y,anchoyalto.

Uma classe pode ter mais de um construtor. Por exemplo, o seguinte

O construtor cria um retângulo cujo origem está no ponto (0, 0).

classe Rectangulo{
int x;
int y;
int largura;
int alto;
Retângulo(int w, int h){
x=0;
y=0;
ancho=w;
alto=h;
}
}

Este construtor cria um retângulo de dimensões nulas situado no ponto (0,

0),

classe Retangulo{
int x;
int y;
int largura;
int alto;
Retângulo(){
x=0;
y=0;
ancho=0;

16
 alto=0;
}
}

Con estas porciones de código definimos la clase, y la guardamos en un archivo

que tenha o mesmo nome que a classe Retângulo e com extensão .java.

public class Rectangulo {

int x;
int y;
int largura;
int alto;
public Rectangulo() {
x=0;
y=0;
ancho=0;
alto=0;
}
public Rectangulo(int x1, int y1, int w, int h) {
x=x1;
y=y1;
ancho=w;
alto=h;
}
public Rectangulo(int w, int h) {
x=0;
y=0;
ancho=w;
alto=h;
}
int calcularArea(){
retornar (largura * altura);
}
void desplazar(int dx, int dy){
x += dx;
y+=dy;
}
boolean estaDentro(int x1, int y1){
se((x1>x)&&(x1<x+ancho)&&(y1>y)&&(y1<y+ancho)){
retornar verdadeiro;

}
retornar falso;
}
}

Os objetos

Para criar um objeto de uma classe usa-se a palavra reservada new.

For example,

Retângulo rect1=newRetângulo(10, 20, 40, 80);

17
nova reserva de espaço na memória para os membros dado e retorna um
referência que é guardada na variável rect1 do tipo Retângulo que
denominamos agora objeto. Dita sentença cria um objeto denominado rect1de
a classe Retângulo chamando o segundo construtor na lista. O retângulo
estará situado no ponto de coordenadas x=10, y=20; terá uma largura de
ancho=40 e uma altura de 80.

Retângulo rect2 = novoRetângulo(40, 80);

Crea un objeto denominadorect2de la claseRectangulollamando al tercer

construtor, o referido retângulo estará situado no ponto de coordenadas x=0, y=0;
e terá uma largura de 40 e uma altura de 80.

Retângulo rect3=newRetângulo();

Crea un objeto denominadorect3de la claseRectangulollamando al primer

construtor, o referido retângulo estará situado no ponto de coordenadas x=0, y=0;
y tendrá una anchura deancho=0 y una altura dealto=0.

Acesso aos membros

Desde um objeto pode-se acessar os membros por meio da seguinte sintaxe

[Link];

Por exemplo, podemos acessar o membro dadoancho, para mudar a largura

de um objeto retangular.

[Link]=100;

O retângulo rect1 que tinha inicialmente uma largura de 40, através deste
sentença se a mudarmos para 100.

Desde um objeto chamamos as funções membro para realizar uma determinada

tarefa. Por exemplo, a partir do retângulo rect1 chamamos a função calcularArea
para calcular a área desse retângulo.

[Link]();

A função membroareadevuelve um inteiro, que vamos guardar em uma variável

enteramedidaArea, para depois usar este dado.

int medidaArea=[Link]();
[Link]("A área do retângulo é " + medidaArea);

Para deslocar o retângulo rect2, 10 unidades para a direita e 20 para cima.

abaixo, escreveremos

[Link](10, 20);

18
Podemos verificar mediante el siguiente código si el punto (20, 30) está en el
interior do retângulo rect1.

se([Link](20,30)){
[Link]("O ponto está dentro do retângulo");
}else{
[Link]("O ponto está fora do retângulo");
}

[Link]() devolve verdadeiro se o ponto (20, 30) que é passado para essa função
membro está dentro do retângulo rect1, executando o primeiro
sentença, caso contrário, a segunda é executada.

Como veremos mais adiante, nem sempre é possível acessar os membros, se

estabelecemos controles de acesso aos mesmos.

classe pública RectanguloApp1 {

public static void main(String[] args) {
Rectangulo rect1=new Rectangulo(10, 20, 40, 80);
Rectângulo rect2=new Rectângulo(40, 80);
Rectangulo rect3=new Rectangulo();
int medidaArea=[Link]();
[Link]("A área do retângulo é " + medidaArea);

[Link](10, 20);

se([Link](20,30)){
[Link]("O ponto está dentro do retângulo");
}else{
[Link]("O ponto está fora do retângulo");
}
}
}

La vida de un objeto

No linguagem C++, os objetos que são criados com new devem ser deletados com
[Link] espaço em memória para o objeto e delete libera tal.
memória. Na linguagem Java, não é necessário liberar a memória reservada, o
o coletor de lixo se encarrega de fazer isso por nós,
liberando o programador de uma das tarefas que mais dor de cabeça lhe dá
produzem, esquecer-se de liberar a memória reservada.

Vamos ver um exemplo

classe pública UmaClasse {

public static void main(String[] args) {
Imagem granImagen=criaImagem();
mostrar(graImagen);
enquanto(condicion){
calcular();

19
 }
}
}

O objeto granImagen continua na memória até que se atinja o final do

função principal, embora seja necessário apenas até o loop while. Em C ou em C+
+ eliminaríamos dito objeto liberando a memória que ocupa mediante delete.
equivalente em Java é o de atribuir ao objeto grandeImagem o valor null.

classe pública UnaClase {

public static void main(String[] args) {
Imagem granImagen=criaImagem();
mostrar(graImagen);
granImagen=null;
enquanto(condicion){
calcular();
}
}
}

A partir da sentença marcada em letra negrita, o coletor de lixo se

encarregará de liberar a memória ocupada por dicha imagem. Assim sendo, será atribuído
o valor nulo remove as referências a objetos temporais que ocupam muita memória
tan pronto como no sean necesarios.

Criamos dois objetos da classe retângulo, da mesma forma que na seção

anterior

Rectângulo rect1=newRectangulo(10, 20, 40, 80);

Rectângulo rect3=newRectangulo();

Se escrevemos

rect3=rect1;

Enrect3se guarda a referência ao objetorect1. A referência ao objetorect3se

perde. O coletor é responsável por liberar o espaço na memória ocupado por
objetorect3.

La destrucción de un objeto es una tarea (thread) de baja prioridad que lleva a

cabo a Máquina Virtual Java (JVM). Portanto, nunca podemos saber quando se
va a destruir un objeto.

Pode haver situações em que é necessário realizar certas operações que

no puede realizar el recolector de basura (garbage collector) cuando se destruye
um objeto. Por exemplo, vários arquivos foram abertos durante a vida de um
objeto, e deseja-se que os arquivos estejam fechados quando esse objeto
desaparece. Pode-se definir na classe um método denominado finalize que
realize esta tarefa. Este método é chamado pelo coletor de lixo
imediatamente antes de o objeto ser destruído.

20
Identificadores

Como se escrevem os nomes das variáveis, das classes, das funções,

etc., é um assunto muito importante para a compreensão e a manutenção
de código. En la introducción a los fundamentos del lenguaje Java hemos tratado
já dos identificadores.

O código deve ser o mais fácil de ler e entender possível.

Alguien que lea el código, incluso después de cierto tiempo, debe ser capaz de
entender lo que hace a primera vista, aunque los detalles internos, es decir, cómo
ele faz, preciso de um estudo detalhado.

Vemos primero un ejemplo que muestra un código poco legible y por tanto, muy
difícil de manter

classe pública Cuen{

private int ba;

Cuen(int ba){
[Link]=ba;
}
public void dep(int i){
ba+=i;
}
public boolean ret(int i){
se(ba>=i){
ba-=i;
retornar verdadeiro;

}
retornar falso;
}
public int get(){
retornar ba;
}
}

As abreviações utilizadas têm significado apenas para o programador

no momento de escrever o código, pois pode esquecer seu significado com
o tempo. Outros programadores do grupo têm que decifrar o significado do
nome de cada variável ou de cada função. O tempo extra que é gasto em
escribir con claridad el nombre de los diversos elementos que entran en el
programa, se ahorra más adelante durante su desarrollo, depuración, y mejora, es
dizer, durante todo o ciclo de vida do programa.

classe ContaBancaria{
private int saldo;
ContaBancaria(int saldo){
[Link]=balance;
}
public void depositar(int cantidad){
balance += quantidade;
}
public boolean retirar(int quantidade){
se(o saldo >= quantidade) {

21
 balance-=quantidade;
retornar verdadeiro;

}
retornar falso;
}
public int obterSaldo() {
retornar saldo;
}
}

Este é um programa simples de uma conta bancária. O tipo de dado pode ser
entero (intolong), se a unidade monetária tem pouco valor como a peseta, ou um
número decimal (double) se a unidade monetária for de grande valor como o Euro e
o Dólar.

El código de las funciones miembro es muy sencillo y su significado se hace

evidente ao ler o programa. A função retirar é do tipo booleano, já que não
(false) estamos autorizados a retirar una cantidad mayor que la existente en ese
momento no banco. No entanto, se (true) estivermos autorizados a retirar uma
quantidade menor do que a que temos na conta.

BIBLIOGRAFIA
[Link]

Hora de consulta: 14:35 p.m.

[Link]

Hora de consulta: 14:46.

[Link]

Hora de consulta: 14:51.

[Link]

Hora de consulta: 15:05.

22