Certificação Java SE 7 Programmer I: tipos de Dados

Declarar e inicializar variáveis - Introdução

Boas vindas!

Neste curso, falaremos sobre a declaração e inicialização de variáveis ou declaring and initializing variables.

As variáveis sempre são usadas para armazenar valores. O Java é uma linguagem de programação tipada, ou seja, todas as variáveis terão seu tipo explícito e, a partir de Java8, há situações em que o tipo pode ser implícito também, mas não veremos este último caso nesta certificação.

Pegaremos nossa classe de Teste que possui um método main() público e estático para trabalharmos.

A declaração de uma variável é sempre feita baseada em seu tipo e seu nome. Aqui, teremos a idade que é um int. Se quisermos imprimi-la, usaremos System.out.println() recebendo idade.

public class Teste {

    public static void main(String[] args) {

        int idade;
        System.out.println(idade);
    }
}

Quando tentarmos compilar este arquivo escrevendo javac Teste.java no terminal, receberemos a resposta de que não podemos usar uma variável que pode não ter sido inicializada, pois idade ainda não possui um valor.

Uma variável local definida no construtor ou em métodos não possui um valor padrão; para usá-la, precisaremos inicializá-la com 15 por exemplo.

public class Teste {

    public static void main(String[] args) {

        int idade;
        idade = 15;
        System.out.println(idade);
    }
}

Feito isso, poderemos ler idade ao rodarmos novamente, recebendo o resultado 15.

Da mesma maneira que inicializamos essa variável após a declararmos, poderíamos inicializá-la já em sua declaração para vermos o resultado da execução.

public class Teste {

    public static void main(String[] args) {

        int idade = 15;
        System.out.println(idade);
    }
}

Porém, devemos tomar um certo cuidado ao inicializarmos, pois só poderemos utilizar a variável se isso ficar claro para o compilador.

Adicionando um laço if() para o caso do length ser maior do que 10 já que a idade é igual a 15, imprimiremos a mensagem "faça outra coisa" para o else na situação contrária.

Se o número de argumentos que passarmos na linha de comando for maior do que 10, o sistema setará a idade para 15 e a imprimirá. Do contrário, exibirá nossa mensagem e printará o valor estabelecido na sequência.

Ou seja, não teremos certeza de que a variável estará inicializada por conta do compilador; o sistema só permitirá a compilação se qualquer um dos caminhos passados tiver a variável inicializada.

public class Teste {

    public static void main(String[] args) {

        int idade;
        if(args.length>10) {
            idade = 15;
        } else {
            System.out.println("faça outra coisa");
        }
        System.out.println(idade);
    }
}

Como resultado da execução, o console indica que a variável pode não ter sido inicializada ainda.

Portanto, teremos que garantir sua inicialização nos dois caminhos de if() para que o compilador tenha certeza.

public class Teste {

    public static void main(String[] args) {

        int idade;
        if(args.length>10) {
            idade = 15;
        } else {
            System.out.println("faça outra coisa");
            idade = 0;
        }
        System.out.println(idade);
    }
}

Desta forma, veremos que precisamos prestar atenção com a declaração e inicialização de variáveis locais; é necessário inicializarmos também em todos os caminhos de if() para garantirmos ao compilador.

Para vermos o caso de a variável não ser local e sim membro, teremos uma classe Carro que terá um ano do tipo inteiro.

O valor padrão de uma variável membro numérica é 0 quando criamos um novo Carro() e o imprimimos. É diferente de uma local porque possui um valor inicial ao compilarmos.

Já as variáveis não numéricas como char de primeiraLetra possuem um valor default em branco que é também 0, mas não é apresentado na impressão.

Os char são numéricos em Java para fins matemáticos, mas seu valor não é impresso. Se imprimirmos primeiraLetra sendo == ao zero, o retorno será true no console.

class Carro {
    int ano;
    char primeiraLetra;
}

public class Teste {

    public static void main(String[] args) {
        Carro carro = new Carro();

        System.out.println(carro.ano);
        System.out.println(carro.primeiraLetra == 0);
    }
}

Outro tipo de variável que pode haver em uma classe e possui valor padrão é o boolean, e aqui testaremos para usado. Para sabermos se o retorno será true ou false, compilaremos e imprimiremos seu resultado.

class Carro {
    int ano;
    char primeiraLetra;
    boolean usado;
}

public class Teste {

    public static void main(String[] args) {
        Carro carro = new Carro();

        System.out.println(carro.ano);
        System.out.println(carro.primeiraLetra == 0);
        System.out.println(carro.usado);
    }
}

Como resultado, descobrirmos que o valor padrão de um booleano é falso, e de todo tipo numérico é zero.

Falta-nos usar uma referência; adicionaremos uma nova classe Motor que referenciará a variável motor dentro de Carro para descobrirmos seu valor default.

class Motor {
}

class Carro {
    int ano;
    char primeiraLetra;
    boolean usado;
    Motor motor;
}

public class Teste {

    public static void main(String[] args) {
        Carro carro = new Carro();

        System.out.println(carro.ano);
        System.out.println(carro.primeiraLetra == 0);
        System.out.println(carro.usado);
        System.out.println(carro.motor);
    }
}

Ao compilarmos, receberemos a impressão de null como sendo o valor padrão de uma referência quando temos uma variável membro.

Este é um exemplo clássico da String; adicionando a variável marca deste tipo, a marca será uma referência para String, já que esta também é um objeto cujo valor padrão é null da mesma forma que motor.

class Motor {
}

class Carro {
    int ano;
    char primeiraLetra;
    boolean usado;
    Motor motor;
    String marca;
}

public class Teste {

    public static void main(String[] args) {
        Carro carro = new Carro();

        System.out.println(carro.ano);
        System.out.println(carro.primeiraLetra == 0);
        System.out.println(carro.usado);
        System.out.println(carro.motor);
        System.out.println(carro.marca);
    }
}

Portanto, descobrimos que cada tipo possui valores padrões, os quais são aplicados em variáveis membros, de instância, de objeto e atributos.

No caso da criação de um novo array, também teremos a variável com valor padrão. Por exemplo, quando criarmos valores do tipo int[] sendo igual a um novo int[] contendo o número 10, cada um dos itens possuirá o valor default 0, visto que se tratará de um tipo numérico.

Em seguida, imprimiremos somente a posição 0 de valores[].

class Motor {
}

class Carro {
    int ano;
    char primeiraLetra;
    boolean usado;
    Motor motor;
    String marca;
}

public class Teste {

    public static void main(String[] args) {
        int[] valores = new int[10];
        System.out.println(valores[0]);

        Carro carro = new Carro();

        System.out.println(carro.ano);
        System.out.println(carro.primeiraLetra == 0);
        System.out.println(carro.usado);
        System.out.println(carro.motor);
        System.out.println(carro.marca);
    }
}

Feito isso, receberemos o valor 0 como retorno da compilação. Se fizermos um array de boolean[] recebendo 10 também, o valor padrão apresentado será false.

Já o retorno será null para o tipo String[] que é uma referência para um objeto.

Portanto, tanto variáveis membro quanto arrays criadas terão o valor padrão de cada uma das posições de acordo com o tipo.

new int[5] é igual a 0; new boolean[5] é igual a false; new object[5] é igual a null.

Os tipos primitivos que não são referências em Java são byte, short, char, int, long, float e o double. O boolean é o único que não é considerado numérico.

Dentre eles, o double e o float são tipos com pontos flutuantes, enquanto os demais são inteiros.

Em Java, não existe a questão de signed e unsigned, ou seja, valores que só são positivos ou só negativos.

Por exemplo, uma variável do tipo byte pode ter valores entre -128 e +127. Os tamanhos de cada um dos tipos são valores que não precisaremos decorar, mas vale a pena se atentar à tabela.

O char é um caso específico e é compatível com tipo numérico, mas apesar de ter o mesmo tamanho de short, somente possui valores positivos a partir de zero, enquanto todos os outros podem ter desde valores negativos até positivos.

As variáveis de pontos flutuantes também podem assumir alguns valores especiais, como +∞ ou -∞, +0 ou -0 e NaN que significa um número inválido. Poderemos chegar nesses resultados por meio de operações como 15.0/0 por exemplo, que é igual a +∞.

Outro ponto importante sobre as variáveis diz respeito aos valores literais; os números primitivos e os tipos primitivos nos permitem ter um valor literal pela facilidade de inserir um número, letra ou booleano.

Mas não poderemos inserir um valor literal ou endereço de memória para um objeto em tipos que são referência.

O tipo primitivo mais comum com valor literal é o boolean; temos tanto valor falso quanto verdadeiro sempre em minúsculo, sendo ambos literais.

Número inteiros são considerados int por padrão, e com casa decimal são double.

Poderemos forçar um valor literal para um tipo usando alguma letra no final como long l = 13L. Desta forma, o compilador funcionará normalmente.

Se criarmos um float f = 13.1, o sistema lerá como double, então teríamos que adicionar uma letra ao final também, como float f = 13.1f por exemplo.

Então poderemos usar as letras d, l e f para indicar quais são os tipos corretos; do contrário, serão somente int ou double por padrão.

Já falamos que números inteiros são int por padrão, exceto em dois casos específicos: poderemos declarar um número int i sendo igual a 0761, mas por termos um 0 no começo, a representação será octal na base 8 de um número. Se o imprimirmos, o resultado será 497, mas se o valor for 01, receberemos 1 como retorno no console.

Porém, se o valor de i for 08, não existirá na base 8. Com isso, o sistema indicará um erro. Já 010 é o próprio número 8 após a compilação.

Portanto, se colocarmos o zero na frente do valor, o número que vier estará na base octal. Isso também não precisará ser decorado pois não será exigido na prova, e bastará sabermos apenas os números válidos e que não é possível escrever 8 após de zero.

A mesma questão acontece se escrevermos 0x para esta variável inteira i, pois se trata de um número hexadecimal que vai de zero a nove e depois A,B,C,D,E, e F para representar outros valores possíveis.

Por exemplo, o valor A significa o número 10, B vale por 11 e assim por diante, mas também não precisaremos decorar essa conversão, e bastará sabermos que depois de 0x poderá ter somente número de zero a nove ou as letras já citadas.

Este x por ser minúsculo ou maiúsculo, pois continuarão a ser números decimais válidos.

//código omitido

public class Teste {

    public static void main(String[] args) {
        boolean valor = true;

        int x = 15;
        double v = 10.2d;
        long l = 13l;
        float f = 13.1f;

        int i = 0xA;
        System.out.println(i);

        String[] valores = new String[10];
        System.out.println(valores[0]);

//código omitido
    }
}

Para a base binária, usaremos b no lugar de x em i para os valores seguintes serem somente 0 ou 1 a serem exibidos no console. Por exemplo, 0b10 retornará 2, 0b11 será 3 e 0b100 resultará em 4 e assim por diante.

Novamente, a conversão entre binário e decimal não será cobrada na prova, e sim que depois de 0b só poderão receber valores com 0 e 1.

A base octal vai de zero até sete, a hexadecimal cuja base é dezesseis vai de zero até nove e depois aceita mais seis caracteres de a até f. Isso é importante sabermos.

O ponto flutuante também pode ter a representação com notação científica. Então poderemos criar um segundo double chamadod2 sendo igual a 3.1E2, que significa 3.1x10²=3.1x100=310 e retornará apenas 310.0 como impressão.

Um segundo exemplo de float chamado f2 igual a 2e3f será impresso como 2000.0. Portanto, poderemos usar notação científica com um número multiplicado por dez elevado a algo.

Porém, se quisermos que seja um float efetivamente, deveremos inserir f ao final do valor da variável.

//código omitido

public class Teste {

    public static void main(String[] args) {
        boolean valor = true;

        int x = 15;
        double v = 10.2d;
        long l = 13l;
        float f = 13.1f;

        double d2 = 3.1E2;
        System.out.println(d2);

        float f2 = 2e3f;

        int i = 0B100;
        System.out.println(i);

// código omitido
    }
}

Se tivermos um número muito grande em uma variável long chamada x2 e quisermos separar suas casas com ponto como é comum no Brasil, teríamos problema pois não é um padrão mundial, o que complicaria bastante nosso trabalho.

A partir da versão Java7, poderemos usar _ para separar os dígitos para padronização. Como queremos que este número seja um long e não um int, bastará colocarmos um l ao final do valor. Veremos essa questão com mais profundidade mais adiante.

//código omitido

public class Teste {

    public static void main(String[] args) {
        boolean valor = true;

        long x2 = 1_234_567_891_234l;

        int x = 15;
        double v = 10.2d;
        long l = 13l;
        float f = 13.1f;

        double d2 = 3.1E2;
        System.out.println(d2);

        float f2 = 2e3f;

        int i = 0B100;
        System.out.println(i);

// código omitido
    }
}

É importante lembrarmos que o _ pode aparecer em qualquer lugar do valor para ser impresso corretamente, desde que esteja entre números ou dígitos responsáveis por representar o valor.

Se o _ estiver no começo ou no final, o programa não compilará, como nestes exemplos:

long x2 = _1_234_567_891_234l; long x2 = 1_234_567_891_234_l; long x2 = 1_234_567_891_234l_;

Porém, não há problemas se tivermos dois underlines ou mais seguidos. Portanto, não podemos ter _ no começo nem no final, muito menos separando apenas letras, pontos, marcadores de tipo e marcadores de base, e sim somente entre números, caracteres que dão valor real ou outros _.

Faremos um exemplo de uma variável c do tipo char sendo igual a 'A' para vermos a impressão somente com a letra A.

//código omitido

public class Teste {

    public static void main(String[] args) {

        char c = 'A';
        System.out.println(c);

        boolean valor = true;

        long x2 = 1_234_567_891_234l;

        int x = 15;
        double v = 10.2d;
        long l = 13l;
        float f = 13.1f;

        double d2 = 3.1E2;
        System.out.println(d2);

        float f2 = 2e3f;

        int i = 0B100;
        System.out.println(i);

// código omitido
    }
}

Nesta variável c, tendo em vista que char é compatível com tipos numéricos, se colocarmos o valor 65 no lugar de 'A', receberemos A como retorno no console. Já 66 imprimirá B, 67 exibirá C e assim por diante.

Se fizermos a variável sete do tipo char sendo igual a 7, a impressão não será o número 7.

Na tabela Unicode, o número não possui equivalência com a letra.

Por fim, a última maneira de inicializar é através do código Unicode \u de um caractere entre aspas simples, como 03A9 que representa o Ω por exemplo, mas podemos imprimir qualquer outro.

//código omitido

public class Teste {

    public static void main(String[] args) {
        char sete = '\u03A9';
        System.out.println(sete);

// código omitido
    }
}

Com isso, abordaremos os nomes identificadores de variáveis, métodos, construtores, classes, interfaces, pacotes e etc., pois existem algumas regras definidas.

A primeira é que não podemos usar uma palavra reservada como identificador; por exemplo, não podemos escrever boolean boolean ou public static public. Diferente de main que não é uma palavra-chave.

Portanto, existe um conjunto enorme de palavras-chave que não podem ser usadas como identificadores, e que devem ser decoradas. A maior parte é de uso comum no dia-a-dia, então é importante para a certificação.

Além dessas palavras reservadas, deveremos decorar outros três valores literais que não podem ser usados como identificadores: true, false e null. Lembrando que toda palavra-chave do Java deve estar em letras minúsculas.

Não há uma regra clara de uso de letras maiúsculas, minúsculas, $, _ e caracteres Unicode, apesar destes últimos não serem recomendáveis no cotidiano, pois é interessante seguirmos um padrão mais abrangente possível para outras nacionalidades.

A única restrição é que não podemos colocar números no início dos nomes de variáveis, pois estaríamos escrevendo um valor literal e não um identificador. O compilador também não roda caracteres especiais como # por exemplo.

Portanto, todas as variáveis e identificadores são case sensitive, ou seja, deveremos sempre manter a exata mesma grafia de uma variável para chamá-la. Por exemplo, idade, IDADE e Idade são três variáveis diferentes.

Com isso, vimos todos os identificadores possíveis.

Diferenciar entre variáveis de referências a objetos e tipos primitivos - Diferenças entre variáveis

Neste passo, falaremos sobre variáveis que podem referenciar um objeto ou que são tipos primitivos.

Na prática, as variáveis primitivas possuem um valor, e o copiamos sempre quando o atribuímos a uma outra variável.

Para exemplificar, criaremos uma nova classe de teste chamada TesteReferencia que terá um método main(). É recomendável que escrevamos essa parte várias vezes para fixá-la bem com todas as variações.

public class TesteReferencia {
    public static void main(String[] args) {

    }
}

Dentro, declararemos uma variável primitiva chamada a do tipo int sendo igual a 10. Em seguida, imprimiremos seu valor.

Os tipos primitivos são sempre por valor; se criássemos uma segunda variável b sendo igual a a, o resultado da println() de b será 10 também.

Apesar de ambas apresentarem 10 como retorno no console, o valor de a é 10 e o de b é a, sendo duas variáveis diferentes.

public class TesteReferencia {
    public static void main(String[] args) {
        int a = 10;
        int b = a;

        System.out.println(a);
        System.out.println(b);
    }
}

Se pegarmos o valor de a que vale 10 e o somarmos com 5 para obter o novo resultado de 15 para a, a compilação e execução exibirá 15 e 10.

Isso acontece porque copiamos o valor de a, sendo que tanto esta quanto a variável b possuem valor 10 apesar de não apontarem para o mesmo resultado.

Mas neste último caso, pedimos para o a ser somado a 5 para passar a valer como 15, enquanto o b continuará a ser 10, justificando os retornos no console.

public class TesteReferencia {
    public static void main(String[] args) {
        int a = 10;
        int b = a;

        a = a + 5;

        System.out.println(a);
        System.out.println(b);
    }
}

Quando usamos a atribuição com =, estamos copiando o valor de um tipo primitivo para outros.

Para vermos a diferença entre as variáveis primitivas e as de referência, faremos o mesmo código com um objeto.

Teremos uma nova classe chamada ObjetoMeu que terá uma variável int chamada valor.

Em seguida, criaremos dois ObjetoMeu em main() de TesteReferencia; o primeiro chamará o1 e será igual a um novo ObjetoMeu(). Dentro, o1.valor receberá o valor 10 e a segunda variável o2 do tipo ObjetoMeu será igual a o1.

Com isso, não parece que estamos criando um segundo ObjetoMeu. Se estivéssemos gerando outro ObjetoMeu, provavelmente estaríamos chamando o construtor, e não é o que fizemos, então esta dica é muito importante.

Imprimiremos o1.valor e o2.valor na sequência.

class ObjetoMeu {
    int valor;
}

public class TesteReferencia {
    public static void main(String[] args) {
        ObjetoMeu o1 = new ObjetoMeu();
        o1.valor = 10;
        ObjetoMeu o2 = o1;

        System.out.println(o1.valor);
        System.out.println(o2.valor);

        int a = 10;
        int b = a;

        a = a + 5;

        System.out.println(a);
        System.out.println(b);
    }
}

O resultado da compilação e execução será 10, 10, 15 e 10 no console conforme o esperado.

Depois, somaremos 5 ao o1.valor da mesma forma que fizemos com a, para então obtermos os resultados de 15, 15, 15 e 10 desta operação na impressão.

Portanto, há diferenças entre variáveis de tipos primitivos e variáveis que são referências para algum objeto; a o1 é uma referência ao nosso objeto.

Quando chamamos new ObjetoMeu() e criamos o construtor, geramos este objeto em memória. Quando definimos a variável o1 que referencia o objeto, fizemos com que o pegasse e o colocasse na variável valor com o valor 10.

Depois, criamos uma nova variável o2 que referencia o mesmo objeto, diferente da atribuição de um tipo primitivo que é uma cópia de seu valor.

Então tanto o1 quanto o2 apontam para o mesmo único objeto. Quando fizemos a soma de 5 com o1.valor, o resultado 15 também servirá para ambas as variáveis.

Quando imprimimos o1.valor e o2.valor, estamos seguindo referências diferentes para o mesmo objeto na memória que passou a ter esse novo valor 15.

Em resumo, a atribuição do tipo primitivo se dá pela cópia do valor da variável, enquanto o outro tipo cria uma nova referência para o mesmo objeto.

Lendo ou escrevendo campos de objetos - Acesso a variáveis

Nesta etapa, falaremos sobre como acessar variáveis membro de objetos, como atributos, variáveis de instância ou campos.

Por exemplo, um carro possui modelo e ano de fabricação, e precisaremos atribuir valores tanto para escrita quanto para leitura.

O primeiro passo é criar uma classe Carro em um novo arquivo que receberá uma variável modelo do tipo String e ano sendo int. Desta forma, teremos dois campos dentro da classe.

Para acessar essas variáveis membro, há algumas formas possíveis; por exemplo, dentro do construtor Carro(), poderemos dizer que o ano é igual a 2014, acessando este campo diretamente.

class Carro {

    String modelo;
    int ano;

    Carro() {
        ano = 2014;
    }
}

Dentro de um construtor ou dentro de um método chamado reseta() como exemplo, poderemos acessar variáveis membro apenas escrevendo seu nome diretamente.

class Carro {

    String modelo;
    int ano;

    Carro() {
        ano = 2014;
    }

    void reseta() {
        ano = 2014;
    }
}

Outra maneira de acessar é utilizar o operador this. antes do nome do campo, servindo como acesso a algum tipo de membro, seja um método ou variável.

No caso de um método de instância, o this. seria a instância. Como estamos dentro de um construtor, o this. é o próprio objeto que está sendo construído.

class Carro {

    String modelo;
    int ano;

    Carro() {
        this.ano = 2014;
    }

    void reseta() {
        this.ano = 2014;
    }
}

O this. é opcional porque não há nenhuma outra variável com nome ano dentro do programa.

Adicionaremos mais um método público de tipo String chamado getDadosDeImpressao() que retornará o modelo somado com "::" e ano.

Novamente estaremos acessando as variáveis membro diretamente, e poderíamos inclusive ter usado o this. também.

Inseriremos mais um método público void de nome setModelo() recebendo os parâmetros String e modelo. Dentro, escreveremos de forma explícita this.modelo sendo igual a modelo.

Neste caso, teríamos problemas caso não usássemos this., pois a variável local modelo é igual à própria variável local modelo, e não faz sentido aplicar o valor de referência da String nela mesma.

Não é o que queremos, pois precisaremos de this.modelo sendo igual a modelo; então, para acessar um campo quando já estamos dentro de um objeto - método de instância ou construtor do objeto -, poderemos acessar diretamente o nome do campo ou usando this..

class Carro {

    String modelo;
    int ano;

    Carro() {
        this.ano = 2014;
    }

    void reseta() {
        this.ano = 2014;
    }

    public String getDadosDeImpressao() {
        return modelo + "::" + ano;
    }

    public void setModelo(String modelo) {
        this.modelo = modelo;
    }
}

Para testarmos, criaremos um novo arquivo Java com uma classe de teste chamada TestaCarro que possuirá o método main().

class TestaCarro {
    public static void main(String args[]) {
    }
}

Dentro, criaremos um Carro a igual a novo Carro(). Para acessar a variável membro modelo, escreveremos a.modelo sendo igual a "Palio".

Novamente o uso de . indica o acesso a algum membro de a que referencia Carro na compilação.

Em seguida, chamaremos o método setModelo() recebendo "Palio 2". Por fim, imprimiremos o resultado de a.GetDadosDeImpressao() para acessar um método do mesmo objeto, e não um dos campos.

Também poderemos imprimir o a.ano para acessar essa variável diretamente.

Portanto, para acessarmos uma variável membro, sempre usaremos o operador . para dizermos que queremos pegar o objeto referenciado pela variável e acessar o membro que quisermos.

No caso da String de modelo, poderemos pedir o objeto referenciado pela variável a, o objeto referenciado pela variável modelo dentro do objeto referenciado pela a, chamando o método lenght() que exibe o tamanho da String, desta forma:

class TestaCarro {
    public static void main(String args[]) {

        Carro a = new Carro;
        a.modelo = "Palio";
        a.setModelo("Palio 2");

        System.out.println(a.getDadosDeImpressao());
        System.out.println(a.ano);
        System.out.println(a.modelo.length());
    }
}

Então poderemos fazer uma sequência de métodos ou Method Chaining concatenados por meio do operador .. Deveremos tomar algum cuidado, pois se algum deles for null e tentarmos chamar algo nele, um NullPointerException pode ser lançado.

Compilaremos os arquivos e rodaremos este código no terminal. O resultado nos apresentará as impressões corretas com os dados do carro, o ano e o tamanho da String.

Portanto, quando queremos acessar variáveis membro dentro de um objeto, há duas maneiras: se já estamos dentro de Carro com o construtor e o método de instância, bastará digitar diretamente o nome da variável que queremos acessar.

Se nenhuma outra variável local existir com o mesmo nome, o sistema saberá que o acesso será para a variável membro.

Caso exista uma variável local de mesmo nome, deveremos aplicar o this. antes. Do contrário, as referências serão para a mesma variável, e o resultado dependerá da situação.

Se quisermos, poderemos colocar this. a qualquer instante antes do nome da variável membro que queremos acessar explicitamente.

Sobre o curso Certificação Java SE 7 Programmer I: tipos de Dados

O curso Certificação Java SE 7 Programmer I: tipos de Dados possui 117 minutos de vídeos, em um total de 47 atividades. Gostou? Conheça nossos outros cursos de Java em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Declarar e inicializar variáveis
• Diferença entre variáveis de referências a objetos e tipos primitivos
• Leia ou escreva para campos de objetos
• Explique o ciclo de vida de um objeto (criação, "de referência" e garbage collection)
• Chame métodos em objetos
• Manipule dados usando a classe StringBuilder e seus métodos
• Criando e manipulando Strings