|
Estrutura switch()
Exemplo:
Class Calculadora
{
public static void main ( String args[] )
{
int operacao = 3;
double op1, op2, res;
op1 = 10;
op2 = 0;
switch( operacao )
{
case 0: res= op1 + op2; break;
case 1:
if( op2 != 0 )
{
res= op1 / op2; break;
}
else
{
System.out.println(“Divisão por zero!”);
Res = 0; break;
}
default: res= -1;
}
System.out.println(“Resultado: “ + res );
}
class Math --- Métodos da classe:
Método ceil(): É utilizada para arredondar um número do tipo double para o seu próximo inteiro.
Sintaxe: Math.ceil ( valor do tipo double ).
Obs: O ( tipo double ) é o único que pode ser utilizado.
Método floor(): Arredonda um determinado número para o seu inteiro anterior.
Sintaxe: Math.floor ( valor do tipo double ).
Método max(): Utilizada para verificar o maior valor entre dois números que podem ser do tipo ( double, float, int ou long )
Sintaxe: Math.max ( valor1 , valor2 ),
Método min(): Utilizada para obter o valor mínimo entre dois números.
Sintaxe: Math.min ( valor1 , valor2 ).
Método sqrt(): Calcula a raiz quadrada de um determinado número.
Sintaxe: Math.sqrt ( valor do tipo double ).
Método pow(): Eleva um número ao quadrado ou a qualquer outro valor de potência.
Sintaxe: Math.pow( valor da base , valor da potência ).
Exemplo:
class Exemplo1
{
public static void main ( args[] )
{
double base=5.5 , potencia=2;
System.out.println("5.5 elevado a 2 = "+ Math.pow( base,potencia ) );// 30.25
System.out.println("25 elevado a 0.5 = "+ Math.pow( 25 , 0.5 ) ); // 5.0
System.out.println("5678 elevado a 0 = "+ Math.pow( 5678 , 0 ) ); // 0
}
}
Método random(): Gera valores de forma aleatória.
Toda vez que a função random() é chamada, será sorteado um valor do tipo double entre ( 0.0 e 1.0 ) - o valor 1 nunca é sorteado.
Para simular o sorteios de números entre ( 0 e 99 ) torna-se necessário o sorteio de números inteiros aleatórios no intervalo de 0 e 99.
Para que esses números possam ser sorteados, é necessário utilizar (*) em conjunto com random(), tornando possível definir o interválo em que o número será sorteado.
O conversor int é usado para truncar a parte do ponto flutuante.
Ficando assim: (int) ( Math.random() * 100 ) Com isso seriam gerados números inteiros entre ( 0 e 99 ).
Exemplo: Programa que simula a geração de 5 cartões contendo 6 números cada.
class Exemplo2
{
public static void main ( String args[] )
{
for ( int qtd=1; qtd <= 5="" qtd="" cart="" es="" p="">
{
for ( int x=1; x <=6; x="" 6="" n="" meros="" aleat="" rios="" p="">
{
int num = (int) (Math.random() * 99) // Gera números aleatórios entre ( 0 e 98 )
System.out.print ( num + " " ); // imprime os números.
}
System.out.println();
}
}
}
Funções de String: Em java as strings são instâncias da classe string.
Sintaxe dos Métodos de manipulação de string:
Nome da string.função(argumento).
Método length(): Utilizada para retornar o tamanho de uma determinada String, incluindo também os espaços em branco.
Sintaxe: string.length()
Exemplo:
class Exemplo3
{
public static void main ( String args[] )
{
String A=”Aprendendo Java”; // ( A ) não é uma variável é objeto
int tamanho= A.length();
System.out.println ( “String: “ + A ); // Aprendendo Java
System.out.println ( “O tamanho da String é: “ + tamanho ); // 15
}
} // Uma variável não pode conter métodos atrelados a ela.
Método charAt(): Retorna um caractere de uma determinada string de acordo com um índice especificado entre parênteses. Sendo zero o índice do primeiro caractere.
Síntaxe: string.charAt ( índice ).
Exemplo:
Class Exemplo4
{
public static void main ( String args[] )
{
String A= “Aprendendo Java”;
System.out.println ( “String= “ + A ); // Aprendendo Java
System.out.println ( “Caracter = “ + A.charAt( 5 ) ); // d
For ( int i=11; i<=14; i="" p="">
System.out.print ( A.charAt(i) ); // Java
}
}
Método toUpperCase() e toLowerCase(): Transforma todas as letras de uma string em maiúscula e minúscula.
Sintaxe: string.toUpperCase()
string.toLowerCase()
Exemplo:
class Exemplo5
{
public static void main ( String args[] )
{
string1= “tExtO em mInUsCulo”;
string2= “TEXTO em MAIUSCULO”;
System.out.println ( string2.toUpperCase() ); // TEXTO EM MAIUSCULO
System.out.println ( string1.toLowerCase() ); // texto em minúsculo
}
}
Método substring(): Retorna uma cópia de caracteres de uma string a partir de dois índices especificados.
Sintaxe: string.substring( índice inicial , índice final )
Exemplo:
class Exemplo6
{
public static void main ( String args[] )
{
String A= “Aprendendo Java”;
System.out.println ( A ); // Aprendendo Java
// Imprime do indice ( 2 ) até o final da string
System.out.println (“do 3caractere até o fim: “ + A.substring(2) );
System.out.println (“do 1 caractere até o 10: “ + A.substring(0,10) );
System.out.println (“do 12 caractere até o 15: “ + A.substring(11,15));
}
}
Retorna:
Aprendendo Java
Aprendendo
Java
Método trim(): Remove todos os espaços em branco que aparecem no início e no final de uma string.
Sintaxe: string.trim()
Exemplo:
class Exemplo7
{
public ststic void main ( String args[] )
{
String frase = “ ** texto **”;
String.out.println ( “Com espaço:” + frase );
String.out.println ( “Sem espaço:” + frase.trim() );
}
}
Obs: Para que os espaços sejam retirados da variável, atribuir o resultado de ( trim ) ‘a própria variável.
Exemplo: frase = frase.trim();
Método replace(): Substitui caracteres individuais em uma string.
Sintaxe: string.replace( caracter a ser substituido, substituição )
Exemplo:
class Exemplo8
{
public static void main ( String args[] )
{
String A= "banana nanica";
System.out.println("Troca caracter 'a' para 'i': " + A.replace( 'a' , 'i' ));
System.out.println();
}
}
Retorna: Troca caracter 'a' para 'i': binini ninici
Método String.valueOf()
Converte diversos tipos de dados em strings.
Aceita vários tipos de argumento ( números ou cadeia ou cadeia de caracteres e transforma-os em strings )
Obs: A utilização mais importante da função ( String.valueOf() )
Exemplo:
class Exemplo9
{
public static void main ( String args[] )
{
int a= 11;
long b= 222;
float c= 3333;
double d= 4.444;
String S = String.valueOf ( a ) + " " + String.valueOf ( b ) + " " + String.valueOf ( c ) + " " + String.valueOf ( d );
System.out.println ( S );
}
}
Retorna: 11 222 3333 4.4444
System.exit(0); // Encerra o programa.
Uma classe pode possuir tantos métodos quanto necessário.
Programa que simula a jogada de um dado ( de seis lados ) DEZ vezes.
class Jogada
{
public static void main ( String args[] )
{
int num= 1;
for ( int vezes=1; vezes <= strong="">10; vezes++ )
{
num= (int) ( Math.random() * 7 ); gera números entre ( 1 e 6 )
if ( num > 0 )
{
System.out.println ( "Jogada " + vezes + ": " + num );
}
else
{
vezes--;
}
}
}
}
Programa que calcule a distância percorrida por um ciclista, fornecer a quantidade de voltas que a roda da bicicleta deu e o diâmetro dessa roda em metros.
O comprimento da roda a partir do diâmetro: c= pi * d/2
c = comprimento da roda
Pi = 3,1416
d = diâmetro da circunferência
Sabendo o comprimento da roda, multiplicá-lo pelo número de voltas para
descobrir a distância do percurso.Arredondar o resultado para o seu próximo
inteiro.
class Exemplo10
{
public static void main ( String args[] )
{
try
{
double c = 0;
double pi = 3.146;
double nvoltas = Double.parseDouble( args[0] ); número de voltas.
double diametro = Double.parseDouble( args[1] ); diâmetro da roda.
C = ( pi*diametro ) / 2; comprimento da roda a partir do diâmetro.
nvoltas = ( C * nvoltas ); número de voltas.
System.out.println("Distancia percorrida: "
+ Math.ceil( nvoltas )+ " metros " );
}
catch ( Exception e )
{
System.out.println( "Dados invalidos! " );
}
}
}
Programa que calcula quantos metros cúbicos de água suporta uma caixa dágua em forma de cubo ( todos os lados iguais ).Dever-se informar o valor do lado, o volume de água será calculado pela formula:
Volume= Lado3 Arredondar o resultado para o seu inteiro anterior.
class Exemplo11
{
public static void main ( String args[] )
{
try
{
System.out.println ("Caixa d´agua de forma cubica");
System.out.println();
System.out.print ("Informe o valor do lado da caixa: ");
Double Lado= Double.parseDouble( args[0] );
Lado= Math.pow ( Lado , 3 ); Eleva o valor do lado ao cubo.
System.out.println();
System.out.println ("Volume: " + Math.floor ( Lado ) + " metros cubicos" );
}
catch ( Exception e )
{
System.out.println ( " Valores informados invalidos! " );
}
}
}
Programa que receba uma frase e mostre-a de forma invertida.
class Exemplo12
{
public static void main ( String args[] )
{
try
{
String Frase = args[0]; Informado ( casa )
char Inverte;
int Tamanho = Frase.length() ; Retorna número de caracteres da frase.
System.out.print ( "Frase invertida: " ); Frase Invertida: asac
for ( int i= Tamanho-1; i >=0; i-- )
{
Inverte = Frase.charAt ( i );
System.out.print ( Inverte );
}
}
catch( Exception e )
{
System.out.println ( "Erro de entrada de dados" );
}
}
}
Métodos que não retornam argumentos.
Sintaxe: qualificadores tipo-do-retorno nome-do-método
Public static void metodo1
Métodos que não retornam valores devem possuir nesse parâmetro ( void ).
Por padrão o nome de um método sempre inicia com uma palavra toda em minúscula.
Exemplo: imprime
Se colocar outra palavra, elas devem começar com maiúscula.
Exemplo: imprimeFrase
Exemplo de declarações de métodos: ( Métodos que não retornam valores )
public static void imprime()
public static void imprimeFrase()
public static void graveArquivoTexto()
Em java é comum um método chamar o outro.
Um método deve possuir o mesmo nome em sua declaração e no ponto em que é invocado.
Quando ( void ) é declarada significa que não existe valor de retorno.
Quando o método é declarado como ( public ) possibilita que ele seja utilizado externamente a classe em que é construído.
Classe para limpar toda a tela
public static void limpa()
{
for ( int i=1; i<=25; i="" p="">
System.out.println();
}
Métodos que recebem um argumento dentros dos parênteses e não retornam valores
Sintaxe: qualificadores tipo-de-retorno nome-do-método(tipo de variável).
import java.io.*;
class Exemplo13
{
public static void main ( String args[] )
{
String frase1=" ", frase2=" ", frase3=" ";
DataInputStream F1; declara um objeto chamado ( frase1 ).
DataInputStream F2;
DataInputStream F3;
try
{
System.out.print( "Digitar Frase1: " );
F1= new DataInputStream(System.in); Obj(frase1) recebe o que foi digitado.
frase1= F1.readLine(); recebe o conteúdo de ( F1 )
System.out.print( "Digitar Frase2: " );
F2= new DataInputStream ( System.in );
frase2= F2.readLine(); recebe o conteúdo de ( F2 )
System.out.print( "Digitar Frase3: " );
F3= new DataInputStream ( System.in );
frase3= F3.readLine(); recebe o conteúdo de ( F3 )
}
catch ( Exception e )
{
System.out.println ( "Argumento invalido!" );
}
limpaTela(); pula uma linha e a limpa
tela( frase1 ); imprime conteúdo da frase1 e vai para a próxima linha.
tela( " " );
tela( frase2 );
tela( " " );
tela( frase3 );
}
public static void tela ( String S ) // declaração do método tela().
{
System.out.println ( S );
}
public static void limpaTela() // declaração do método limpaTela()
{
System.out.println();
}}
Exemplo:
Classe com dois métodos que não retornam valores (além do main).
Os métodos são executados em cascata: (main chama) à (tela que por sua vez chama)à tempo
class Exemplo14
{
public static void main( String args[] )
{
String frase1= "frase1" ;
String frase2= "frase2" ;
String frase3= "frase3" ;
tela( frase1 );
tela( frase2 );
tela( frase3 );
}
public static void tela( String S ) S recebe as variáveis frase.
{
System.out.println( S );
tempo(1);
}
public static void tempo( int Segundos )
{
try
{
Thread t;
t= new Thread();
t.start();
t.sleep( Segundos * 1000 );
}
catch ( InterruptedException e ) { }
}
}
Utilização na linha de comando: java Exemplo14
Retorna: frase1
frase2
frase3
Um método pode receber mais de um argumento do mesmo tipo ou não.
Exemplos:
public static void tela( String S1, String S2 )
O método recebe dois argumentos do tipo String.
Public static void tela( double A, int B, float C, String S )
Métodos que retornam argumentos
Sintaxe para a declaração de métodos que retornam valores:
Public static int soma( int x, int y )
Esse método receberá 2 argumentos inteiros e retornará um número do tipo (int).
Os valores ( recebidos ) e ( retornados ) não precisam ser do mesmo tipo.
Mostra a utilização de um método que recebe duas variáveis tipo string
( args[0] e args[1] ) retornando s soma desses números com inteiro.
class Exemplo15
{
public static void main( String args[] )
{
if ( args.length == 2 )
System.out.println( "Resultado= " + soma( args[0], args[1] ) );
else
System.out.println( "Entre com 2 valores inteiros!" );
}
public static int soma( String Num1, String Num2 )
{
int x=0, y=0;
try
{
x= Integer.parseInt ( Num1 ); Converte de ( string ) para ( inteiro ).
y= Integer.parseInt ( Num2 );
}
catch ( NumberFormatException e )
{
System.out.println( "Digitar apenas numeros!" );
System.exit(0); Encerra o programa.
}
return( x + y ); retorna a soma dos argumentos ( arg[0] e arg[1] ).
}
}
Recursividade: Ocorre quando um método chama a si próprio, direta ou indiretamente por meio de outro método.
Mostra uma recursividade gerada para imprimir o fatorial do números inteiros de ( 0 a 10 ).
Exemplo:
class Exemplo16
{
public static void main ( String args[] )
{
for ( long i=0; i<=10; i="" p="">
System.out.println ( i + "! = " + fatorial( i ) + " Passo"+i );
}
public static long fatorial ( long num )
{
if ( num <= 1="" p="">
return 1;
else
return num * fatorial( num - 1 );
}
}
Sobrecarga:
Java permite que vários métodos sejam definidoa com o mesmo nome, desde que eles tenham um conjunto de parâmetros diferentes, essas diferenças podem ser: no número, tipos ou ordem dos parâmetros.
Obs: O método ( println() ) pode receber dados de tipos diferentes graças a sobrecarga de métodos.
Exemplo de sobrecarga de método.
class Exemplo17
{
public static void main ( String args[] )
{
System.out.println( "area de um quadrado : " + area( 3 ) );
System.out.println( "area de um retangulo: " + area( 3, 2 ) );
System.out.println( "area de um cubo : " + area( 3, 2, 5) );
}
public static double area ( int x )
{
return (x * x);
}
public static double area ( int x, int y )
{
return (x * y);
}
public static double area ( int x, int y, int z )
{
return (x * y * z);
}
}
linha de comando: java Exemplo17
Retorna: area de um quadrado : 9
area de um retangulo: 6
area de um cubo : 30
Acesso a Métodos de outras classes
Qualquer método criado em uma classe pode ser utilizado em outra classe.
Obs: É necessário que a classe utilizada esteja no mesmo diretório da classe que contém o método.
Com o recurso de reaproveitamento de código são criados os ( packages ) em java que agrupam classes de mesma natureza.
Sintaxe: nomedaclasse.nomedométodo
Para que a invocação de um método de outra classe seja possível, é necessário que a classe utilizada esteja no mesmo diretório da classe que contém o método.
No arquivo autoexec.bat (windows 95/98) esteja declarada na variável de ambiente classpath a sequência de caracteres ( ;.; ). Dessa forma, uma classe externa pode ser encontrada no diretório default.
Recebe o raio de uma esfera ( tipo double ) e chama o método volumeEsfera para calcular e exibir o volume da esfera na tela.
class Exemplo18
{
public static void main ( String args[] )
{
if( args.length == 1 ) // verifica se foi informado valor do raio da esfera
System.out.println("Volume da Esfera = " + volumeEsfera( args[0] ) );
else
System.out.println("Informe apenas o raio da esfera!");
}
public static double volumeEsfera( String Vol )
{
double raioEsfera=0, volume=0, pi= 3.1416;
try
{
raioEsfera= Double.parseDouble( Vol );//Converte (Vol) string para double
}
catch( NumberFormatException e )
{
System.out.println ("Digite apenas numeros");
System.exit(0); // Encerra o programa.
}
volume= ( 4.0 / 3.0 ) * pi * Math.pow( raioEsfera , 3 );
return( volume );
}}
Declaração e Inicialização de objetos DATE.
Exige a utilização da classe Date.
Utilizar uma classe externa é necessário que ela esteja na mesma pasta da aplicação.
Outra maneira de utilizar classes externas é por meio da diretiva ( import ).
As diretivas import devem ser inseridas antes da declaração do nome da classe.
Sintaxe: import nome-do-pacote OU nome-da-classe
A utilização de classes externas possibilita a declaração de objetos.
Declaração de um objeto Date: Date nome-do-objeto;
Exemplo: Date data; à data é um objeto declarado da classe “Date”.
Para que um objeto possa ser usado é necessário que seja inicializado.
Para inicialização dos objetos é usada a instrução ( new ).
Inicialização de um objeto: nome-do-objeto = new nome-da-classe
Exemplo: data = new Date();
Esta declaração indica que o objeto ( data ) será inicializado com a
Data e Hora do sistema.
Para inicializar o objeto com outra data:
data = new Date(“October 23, 2001”);
Declaração e Inicialização de objetos em uma linha
nome-da-classe nome-do-objeto = new nome-da-classe();
Date data = new Date();
Resumo: data é o objeto da classe Date.
Métodos para manupulação da data
Métodos da classe: Date
data.getDate() Retorna o dia do mês armazenado no objeto data.
data.getDay() Retorna o dia da semana ( 0 para Domingo até 6 para Sábado ).
data.getYear() Retorna o ano armazenado no objeto data.
Retorna os dois últimos algarismos do ano.
Exemplo: 1998 retornará 98.
2000 ou superior retornam 3 dígitos.
2000 retornará 100.
2001 retornará 101 e assim sucessivamente.
data.setDate(dia) Define o dia do mês para dia do objeto data.
data.setMonth(mes) Define o mês para mês do objeto data.
data.setYear(ano) Define o ano para anodo objeto data.
Data.toGMTString() Retorna uma string representando o objeto data como GMT, isto é, com a data e hora de Londres.
Exemplo:
import java.util.Date; importa a classe Data.
class Exemplo19
{
public static void main ( String args[] )
{
Date data = new Date(); Cria e inicializa o objeto ( data ).
//Todas as informações da data.
System.out.println( data ); Wed Feb 26 08:51:08 GMT-03:00 2003
//Mostra o mês.
System.out.println("Mes atual: " + data.getMonth() ); Mês atual: 1
//Dia da semana.
System.out.println("Dia da semana: " + data.getDay() ); Dia da semana: 3
//Mostra dia do mês.
System.out.println("Dia do mês: " + data.getDate()); Dia do mês: 26
//Mostra dia do mês.
System.out.println("Ano corrente: " + data.getYear()); Ano Corrente: 103
//Define o dia.
data.setDate(5); Seta o dia= 5
//Define o mês.
data.setMonth(11); Seta o mês= 11
//Define o ano.
data.setYear(2001); Seta o ano= 2001
// Mostrando a data modificada.
System.out.println( data ); Thu Dec 05 10:59:06 GMT-03:00 3901
System.out.println("Data como GMT: " + data.toGMTString());
“Data como GMT: 5 Dec 3901 13:59:06 GMT
}
}
Retorna:
Wed Feb 26 08:51:08 GMT-03:00 2003
Mês atual: 1
Dia da semana: 3
Dia do mês: 26
Ano corrente: 103
Sun Dec 15 08:51:00 GMT-03:00 3901
Data como GMT: 15 Dec 3901 11:51:08 GMT
Métodos para manipulação de hora
Utilização da declaração: data = new Date(“October 23, 2001 10:42:15”)
data.getHours() – Retorna HORA entre (0-23) do objeto data, retornará ( 10 )
data.getMinutes() – Retorna MINUTOS entre (0-59) do objeto data, retornará ( 42 )
data.getSeconds() – Retorna os SEGUNDOS (0-59) do objeto data, retornará ( 15 )
data.getTime() – Retorna o número de MILISEGUNDOS decorridos desde 1o de Janeiro de 1970, 00:00:00
Utilizado para fazer cálculos entre datas.
data.getTimeZoneOffSet() – Retorna diferença em minutos da hora local em relação a GMT.
data.parse( String ) – Analisa string e retorna o número de milissegundos decorridos desde 1o de janeiro de 1970, 00:00:00
data.setHours( horas ) – Define a hora do objeto data.
data.setMinutes( minutos ) – Define os minutos do objeto data.
data.setSeconds( valor ) – Define a hora para valor, que representa o número de milissegundos decorridos desde 1o de janeiro de 1970, 00:00:00
data.setTime( valor ) – Define a hora para valor, que representa ...
data.toLocaleString() – Retorna uma string contendo a data e hora do ( objeto data ), levando em conta o fuso horário
corrente.
Principais métodos referente à hora
import java.util.Date; importa a ( classe Date )
class Exemplo20
{
public static void main (String args[] )
{
Date Data = new Date(); //cria e inicializa o objeto ( Data ).
System.out.println( Data ); //Todas as informações de data e hora. Web Feb 26 12:39:07 GMT-03:00 2003
System.out.println("Horas: " + Data.getHours() ); Horas: 12 -> hora local.
System.out.println("Minutos: " + Data.getMinutes()); Minutos: 45 -> local.
System.out.println("Segundos: " + Data.getSeconds() ); Segundos: 10 -> local
System.out.println("Milisegundos desde 1970: " + Data.getTime() ); //1046280499328 milisegundos desde 1970
System.out.println("Diferença de GMT: " + Data.getTimezoneOffset() );
// Alterar Hora, Minutos e Segundos
Data.setHours(14); //altera a hora
Data.setMinutes(25); //altera os minutos
Data.setSeconds(13); //altera os segundos
System.out.println( Data ); mostra a hora modificada
System.out.println("Data e hora (horario corrente): "+ Data.toLocaleString()); //26/02/2003 14:25:13
}
}
Programa que controla a hora que o usuário está acessando o aplicativo.
É usada a variável ( hora ) para controlar a hora que o usuário está acessando o programa.
import java.util.Date;
class Exemplo0603
{
public static void main (String args[])
{
Date data = new Date(); // cria e inicializa objeto data com data e hora atual
int hora=0, min=0, sec=0;
hora= data.getHours();
min= data.getMinutes();
sec= data.getSeconds();
System.out.println("Agora sao " + hora+"h:" + min+"m" + sec+"s");
if ( hora >=0 && hora < 6 )
System.out.println("Boa madrugada!" );
if ( hora >=6 && hora < 12 )
System.out.println("Bom Dia!" );
if ( hora >= 12 && hora < 18 )
System.out.println("Boa tarde!");
if ( hora >=18 )
System.out.println("Boa noite");
}
}
Programa que simule promoções em um site, cada dia da semana mostrar uma promoção diferente.
import java.util.Date;
class Exemplo21
{
public static void main ( String args[] )
{
Date data = new Date(); // cria e inicializa um objeto.
int dia= data.getDay(); // retorna o dia da semana armazenado no objeto data e
// atribui o valor variável do tipo inteiro ( dia ).
switch( dia )
{
case 0: System.out.println("Neste Domingo Promocao de biscoitos!");
System.out.println("Nao percam!"); break;
case 1: System.out.println("Nesta Segunda-feira Promocao de lapis!");
System.out.println("Nao percam!"); break;
case 2: System.out.println("Nesta Terca-feira Promocao de borracha!");
System.out.println("Nao percam!"); break;
case 3: System.out.println("Nesta Quarta-feira Promocao de canetas!");
System.out.println("Nao percam!"); break;
case 4: System.out.println("Nesta Quinta-feira Promocao de cadernos!");
System.out.println("Nao percam!"); break;
case 5: System.out.println("Nesta Sexta-feira Promoção de cola!");
System.out.println("Nao percam!"); break;
case 6: System.out.println("Neste Sabado Promoção de algodão!");
System.out.println("Nao percam!"); break;
default: System.out.println("Nao e um dia valido!");
}
}
}
Programa que mostre na tela o dia atual na tela.
Utilizar métodos para retornar o dia da semana e do mês por extenso.
Transformar os números inteiros retornados pelos métodos getDay() e getMonth()
em seus respectivos inteiros
Formato apresentado ( Hoje é Sexta-feira, dia 27 de Fevereiro de 2003 ).
import java.util.Date;
class Exemplo22
{
public static void main ( String args[] )
{
Date data = new Date();
String diaS=" ", m=" ", Ano=" ", A=" ";
int diaSemana = data.getDay(); retorna dia semana(0 até 6 - Domingo à Sábado )
int diaMes = data.getDate(); retorna dia do mes. ( 15 )
int mes = data.getMonth(); retorna (0 até 11)= Janeiro até Dezembro.
int ano = data.getYear(); retorna (98 - 1998
99 - 1999
100 - 2000
101 - 2001
// Verifica o dia da semana
switch( diaSemana )
{
case 0: diaS=" Domingo, "; break;
case 1: diaS=" Segunda-Feira, "; break;
case 2: diaS=" Terca-Feira, " ; break;
case 3: diaS=" Quarta-Feira, "; break;
case 4: diaS=" Quinta-Feira, "; break;
case 5: diaS=" Sexta-Feira, " ; break;
case 6: diaS=" Sabado, "; break;
}
//Verifica o mes.
switch( mes )
{
case 0: m="Janeiro"; break;
case 1: m="Fevereiro"; break;
case 2: m="Marco"; break;
case 3: m="Abril"; break;
case 4: m="Maio"; break;
case 5: m="Junho"; break;
case 6: m="Julho"; break;
case 7: m="Agosto"; break;
case 8: m="Setembro"; break;
case 9: m="Outubro"; break;
case 10: m="Novembro"; break;
case 11: m="Dezembro"; break;
}
A= String.valueOf(ano);
A= "20" + A.substring(1,3);
System.out.println("Hoje e" + diaS+diaMes +" de "+ m +" de "+A);
}
}
Definições sobre a Orientação a Objetos
Uma classe que possui esse método é uma aplicação ou programa que pode utilizar classes externas.
Para definir uma classe , é usada a palavra reservada “class”.
Exemplo:
Qualificador class produto
{
// atributos da classe
// métodos da classe
}
Existem dois tipos de qualificadores ( public e package ).
public – indica que o conteúdo público da classe pode ser usado livremente por outras classes do mesmo pacote ou de outro pacote.
Um pacote é um diretório.
package – indica que o conteúdo da classe pode ser usado apenas por classes do mesmo pacote – por classes localizadas no mesmo diretório.
Um único arquivo java pode conter diversas classes, mas apenas uma delas pode ser definida como pública.
Todo nome de classe inicia com uma letra maiúscula.
As classes são modelos a partir dos quais podem ser criados objetos.
Um pacote ( package ) em java é um diretório em que está armazenada uma ou mais classes.
Geralmente as classes de mesma afinidade, ou mesmo propósito, são armazenadas num mesmo local.
Do ponto de vista da programação, os packages representam as bibliotecas ( libraries ) em oura linguagem.
Para utilizar classes de um pacote é usada a diretiva ( import ), conforme demonstrado anteriormente.
Exemplo: import nome-do-pacote.nome-da-classe
import java.util.Date;
Será usada a classe ( Date ) do pacote java.util
Ou seja
A classe ( Date ) está localizada na pasta javautil.
Partes que compõem uma Classe
As variáveis de instância, atributos ou dados membro são chamdos pela própria definição.
São pertencentes à própria classe, destinadas a armazenar alguma informação.
Serão instanciadas ( usadas ) pelos objetos quando eles forem criados.
Exemplo:
public class Produto
{
int codigo;
String nome;
int quantidade;
double preco;
// definições de métodos
}
Instanciação de uma Classe
A criação de um objeto a partir de um classe é chamada de instanciação.
Corresoinde à alocação de memória para armazenar informações de um objeto.
Semelhante a ao que ocorre na declaração de uma variável qualquer.
São reservados endereços de memória para armazenar os dados correspondentes.
( classe ) representa um modelo abstrato que server como base.
( objetos ) representam modelos concretos.
( new ) Para instanciar im objeto qualquer.
Uma vez definida uma classe; podem ser criados infinitos objetos a partir dela e cada um terá suas características.
Exemplo:
public class Produto
{
// declaração de 4 variáveis de instância.
int codigo;
String nome;
int quantidade;
double preco;
// definição dos métodos
}
Exemplo de utilização de classes e objetos.
class Usaproduto
{
public static void main ( String args[] )
{
Produto A,B,C,d,e;
Contém declaração dos objetos (A,B,C) que serão criados a partir da classe Produto.
Essa declaração diz ao compilador que serão criados três objetos por meio da classe Produto.
Cada objeto possuirá as quatro variáveis ( declaradas na classe Produto ).
Poderá manipular seus valores internamente, isto é, cada objeto.
Poderá possuir diferentes valores para essas variáveis de instância.
O objeto (A) pode armazenar o conteúdo "Sabonete" na variável "nome"
O objeto (B) pode armazenar o conteúdo "Detergente" na variável "nome"
O objeto (C) pode armazenar o conteúdo "Shampoo" na variável "nome"
Exemplo:
A.nome= "Sabonete"; A -> variável de instância.
B.nome= "Detergente";
C.nome= "Shampoo";
A= new Produto(); //Instanciação dos objetos em sua forma mais simples.
B= new Produto();
C= new Produto();
d= new Produto();
e= new Produto();
Ao instanciar objeto,são atribuidos valores iniciais às variáveis de instância.
System.out.println( A.codigo + " " + A.nome + " ");
System.out.println( A.quantidade + " " + A.preco );
A.codigo= 10;
A.nome= "sabonete";
A.quantidade= 5;
A.preco= 0.54;
System.out.println(A.codigo + " " + A.nome + " ");
System.out.println(A.quantidade + " " + A.preco);
B.codigo= 11;
B.nome= "Detergente";
B.quantidade= 35;
B.preco= 1.25;
System.out.println(B.codigo + " " + B.nome + " ");
System.out.println(B.quantidade + " " + B.preco );
C.codigo= 12;
C.nome= "Shampoo";
C.quantidade= 3;
C.preco= 3.65;
System.out.println(C.codigo + " " + C.nome + " ");
System.out.println(C.quantidade + " " + C.preco );
d.codigo= 1002;
d.nome= "doce";
d.quantidade= 300;
d.preco= 10.37;
System.out.println(d.codigo + " " + d.nome + " ");
System.out.println(d.quantidade + " " + d.preco );
e.codigo= 12384;
e.nome= "agua";
e.quantidade= 1981;
e.preco= 26.03;
System.out.println(e.codigo + " " + e.nome + " ");
System.out.println(e.quantidade + " " + e.preco );
}
}
Compartilhamento de variáveis entre os objetos
Para termos essa funcionalidade basta declarar a variável como sendo do tipo static, o conteúdo da variável será estático, controlado pela classe.
Como visto anteriormente, cada objeto criado trata as variáveis de instância de forma exclusiva ( cada objeto possui uma variável atrelada a si próprio ).
Em muitos casos é necessário compartilhar uma variável entre todos os objetos.
Essa característica faz com que o conteúdo da variável seja controlado pela própria classe e não pelos objetos individualmente.
Sem a declaração ( static ), cada objeto criado trata as variáveis de instaância de forma exclusiva, cada objeto possui uma variável ligada a si ( sem compartilhar com outros objetos ).
public class Produto /*A classe Produto não é uma classe executável,mas apenas um { modelo a partir do qual
podemser criados outros objetos. */
{
// declaração de 4 variáveis de instância.
static int codigo;
String nome;
int quantidade;
double preco;
// definição dos métodos
}
Exemplo de compartilhamento de uma variável entre os objetos.
class Usaproduto2
{
public static void main ( String args[] )
{
Produto A, B, C; //declara os os objetos ( A,B,C) da classe Produto
A= new Produto(); //Inicializa o objeto ( A ) da classe Produto.
B= new Produto();
C= new Produto();
9 A.codigo= 1;
10 System.out.println("Valor de codigo em A: " + A.codigo ); // 1
11 System.out.println("Valor de codigo em B: " + B.codigo ); // 1
12 A.codigo= 2;
13 System.out.println("Valor de codigo em A: " + A.codigo ); // 2
14 System.out.println("Valor de codigo em B: " + B.codigo ); // 2
15 System.out.println("Valor de codigo em C: " + C.codigo ); // 2
}
}
A linha (9) atribui o valor 1 á variável codigo do objeto A.
Como a variável é estática, todos os objetos vão enxergar esse mesmo valor.
As linha (10 e 11) mostrarão os valores da variável codigo para os objetos ( A e B ) em que ambos são iguais.
Na linha (120) a variável codigo recebe valor (2) com a utilização do objeto (B).
Todos os objetos ( A,B,C ) possuem o mesmo valor para essa variável.
Declaração de métodos de uma classe
Os atributos armazenam os dados associados aos objetos.
Os métodos podem realizar operações com os atrinutos ou ainda realizar cetas ações com os objetos.
Por meio dos métodos é possível imitar o comportamento de um objeto no mundo real.
Uma classe chamada Veiculo pode possuir um método para realizar o processo de aceleração, aumentando o valor de um atributo velocidade,ou seja, invocar o método acelerar, simula-se uma pessoa pisando no acelerador do veículo.
Por meio de méotodos, os objetos podem trocar mensagens entre si.
Da mesma forma que as variáveis de instância, os métodos são herdados pelos objetos.
A partir da declaração de uma classe podem ser criados inúmeros objetos que herdam as características de classe.
A classe Produto com dois métodos :
mostraPreco() - mostrar na tela o valor atual do produto.
atualizaPreco() - atualizar o valor do preço do produto de acordo como o valor da porcentagem passado como argumento.
A classe “Produto” não é uma classe executável, mas apenas um modelo a partir do qual podem ser cirados outros objetos.
public class Produto
{
// declaração de 4 variáveis de instância.
int codigo;
String nome;
int quantidade;
double preco;
// definição dos métodos
public void mostraPreco()
{
System.out.println( preco );
}
public void atualizaPreco( double porc )
{
preco= preco + (preco * porc) / 100;
}
}
Para implementar a classe produto que contém agora 2 métodos será utilizada a classe Usaproduto2.
class Usaproduto3
{
public static void main ( String args[] )
{
//Produto A,B,C; declara os objetos (A,B,C) da classe Produto.
A= new Produto(); inicializa o objeto (A) da classe Produto.
B= new Produto();
C= new Produto();
A.codigo = 10;
A.nome = "Sabonete";
A.quantidade = 5;
A.preco = 0.54;
System.out.println(A.codigo + " " + A.nome + " ");
System.out.println("Valor unitario: " + A.preco );
System.out.print("Total de sabonetes: " + A.quantidade + " ");
System.out.println("Valor total = R$ " + ( A.quantidade * A.preco ) );
for (int i=0; i < 3; i++)
System.out.println();
A.mostraPreco();
A.atualizaPreco(12);
System.out.print("A.mostraPreco() = " );
A.mostraPreco();
B.preco = 5.45;
System.out.print("B.mostraPreco() = ");
B.mostraPreco();
B.atualizaPreco(25);
System.out.print("B.mostraPreco() = ");
B.mostraPreco();
}
}
Encapsulamento ou Acessibilidade
O Termo encapsulamento ou acessibilidade: define o que está visível na classe, é a forma como os elementos da classe podem ser vistos e utilizados por outras classes.
Variáveis e métodos declarados na classe são visíveis a todos os objetos criados, pode ser uma característica desejável.
Na maioria das vezes, algumas aplicações necessitam ocultar certos métodos ou Variáveis, utilizando para esse fim o encapsulamento ou acessibilidade.
Com a utilização do encapsulamento se define o que está acessível na classe, é a forma como os elementos da classe podem ser vistos e utilizados por outra classe.
Para determinar o nível de acesso dos elementos de uma classe, são usados os qualificadores:
public – private – package e protect
Restringir acesso a determinadas partes da classe significa controlar seu uso.
Pode ser uma necessidade em algumas situações.
Por restrições de acesso é possível assegurar que certas variáveis de instância tenham valores restritos, só podendo ser acessados da própria classe e não por intermédio de classes externas.
Vantagens do uso do Encapsulamento
Pode ocultar certos detalhes de implementa;cão, reduzindo o tamanho do código dos programas, o código fica mais legível e reduz erros de programação.
EXEMPLO DE USO DO Encapsulamento
Uso do encapsulamento em uma classe ( Veiculo ).
As duas classes estão declaradas em um mesmo arquivo java.
São duas classes distintas apesar de estarem no mesmo arquivo.
Poderiam ser declaradas separadamente.
class Veiculo Página: 128
{
String nome;
private float velocidade; /* Qdo a variável é declarada como "private" apenas a própria classe pode alterar seu
conteúdo. */
public void acelera()
{
if ( velocidade <= 10="" p="">
velocidade++;
}
void frea()
{
if ( velocidade > 0 )
velocidade--;
}
void mostraVelocidade()
{
System.out.println( velocidade );
}
}
class Exemplo0701
{
public static void main (String args[] )
{
Veiculo v1; (v1) é declarado como objeto da classe Veiculo.
v1= new Veiculo(); objeto (v1) é inicializado.
v1.nome= "Gol";
System.out.println( "v1.nome = " + v1.nome);
for ( int i = 1; i <= 5="" i="" p="">
{
System.out.print("v1.mostraVelocidade() (Acelerando)= ");
v1.mostraVelocidade();
v1.acelera();
}
System.out.print("v1.mostraVelocidade() (Velocidade maxima) = ");
v1.mostraVelocidade();
for ( int x = 5; x >= 0 ; x-- )
{
System.out.print("frea() (Freando o carro) = "); v1.mostraVelocidade();
v1.frea();
}
// System.out.println( v1.velocidade );
}
}
Construtores
Responsável por contruir um objeto com determinados valores.
O método construtor é invocado pelo operador ( new ) toda vez que um objeto é criado ( instanciado )
Até agora, em todas as instanciações ( inicializações de objetos foi usada a palavra reservada ( new ), utilizads da seguinte forma: Veiculo v1 = new Veiculo; à contrua (v1) como sendo objeto da classe Veiculo.
O operador ( new ) é o responsável pelo processo de instanciação ou inicialização do objeto, representa uma forma simples de atribuir valores ( default ) a um objeto.
Seguindo essa declaração, o objeto é inicializado com valores ( default ), desde que não exista a presença do método contrutor.
O método construtor é o responsável por construir um objeto com determinados valores.Sendo assim, o método construtor é invocado pelo operador ( new ) toda vez que um objeto é criado ( instanciado ).
O método construtor é responsável por alocar espaço na memória para a manipulação do novo objeto que está sendo criado e pode conter as seguintes atribuições:
- abrir arquivos, inicializar periféricos, inicializar variáveis de instância ou outros procedimentos, dependendo das
necessidades do objeto criado.
O método construtor pode conter também a chamada para outros métodos, possibilitando a criação de objetos mais complexos.
Ele deve sempre ter o mesmo nome da classe em que ele se localiza.
Se um construtor não for declarado, é assumido um construtor default, em que as variáveis são inicializadas com os seguintes conteúdos:
- Variáveis numéricas recebem zero.
- Valores lógicos recebem false.
- Objetos recebem null.
O método construtor funciona como um método qualquer da linguagem, pode receber argumentos para que os objetos sejam criados com quaisquer valores passados no momento de sua inicialização ou ( instanciação ).
Definimos um construtor de forma personalizada para impedir que ele assuma valores default para os dados membro.
Dados membro igual a variáveis de instância ou atributos.
Suponha a necessidade de crias 2 objetos com a classe Cliente, com diferentes conteúdos psra a variável nome.
class Cliente
{
int codigo; variável de instância, atributos ou dados membro.
String nome; variável de instância, atributos ou dados membro.
String cidade; variável de instância, atributos ou dados membro.
Cliente( String n ) método construtor recebe o nome do cliente
{
nome = n;
cidade= "Rio de Janeiro"; inicializa ( cidade ) com um valor padrão.
}
}
class Usacliente
{
public static void main ( String args[] )
{
Cliente c1 = new Cliente("Manoel"); // invoca método construtor, envia o nome do cliente.
Cliente c2 = new Cliente("Simone"); // invoca método construtor, envia o nome do cliente.
System.out.println( c1.nome );
System.out.println( c2.nome);
System.out.println( c2.cidade );
System.out.println( c2.nome);
System.out.println( c1.nome );
}
}
O objeto (c1) foi instanciado ou inicializado duas vezes, o espaço alocado por ( c1.nome ) fica perdido na memória.
A liguagem Java possui um processo automático para limpeza de objetos não utilizados depois de um certo tempo, sendo feito por um processo de (Coleta automática de lixo).
Toda ves que um objeto deixa de ser referenciado pelo programa, fica perdido na memória e recebe uma marca para eliminação futura.
Quando o programa fica ocioso, o gerenciador automático de memória destroi os objetos perdidos e libera os recursos anteriormente alocados ao sistema.
Com esse processo torna-se desnecessário liberar a memória explicitamente em um programa em java , já que é feito de forma automática.
Destrutores
Responsáveis por liberar recursos usados pelos objetos durante a execução do programa.
Construtores alocam espaço inicial na memória.
Os destrutores liberam esse espaço alocado, liberando recursos.
A importância dos destrutores são a liberação de recursos do sistema.
Herança
Em java a herança ocorre quando uma classe passa herdar características ( atributos e métodos ) definidas em outra
classe definidas em uma outra classe como sendo sua ancestral ou superclasse.
A herança possibilita o compartilhamento ou reaproveitamento de recuros definidos anteriormente em outra classe.
A classe que fornece os recursos é chamada de superclasse.
A classe que recebe os recuros é chamada de subclasse.
Herança e especialização estão sempre envolvidos.
Quando uma classe herda características de outra classe, ela pode implementar partes específicas que não foram
feitas na classe original ( superclasse ), tornando a classe que executou uma determinada implementação especializada em
algum processo.
Exemplo do uso dos conceitos de herança e especialização.
class Veiculo É uma superclasse porque fornece recursos para a subclasse (Veiculo2).
{
String nome; //variável de instância, atributos ou dados membro.
float velocidade; //variável de instância, atributos ou dados membro.
public void acelera()
{
if ( velocidade <= 10 )
velocidade++;
}
public void frea()
{
if ( velocidade > 0 )
velocidade--;
}
}
Supondo que exista a necessidade de uma outra classe possuir a mesma funcionalidade da classe ( Veiculo ), mas
também com a necessidade de possuir métodos para ( ligar ) e ( desligar ) o Veiculo.
Para não ter que criar uma nova classe contendo todas as características da classe Veiculo ( Superclasse ) as
características da classe Veiculo podem ser apliadas por meio da palavra "extends".
A classe ( Veiculo2 ) herda toda a funcionalidade da classe ( Veiculo ).
A classe Veiculo2 por meio de ( extends ) estende a funcionalidade da classe veículo, herdando todas as suas características e acrescentando novas funcionalidades:
- uma variável de instância p/ saber se o motor está ligado.
- um método p/ ligar o veículo e uma para desligar.
Ao instanciar o objeto (v1),ele receberá todas as variáveis de instância e todos os métodos presentes nas classes Veiculo e Veiculo2.
O objeto (v1) receberá às variáveis: nome, velocidade e ligado. e os métodos: frea, acelera, liga e desliga.
class Veiculo2 extends Veiculo
{
boolean ligado;
public void liga()
{
ligado = true;
}
public void desliga()
{
ligado = false;
}
}
Se alterar a classe Veiculo (superclasse),todas as mudanças serão refletidas na classe Veiculo2 (subclasse).
Por herança é possível criar uma hierarquia de classes.
Qualquer alteração realizada numa classe de nível superior irá refletir nas classes de níveis inferiores.
As classes adicionadas a uma hierarquia podem (especializar) ou (restringir) o comportamento das classes superiores.
|
Superclasse
Subclasses
|
|
|
|
||||||
Página: 135
POLIMORFISMO
Analizando a hierarquia de classesda figura de forma inversa,se verifica a
generalização das classes relacionadas.
Cada classe da hierarquia pode assumir a mesma funcionalidade da superclasse e
sendo tratada como tal.
Se a superclasse modificar sua estrutura, imediatamente as classs da hierarquia
serão afetadas. Pode-se notar que uma classe da hierarquia pode assumir
diferentes formas (funcionalidaddes), de acordo com as classes de nível
superior.
|
Exemplos para compreender o polimorfismo:
|
class Veiculo3 extends Veiculo
{
boolean turbo;
public void ligaTurbo()
{
turbo = true;
}
public void desligaTurbo()
{
turbo = false;
}
}
class Generica
{
public static void main( String args[] )
{
Veiculo2 a = new Veiculo2(); cria objeto (a) da classe Veiculo2
Veiculo3 b = new Veiculo3(); cria objeto (b) da classe Veiculo3
a.velocidade = 10;
b.velocidade = 20;
mostraVelocidade(a); 10
mostraVelocidade(b); 20
}
public static void mostraVelocidade( Veiculo veic )
O método mostraVelocidade está recendo como argumento um objeto
do tipo Veiculo, ou seja, a Superclasse.
{
System.out.println( veic.velocidade );
}
}
É uma superclasse porque fornece recursos para a subclasse ( Veiculo2 ).
class Veiculo
{
String nome; variável de instância, atributos ou dados membro.
float velocidade; variável de instância, atributos ou dados membro.
public void acelera()
{
if ( velocidade <= 10 )
velocidade++;
}
public void frea()
{
if ( velocidade > 0 )
velocidade--;
}
}
A classe Veiculo2 herda toda a funcionalidade da classe Veiculo. */
class Veiculo2 extends Veiculo
{
boolean ligado;
public void liga()
{
ligado = true;
}
public void desliga()
{
ligado = false;
}
}
class Veiculo3 extends Veiculo
{
boolean turbo;
public void ligaTurbo()
{
turbo = true;
}
public void desligaTurbo()
{
turbo = false;
}
}
______________________________________________________________________________________
class Generica
{
public static void main( String args[] )
{
Veiculo2 a = new Veiculo2(); cria objeto (a) da classe Veiculo2
Veiculo3 b = new Veiculo3(); cria objeto (b) da classe Veiculo3
a.velocidade = 10;
b.velocidade = 20;
mostraVelocidade(a); // 10
mostraVelocidade(b); // 20
}
public static void mostraVelocidade( Veiculo veic )
Método mostraVelocidade está recendo como argumento objeto do tipo Veiculo, ou
seja, a Superclasse.
{
System.out.println( veic.velocidade );
}
}
Exemplos em geral
Manipulando string
import java.io.*;
class MostraApaga
{
public static void main (String args[])
{
String frase=" ";
DataInputStream F1;
try
{
System.out.print("Digitar uma palavra: ");
F1= new DataInputStream( System.in );
frase= F1.readLine();
int tamanho= frase.length();
for(int i=0; i <= tamanho; i++ )
{
System.out.println( frase.substring(0,i) );
}
for( int x=0; x <= tamanho; tamanho-- )
{
System.out.println( frase.substring(0,tamanho) );
}
}
catch( Exception e )
{
System.out.println("Erro interno");
}
}
}
Execução: java MostraApaga
Digitar uma palavra: teste
t
te
tes
test
teste
teste
test
tes
te
t
Números aleatórios entre (0 e 99)
class ParImpar
{
public static void main (String args[])
{
double Valor=0;
int par=0, impar=0;
System.out.print("Valores Gerados: ");
for ( int i=1; i<=10; i++ )
{
Valor= (int)(Math.random()*100);
System.out.print( (int)Valor+" " );
}
System.out.println();
}
}
Execução: Valores Gerados: 54,52,86,25,85,97,40,56,14,35
ACESSO A DADOS MEMBRO POR MEIO DE OBJETOS
class Livro
{
String titulo; dado membro, variável de instância
int numpaginas; estas variáveis terão acesso por meio de objetos.
String autor;
String Editora;
double valor;
public static void main( String arg[] )
{
Livro livroLiteratura = new Livro(); declara E inicializa obj livroLiteratura da
classe Livro
livroLiteratura.titulo = "Dom Casmurro";
livroLiteratura.numpaginas = 200;
livroLiteratura.autor = "Machado de Assis";
livroLiteratura.Editora = "Atica";
livroLiteratura.valor = 30.00;
System.out.println( titulo ); ----->forma errada
System.out.println( livroLiteratura.titulo );
}
}
VARIÁVEIS DE CLASSE
Tipo diferente de variável de instância ( a diferença é que ela é enxergada por
toda a classe.
Variáveis de classe não são particulares da cada objeto como acontece com
variáveis de instância.
Uma vez atribuído um valor para esta variável, todos os objetos da classe
assumirão este valor para esta variável.
A DECLARAÇÃO DE UMA VARIÁVEL DE CLASSE É PRECEDIDA DA PALAVRA RESERVADA STATIC.
Exemplo:
class Carro
{
static String marca; Variável de classe – Tipo de variável de instância em que
ela é enxergada por toda a classe.
static int potencia;
static int ano;
public static void main ( String args[] )
{
Carro palio = new Carro();
Carro corsa = new Carro();
palio.marca = "fiat"; Uma vez atribuído um valor para esta variável, todos os
objetos da classe assumirão este valor para esta
variável.
palio.potencia = 90;
palio.ano = 2001;
System.out.println( corsa.marca ); fiat
System.out.println( corsa.potencia ); 90
System.out.println( corsa.ano ); 2001
}
}
REFERÊNCIA A OBJETOS
O operador (new) é o responsável pela criação efetiva do objeto.
Sendo assim, a declaração e a criação podem ser feitas separadamente.
Exemplo:
Veiculo carro1; à Foi declarado o objeto carro1.
carro1 = new Veiculo(); à O objeto carro1 é criado.
Outra construção válida é:
Veiculo carro1; à Foi declarado o objeto carro1.
carro1 = new Veiculo(); à O objeto carro1 é criado.
Veiculo carro2 = carro1; à O objeto carro2 é declarado mas não foi criado.
O objeto ( carro2 ) passa a ser um apelido para o objeto ( carro1 ).
Qualquer alterações feitas nos dados de um dos objetos afetará diretamente o
dado correspondente no outro.
Na realidade existe apenas um objeto com duas denominações.
carro2 é uma referência para carro1.
Exemplo:
class Veiculo
{
static String marca; Variável de classe – Tipo de variável de instância em que
static int potencia; ela é enxergada por toda a classe.
static int ano;
public static void main ( String args[] )
{
Veiculo palio = new Veiculo();
Veiculo corsa = palio; objeto (corsa) é um apelido p/ objeto (palio)
palio.marca = "fiat"; Qualquer alterações feitas nos dados de um dos objetos
afetará diretamente o dado correspondente no outro.
Isso ocorre porque ao atribuir um objeto a outro, é seu
Endereço que está sendo atribuído.
palio.potencia = 90;
palio.ano = 2001;
System.out.println( corsa.marca ); fiat
System.out.println( corsa.potencia ); 90
System.out.println( corsa.ano ); 2001
corsa.marca = "F";
corsa.potencia = 50;
corsa.ano = 2003;
System.out.println(" ");
System.out.println( palio.marca ); F
System.out.println( palio.potencia ); 50
System.out.println( palio.ano ); 2003
}
}
Página: 141 e 142
ARRAYS
Em java, os arrays são objetos que permitem armazenar uma lista de itens
relacionados.
Arrays Unidimensionais
Sintaxe: tipo-de-dado nome-do-array[] = new tipo-do-dado(quantidade)
Exemplos:
Int N[] = new int[100];
Cria um array de nome N que comtem 100 elementos do tipo int.
Seu índice varia de ( 0 a 99 )
String mes[] = new String[12];
Cria um array de nome mês de 12 elementos do tipo string.
Seu índice varia de ( 0 a 11 )
class VetorSimples
{
public static void main( String args[] )
{
int vetor[] = new int[5]; Cria um array de nome Vetor que contém 5 elementos
do tipo (int).
Indice varia de ( 0 até 4 )
vetor[0]= 1;
vetor[1]= 2;
vetor[2]= -4;
vetor[3]= 8;
for(int i=0; i <= 3; i++)
{
System.out.println( "Valor do Vetor["+i+"]= " + vetor[i] );
}
}
}
Execução: java VetorSimples
vetor[0]= 1;
vetor[1]= 2;
vetor[2]= -4;
vetor[3]= 8;
Armazenamento de Valores em um vetor de Bytes
Declaramos um vetor de bytes,onde cada byte representa um caracter fornecido
como entrada.
O valor a ser armazenado neste vetor é obtido via teclado pelo do método read()
e armazenado numa String.
byte S[] = new byte[20];
Syste.in.read(S);
String str = new String(S);
Para eliminar espaço inutilizado no vetor:
String str = new String(S).trim();
Importação de Classes ou Pacotes para Leitura de Dados
Em um subdiretório chamado io, abaixo do subdiretório java existem várias
classes que definem recursos de I/O, como métodos, constantes ....
Importaremos a classe que define o método read().
Ele está definido e outras também nas classes DataInput e DataInputStream
import java.io.DataInputStream;
ou
import java.io.*
O método read() deve ser utilizado em um bloco protegido senão apresentará um
erro durante a compilação.
import java.io.*; definem recursos de entrada e saída, em particular o
método read().
class LeituraSimples
{
public static void main(String args[])
{
byte S[] = new byte[40];
String Str;
System.out.println("Digite seu nome: "); marcos
try
{
System.in.read(S); Entrada de dados pela linha de comando ( System.in )
Str = new String(S).trim(); elimina espaços não utilizados
System.out.println( Str.toUpperCase() ); converte p/maiúscula.
int A= Str.length();
System.out.println("Tamanho do vetor:" + A ); 6
}
catch( Exception ex )
{
System.out.println( ex.toString() );
}
}
}
/* Execução: Digite seu nome:
marcos
MARCOS
Tamanho do vetor: 6*/