domingo, 18 de maio de 2014

Manipulação da Classe DATE
 




A classe representa o tempo, um tempo é composto por ano, mês, dia atual, minuto atual, entre outras propriedades que essa classe possui.
Esta classe é bem simples de se trabalhar, mas muitos de seus métodos foram sendo deixados de lado por não trabalhar muito bem com internacionalização e etc.
Hoje a maioria dos métodos da classe Date estão classificados como deprecated (depreciados), ou seja, são métodos que não são mais utilizados, Por isso essa classe foi substituída pela classe Calendar, para haver suporte correto à internacionalização do sistema de datas.



Testando a Classe Date:

Exemplo a seguir aplicando date no formato internacional:

- Importamos o java.util.Date; Pois ja é uma classe criada pelo Java.
- Instanciamos um objeto da CLASSE DATE.
- Para exibirmos a data atual usamos sysout... +data(Objeto da Classe Date)



O resultado é a saída da data no modo Internacional.


Classe DateFormat:

Essa classe permite converter informações do tipo String para data do tipo Date, permitindo seguir um formato. Consegue-se trabalhar ao contrário, convertendo um dado do tipo Date para uma String. Por ser uma classe abstrata, não é possível instanciá-la, por isso deve ser usado para método estático getDateInstance()

Sempre quando declarado é preciso importar o pacote java.text.
A classe DateForma nos fornece vários tipos de formato para data como:
Dateformat.SHORT // 03/04/14
Dateformat.MEDIUM // 03/04/2014
Dateformat.LONG //3 de Abril de 2014
Dateformat.FULL //Sábado, 3 de Abril de 2014.



Testando a Classe DateFormat:

No exemplo abaixo usamos três tipos de formatação DATA, HORA e DATA E HORA.



No final temos todas as datas formatadas.

Exercícios 

1) Use as manipulações de Date com as informações acima.
A) Crie uma saída de data no modo internacional 
B) Escolha uma data desejada e converta nos três tipos exemplificados do DateFormat.







Vídeos Manipulação Date:









Referência:


http://www.devmedia.com.br/manipulando-datas-em-java/21765




GRUPO MADUREIRA INTEGRANTES: 

Lucas Leon - RM 71341
Mariana Chechetti - RM 71804
Thiago Zanettin - RM 72424

Erros e exceções

Explicação



Mesmo que um comando ou expressão estejam sintaticamente corretos, talvez ocorra um erro na hora de sua execução. Podemos usar tratamento de exceções para detectar erros e manipular esses erros, ou seja, tratá-los. Erros detectados durante a execução são chamados exceções e não são necessariamente fatais. Porém, podem terminar o programa ou retornar um valor de erro indicando falha, por exemplo. Esse problema representa situações anormais (exceções) ou inválidas (erros) durante o processo de execução.
Os métodos “geram uma exceção” quando, por uma razão qualquer, falham. O controle, então, passa imediatamente ao “gestor de exceções” apropriado. Uma maneira de tratar exceções é pelo comando try/catch/finally:
No bloco try estão colocados os comandos que podem provocar o lançamento de uma exceção.
Essas exceções são capturadas em um ou mais comandos catch, colocados após o bloco try.
O comando finally contém código a ser executado, independente de outros comandos. É opcional, mas quando presente, é sempre executado.
Em Java, especificamente, existem classes específicas (classes de exceção) e que sempre utilizam o sufixo *Exception. Elas são utilizadas para tratar erros (exceções não verificadas) e exceções (exceções verificadas).

Exceções verificadas e não verificadas
Toda exceção verificada deriva da class Exception.
As não verificadas ou não-checadas derivam da class RuntimeException.
Throwable é o pai de todas as exceções.
Error não são exceções e sim erros que jamais poderiam ter acontecido. Por exemplo, o estouro da memória.
Exception são as classes que lançam exceções e não erros de programação. Exemplo: tentar abrir um arquivo que não existe. Então é lançado uma exceção verificada, porque a classe de leitura de arquivos deriva de Exception.
RuntimeException são exceções que indicam erros de programas (não de lógica, pois senão não passaria pelo compilador). Esse tipo de exceção é conhecido como não verificada. Sendo assim, não é requisito declarar uma cláusula try{} e catch{}. Ex.: tentar converter “dois” em “2”.
Erros são tratados através de RuntimeException e suas subclasses. Todas as outras classes de exceção são exceções verificadas.
As exceções verificadas são geralmente aquelas que um programa pode recuperar ainda em tempo de programação. Exemplos incluem FileNotFoundException, ParseException , etc. Um programador pode verificar se essas exceções usando o bloco try-catch ou simplesmente deixar que um outro ponto do código as verifique - utilizando a key-word "throws". Por outro lado, temos exceções não verificadas. Estas são as exceções que não acontecem se está tudo em ordem. Exemplos incluem ArrayIndexOutOfBoundException , ClassCastException , OutOfMemoryError , StackOverflowError , etc.


Referência
Uma exceção representa uma situação que normalmente não ocorre e representa algo de estranho ou inesperado no sistema.
Os erros em Java são um tipo de exceção que também podem ser tratados. Eles representam problemas na máquina virtual e não devem ser tratados em 99% dos casos, já que provavelmente o melhor a se fazer é deixar a JVM encerrar (ou apenas a Thread em questão).
Fonte: CAELUM
Veja este vídeo sobre tratamento de erros e exceções no JAVA
Exemplo utilizando os conceitos aprendidos


Abaixo está um exemplo de tratamento de erro ou exceção. Tentaremos atribuir uma String de letras a um objeto inteiro.
Como não é possível atribuir uma String de letras a um objeto inteiro, uma exceção de formato de número é lançada.
O código acima apresentará algo como:
Não é possível atribuir a string ABC a um Objeto Inteiro.
A seguinte mensagem foi retornada:
For input string: "ABC"
Perceba que a linha System.out.println("A variável i vale " + i) não foi executada, pois houve um erro na linha anterior. Portanto, apenas a mensagem de tratamento do erro NumberFormatException foi impressa na tela.


Exercício prático


Faça um programa Java que solicite dois números ao usuário e, em seguida, imprime o resultado da divisão do primeiro pelo segundo. Trate a exceção “ArithmeticException”. Teste o método “getMessage” de “Exception” e observe o tipo de mensagem.


Exercício teórico


Quando seria apropriado usar o método try/catch?


Bibliográfia
http://www.inf.pucrs.br/flash/lapro2/1-excecoes.pdf
Alunos

Gustavo Cortes  - RM: 71052
Filippe Eduardo - RM: 72381

Variáveis, Constantes, Operadores aritméticos e funções aritméticas.

Variáveis:


Os programas usam os recursos de hardware para executar algoritmos.
O processador executa os cálculos necessários.
A memória armazena dados e os serve para o processador.
O jeito que os programas utilizam para ler e escrever os dados(valor ou expressão)  da memória são conhecidos como variáveis.
Para simplificar a variável é um espaço na memória que reservamos e damos um nome  que pode ser alterado ao longo do tempo, sendo mais técnico, a variável é uma "posição" localizada em um determinado espaço na memória para representar um dado dentro do tempo de execução(runtime) do programa.

Por exemplo:

Criamos uma variável nomeada "idade" para armazenar a idade de uma pessoa.

Imagine uma gaveta etiquetada em uma cômoda.
Nessa cômoda existem 3 gavetas etiquetadas.
(Quando criamos uma variável especificamos que tipo de dado pode ser armazenado)
Para cada gaveta há uma "etiqueta"(um tipo de variável).
Nessa cômoda existem 3 etiquetas:

• uma chamada idade ;
• uma chamada nome;
• uma chamada altura;

Na gaveta da etiqueta idade só poderá ser armazenada números inteiros, nomes(letras,"textos", etc) e altura em números reais.
Concluindo, ao etiquetarmos estamos nomeando e definindo o tipo da variável onde aquela variável só vai aceitar dados daquele tipo.
=======================================================================
Tipos de Linguagens de dados e variáveis:

Geralmente os programas que trabalham com variáveis exigem alguns tipos de dados ou não .
A verificação deles pode variar conforme o sistema operacional e a linguagem de computador .
As linguagens podem ser classificadas como:
• fortemente tipadas: nela todos os tipos de variáveis precisam ser classificadas especificamente ;
(ex: Java, C, Fortran e Cobol).
• fracamente tipadas: nela os tipos de dados podem ser alterados durante a execução do programa ;
(ex: PHP, Javascript, Ruby e  Python).
• não tipadas: nela existe apenas um tipo de dado ou nenhum;
(ex: Linguagem de montagem, Assembly e  BCPL).

O tipo de Dado primitivo geralmente é o dado mais básico que pode ou não se corresponder com a memória.
O tipo de Dado composto é construído a partir de tipos primitivos e/ou compostos.
A ANSI (American National Standards Institute) determina os tipos de dados que todos os SGBD's(Sistema de Gerenciamento de Banco de Dados) devem possuir mas cada SGBD utiliza o nome que acha apropriado e relaciona com o tipo determinado pela ANSI.
Alguns tipos de dados mais comuns nas linguagens de programação:
•  inteiro: é um intervalo do conjunto dos inteiros;
•  caractere: um caractere;
•  booleano: possui apenas dois valores;
•  decimal: guarda um numero fixo de dígitos decimais;

=======================================================================
Exemplos de exercícios:
Considerando uma cômoda como um programa as gavetas como locais para armazenar as variáveis e as etiquetas como tipo de dados:
a) para armazenar uma palavra que tipo de dado usamos?
R:caractere
b) como podemos nomear uma gaveta onde queremos colocar camisas, bermudas e meias?
R:roupas


Monte um algoritmo no VisualG que descreva a soma de 2 números reais:

// Função : "Somar dois números reais"
// Seção de Declarações
var
num1,num2,resultado:real
inicio
// Seção de Comandos
escreval("digite um número:")
leia(num1)
escreval("digite outro número:")
leia(num2)

resultado <- num1+num2
escreval("a soma dos números digitados é:",resultado)
fimalgoritmo


http://foldoc.org/data+type

http://pt.wikipedia.org/wiki/Vari%C3%A1vel_%28programa%C3%A7%C3%A3o%29

http://www.decom.ufop.br/romildo/cea030.2011-1/slides/05-tipos-variaveis-expressoes.pdf
Pag: 18/56 variáveis II





=================================//==================================

Constantes

O que é uma constante?


Ao contrário das variáveis a constante é um espaço reservado na memória para armazenar um valor que não muda com o tempo, não podemos atribuir um novo valor, ela recebe um valor final imutável. Um exemplo marcante é o valor de PI (3.14159265359…) o PI não muda, nunca irá mudar! Logo é constante!

Como declaramos uma constante?

Utilizamos o modificador “final” e devem ser escritas com letras maiúsculas e separadas por uderline.

public class ExContantes1{
            private final long NUMERO_CONSTANTE = 380L;
            public final double OTHER_NUMBER = 180.35;
           
            public static void main (String[] args) {
                        final char VARIAVEL_CONSTANTE = 'A';

Agora é a sua vez!

Encontre o erro:

private Final double CONSTANTE = 100;
private final char otherConstante = ‘A’;
private final double NUMBER = 1000;


Referencias:







=================================//==================================



Operações Aritméticas

Operações aritméticas são comandos que nos permitem fazer cálculos aritméticos.


Tipos de operadores:

OPERADOR
OPERAÇÃO
TIPOS DOS OPERANDOS
TIPO DO RESULTADO
+
adição
inteiro
inteiro


real
real




-
subtração
inteiro
inteiro


real
real




*
multiplicação
inteiro
inteiro


real
real




/
divisão
inteiro
real


real
real




div
divisão inteira
inteiro
inteiro




mod ou %
resto da divisão inteira
inteiro
inteiro

=======================================================================
Prioridades de operadores:
Alguns dos operadores tem prioridades mais altas do que outros, o que significa que a ordem do qual será feito o cálculo começará por eles. Ordem por prioridade mais alta a mais baixa:
*, /, div, mod; +, -.

Exceções de prioridades:
Há alguns casos onde as prioridades não são válidas, como no uso de parênteses onde os números que estão dentro dos parênteses terão a prioridade.

Se houver um cálculo com operadores de mesma prioridade o cálculo será feito na ordem em que aparecem da esquerda para a direita.

=======================================================================
Exemplo de uso dos operadores:
Adição:                 4+2=6:inteiro        2,25+3,35=5,6:real
-------------------------------------------------------------------------------
Subtração:             4-2=2:inteiro        6,5-1,15=5,35:real
-------------------------------------------------------------------------------
Multiplicação:        4*2=8:inteiro        1,2*5=6:real
-------------------------------------------------------------------------------
Divisão:                 5/2=2,5                6,3/3=2,1:real
-------------------------------------------------------------------------------
Divisão inteira:       4div2=2:inteiro
-------------------------------------------------------------------------------
Resto da divisão:   10(mod ou %)3=1

=======================================================================
Descrição do site sobre o assunto:
Fáceis de utilizar, parecem muito com um cálculo realizado em uma calculadora comum. Vejamos uma tabela com os operadores básicos:


Operador
Cálculo Realizado
Exemplo
Resultado
+
Soma entre dois números
4 + 8
12
-
Subtração entre dois números
32 – 9
23
*
Multiplicação entre dois números
6 * 8
48
/
Divisão entre dois números
48 / 16
3
%
Resto da divisão entre dois números
21 % 2
1



O único operador que talvez nem todos conheçam ou se lembrem é o operador de resto da divisão. Funciona assim: Digamos que você divida 10 por 3. O resultado dá 3 e sobra 1. Então, se utilizarmos o operador de resto da divisão (também conhecido como módulo) para esse mesmo cálculo, o resultado será 1. Se fizéssemos 20 % 3 o resultado seria 2 ou seja, o resto da divisão de 20 por 3.

=======================================================================
Exercícios:
Teórico:
Descreva uma situação onde a prioridade do operador não será válida.

Prático:
Resolva o cálculo: 3+(10*(8/4))/5

=======================================================================
Links dos sites:
http://www.cultura.ufpa.br/ferreira/Disciplinas/Programacao/OperadAritmLog.htm
http://www.activeinfo.com.br/curso_programacao/operadores_aritmeticos.html

=======================================================================

Abaixo temos uma videoaula exemplificando o caso:




=================================//==================================


Funções Aritméticas:

Em java, temos a classe java.lang.Math que fornece diversos métodos estáticos permitindo trabalhar com funções e operações matemáticas, como trigonometria, exponenciação,
radiciação, módulo ou valor absoluto. Como os métodos são estáticos,
eles só precisam ser referenciados através do nome
da classe, sem necessidade de uma instância para ela.
Valor absoluto (módulo)
Existem quatro métodos que retornam o valor
absoluto de um número, todos eles chamados abs. Os métodos
abs() aceitam os tipos int, float, long e double.
Exemplo:
public static int abs(int a);
public static float abs(float a);
public static long abs(long a);
public static double abs(double a);

Para retornar o valor absoluto do float utilizando o método abs(), teremos:
float num = -2,5F;
num = Math.abs(num);
// retornando o valor 2,5F

Método Sqrt()
Para que nossos programas possam extrair a
raiz quadrada de algum número usaremos o método sqrt() da
classe Math. Veja o seu formato:
public static double
sqrt(double a) throws ArithmeticException;


Podemos obter pelo método sqrt(), por exemplo,
o valor da raiz quadrada de 2,5:
float num = 2,5F;
num = (float) Math.sqrt(num);
// retorna 1,58113


Podemos observar nesse exemplo uma conversão
explícita que atribui um valor de retorno do tipo double a
um float (o método sqrt() retornará sempre um float).
Método cos()
No estudo das relações trigonométricas em um
triângulo retângulo, o cosseno relaciona o cateto adjacente
à hipotenusa do triângulo, como mostra a figura abaixo:
Usaremos o método cos() da classe Math para
retornar o cosseno de um ângulo. Veja o formato deste método:
public static double
cos(double a);


Podemos obter, por exemplo, o cosseno do ângulo
1,047197 é obtido da seguinte forma:
double num, angle = 1,047197D;
num = Math.cos(angle);
// retorna 0,5


As instruções acima atribuirão à variável um
valor de 0,707107 para o cosseno do ângulo 0,785398. É importante reforçar que quando trabalharmos com ângulos, estaremos semprevlidando com valores em radianos.

Para entender melhor sobre o assunto, temos a tabela abaixo com mais funções e em outras linguagens:
Português Estruturado
Descrição
Java
Javascript
Ruby
quad(x)
Eleva ao Quadrado
Math.pow(x, 2)
Math.pow(x, 2)
x ** 2
exp(x, y)
Exponenciação
Math.pow(x, y)
Math.pow(x, y)
x ** y
raiz(x)
Raiz Quadrada
Math.sqrt(x)
Math.sqrt(x)
Math.sqrt(x)
abs(x)
Número sem sinal
Math.abs(x)
Math.abs(x)
x.abs
arredonda(x)
Arredonda o número para cima ou para baixo dependendo dos números após o ponto
Math.round(x)
Math.round(x)
x.round
pouco utilizado
Retorna o maior valor inteiro menor ou igual ao número dado
Math.floor(x)
Math.floor(x)
x.floor
pouco utilizado
Retorna o menor inteiro maior ou igual ao número dado.
Math.ceil(x)
Math.ceil(x)
x.ceil
pouco utilizado
Retorna um número aleatório entre 0 e 1.
Math.random()
Math.random()
rand()



Exemplo das funções em java:






Executando as funções acima, resulta na próxima imagem:









Descanso:

Faça um cálculo em java utilizando algumas das funções que retorne e exiba a raiz quadrada do resultado.



Descanso teórico:

No exemplo abaixo, o valor a ser exibido no resultado é um valor randômico ou um valor fixo?


public class Exemplo {

public static void main(String[] args) {

int limiteInferior = 5;
int limiteSuperior = 10;
int alcance = limiteSuperior - limiteInferior;

double coeficiente = Math.random();

System.out.println( Math.round(limiteInferior + coeficiente * alcance));

  }
}

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

Mais sobre funções:




================ Grupo GETR ===================

Integrantes:

Eduardo Keiti Gushiken

George Luis

Rodrigo Teixeira 

Thomas Ruibasciki