Capítulo 1 - Fundamentos da Linguagem

Esse capítulo é bastante significativo para a assimilação dos demais conteúdos, pois ataca todos os conceitos iniciais da linguagem
Java, portanto estude-o com bastante cuidado e atenção !
Palavras-Chave
Na linguagem Java, 49 são as palavras chaves e você deverá memorizá-las. Não tente fazer como fazíamos no ensino fundamental
para decorar a tabuada (como era difício a do 9, lembra?), essa assimilação será com o tempo, mesmo assim, dê uma olha na lista
a seguir, e observe que TODAS as palavras chaves são definidas em letras 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
Não tente decorar todas elas, tente entender o que elas fazem, isso será possível com o desenvolver dos capítulos.
LEMBRE-SE: null, false, true (Não são palavras chaves, são valores literais!)
Tipos primitivos:
byte - Inteiro de 8 bits com sinal
short - Inteiro de 16 bits com sinal
int - Inteiro de 32 bits com sinal
long - Inteiro de 64 bits com sinal

char - Caracter Unicode (16 bits sem sinal)
float - Ponto flutuante de 32 bits com sinal
double - Ponto flutuante de 64 bits com sinal
boolean - Valor indicando true ou false
Modificadores de acesso:
private - Define que um método ou variavel seja acessada somente pela própria classe
protected - Faz com que uma subclasse acesse um membro da superclasse, mesmo estando em pacotes diferentes
public - Faz com que um identificador possa ser acessado de qualquer outra classe.
Modificadores de classe, métodos e variável:
abstract - Define uma classe abstrata
class - Define a implementação de uma classe
extends - Define qual a hierarquia de classes, quem é a superclasse
final - Faz com que um identificador não possa ser alterado
implements - Faz com que uma classe implemente todos os métodos de uma interface
interface - Define uma interface
native - Define que o método será escrito em linguagem nativa como C, C++
new - Instancia um novo objeto na pilha
static - Defina um identificado de classe e não de instância
strictfp - Define que o método esta segundo o padrao IEE754
synchronized - Define que um método só poderá ser acessado por uma única thread por vez
transient - Faz com que uma variável não seja serializada
volatile - Indica que uma variável pode não ficar sincronizada ao ser usada por threads
Controle de Fluxo:
break - Faz com que o fluxo seja desviado para o fim do bloco
continue - Muda o curso do fluxo para a proxima iteracao do loop
if - Testa o valor lógico de uma condição
else - Indica qual o bloco que deverá ser executado caso o teste feito pelo if seja falso

Define o bloco de decisão que executará se por acaso ocorrer no bloco try uma exceção pré-definida finally .Executa um bloco quantas vezes a condição se fizer verdadeira.Finaliza a execução de um método.Usado no projeto.Importa uma ou todas as classes de um pacote package . mesmo que uma exceção seja lançada throw . testa uma expressão para verificar alternativas para o programador.Bloco que sempre será executado.Refere-se a instância do objeto Retorno: void .Testa o valor de uma variavel indicada pelo switch for .Executa um bloco quantas vezes a condição se fizer verdadeira.Testa se um objeto é instancia de uma classe qualquer Tratamento de erros: catch .Bloco que será executado caso nenhuma condição case satisfaça o swicth switch .Refere-se a superclasse imediata this .Iniciar um bloco com auditoria assert . Controle de pacotes: import .Indica que um método pode lançar algum tipo de exceção try . A condição é testada antes do bloco return .Iniciar uma sequencia de testes para uma variavel a ser testada pelo case case . Variáveis/Herança: super . podendo opcionalmente retornar um valor instanceof .Define que a(s) classes farão parte de um pacote.default .Usado para executar um bloco quantas vezes forem necessárias para satisfazer sua condição do .Define que um método não retorna nada .Lança uma exceção throws . A condição é testada depois do bloco while .

todos começam com letras minúsculas (pois também são palavras chaves). ou seja. Por isso. use final goto . com um pouco de fé e perseverança. Mas o que isso significa? deve ter vindo à sua mente! Significa que podem ser negativos ( . valores padrões. e como você já deve ter percebido.Não use para definir uma variável. suas faixas de valores.1 4. tudo se resolve! A Java é composta por 8 (oito) tipos primitivos. conversões implicitas e explícitas.Reservadas mas não utilizadas: const . int 5.) ou positivos ( + ). byte 8 -2^7 à 2^7 -1 3. não hesite em responder que NÃO! Outro conceito importante sobres os tipos primitivos em Java é que todos os tipos numéricos tem sinal. Observe a tabela de valores abaixo: 1.Não serve para nada Tipo primitivos: Você precisará saber "tudo" sobre os tipos primitivos. prepare-se o seu pesadelo começou! Mas não se preocupe. short 16 -2^15 à 2^15 . portanto se você for tiver que responder uma pergunta onde aparece perguntando por exemplo se String é um tipo primitivo. long 32 64 fórmula -2^31 à 2^31-1 -2^63 à 2^63-1 faixa -128 ~ +127 -32768 a +32767 -2147483648 a +2147483647 -9223372036854775808 a +9223372036854775807 . o tipo int pode ter o numero -1 como tambem o numero +1. e muito mais. tipo bits 2.

não é necessário saber a faixa de valores. float . Mas a única coisa que você precisa saber é a faixa de valores do tipo char.Dica sem ônus: Lembre-se da palavrinha bsil (já está no aurélio). Você deve estar se perguntando. Se ainda ficou confuso. . E porque só subtrai -1 da faixa positiva ? Porque o zero é incluído no intervalo também. Um regra nós sabemos: o tipo byte em Java é representado por oito bits. pode-se atribuir à uma variável char o valor 100 ou 14555 ou 65535. Também pode ser representado por um número inteiro de 16 bits sem sinal. 2 ^ 16 . l-long ! Pois "1 byte é representado por 8 bits". teremos 10000000. como esse numero é composto por oito bits não é possível adicionar o bit do sinal portanto o numero 128 positivo não está no intervalo do tipo byte. Se convertermos o número +125 em bits teremos 1111101 e ficaria representado da seguinte forma: 01111101 (observe que o zero inicial indica que é um numero positivo. e está na faixa negativa pois o bit mais significativo a esquerda é 1 que indica sinal negativo. mas não 65536 ! Pois essa é a faixa de valores da tabela Unicode para representação de caracteres de qualquer idioma. certo ? 1 Bit é usado para guardar o sinal.É um tipo numérico ponto flutuante de 64 bits (COM SINAL) ! Apesar de ter um tamanho definido por 64 bits. i-int. vamos fazer um teste. isso até Hitler morreu sabendo! Entendendo essa fórmula maluca. boolean ! char . double. Quais os bits representam o numero 127 ? Tipos primitivos (não acabou): Os demais tipos primitivos são: char.. que indica os tipos b-byte. ou seja. s-short. double ..É representado por caracter Unicode de 16 bits (sem sinal). float. não é necessário saber a faixa de valores. seria um numero negativo). Se 1 bit é usado para guardar o sinal (+) ou (-). Agora se convertermos o numero +128 em bits. estranho mas se o primeiro digito fosse um 1.1 = 65535 (valores possíveis). porque deve elevar a 7 (sete) no caso do byte e não a 8 (oito). então sobrou 7 bits para representar um número.É um tipo numérico ponto flutuante de 32 bits (COM SINAL) !! Apesar de ter um tamanho definido por 32 bits.

} Na linha 5 houve um conversão implícita perfeitamente possível pois o tipo da variável y é long. } 9. maior que o tipo da variável x. Por exemplo: 1. 8. public class Conversao { 2. fazer conversões entre os tipos numéricos. mas uma regra não pode ser quebrada: nunca você poderá convertar um tipo de maior valor (bits) em um número de menos valor. 7. int x = 10. // não é possível 7. 1. 3. x = (int)y. x = y. 5. public static void main(String[] args) { 3. y = x. ou seja. Conversões implicitas/explícitas: Você pode sempre que precisar.boolean . long y = 20.Um valor que indicado pelos valores literais: true ou false. 4. 5. 2. . // perfeitamente possível 6. // quero correr o risco e deixa eu queto ! 8. 6. 9. 4.

mas o compilador não permitirá essa operação.11. int seis = 06. int sete = 07. decimal (base 10) e hexadecimal (base 16) ! Será bom você estudar um pouco sobre esses sistemas de numeração. public static void main(String[] args) { 3. // idem ao decimal 7 . pois o tipo long é maior que int. char u = 'k'. possa testar você em alguma questão! Mas observe o código abaixo e veja como se representam valores literais em octal e hexadecimal (pois decimal você viu acima): 1.uma conversão explícita foi realizada e o compilador gentilmente atendeu à solicitação do programador. 4. double d = 9832.Na linha 6 houve um tentativa de conversão. pode-se que os sacanas dos caras que fazem a prova. boolean b = false. // idem ao decimal 6 4. // literal inteiro 2. public class Octal { 2. Na linha 7. Literais Inteiros: Um valor literal em Java é um valor escrito no código fonte e identificado como um tipo primitivo como por exemplo: 1. // literal char // literal boolean // literal double Há três maneiras de representar valores inteiros em Java: octal (base . int x = 10. 3.

// 12253946 (decimal) 8. int oito = 010.5. int vinte_e_nove = 0x1D. public class Hexadecimal { 2. int vinte_e_nove = 0x1D. // 12253946 (decimal) 7. // 29 (decimal) 6. // 29 (decimal) 5. public static void main(String[] args) { 3. } 8. } 9. 1. int valor = 0xBAFAFA. int quinze = 0xF. } // 15 (decimal) Deve vir precedido do sufixo (0x) ! É um dos poucos casos na linguagem em que não importa se as letras forem maiúsculas ou . // idem ao decimal 8 6. } Ou seja. saiba que está representando um número octal. int nove = 011. se você ver o numero 0 antes de um número. // idem ao decimal 9 7. int valor = 0XBaFaFa. 4.

7. por isso.} // ok. // erro! . Na linha 7 o compilador sabe que FF em hexa equivale a +255 o que não pode ser suportado. ou seja. conversão implícita Na linha 6 o compilador sabe que F em hexa equivale a 15. mas intimamente ele fala: CARA OLHA O QUE VOCÊ ESTÁ QUERENDO ME FORÇAR A FAZER !!! (%#%$!#%) Literais de ponto flutuante: . } 10. conversão implicita 5. Todos os tipos inteiros literais (tanto octal quanto hexa) são por padrão definidos como int. // ok. byte f = (int)0xff. 4. portanto se ver no exame um questão que atribui a uma variavel menor que int (em bits) isso dará erro de compilação. 10. public class ConversaoHexa { 2. 6. erro! Na linha 8 o compilador só não chinga o programador por conflito de drivers entre seu sistema operacional com sua placa de som. sem conversão 4. 3. Veja o código a seguir: 1. 8. 7. então ele realiza a conversão.255 não é comportado 9. int a = 0xbafa. public static void main(String[] args) { 3. // ok. long b = 0xfff. byte e = 0xff. 5. // erro! . // ok.minúsculas. o que pode ser perfeitamente suportado no tipo byte. byte d = 0xf.255 não é comportado 8. conversão explícita 6. 2. 9. long c = 0xfffL. 1.

3. 2. 8.public static void main(String[] args) { 3. 6. // ok tipo int para float conv implicita 5.0 é um tipo double (o padrão dos literais de ponto flutuante) não pode ser atribuído a uma variável float.} // ok .0.float d = (float)2147483647.public class Teste { 2. 9.0. 5.Um valor literal de ponto flutuante por padrão em Java é definido com double de 64 bits. 4.} 9. portanto de você quiser atribuir um valor literal floatvocê deverá adicionar o sufixo f no final do valor como o exemplo: 1. // ok 8. // ok tipo double 4. o compilador reclamará pois 2147483647. Na linha 6 é feito uma conversão explícita. 7.0f.float e = 2147483647. // erro! double -> float 6. 7.float b = 2147483647.double a = 9223372036854775807.0.float c = 2147483647.conversão Na linha 4. Na linha 7 é atribuído um valor float por causa do sufixo f Literais booleanos: . 1. funciona pois 2147483647 é um literal int e não double! Não tem decimal ! Na linha 5.

// ok . public static void main(String[] args) { 3. boolean c = 1. // ok 5. } // erro de compilacao Cuidado que em Java diferentemente de C e outras linguagens não se pode atribuir o valor 0 ou 1 para literais booleanos. public class Carac { 2.Os valores literais booleanos são compreendidos entre true ou false e só ! 1. public class LitBoo { 2. } 7.se você não sabe o que é apóstrofo. boolean a = true. public static void main(String[] args) { 3. 6. // ok 4. char a = 'a'. é o mesmo que aspas simples ' 1. boolean b = false. Literais Caracteres: Os valores literais caracteres são compreendidos com um único caracter entre apóstrofo .

precisa de conversão O tipo char pode aceitar valores fora de sua faixa.1 = 65535. public static void main(String[] args) { 3. char b = '@'. ARRAY . // ok 5. } 7. 4. char b = (char)-65. 5. } // refere-se a letra N Como foi falado. Veja no código abaixo: 1. public class A { 2. char a = 65. // fora do intervalo. } 7. 6. o tipo char nada mais é do que um tipo inteiro sem sinal de 16 bits. char c = (char)70000. char c = '\u004E'. desde haja uma conversão explícita. portanto você poderá atribuir 2 ^ 16 .4. } // fora do intervalo. precisa de conversão 6.

com isso cria-se um objeto na pilha com espaço necessário para armazenar os elementos do objeto.Atribuir valores aos elementos do array. // só pode mencionar a quantidade de elementos.Especificar um nome e o tipo do array. 1. Construir . Se você ver uma questão onde aparece algo como no trecho a seguir. todos os elementos são inicializados com seus valores . 2 -> com um total de 3 elementos. na construção Construindo um array int[] a = new int[3]. pois somente na construção que a JVM saberá quantos elementos serão composto o array. ou seja. ou seja. a não ser que você faça tudo em uma única linha (isso será mostrado posteriormente). pois só existem os elementos 0. Nunca coloque a quantidade de elementos do array no passo de declaração. numero de elementos. No passo de construção. // Recomendado Thread b[] = new Thread[1].Um array em Java é um objeto criado na pilha (mémoria). Observe que ainda não se sabe quantos elementos esses array armazenará. não sabe qual será o custo para a memória desse array. usado para armazenar e trabalhar com elementos semelhantes por seu tipo.Informar o tamanho do array. Esse passo reserva espaço na memória para os elementos do objeto array. marque sempre erro de compilação. Usa-se a palavra new conjugada com o tipo do array. Para que se possa utilizar um array você deverá: Declarar . // Recomendado Thread b[]. String []c = new String[19]. Nunca se esqueça. Inicializar . Declarando um array int[] a. em Java a contagem dos elementos SEMPRE COMEÇARÁ EM 0 (ZERO). String []c. portando uma referência ao elemento a[3] (no array a acima) causará um erro. int[3] a.

padrão. int[] x. 3. seus elementos são automaticamente inicializados com seus valores padrão. // inicializando Observe o seguinte código: 1.0 boolean false char '\u0000' Object null Inicializando um array Atribuir valores aos elementos de um objeto array.public static void main(String[] args) { 3. // construindo x[0] = 10.f = new float[1]. 2. Veja a tabela a seguir: TIPO VALOR PADRÃO byte 0 short 0 int 0 long 0 float 0. 4.0 double 0. .float[] f.public class ArrayInicia { 2. // inicializando x[1] = 20. Quando um array é contruído. // declarado x = new int[2]. 4. 1.

Não vale olhar.f[0] = 9. não hesite em marcar a resposta: Erro de compilação !!! int[3] a = {1. construção e inicialização podem ser realizados em uma única linha de código. o número de elementos entre as chaves { }. parabéns por você ser uma pessoa de opnião! Mas infelizmente você errou !!! Lembra-se que todo valor literal ponto flutuante em Java é por padrão double.0.println("valor depois "+f[0] ). Caso você se depare com uma questão (como o código abaixo) que especifica o número de elementos juntamente com a inicialização na mesma linha. false }.0 e 9. EUREKA !!! boolean[] c = { false.System. char[] b = {'a'. true.1. 6.} 9.println("valor antes "+f[0] ). portanto esse código não compila. // erro de compilação Array Multidimensional . 5. 8.) Se você respondeu 0.'c'}. 7. 2. 1}.0.out. por isso: PRESTE MAIS ATENÇÃO !!! Os três passos para a utilização de um array: declaração.0f.} O que será impresso na linha 5 e 7 ??? ( Feche os olhos e responda !!. Se alterarmos esse código e adicionar o sufixo f na linha 6 => f[0] = 9.out.5.. o resultado seria 0. 9. 6. 8.'b'. visto que está implícito o tipo no início. int[] a = {0.. 7.System. Observe que a palavra chave new não foi utilizada..0.1}.1.0 e 9.

(Complicado?) int[][] i = new int[2][]. // construído o elemento 1 do array i Quantos objetos foram criados na pilha ? 1 referenciado por a 2 referenciados por a[0] e a[1] Total de objetos criados: 3 (três) Agora observe o seguinte código: 1.Um array multidimensional é um array com mais de uma dimensão (isso é ridículo de dizer!). null. // construído o elemento 0 do array i i[1] = new int[3]. Para utilizar seus elementos. O que isso significa ? O que são os elementos de i ?? Significa que foi criado um objeto na pilha chamado a. String s = new String("Kuesley"). ou seja. 4. você deverá construí-los como mostra o código a seguir: i[0] = new int[2]. 5. } 6. public class TestArray { 2. Portanto um array definido como: int[][] i = new int[3][]. } . e seus elementos ainda não foram contruídos. public static void main(String[] args) { 3. nada mais é do que um objeto array i que contém três objeto array (ainda não construído) dentro. String[] nomes = { s. new String("Kuesley") }. é uma coleção de objetos array dentro de um objeto array.

public class A { 2. int soma = obj_a. O elemento 1 não tem um objeto referenciado. Array Anônimo Como o próprio nome já diz.println("Soma do array é: "+soma).out. 6. A obj_a = new A(). 4. System.3 } ). public int somarArray( int[] a ) { . 5.somarArray( new int[] { 0.Quantos objetos foram criados na pilha ?? 1 obj String referencido por s 1 obj array de String referenciado por nomes 1 obj String referenciado por nomes[2] Observe que o elemento 0 é apenas uma referência para s portanto não é criado um novo objeto. e você não queira criar um array. Veja como no código abaixo: 1. já o elemento 2 é um objeto String. Imagine que você precise passar um objeto array como parâmetro para um método. } 7.1.2. basta passar anonimamente. public static void main(String[] args) { 3. é um objeto array criado sem a definição de um nome.

i < a. numeros[1] = numeros[0]. return rc.1.2. 9. rc += a<i>. ISSO SERÁ DEDUZIDO DOS ELEMENTOS ENTRE O PAR DE CHAVES !!! Array . int rc = 0. LEMBRE-SE: NUNCA ESPECIFIQUE O TAMANHO ENTRE OS COLCHETES. } Observe que não foi criado um objeto array com um identificador específico e passado como parâmetro. numeros[2] = new int[] { 0. Outro exemplo: int[][] numeros = new int[3][]. 11.length.3 }. } 12.8. } 14. numeros[0] = new int[10]. foi criado no momento em que se passará o argumento. 13.Observações Algumas regras devem ser consideradas no uso de array que referenciam objetos! . i++) { 10. for ( int i=0.

7. 2. Car[] cars = new Car[3]. 3. class Mazda extends Car { } 3. public class Test { 8. 5. Fusca f = new Fusca(). } 13. class VMax { } 5. Por que isto é possivel ? Existe um pergunta que você sempre deverá fazer. 12. . 1. para saber se uma classe X pode ser armazenada em um array do tipo Y. 4. class Car implements CarMove { } 2. 7. interface CarMove { } 6. // instanciando um obj do tipo Fusca 11. 10. cars[0] = f. public static void main(String[] args) { 9. } Observe que na linha 5. um objeto Fusca foi armazenado em um array do tipo Car.Dado as classes: 1. class Fusca extends Car { } 4. 6.

Fusca[] fuscas = new Fusca[3]. 4. 7. 5. 2. } 7. Fusca ): 1. 1. public class Test { 2. Fusca é uma subclasse de Car ? Se a resposta for positiva. } Isso é possível ?? Se tem dúvida. 4. 6. 3. fuscas[0] = c. essa atribuição é perfeitamente possível ! Agora observe o seguinte código (baseando-se nas mesmas classes Car. Car c = new Car(). 6. public static void main(String[] args) { 3. faça você mesmo e faça o teste e sem preguiça !!! Aproveite e teste o seguinte: . 5.X é membro de Y Em nosso contexto: Fusca é membro de Car ? Em outras palavras.

1. public static void main(String[] args) { 3. 1. 5. 5. cm[0] = new Car(). public static void main(String[] args) { 3. 5. Fusca[] f = new Car[1]. 2. 4. CarMove[] cm = new CarMove[4]. } 6. 3. cm[3] = new VMax(). 4. public class Test { 2. pode receber referencias de instâncias de classes que implementem essa interface. 6. 4. // ok! Mazda implementa CarMov 7. public class Test { 2. 1. cm[2] = new Mazda(). } O que acontecerá com o código acima ? Mudando um pouco de assunto! Um objeto array de uma interface. // ok! Fusca implementa CarMov 6. cm[1] = new Fusca(). Car[] c = new Fusca[1]. // erro de compilação // ok! Car implementa CarMov .

0}.2. public class Test { 2. portanto ESTUDE! Se achas que estou brincando imagine a seguinte questão ? 1. } 9. n = m. int[] m = new int[] {8. } LEMBRE-SE: Vmax é membro de CarMove ??? Cuidado com detalhes de atribuições tais como: int[] n = new int[10]. enquanto que m tem apenas uma! Porém o seguinte código seria perfeitamente possível: n[0] = m.8. int[] m = new int[] {1.2. // ok! mesmo tipo int[][] n = new int[3][].3}.2. 1. 2. public static void main(String[] args) { . n = m. // erro! objetos diferentes A JVM não elimina o objeto n da pilha e subtitui pelo valor de m! Observe também que o array n tem 2 dimensões. // ok! As questões relacionadas com array multidimensionais são esdrúxulas.1.

???? 12. 6.} 13. 12. e) nums[0][0][3] = 9. 11. nums[1][0] = simple.3 }. c) nums[1][0][3] = 9. 6.2.3.5}. 5. nums[0][0] = new int[10].} 1) Qual das linhas abaixo poderão ser colocadas na linha 11 do código acima sem que dê erro de compilação ?? (marque mais de uma) a) nums[1][0] = nums[0][0]. b) nums[1][0] = 10. 9. nums[1] = new int[3][]. 4.3. 9. 8.nums[1][2] = new int[] { 1. 10. nums[0] = new int[1][]. 13.3. 8. 7.3 }. nums[1][1] = new int[] { 3. 10. 7. int[][][] nums = new int[2][][]. 5. int[] simple = new int[] {1.2. 11. f) nums[0][0] = nums[2][1] . 4. 3.4. d) nums[1][0][2] = 9.

3. Book b = new Book(). (Mesmos valores atribuídos na inicialização de um array estudado anteriormente): 1. public static void main(String[] args) { 4. } Resultado: O titulo é null ! String é um objeto e não um tipo primitivo! Para utilizar um variável primitiva.title). String title.out. } 7. caso contrário o compilador lhe tratará de forma inescrupulosa ! . // instanciando a classe 5.println("O titulo é "+b.[color=green:8dd638c6bd]Resposta no final do capítulo !!![/color:8dd638c6bd] Não é sacanagem. os caras dão questões daí pra pior !!! Variáveis de Instância Declarada no escopo da classe. public class Book { 2. você SEMPRE terá que inicializá-la. System. 6. e tem um valor padrão conforme o seu tipo.

out. Periodo p = new Periodo(). 3. public class TheBookonTheTable { 2. import java. Date data. esse membro é inicializado com null (pois em Java null é um valor) e quando é declarado no escopo de um método. 2. } O código acima gerará um conflito entre o programador e o compilador! Não tente ! É irreparável!!! Objeto Local Um Objeto locai (variável declarada dentro de um método) tem comportamento distinto de uma variável de instância. portanto qualquer ousadia de uso. o objeto não é inicializado. 5.println("o valor de i é "+i). 5. 1. 4. e uma instância dessa classe é criada.util. } 6. System. public static void main(String[] args) { 4. relações cortadas com o compilador! 1.*. . public class Test { 3. 5.1. Quando um objeto é declarado como membro de uma classe. 2. public static void main(String[] args) { 3. int i. 4.

10.fim == null) System.print("inicio é nulo").6. 8. // ok . 11. } 10.recomendado main(String[] args) { . mas algumas observações devem ser ressaltadas nesse capítulo.. 7. 13.. 6.} 11..membro é nulo 8. pois o objeto local data não foi inicializado ! Método main Você já deve estar cansado de ver as declarações public static void main(String[] args). 9.} O compilador mostrará um erro na linha 6.out...Date fim. 14. } // válido main(String a []) { ... } // válido ....print("fim é nulo").membro é nulo 9. if (p. // erro de compilação 7.out. } // válido main(String a[]) { . porém saiba que essa é a chave para a JVM executar uma aplicação em Java..out.inicio == null) System.class Periodo { 12. // ok .print("inicio é nulo"). } // válido . } // válido main(String [] a) { . Observe: public static static public public static public static public static public static void void void void void void main(String[] args) { . if (data == null) System. if (p.. 12. Maiores detalhes sobre modificadores serão vistos no capítulo 2.Date inicio. 13. 14. } // válido main(String[] a) { .

4. public static void main(String[] args) { 3. quando um programa Java está sendo executado. public class Test { 2. dois parâmetros estão sendo passados: Kuesley Fernandes Portanto com o seguinte código: 1. System.println("Meu nome é: "+args[0]+args[1]).out.public static void main([]String args) { .. } // não é válido Mas o que é esse array de String que o método main recebe ? Esse array é usado para receber parâmetros da linha de comando. } O Resultado seria: Meu nome é Kuesley Fernandes E se fosse executado: c:###BOT_TEXT###gt;java Test Kuesley Qual seria o resultado ?? TESTE !!! QUESTÃO: 2) O que fará o seguinte código ? . } 5. c:###BOT_TEXT###gt;java Test Kuesley Fernandes Nesse caso..

} else { 8.out. 3.out. 7. System. 5.println("ERRO"). public static void main(String[] args) { 4.1. } a) Mostrará ERRO na tela b) Mostrará OK na tela c) Programa não irá compilar d) Uma exceção será lançada e) Mostrará null na tela Resposta no final do capítulo !!! Bom acho que chagamos ao final do capítulo 1. int[] a. System. } 11. public class Array { 2. Array obj = new Array(). esse capítulo é fundamental para o entendimento dos seguintes !!! . 9. if (obj == null) { 6. } 10.println("OK").

c. f Lembre-se compilar até compila. 2) b Leia também: Fundamentos da Linguagem Modificadores Operadores e atribuições Controle de Fluxo Orientação a Objetos Java Lang e Wrappers Objetos e Conjuntos Classes Internas Threads (Segmentos) . d.Respostas dos exercícios propostos: 1) a. e. porém a resposta f gerará um exceção em tempo de execução.