Caracteristicas Básicas.

    ~Ryokusei™~
    ~Ryokusei™~
    Programador
    Programador

    Posts : 6
    Data de inscrição : 05/09/2010

    Caracteristicas Básicas. Empty Caracteristicas Básicas.

    Mensagem por ~Ryokusei™~ em Qui Set 09, 2010 7:33 pm

    Responder com citação

    caracteristicas basicas

    Mensagem •Admin• em Dom 5 Set 2010 - 13:52
    Características Básicas

    Este capítulo apresenta as características básicas da linguagem, como identificadores, palavras chave, valores literais, tipos de dados e operadores.
    3.1 Palavras chave e valores literais

    Java possui 49 palavras chave, todas elas são escritas em minúsculas:

    byte - short - int - long - char - boolean - double - float - public - private - protected - static - abstract - final - strictfp - transient - synchronized - native - void - class - interface - implements - extends - if - else - do - default - switch - case - break - continue - assert - const - goto - throws - throw - new - catch - try - finally - return - this - package - import - instaceof - while - for - volatile - super

    Possui três identificadores que são valores literais:

    null, false, true

    Cada uma dessas palavras serão vistas mais adiante no tutorial.
    3.2 Tipos primitivos

    Existem somente oito tipos primitivos em Java, todo o resto é objeto. Estes tipos ficaram na linguagem pela sua velocidade de intera´ão, e por isso não foram transformados em Objetos. Como não são objetos a sua declara´ão já cria a variável em memória não necessitando de construtores.

    Nesta se´ão os tipos Array e String não são tratados, pois não são considerados tipos primitivos. Ambos são classes e serão tratadas no capítulo sobre classes.
    3.2.1 Numéricos inteiros

    Todos esses tipos possuem uma representa´ão interna em complemento de dois. O valor default para esses atributos é 0 e cada vez que se usar uma constante numérica no código fonte ela será um int a não ser que se coloque a constante? L? no final do número.

    * byte - Tamanho de 8 bits com sinal. Valores de - 128 a + 127.
    * short - Tamanho de 16 bits com sinal. Valores de - 32.768 a + 32.767.
    * int - Tamanho de 32 bits com sinal. Valores de - 2.147.483.648 a + 2.147.483.647.
    * long - Tamanho de 64 bits com sinal. Valores de - 9.223.372.036.854.775.808 a + 9.223.372.036.854.775.807.

    Exemplo:

    100L = > long
    100 = > int
    0L = > long
    0 = > int

    Não existe os tipos unsigned, long int ou short int em Java.
    3.2.2 Ponto flutuante

    Os pontos flutuantes seguem a representa´ão IEEE 754, sendo que 0.0 é o valor default. No código fonte, tudo o número com decimais será um float a não ser que o caractere ? d ? ou ? D ? estejam no final do número.

    * float - Tamanho de 32 bits com sinal. Valores de - 1.40239846E-45 a + 3.40282347E + 38 (com nove dígitos significativos de precisão).
    * double - Tamanho de 64 bits com sinal. Valores de - 4.94065645841246544E-324 a + 1.79769313486231570E + 308 (com 18 dígitos significativos de precisão).

    Exemplo:

    100.0 = > float
    100.00d = > double
    0 = > float
    0f = > float
    0d = > double

    3.2.3 Caractere

    O caractere guarda o valor traduzido de um código ASCII. Seu valor default é o código zero, \ 0;



    char - Caractere Unicode com tamanho 16 bits sem sinal. Valores possíveis 0 a 65535

    O char também pode ser representado por um numero inteiro de 16 bits sem sinal, ou seja, pode-se atribuir Ã* uma variável char o valor 100 ou o valor 65535, pois se está operando com os valores da tabela Unicode que representam caracteres de qualquer idioma.
    3.2.4 Booleano

    Tipos boleanos identificam verdadeiro ou falso e podem ser utilizados diretamente em expressões de retorno para testes como if, switch, while e for., porém não podem ser comparados com variáveis ou constantes numéricas como em C.

    boolean - Valor indicando true ou false. Tamanho de 8 bit.

    3.2.5 Valores padrão

    Abaixo segue uma lista com os valores padrões de todos os tipos primitivos, sendo que não é necessário inicializar as variáveis com esses valores, a máquina virtual cuidará desse trabalho.



    * byte = 0;
    * short = 0;
    * int = 0;
    * long = 0;
    * float = 0.0;
    * double = 0.0;
    * boolean = false;
    * char = ` \ u0000 ';
    * Object = null;

    Um objeto, como veremos mais adiante, é inicializado com valor null, pois ele necessita que a instância seja criada explicitamente, o que não ocorre em tipos primitivos.
    3.3 Identificadores

    Os identificadores em Java iniciam com uma letra, um sublinhado ? _ ? ou um sinal de dólar " $ " e podem possuir números após o primeiro caractere da palavra. Pela premissa de ser case-sensitive existe uma diferencia´ão entre letras maiúsculas e minúsculas. Identificadores válidos são: identificador, meu_Carro, MeuCarro2, _atributo, $bola _2seg

    Identificadores usados para determinar nomes de variáveis, atributos de classe ou de instância, parâmetros e métodos.
    3.4 O operador de atribui´ão

    O sinal de atribui´ão em Java é o " = " igual ao " = " do C e ao ": = " do Delphi. Vale deixar gravado que a compara´ão é feita com " = = " como no C. Uma atribui´ão é feita com a seguinte sintaxe:

    = ;

    Veja o exemplo:

    public class Atribui´ão {
    public static void main (String [] args) {
    int x = 1;
    int y = 5;
    }
    }

    No exemplo é atribuído as variáveis inteiras x e y os valores 1 e 5 respectivamente.
    3.5 Literais

    O valor literal é um valor escrito no código fonte e identificado como de um tipo primitivo.

    int x = 1; // literal inteiro
    char u = 'a'; // literal char
    boolean b = true; // literal boolean
    double d = 002.11d; // literal double

    Há três maneiras de representar literais numéricos inteiros em Java:

    - octal (base Cool. Representado com um 0 na frente de cada valor numérico. Exemplo:

    int x = 01;
    int x = 0931;
    int x = 021;

    - hexadecimal (base 16). Representado com um 0x na frente de cada valor numérico. Exemplo:

    int quinze = 0xF; // 15 (decimal)
    int vinte_e_nove = 0x1D; // 29 (decimal)
    int vinte_e_nove = 0x1D; // 29 (decimal)
    int valor = 0xBAFAFA; // 12253946 (decimal)
    int valor = 0XBaFaFa; / / 12253946 (decimal)

    - decimal (base 10). Representado normalmente como o primeiro exemplo.

    Caracteres também possuem representa´ão especial. Todo o caractere se encontra entre aspas simples, porém pode-se atribuir um valor inteiro ao caractere sem precisar de uma conversão explícita. Alguns exemplos são:

    char a = 'A'; // letra A
    char b = '&'; // caractere &
    char c = '\u004D'; // letra M (Unicode)
    char d = '\n'; // Pula de linha
    char e = '\t'; // Tab
    char f = '\r'; // Retorno de carro
    char g = '\b'; // Backspace
    char h = '\f'; // FormFeed
    char i = ''; // Barra
    char j = '''; // Apostrofo
    char k = '"'; // Aspas duplas
    char l = 65; // char recebe o valor de um int
    char m = (char) -1; // fora do intervalo, conversão explícita
    char n = (char) 100000; // fora do intervalo, conversão explícita

    3.6 Conversões entre tipos primitivos

    Existem duas maneiras de fazer conversões de tipos:

    1. Conversão implícita, quando o tamanho de uma variável é maior que o tamanho da variável ou o valor que está sendo atribuído. Exemplo:

    int y = 10;
    long x = y;

    O tamanho de int é menor que o de long, portanto é perfeitamente aceitável.

    2. Conversão explícita, quando o tamanho de uma variável é menor que o tamanho da variável ou o valor que está sendo atribuído. Exemplo:

    long y = 10L;
    int x = (int) y;

    O tamanho de long é maior que o de int, portanto necessita indicar uma conversão. Esta indicativa é feita pelo tipo da variável, que irá receber o valor, entre parênteses: (int). Se esta informa´ão não for colocada, ocorreria um erro de compila´ão indicando tipos incompatíveis. Outra forma é usar as constantes de identifica´ão de tipos para fazer uma conversão explícita, como em: long y = 10L;
    3.7 Operadores aritméticos

    Operadores aritméticos são aqueles que efetuam opera´ões aritméticas em um ou mais tipos primitivos. A seguir são apresentados os operadores aritméticos unários, que atuam sobre um único identificador.

    Op Nome Uso Descri´ão
    ++ Incremento var++ / ++var Retorna e adiciona / adiciona e retorna.
    -- Decremento var-- / --var Retorna e subtrai / subtrai e retorna.
    - Negativo -var Inverte o sinal da variável
    + Positivo +var Não tem efeito.

    Abaixo estão os operadores aritméticos que atuam sobre duas variáveis.

    Op Nome Uso Descri´ão
    + Adi´ão x + y Soma x com y.
    - Subtra´ão x - y Subtrai y de x.
    * Multiplica´ão x * y Multiplica x por y.
    / Divisão x / y Divide x por y.
    % Resto x % y Resto da divisão de x por y.

    3.8 Operadores relacionais e lógicos

    Os operadores relacionais e lógicos são utilizados em testes e condi´ões de entrada em um fluxo do programa. Abaixo estão todos eles relacionados.

    Op Nome Uso Descri´ão
    > Maior que x > y x maior que y.
    >= Maior ou igual a x >= y x maior ou igual a y.
    < Menor que x < y x menor que y
    <= Menor ou igual a x <= y x menor ou igual a y.
    == Igual a x == y x igual a y.
    != Diferente de x != y x diferente de y.
    ! NÃO lógico (NOT) !y contrário de y.
    && E lógico (AND) x && y x e y.
    || OU lógico (OR) x ||y x ou y.
    instanceof Verif Instância x instanceof X x é instância da classe X

    3.9 Operadores bitwise

    Os operadores bitwise são aqueles que alteram o valor das variáveis em opera´ões lógicas diretamente no processador, tornando-as muito mais performáticas. Estas opera´ões são geralmente chamadas de ? tratamento por bits ? pois são opera´ões que comparam e modificam a variável bit por bit.

    Op Nome Uso Descri´ão
    ~ Inversão ~x Inversão dos bits de x.
    & E lógico x & y AND bit a bit entre x e y.
    | OU lógico x | y OR bit a bit entre x e y.
    ^ OU excl. lógico x ^ y XOR bit a bit entre x e y.
    << Desloc. a esq. x << y Desloc. a dir os bits de x, y vezes.
    >> Desloc. a dir. x >> y Desloca a direita os bits de x, y vezes.
    >>> Desloc. a dir. x >>> y Preenche zero a esquerda de x, y vezes.

    3.10 O operador de atribui´ão composto

    Já foi apresentado o operador de atribui´ão " = ". Porém este operador pode funcionar em conjunto com outros operadores reduzindo o tempo de processamento de determinadas chamadas. O operador de atribui´ão composto junta um operador aritmético ou de bitwise com o operador de atribui´ão. É sempre utilizado na sintaxe var = var como no exemplo abaixo:

    public class OperadorAtribuicaoComposto {
    public static void main (String [] args) {
    int x = 1;
    x + = 5;
    }
    }

    Neste exemplo a variável inteira x é inicializada com 1 e na linha seguinte é realizado uma opera´ão composta: A soma e atribui´ão. Esta instru´ão é semelhante a esta: x = x + 5;. O resultado em x será 6. Outros exemplos são:

    public class OperadorAtribuicaoComposto {
    public static void main (String [] args) {
    int x = 1; // Atribui 1 a x
    x += 5; // Equivalente a x = x + 5; x é igual a 6
    x *= 2; // Equivalente a x = x * 2; x é igual a 12
    x /= 2; // Equivalente a x = x / 2; X é igual a 6
    x -= 3; // Equivalente a x = x - 3; x é igual a 3
    x %= 5; // Equivalente a x = x % 5; x é igual a 3
    x |= 4; // Equivalente a x = x | 4; x é igual a 7
    x ^= 1; / / Equivalente a x = x ^ 1; x é igual a 6
    x &= 255; / / Equivalente a x = x & 255; x é igual a 6
    x <<= 2; / / Equivalente a x = x << 2; x é igual a 24
    x >>= 4; // Equivalente a x = x > > 3; x é igual a 1
    x >>>= 7; / / Equivalente a x = x > > > 7; x é igual a 0
    }
    }

    3.11 Precedência de operadores

    Tabela de precedência de operadores em ordem decrescente, ou seja, o que está mais acima, ocorre antes.
    Precedência
    + + - - + - ! (cast)
    * / %
    + -
    << >> >>>
    <>< = > = instanceof
    = =! =
    &
    ^
    |
    &&
    | |
    ?:
    = * = / = % = + = - = << = >> = >>> = & = | =
    4 Comandos de decisão, repeti´ão e desvio

    Este capítulo apresentará o extremamente necessário para a constru´ão de qualquer sistema em Java. Declara´ão de variáveis, comandos de decisão, repeti´ão e desvio de fluxo no programa. 4.1 Declara´ão e Inicializa´ão de Variáveis
    A declara´ão de variáveis em Java pode ser feita em qualquer local do código fonte desde que esteja dentro de uma classe. Quando a declara´ão da variável é feita globalmente, ou seja, na estrutura da classe, é dita que a variável é um atributo, caso contrário ela continua sendo chamada de variável. O escopo ou a vida de uma variável em Java dura de acordo com o bloco onde ela foi declarada. A variável é criada no primeiro acesso a ela e destruída após o interpretador sair do bloco de execu´ão ao qual ela pertence.

    Em Java a declara´ão de variáveis é feita pelo tipo e depois um identificador. A declara´ão muitas vezes é acompanhada pela inicializa´ão a qual acrescenta o sinal de atribui´ão e um valor literal ou variável.

    A declara´ão de uma variável é feita no formato:

    Tipo identificador [= valor_inicial];

    Observando o exemplo 4.1 pode-se identificar várias maneiras de declarar inicializar tipos primitivos e objetos. Na linha 3 existe uma declara´ão simples, ela está criando uma variável byte e o valor de bt será 0. Na linha 4 há a declara´ão de três variáveis do tipo short: sht1, sht2 e sht3. Todas as três serão inicializadas com zero. Na linha 5 existe a declara´ão de um inteiro i e a sua inicializa´ão atribuindo o valor 9 para a variável. Na linha 6 há duas variáveis sendo criadas: f1 e f2, ambas receberão o mesmo valor 98.76. Na última linha existe a declara´ão de uma variável de tipo complexa String. String é a classe que armazena uma cadeia de caracteres sem tamanho definido em Java. No exemplo, ela está sendo inicializada com a cadeia " TESTE ". Exemplo:

    public class DeclarandoVariáveis {
    int atributo = 9; // Declarando uma variável global => Atributo.

    public void main(String[] args) {
    byte bt; // Declara´ão simples
    short sht1, sht2, sht3; // Declara´ão múltipla
    int i = 9; // Declara´ão e inicializa´ão
    float f1, f2 = 98.76 // Declara´ão e inicializa´ão múltipla
    String str = "TESTE" // Declara´ão e cria´ão de um objeto String
    }
    }

    4.2 Instru´ões de Desvio

    Linguagens de alto nível implementam várias estruturas de controle do fluxo do programa para facilitar o desenvolvimento de programas e promover um melhor estilo de programa´ão. Os comandos de sele´ão e repeti´ão são mais empíricos do que os comandos tradicionais em linguagem de máquina.

    Java possui duas instru´ões de desvio condicionais mais uma palavra reservada que não deve ser usada. Todas elas existem em várias outras linguagens e plataformas.
    4.2.1 Comando: if

    O comando if executa um trecho de código apenas uma vez, dependendo de sua condi´ão. A sintaxe segue a sintaxe abaixo.

    if ( <condi´ão> ) {
    <comandos>
    } else {
    <comandos>
    }


    A condi´ão é uma expressão da linguagem java e pode ser qualquer conjunto de opera´ões que retornem um valor booleano. Ex: (i > = 0) ou (a = = 5 & & b! = 5 | | c = = a) O " comandos 1 " e " comandos 2 " são um conjunto de um ou mais comandos da linguagem Java. No caso de ser apenas um comando o uso de {} não é necessário.

    Se a condi´ão for verdadeira o interpretador executará o " comandos 1 " caso contrário o bloco " comandos 2 " será executado. Exemplo:

    public class ExemploIf {
    public static void main(String[] args) {
    int i = 8;
    // If que dirá se o valor do i é igual a 1 ou igual a dois.
    if (i \% 2)
    System.out.println("Oito é divisível por dois");
    else
    System.out.println("Oito não é divisível por dois");

    // Verifica se o nome é Vitor.
    String nome = "Vitor";
    if (nome.equals("Vitor")) {
    System.out.println("Nome é Vitor");
    } else {
    System.out.println("Nome não é Vitor");
    }
    }
    }

    No primeiro if do exemplo é testado se o valor de i é divisível por 2, ou seja, se valor de i é par. Se for divisível, é impresso o texto Oito é divisível por dois, caso contrário é impresso o texto Oito não é divisível por dois na linha de comando.

    No segundo exemplo é feito um teste para saber se a variável String nome é igual a Vitor. Em compara´ão de objetos sempre usa-se o método equals. Se o valor de nome for Vitor é impresso Nome é Vitor, caso contrário é impresso Nome não é Vitor.
    4.2.2 Comando: switch

    O comando switch é o mesmo do C e é semelhante ao case do Delphi. Permite selecionar o bloco de código a ser executado baseado no teste lógico de uma expressão. O switch é a forma evoluída para o if, podendo tratar mais de dois blocos de execu´ão.

    Sintaxe:

    switch ( <expressão> ) {
    case <valor1>:<comandos 1>
    [break;]
    case <valor2>:<comandos 2>
    [break;]
    case <valor3>:<comandos 3>
    [break;]
    case <valor4>:<comandos 4>
    [break;]
    ...
    default: <comandos default>
    }

    O comando switch executa a expressão e compara o valor encontrado com os valores: , , , etc. Quando encontra a igualdade ele executa o bloco de comandos daquele valor. A execu´ão continuará até o final do switch ou até que ele encontre um break;. Exemplos:

    public class ExemploSwitch {
    public static void main(String[] args) {
    int i = 2;
    // Switch que irá imprimir na tela o valor 2
    switch (i) {
    case 1 : System.out.println("Valor de i é 1");
    break;
    case 2 : System.out.println("Valor de i é 2");
    break;
    case 3 : System.out.println("Valor de i é 3");
    break;
    default: System.out.println("Default");
    }

    // Switch que irá imprimir na tela o valor "Vitor"
    String nome = "Vitor";
    switch (nome.hashcode()) {
    case "Vitor".hashCode() : System.out.println("Valor de nome é Vitor");
    break;
    case "Paulo".hashCode() : System.out.println("Valor de nome é Paulo");
    break;
    default: System.out.println("Default");
    }
    }
    }

    Não é necessário utilizar as chaves ({}) para delimitar um bloco de comandos, pois o interpretador executará todos eles até encontrar um break ou o switch finalizar.

    A única limita´ão do switch é que a deve retornar um valor numérico inteiro, qualquer um de seus quatro tipos primitivos. O switch não funciona com String, float, char e boolean por exemplo. E é por este motivo que no segundo switch do exemplo é utilizado o método hashcode (), que retorna um código inteiro único para cada String diferente.
    4.2.3 Comando: goto

    Há um consenso entre os desenvolvedores de software de que instru´ões goto devem ser usadas somente para criar estruturas de controle, de sele´ão ou repeti´ão, caso elas não existam na linguagem trabalhada. E é exatamente por isso que, embora a palavra goto seja uma palavra reservada do Java, ela não pode ser utilizada, o compilador Java acusará erro se encontrá-la no código.

    Os especialistas afirmam que o goto polui o código fonte e se não for utilizado adequadamente pode se tornar um problema maior do que o próprio software.
    4.3 La´os

    La´os controlam uma repeti´ão de execu´ão de acordo com uma condi´ão imposta. Em Java, assim como tantas outras linguagens, existem três tipos de la´o: for, while e do.. while.
    4.3.1 Comando: for

    O comando for cria um la´o de repeti´ão no fluxo do programa baseado em três parâmetros:

    * expressão inicial: Onde é executado apenas uma vez, na entrada do la´o.
    * condi´ão: É executado a cada itera´ão do la´o e determina quando o programa deve sair do mesmo. Caso a condi´ão seja verdadeira, repete-se os do la´o uma vez, caso seja falsa, o programa pula para a próxima instru´ão seguinte ao la´o.
    * incremento: É uma opera´ão normal, executada a cada itera´ão. Geralmente é usada para incrementar contadores ou configurar variáveis.

    Sintaxe:

    for (<expressão inicial>; <condi´ão>; <incremento>) {
    <comandos>
    }

    Exemplos:

    public class ExemploFor {
    public static void main(String[] args) {
    for (int i=0; i<10; i++) {
    System.out.println("Contador é " + i);
    }

    for (; {
    System.out.println("La´o infinito.");
    }
    }
    }

    O primeiro for do exemplo acima irá apresentar 10 mensagens indicando o contador de 0 até 9. Quando o valor do inteiro i ser igual a 10 o interpretador java alternará o fluxo para o início do outro for.

    No segundo for do exemplo o código entra num la´o infinito, ou seja o programa não termina, sequer sairá do la´o, já que não existe condi´ão para que tal evento ocorra.
    4.3.2 Comando: while

    O comando while é utilizada quando não se quer que o corpo do la´o seja necessariamente executado. A expressão de compara´ão é avaliada antes que o la´o seja executado, enquanto ela for verdadeira os são repetidos.

    Sintaxe:

    while (<condi´ão>) {
    <comandos>
    }

    Exemplos:

    public class ExemploWhile {
    public static void main(String[] args) {
    int i=0;
    while(i++<10) {
    System.out.println("Contador é " + i);
    }

    while(true) {
    System.out.println("La´o infinito.");
    }
    }
    }

    Assim como nos exemplos com o comando for, o primeiro exemplo imprime contadores de 0 até 9 e o segundo é um la´o infinito, pois o resultado da condi´ão sempre será verdadeiro.
    4.3.3 Comando: do.. while

    O comando do.. while é utilizada quando se quer que o corpo do la´o seja executado pelo menos uma vez. A expressão de compara´ão é avaliada depois que o la´o foi executado, enquanto ela for verdadeira os são repetidos.

    Sintaxe:

    do {
    <comandos>
    } while (<condi´ão>);

    Exemplos:

    public class ExemploDoWhile {
    public static void main(String[] args) {
    int i=0;
    do {
    System.out.println("Contador é " + i);
    } while(++i<10)

    do {
    System.out.println("La´o infinito.");
    } while(true);
    }
    }

    Assim como nos exemplos anteriores, o primeiro exemplo do comando do.. while imprime contadores de 0 até 9 e o segundo é um la´o infinito, pois o resultado da condi´ão sempre será verdadeiro. Embora a diferen´a entre os dois comandos while sejam mínimas, cada uma é utilizada em uma determinada ocasião.
    4.4 Comandos: break e continue

    É a declara´ão de desvio usada para sair de um la´o antes do normal. O tipo determina para onde é transferido o controle. O break é transfere o controle para o final de uma constru´ão de la´o (for, do, while ou switch). O la´o vai encerrar independentemente de seu valor de compara´ão e a declara´ão após o la´o será executada. Exemplo:

    int i = 0;
    while (true) {
    System.out.println(i);
    if ( i++ >= 10 )
    break;
    }

    Este exemplo imprime os valores da variável i de 0 até 9.

    A declara´ão continue faz com que a execu´ão do programa volte imediatamente para o início do la´o, porém para a próxima intera´ão. O continue faz o interpretador pular para a próxima itera´ão e obriga-o a testar a condi´ão. Exemplo:

    for (int i = -10; i<10; i++) {
    if ( i == 0 )
    continue;
    System.out.println(i);
    }

    No exemplo, é impresso os valores de - 10 até 9 pulando o número zero.

    Chegamos ao final de mais uma etapa.
    Na próxima veremos um pouco sobre Orienta´ão a Objetos.


      Data/hora atual: Ter Jan 21, 2020 2:53 pm