Por João Araujo (adaptado do curso de Oscar Farias).

1. Linguagem totalmente Orientada a Objetos
2. Portabilidade
3. Alta Performance
4. Facilidades para Processamento Distribuído
5. Ambiente Seguro

Cada SO necessita que o programa seja recompilado

• Código C → Compilador C → Executável para Windows
• Código C → Compilador C → Executável para Linux
• Código C → Compilador C → Executável para Mac

• JVM = Java virtual machine.
• JRE = Java Runtime Environment, ambiente de execução Java, formado pela JVM e bibliotecas, tudo que você precisa para executar uma aplicação Java.
• JDK = Java Development Kit: Para desenvolvedores, ou seja, quem quiser programar em Java.

• É a tecnologia padrão do Java.
• Necessário para desenvolver e executar as aplicações Java.

• É a tecnologia baseada em componentes distribuídos do Java, para aplicações empresariais.
• Visa o desenvolvimento de aplicações de grande porte.

• É a tecnologia voltada ao desenvolvimento de aplicações para dispositivos leves e móveis.

• Java tem baixa produtividade para sistemas pequenos.
• Deve ser usada em projetos de médio e grande porte.

Exceção (parcial): os tipos de dados primitivos. Estes tipos são padronizados para todas as plataformas. São eles:

<note warning>Java não tem tipos unsigned!</note>

São usados para representar os tipos de dados primitivos.
Iniciando com:

• 0 → octais
• 0x ou 0X → hexadecimais
• literais maiores que 0x7FFFFFFF (2.147.483.647) são automaticamente assumidos como long. Qualquer literal inteiro seguido de l ou L é um long.

• floating-point: contêm expoente ou ponto decimal.
• Podem ser float ou double.
• Por default são do tipo double.
  • Ex.: 6.2832, 0.1, 10E-13, 2.5 E12 (double)
  • Float: 45.34F, 0.1F, 2.7987F, 11.3E-23F.
  • Double:23.52D, 1..88E-3D.

• Booleans: Podem assumir um dos dois valores (constantes) true ou false. Não pode haver cast para inteiros.
• Character: são representados por um único caracter entre aspas. Ex.: ‘a’, ‘ ‘.
  • Um character pode também ser definido por : ‘\xNN’, onde NN é o valor UNICODE do caracter.
• Seqüências de escape são usadas para representar caracteres especiais e são precedidas por uma barra invertida (\).
  • \n new line, \t tab, \r carriage return, \b backspace

// A program to display the message
// "Hello World!" on standard output
public class HelloWorld {
   public static void main(1.5.0/docs/api/java/lang/String.html">String[] args) {
       1.5.0/docs/api/java/lang/System.html">System.out.println("Hello World!");
   }
}    // end of class HelloWorld

public class program-name   {
     optional-variable-declarations-and-subroutines
    public static void main(1.5.0/docs/api/java/lang/String.html">String[] args) {
        statements
    }
     optional-variable-declarations-and-subroutines
}

• Para compilar um programa em bytes codes independentes de arquitetura:
  • javac <filename>
  • filename é um arquivo .java
• O compilador gera um arquivo <classname>.class para cada classe. Cada arquivo contém os byte-codes para a classe correspondente .
• O interpretador JAVA executa os byte-codes
  • java <classname>

• Bytecodes não são legíveis pelo seres humanos.
• Podemos ler os mnemônicos com o programa javap
• javap -c HelloWorld

Compiled from "HelloWorld.java"
class HelloWorld extends java.lang.Object{
HelloWorld();
  Code:
   0:	aload_0
   1:	invokespecial	#1; //Method java/lang/Object."<init>":()V
   4:	return

public static void main(java.lang.String[]);
  Code:
   0:	getstatic	#2; //Field java/lang/System.out:Ljava/io/PrintStream;
   3:	ldc	#3; //String Hello World!
   5:	invokevirtual	#4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   8:	return

}

• javac HelloWorld.java
• java HelloWorld

/**
 * This class implements a simple program that
 * will compute the amount of interest that is
 * earned on $17,000 invested at an interest
 * rate of 0.07 for one year. The interest and
 * the value of the investment after one year are
 * printed to standard output.
 */
// One line comment

public class Interest {
   public static void main(String[] args) {
 
double principal; // The value of the investment.
double rate;      // The annual interest rate.
double interest;  // Interest earned in one year.
 
principal = 17000;
rate = 0.07;
interest = principal * rate;   // Compute the interest.
principal = principal + interest;
      // Compute value of investment after one year, with interest.
      // (Note: The new value replaces the old value of principal.)
System.out.print("The interest earned is $");
System.out.println(interest);
System.out.print("The value of the investment after one year is $");
System.out.println(principal);
   } // end of main()
} // end of class Interest

• Uma variável tem um tipo, que não pode ser mudado.
  • int a;
• podemos atribuir valores
  • a = 20;

podemos também dar a carga inicial quando declaramos:

   int a = 20;
   double pi = 3.14;
   double x = 3 * 5;
   boolean verdade = true;
   char letra = ’a’;

• Em algumas situações, valores de variáveis são incompatíveis para atribuição:

  double var_double = 3.1415;
  int var_int = var_double; // não compila
  int var_int1 = 3.14; // não compila
  double var_double1 = 5; // ok, o double pode conter um número inteiro
  int var_int2 = var_double1; // não compila

Do menor para maior, funciona:

  int i = 5;
  double d2 = i;

• Um tipo pode ser interpretado como outro.

  double d3 = 3.14;
  int i = (int) d3;

  float x = 0.0;//Não funciona
  float x = 0.0f;// Funciona
  double d = 5;
  float f = 3;
  float x = f + (float) d;

• if statement
• for loop
• while loop
• switch statement

	if  (boolean expression)  {
   		//... qualquer número de comandos
	}
	else  {
 		//... qualquer número de comandos
	}

	while (boolean expression)  {
		  //... qualquer número de comandos
	}
 
	do  {
		  //... qualquer número de comandos 
	}  while (boolean expression);

	for (expr1; expr2; expr3) {
		//...qualquer número de comandos
	}

Equivalente a:

	avalia expr1;  //inicialização do loop
	while (expr2) {
		//... Qualquer número de comandos
	     avalia expr3 // expressão para controlar o loop
	}

	switch (expr)  {
		case cexpr1:  
			// comandos JAVA
			break;
		case cexpr2:  
			// comandos JAVA
			break;
		... 
		case cexprn:  
			// comandos JAVA
			break;
		default:
			// mais comandos JAVA
	}

• Não se pode declarar um array com um tamanho pré-definido.
• Deve ser declarado como uma variável não inicializada.
• Podem ser usados para classes e tipos primitivos de dados

	int		numbers[];     //para arrays de inteiros
	String	myStrings [];  // para arrays de objetos do tipo string	
	String[]	myStrings;      //forma alternativa

• O próximo passo é criar o array através do uso do operador new.
• Constrói-se uma instância do objeto.

    int numbers[] = new int[5];  //array de inteiros, de dimensão 5.
    String  myStrings[] = new Strings[20] ;  //array de Objetos String, de dimensão 20.

• Os slots ainda nada contêm.
• Todavia são inicializados com valores default (inteiros: 0; objetos String: null).
• Finalmente atribuem-se valores aos elementos do array.

	myStrings[0] = “My first String”;
	myStrings[1] = “My second String”;
	numbers[0] = 20;

• IndexOutOfBoundException (índice inválido)
• Uma variável instância pública chamada length é usada para se obter o tamanho do array.

	Int	q = numbers.length;   // q = 5

• JAVA não suporta arrays multidimensionais
• Podem ser simulados através de arrays de arrays <

	int k[][] = new int[5][4];
	k[1][3] = 100;	//atribui valor a um dos elementos do array

Outra forma de se criar um array:

	int z[][];
	int outerSize = 5;
	int innerSize = 4;
	z = new int[outerSize][innerSize];

class TestArray { 
	public static void main (String args[]) {
 	int z[][];
	int outerSize = 5;
	int innerSize = 4;
    	z = new int[outerSize][innerSize];
	int i, j , k;  // linha --> i;  coluna --> j
	for (i = 0, k = 0; i < innerSize; i++)
		for (j = 0; j < outerSize; j++) {
			z[j][i] = k++;
			System.out.println("i = " + i + " j = " + j + " " + z[j][i]);
		}

   	int w[][] = new int[10][];
	w[0] = new int[5];
	w[3] = new int[3];
	System.out.println (w.length + "  " + w[0].length + " "+ w[3].length);
	w[10] = new int[3];	  // OutOfBoundException  
 
	/* int y[][] = new int [10][];	   // missing array dimension  
	y[0][] = new int [5];	   // missing array index 
	y[][2] = new int [10]; */
	}
}

• Um dos grandes desafios para os programadores sempre foi o de como manipular erros em tempo de execução de modo elegante e eficiente.
• Na programação tradicional usava-se o comando return para se passar um código indicando erro ou sucesso.
• O código ficava sobrecarregado com uma série de if …else em torno de cada chamada à função.
• Frequentemente os programadores ignoravam o código de retorno e omitiam o código necessário ao tratamento dos erros, levando o programa a terminar de maneira abrupta e inesperada.
• A causa dos erros não se tornava logo visível.

• Um exception handler é freqüentemente chamado de um bloco try-catch.
• No bloco try encontra-se o código a ser executado e que corresponde ao curso de ação normal.
• Se ocorrer um erro, Java ou o método chamado podem gerar um objeto (exception object) para indicar o problema.
• O exception object é passado ao run-time system em busca de um modo para tratar (handle) o erro.
• O ato de passar o exception object para o run-time system é chamado throwing an exception.

try {
   double x;
   x = Double.parseDouble(str);
   System.out.println( "The number is " + x );
}
catch ( NumberFormatException e ) {
   System.out.println( "Not a legal number." );
}

enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY }
Day weekday; // User’s response as a value of type Day.
while ( true ) {
   String response; // User’s response as a String.
   TextIO.put("Please enter a day of the week: ");
   response = TextIO.getln();
   response = response.toUpperCase();
   try {
      weekday = Day.valueOf(response);
      break;
   }
   catch ( IllegalArgumentException e ) {
      TextIO.putln( response + " is not the name of a day of the week." );
   }
}

Fim deste módulo