Google android p/ Noobs - SUPER 2014 - UPE

Android p/ Noobs
Levi Saturnino

O que vamos ver?
• O que é um programa?;
• Linguagem de Máquina vs Linguagem Humana;
• Meu primeiro programa, oh! que legal;
• if-else, switch, for e while
• Agora é tudo Orientado a Objeto
• “Array” o que é isso?
• COLLECTIONS mil vezes melhor do quer o Array!;

O que é um Programa?
• Um dos maiores benefícios da utilização de
computadores é a automatização de
processos realizados manualmente por
pessoas.
• Basicamente, os computadores são capazes
de executar instruções matemáticas mais

• Essa simples capacidade permite que eles
resolvam problemas complexos de maneira
mais eficiente.
• Porém, eles não possuem a inteligência
necessária para definir quais instruções
devem ser executadas para resolver uma

• Dessa forma, uma pessoa precisa definir um
roteiro (algoritmo) com a sequência de
comandos necessários para realizar uma
determinada tarefa e depois passar para um
computador executar esse roteiro.
• Formalmente, esses roteiros são chamado de

Linguagem de Máquina
• Os computadores só sabem ler instruções
escritas em linguagem de máquina. Uma
instrução escrita em linguagem de máquina é
uma sequência formada por “0” e “1” que
representa a ação que um computador deve
executar.

• Teoricamente, as pessoas poderiam escrever os
programas diretamente em linguagem de máquina. Na
prática, ninguém faz isso pois é uma tarefa muito
complicada e demorada.
1110000111111011101000001110000000001011010000
0010011100110100100001101110000000000101001100
• Um arquivo contendo as instruções de um programa
em Linguagem de Máquina é chamado de executável.

• Como vimos anteriormente, escrever um
programa em linguagem de máquina é
totalmente inviável para uma pessoa.
• Para resolver esse problema, surgiram as
linguagens de programação, que tentam se
aproximar das linguagens humanas. Confira
um trecho de um código escrito com a

class OlaAndroid {
public static void main ( String [] args ) {
//imprimir na tela o nome Olá Android
System .out . println ("Olá Android ") ;
}
}

Compilador
Por um lado, os computadores processam apenas
instruções em linguagem de máquina.
Por outro lado, as pessoas definem as instruções em
linguagem de programação. Dessa forma, é
necessário traduzir o código escrito em linguagem
de programação por uma pessoa para um código em
linguagem de máquina para que um computador

Compilador
• Essa tradução é realizada por programas
especiais chamados compiladores.

Variáveis
• Basicamente, o que um programa faz é
manipular dados. Em geral, esses dados são
armazenados em variáveis localizadas na
memória RAM do computador.
• Uma variável pode guardar dados de vários
tipos: números, textos, booleanos (verdadeiro
ou falso), referências de objetos.

Variáveis
• Além disso, toda variável possui um nome que
é utilizado quando a informação dentro da
variável precisa ser manipulada pelo
programa.

Variáveis
• Na linguagem de programação Java, as
variáveis devem ser declaradas para que
possam ser utilizadas.
• A declaração de uma variável envolve definir
um nome único (identificador) dentro de um
escopo e um tipo de valor.

Variáveis
• As variáveis são acessadas pelos nomes e
armazenam valores compatíveis com o seu
tipo.
// Uma variável do tipo int chamada numeroDaConta .
int numeroDaConta ;
// Uma variável do tipo double chamada precoDoProduto .
double precoDoProduto ;

Tipos Primitivos de Variáveis
• A linguagem Java define um conjunto de tipos
básicos de dados que são chamados tipos
primitivos.
• A tabela abaixo mostra os oito tipos
primitivos da linguagem Java e os valores
compatíveis

Tabela Variáveis de Primitivos

CAST DAS PRIMITIVAS
● Duas formas de Cast: Explícito e Implícito ou automática

Vamos relembrar?
• Crie um programa que imprima o seu nome
ou mensagem na tela usando o print que é a
saída no java.
• depois vamos usar o class Scanner para
entrada de dados e implementar no mesmo
código.

Operadores
Para manipular os valores das variáveis de um
programa, devemos utilizar os operadores
oferecidos pela linguagem de programação
adotada. A linguagem Java possui diversos
operadores e os principais são categorizados
da seguinte forma:

Operadores
• Aritmético ( +, -, *, /, % )
• Atribuição ( =, +=, -=, *=, /=, %= )
• Relacional ( ==, !=, <, <=, >, >= )
• Lógico ( &&, || )

Aritmético
Os operadores aritméticos funcionam de forma muito semelhante aos operadores na matemá-
tica. Os operadores aritméticos são:
• Soma +
• Subtração -
• Multiplicação *
• Divisão /
• Módulo %

Aritmético
int umMaisUm = 1 + 1; // umMaisUm = 2
int tresVezesDois = 3 * 2; // tresVezesDois = 6
int quatroDivididoPor2 = 4 / 2; // quatroDivididoPor2 = 2
int seisModuloCinco = 6 % 5; // seisModuloCinco = 1
int x = 7;
x = x + 1 * 2; // x = 9
x = x - 3; // x = 6
x = x / (6 - 2 + (3*5) /(16 -1) ) ; // x = 2

Exemplo de código Aritmético
class TestaIdade {
public static void main(String[] args) {
// imprime a idade
// falar de Scanner para entrada de dados
int idade = 20;
System.out.println(idade);
// gera uma idade no ano seguinte
int idadeNoAnoQueVem;
idadeNoAnoQueVem = idade + 1;
// imprime a idade
System.out.println(idadeNoAnoQueVem);
}
}

Atribuição
Nas seções anteriores, já vimos um dos operadores de atribuição, o operador = (igual).
Os operadores de atribuição são:
• Simples =
• Incremental +=
• Decremental -=
• Multiplicativa *=
• Divisória /=
• Modular %=

Atribuição
int valor = 1; // valor = 1
valor += 2; // valor = 3
valor -= 1; // valor = 2
valor *= 6; // valor = 12
valor /= 3; // valor = 4
valor %= 3; // valor = 1

As instruções acima poderiam ser escritas de outra forma:
int valor = 1; // valor = 1
valor = valor +2; // valor = 3
valor = valor -1; // valor = 2
valor = valor * 6; // valor =12
valor = valor / 3; // valor = 4
valor = valor % 3; // valor = 1
Como podemos observar, os operadores de atribuição, com exceção do simples ( = ), reduzem a
quantidade de código escrito. Podemos dizer que esses operadores funcionam como “atalhos”
para as operações que utilizam os operadores aritméticos.

Relacional
Muitas vezes precisamos determinar a relação entre uma variável ou valor e outra outra variável
ou valor. Nessas situações, utilizamos os operadores relacionais. As operações realizadas com
os operadores relacionais devolvem valores do tipo primitivo boolean. Os operadores relacionais
são:
• Igualdade ==
• Diferença !=
• Menor <
• Menor ou igual <=
• Maior >
• Maior ou igual >=

Relacional
int valor = 2;
boolean t = false; // t = true
t = ( valor == 2); // t = false
t = ( valor != 2); // t = false
t = ( valor < 2); // t = true
t = ( valor <= 2); // t = true
t = ( valor > 1); // t = true
t = ( valor >= 1); // t = true

Lógico
A linguagem Java permite verificar duas ou mais condições através de operadores lógicos. Os
operadores lógicos devolvem valores do tipo primitivo boolean. Os operadores lógicos são
• “E” lógico &&
• “OU” lógico ||

Lógico
int valor = 30;
boolean teste =false ;
teste = valor < 40 && valor > 20; // teste = true
teste = valor < 40 && valor > 30;// teste = false
teste = valor > 30 || valor > 20; // teste = true
teste = valor > 30 || valor < 20; // teste = false
teste = valor < 50 && valor == 30; // teste = true

IF-ELSE
O comportamento de uma aplicação pode ser influenciado por valores definidos pelos usuários.
Por exemplo, considere um sistema de cadastro de produtos. Se um usuário tenta adicionar um
produto com preço negativo, a aplicação não deve cadastrar esse produto.
Caso contrário, se o preço não for negativo, o cadastro pode ser realizado normalmente.
Outro exemplo, quando o pagamento de um boleto é realizado em uma agência bancária, o sis-
tema do banco deve verificar a data de vencimento do boleto para aplicar ou não uma multa por
atraso.

IF-ELSE
Para verificar uma determinada condição e decidir qual bloco de instruções deve ser executado,
devemos aplicar o comando if.
if ( preco < 0) {
System . out . println ( " O preço do produto não pode ser negativo " ) ;
} else {
System . out . println ( " Produto cadastrado com sucesso " ) ;
}

IF-ELSE
int idade = 15;
boolean amigoDoDono = true;
if (idade < 18 && amigoDoDono == false) {
System.out.println("Não pode entrar");
}
else {
System.out.println("Pode entrar");
}

IF-ELSE
O comando if permite que valores booleanos sejam testados. Se o valor passado como parâ-
metro para o comando if for true , o bloco do if é executado. Caso contrário, o bloco do else é
executado.
O parâmetro passado para o comando if deve ser um valor booleano, caso contrário o código
não compila. O comando else e o seu bloco são opcionais.

WHILE
Em alguns casos, é necessário repetir um trecho de código diversas vezes. Suponha que seja
necessário imprimir 10 vezes na tela a mensagem: “Bom Dia”. Isso poderia ser realizado colocando
10 linhas iguais a essa no código fonte:
System.out.println ( " Bom Dia " ) ;
Se ao invés de 10 vezes fosse necessário imprimir 100 vezes, já seriam 100 linhas iguais no
código
fonte. É muito trabalhoso utilizar essa abordagem para solucionar esse problema.

WHILE
Através do comando while, é possível definir quantas vezes um determinado trecho de código
deve ser executado pelo computador.
int contador = 0;
while ( contador < 100) {
System . out . println ( " Bom Dia " ) ;
contador ++;
}

WHILE
A variável contador indica o número de vezes que a mensagem “Bom Dia” foi impressa na tela.
O operador ++ incrementa a variável contador a cada rodada.
O parâmetro do comando while tem que ser um valor booleano. Caso contrário, ocorrerá um
erro de compilação.

WHILE
int idade = 15;
while (idade < 18) {
System.out.println(idade);
idade = idade + 1;
}

FOR
O comando for é análogo ao while . A diferença entre esses dois comandos é que o for recebe
três argumentos.
for (inicializacao; condicao; incremento) {
codigo;
}
Ex.
for ( int contador = 0; contador < 100; contador ++) {
System.out.println ( " Bom Dia " ) ;
}

exercicio
1) entre com um numero double e imprima um numero inteiro
2) Entrar com dois números e imprimir o menor número (suponha números
diferentes).
3) Imprima todos os números de 150 a 300.
4) Imprima a soma de 1 até 1000.
5) Imprima todos os múltiplos de 3, entre 1 e 100.

ORIENTAÇÃO A OBJETOS
Orientação a objetos é uma maneira de programar que ajuda na organização e resolve muitos
problemas enfrentados pela programação procedural.

Criando um tipo
Considere um programa para um banco, é bem fácil perceber que uma entidade extremamente
importante para o nosso sistema é a conta.
Nossa ideia aqui é generalizarmos alguma informação, juntamente com funcionalidades que toda
conta deve ter.
O que toda conta tem e é importante para nós?
• número da conta
• nome do dono da conta
• saldo
• limite

Criando um tipo
O que toda conta faz e é importante para nós? Isto é, o que gostaríamos de “pedir à conta"?
• saca uma quantidade x
• deposita uma quantidade x
• imprime o nome do dono da conta
• devolve o saldo atual
• transfere uma quantidade x para uma outra conta y
• devolve o tipo de conta
Com isso, temos o projeto de uma conta bancária. Podemos pegar esse projeto e acessar seu
saldo? Não. O que temos ainda é o projeto. Antes, precisamos construir uma conta, para poder
acessar o que ela tem, e pedir a ela que faça algo.

Uma classe em Java
Vamos começar apenas com o que uma Conta tem, e não com o que ela faz (veremos logo em
seguida). Um tipo desses, como o especificado de Conta acima, pode ser facilmente traduzido
para Java:
class Conta {
int numero; // atribuido ou estado class
String dono;
double saldo;
double limite;
// ..
}

Criando e usando um objeto
Já temos uma classe em Java que especifica o que todo objeto dessa classe deve ter.
Mas como usá-la? Além dessa classe, ainda teremos o Programa.java e a partir dele é que
vamos utilizar a classe Conta .
Para criar (construir, instanciar) uma Conta , basta usar a palavra chave new . Devemos utilizar
também os parênteses, que descobriremos o que fazem exatamente em um capítulo posterior:
class ContaTeste {
new Conta();
}
}

Bem, o código cria um objeto do tipo Conta , mas como acessar esse objeto que foi criado?
Precisamos ter alguma forma de nos referenciarmos a esse objeto. Precisamos de uma variável:
class ContaTeste {
Conta minhaConta;
minhaConta = new Conta();
}
}

Pode parecer estranho escrevermos duas vezes Conta : uma vez na declaração da variável e outra
vez no uso
do new . Mas há um motivo, que em breve entenderemos.
Através da variável minhaConta , podemos acessar o objeto recém criado para alterar seu dono ,
seu saldo , etc

class Programa {
Conta minhaConta;
minhaConta.dono = "Levi";
minhaConta.saldo = 1000.0;
System.out.println("Saldo atual: " + minhaConta.saldo);
}
}
É importante fixar que o ponto foi utilizado para acessar algo em minhaConta . A minhaConta
pertence ao Levi, e tem saldo de mil reais.

Métodos
Dentro da classe, também declararemos o que cada conta faz e como isto é feito - os
comportamentos que
cada classe tem, isto é, o que ela faz. Por exemplo, de que maneira que uma Conta saca dinheiro?
Especifica-
remos isso dentro da própria classe Conta , e não em um local desatrelado das informações da
própria Conta.
É por isso que essas “funções” são chamadas de métodos. Pois é a maneira de fazer uma
operação com um
objeto.
Queremos criar um método que saca uma determinada quantidade e não devolve nenhuma
informação
para quem acionar esse método:

Métodos
class Conta {
double salario;
// ... outros atributos ...
void saca(double quantidade) {
double novoSaldo = this.saldo - quantidade;
this.saldo = novoSaldo;
}
}
A palavra chave void diz que, quando você pedir para a conta sacar uma quantia, nenhuma
informação será
enviada de volta a quem pediu.

Métodos
Da mesma forma, temos o método para depositar alguma quantia:
void deposita(double quantidade) {
this.saldo += quantidade;
}

Testa os Métodos
class TestaAlgunsMetodos {
// criando a conta
Conta minhaConta;
// alterando os valores de minhaConta
minhaConta.dono = "Duke";
minhaConta.saldo = 1000;
// saca 200 reais
minhaConta.saca(200);
// deposita 500 reais
minhaConta.deposita(500);
System.out.println(minhaConta.saldo);
}
}

Métodos com retorno
Um método sempre tem que definir o que retorna, nem que defina que não há retorno, como nos
exemplos anteriores onde estávamos usando o void .
Um método pode retornar um valor para o código que o chamou. No caso do nosso método saca ,
podemos devolver um valor booleano indicando se a operação foi bem sucedida.

class Conta {
// ... outros métodos e atributos ...
boolean saca(double valor) {
if (this.saldo < valor) {
return false;
}
else {
this.saldo = this.saldo - valor;
return true;
}
}
}

A declaração do método mudou! O método saca não tem void na frente. Isto quer dizer que,
quando é
acessado, ele devolve algum tipo de informação. No caso, um boolean . A palavra chave return
indica que o
método vai terminar ali, retornando tal informação.
imagem

Exemplo de uso:
boolean consegui = minhaConta.saca(2000);
if (consegui) {
System.out.println("Consegui sacar");
} else {
System.out.println("Não consegui sacar");
}

Ou então, posso eliminar a variável temporária, se desejado:
if (minhaConta.saca(2000)) {
System.out.println("Consegui sacar");
} else {
System.out.println("Não consegui sacar");
}

O método transfere()
se quisermos ter um método que transfere dinheiro entre duas contas?
Podemos ficar tentados a criar um método que recebe dois parâmetros: conta1 e conta2 do tipo
Conta . Mas cuidado: assim estamos pensando de maneira procedural.
class Conta {
// atributos e métodos...
void transfere(Conta destino, double valor) {
this.saldo = this.saldo - valor;
destino.saldo = destino.saldo + valor;
}
}

Para deixar o código mais robusto, poderíamos verificar se a conta possui a quantidade a ser
transferida disponível. Para ficar ainda mais interessante, você pode chamar os métodos deposita
e saca já existentes para fazer essa tarefa:

class Conta {
// atributos e métodos...
boolean transfere(Conta destino, double valor) {
boolean retirou = this.saca(valor);
if (retirou == false) {
// não deu pra sacar!
return false;
}
else {
destino.deposita(valor);
return true;
}
}
}

Continuando com atributos
As variáveis do tipo atributo, diferentemente das variáveis temporárias (declaradas dentro de um
método), recebem um valor padrão. No caso numérico, valem 0, no caso de boolean , valem false
. Você também pode dar valores default, como segue
class Conta {
int numero = 1234;
String dono = "Duke";
String cpf = "123.456.789-10";
double saldo = 1000;
double limite = 1000;
}
Nesse caso, quando você criar uma conta, seus atributos já estão “populados” com esses valores
colocados.

As variáveis do tipo atributo, diferentemente das variáveis temporárias (declaradas dentro de um
método), recebem um valor padrão. No caso numérico, valem 0, no caso de boolean , valem false
. Você também pode dar valores default, como segue
class Conta {
int numero = 1234;
String dono = "Duke";
String cpf = "123.456.789-10";
double saldo = 1000;
double limite = 1000;
}

Imagine que comecemos a aumentar nossa classe Conta e adicionar nome, sobrenome e cpf do
cliente dono da conta. Começaríamos a ter muitos atributos... e, se você pensar direito, uma
Conta não tem nome , nem sobrenome nem cpf , quem tem esses atributos é um Cliente . Então
podemos criar uma nova classe e fazer uma composição
Seus atributos também podem ser referências para outras classes. Suponha a seguinte classe
Cliente :
class Cliente {
String nome;
String sobrenome;
String cpf;
}

class Conta {
int numero;
double saldo;
double limite;
Cliente titular;
...
}
// depois já instanciar o Cliente
Cliente titular = new Cliente()

E dentro do main da classe de teste:
class Teste {
Conta minhaConta = new Conta();
Cliente c = new Cliente();
minhaConta.titular = c;
// ...
}
}

Aqui, simplesmente houve uma atribuição. O valor da variável c é copiado para o atributo titular do
objeto ao qual minhaConta se refere. Em outras palavras, minhaConta tem uma referência ao
mesmo Cliente que c se refere, e pode ser acessado através de minhaConta.titular
Você pode realmente navegar sobre toda essa estrutura de informação, sempre usando o ponto:
Cliente clienteDaMinhaConta = minhaConta.titular;
clienteDaMinhaConta.nome = "Duke";
Ou ainda, pode fazer isso de uma forma mais direta e até mais elegante:
minhaConta.titular.nome = "Duke";

Mas, e se dentro do meu código eu não desse new em Cliente e tentasse acessá-lo diretamente?
class Teste {
Conta minhaConta = new Conta();
minhaConta.titular.nome = "Manoel";
// ...
}
}
Quando damos new em um objeto, ele o inicializa com seus valores default, 0 para números, false
para boolean e null para referências. null é uma palavra chave em java, que indica uma
referência para nenhum objeto.

Se, em algum caso, você tentar acessar um atributo ou método de alguém que está se
referenciando para null , você receberá um erro durante a execução ( NullPointerException , que
veremos mais à frente). Da para perceber, então, que o new não traz um efeito cascata, a menos
que você dê um valor default (ou use construtores, que também veremos mais a frente):
class Conta {
int numero;
double saldo;
double limite;
Cliente titular = new Cliente();
// quando chamarem new Conta, havera um new Cliente para ele.
}

Com esse código, toda nova Conta criada já terá um novo Cliente associado, sem necessidade de
instanciá-lo logo em seguida da instanciação de uma Conta . Qual alternativa você deve usar?
Depende do caso: paratoda nova Conta você precisa de um novo Cliente ? É essa pergunta que
deve ser respondida. Nesse nossocaso a resposta é não, mas depende do nosso problema.

Um pouco de arrays
Dentro de um bloco, podemos declarar diversas variáveis e usá-las:
int idade1;
int idade2;
int idade3;
int idade4;
Isso pode se tornar um problema quando precisamos mudar a quantidade de variáveis a serem
declaradas de acordo com um parâmetro. Esse parâmetro pode variar, como por exemplo, a
quantidade de número contidos num bilhete de loteria. Um jogo simples possui 6 números, mas
podemos comprar um bilhete mais caro, com 7 números ou mais.
Para facilitar esse tipo de caso podemos declarar um vetor (array) de inteiros:

Um pouco de arrays
int[] idades;
O int[] é um tipo. Uma array é sempre um objeto, portanto, a variável idades é uma referência.
Vamos precisar criar um objeto para poder usar a array. Como criamos o objeto-array?
idades = new int[10];
O que fizemos foi criar uma array de int de 10 posições e atribuir o endereço no qual ela foi criada.
Podemos ainda acessar as posições do array:
idades[5] = 10;

Um pouco de arrays
O código acima altera a sexta posição do array. No Java, os índices do array vão de 0 a n-1, onde
n é o tamanhom dado no momento em que você criou o array. Se você tentar acessar uma
posição fora desse alcance, um erro ocorrerá durante a execução.

Um pouco de arrays
No caso do bilhete de loteria, podemos utilizar o mesmo recurso. Mais ainda, a quantidade de
números do nosso bilhete pode ser definido por uma variável. Considere que n indica quantos
números nosso bilhete terá, podemos então fazer:
int numerosDoBilhete[] = new int[n];
E assim podemos acessar e modificar os inteiros com índice de 0 a n-1 .

Arrays de referências
É comum ouvirmos “array de objetos”. Porém quando criamos uma array de alguma classe, ela
possui refe-rências. O objeto, como sempre, está na memória principal e, na sua array, só ficam
guardadas as referências(endereços).
Conta[] minhasContas;
minhasContas = new Conta[10];

Quantas contas foram criadas aqui? Na verdade, nenhuma. Foram criados 10 espaços que você
pode utilizar para guardar uma referência a uma Conta. Por enquanto, eles se referenciam para
lugar nenhum ( null ). Se você tentar:
System.out.println(minhasContas[0].saldo);
Um erro durante a execução ocorrerá! Pois, na primeira posição da array, não há uma referência
para uma conta, nem para lugar nenhum. Você deve popular sua array antes.
Conta contaNova = new Conta();
contaNova.saldo = 1000.0;
minhasContas[0] = contaNova;
Ou você pode fazer isso diretamente:
minhasContas[1] = new Conta();
minhasContas[1].saldo = 3200.0;
Uma array de tipos primitivos guarda valores, uma array de objetos guarda referências.

Percorrendo uma array
Percorrer uma array é muito simples quando fomos nós que a criamos:
public static void main(String args[]) {
int[] idades = new int[10];
for (int i = 0; i < 10; i++) {
idades[i] = i * 10;
}
for (int i = 0; i < 10; i++) {
System.out.println(idades[i]);
}
}

Porém, em muitos casos, recebemos uma array como argumento em um método:
void imprimeArray(int[] array) {
// não compila!!
for (int i = 0; i < ????; i++) {
System.out.println(array[i]);
}
}

Até onde o for deve ir? Toda array em Java tem um atributo que se chama length , e você pode
acessá-lo
para saber o tamanho do array ao qual você está se referenciando naquele momento:
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}

Arrays não podem mudar de tamanho
A partir do momento que uma array foi criada, ela não pode mudar de tamanho.
Se você precisar de mais espaço, será necessário criar uma nova array e, antes de se referir ela,
copie os elementos da array velha.

Percorrendo uma array no Java 5.0
O Java 5.0 traz uma nova sintaxe para percorremos arrays (e coleções, que veremos mais a
frente).
No caso de você não ter necessidade de manter uma variável com o índice que indica a posição do
elemento
no vetor (que é uma grande parte dos casos), podemos usar o enhanced-for.
class AlgumaClasse{
public static void main(String args[]) {

int[] idades = new int[10];
for (int i = 0; i < 10; i++) {
idades[i] = i * 10;
}
// imprimindo toda a array
for (int x : idades) {
System.out.println(x);
}
}
}

ão precisamos mais do length para percorrer matrizes cujo tamanho não conhecemos:
class AlgumaClasse {
for (int x : array) {
System.out.println(x);
}
}
}
O mesmo é válido para arrays de referências. Esse for nada mais é que um truque de compilação
para facilitar essa tarefa de percorrer arrays e torná-la mais legível.

Herança, reescrita e polimorfismo

exercicio
Um domínio é composto pelas entidades, informações e processos relacionados a um determi-
nado contexto. Uma aplicação pode ser desenvolvida para automatizar ou tornar factível as tarefas
de um domínio. Portanto, uma aplicação é basicamente o “reflexo” de um domínio.
Para exemplificar, suponha que estamos interessados em desenvolver uma aplicação para facili-
tar as tarefas do cotidiano de um banco. Podemos identificar clientes, funcionários, agências e
contas como entidades desse domínio. Assim como podemos identificar as informações e os
processos
relacionados a essas entidades.

Introdução - Android
Os aplicativos Android são desenvolvidos com JAVA - a linguagem de
programação mais usada do mundo.
Essa linguagem foi uma escolha lógica para a plataforma Android, porque é
poderosa, gratuita e de código-fonte aberto.
O java é usado para desenvolver aplicativos empresarias de larga escala,
melhorar a funcionalidade de servidores Web, fornecer aplicativos para
aparelhos de consumidor (por exemplo, telefones celulares, pagers e
assistente digitais pessoais) e para muitos outros propostos.
O java permite desenvolver aplicativos que são executados em uma variedade
de dispositivos, sem nenhum código especifico para plataforma.

Introdução - Android
Os programadores java experientes pode se aprofundar rapidamente no
desenvolvimento com Android, usando as APIs (intefaces de programa de
aplicativo) Android e outras disponíveis de terceiros.
O grau de abertura da plataforma estimula a rápida inovação. O Android esta
disponível em dispositivos de dezenas de fabricantes de equipamento originais
(OEMs - original equipement manufactres) em 48 países, por meio de 59
empresas de telefonia. A intensa concorrência entre os OEMs e as empresas
de telefonia beneficia os clientes.
A linguagem java e orientada a objetos e tem acesso a poderosas bibliotecas
de classe que ajudam a desenvolver aplicativos rapidamente. A programação
de interfaces gráficas do usuário com Java é baseada em eventos.

Dificuldades em aprender programação
Android
Para ser um programador, a pessoa precisa possuir (ou desenvolver)
algumas características:
- gostar de resolver problemas
- capacidade de pensamento lógico abstrato
- capacidade de planejamento
- conhecer lógica e lógica de programação
- conhecer a sintaxe e semântica de alguma linguagem de programação
- conhecer estrutura de dados
- conhecer banco de dados
- conhecer a linguagem SQL
- conhecer o equipamento em que o programa vai rodar
- saber pesquisar no Google
- etc...

Android
E algumas para o Android:
- conhecer programação Java
- conhecer programação orientada a objetos
- conhecer programação orientada a eventos
- conhecer programação concorrente
- conhecer a plataforma Android
- conhecer a filosofia da plataforma (arquitetura)
- conhecer os componentes básicos de uma aplicação (activities,
services, broadcastReceivers e content providers)
- conhecer os recursos existentes para implementar os componentes

Android
Para se programar Android, normalmente é requerido que o programador
tenha essas características de imediato, ou seja, fica difícil para um iniciante.
Por isso, eu sempre recomendo usar um livro como guia para o prendizado.
A falta de alguma competência se deve na maioria das vezes à pressa em
iniciar algum projeto. O novato salta alguns tópicos e vai direto para a
codificação.
Aí, com certeza, vai encontrar diversos obstáculos. Que vão desde
problemas com lógica, desconhecimento da linguagem Java, conceitos de
classes e objetos, programação concorrente, etc. Ou seja, problemas de

Android
formação básica, que todo candidato a programador Android, já deveria ter
superado, chegando aos problemas com a plataforma Android propriamente
dita.
Neste ponto, entram além dos novatos, os que já programam uma outra
linguagem. Na grande maioria das vezes, o tempo gasto com problemas
simples, supera em muito o tempo para adquirir o conhecimento necessário,
se o aprendizado fosse planejado.

Android
A recomendação para melhorar o rendimento nessa fase varia de acordo
com o perfil de cada pessoa, obviamente, mas pode ser resumida de uma
maneira geral da seguinte forma: faça uma avaliação pessoal das suas
necessidades de aprendizado e monte um plano de estudos.

Como ser um bom programador Android
Você quer ser um bom programador Android? Então desenvolva as seguintes características
ao máximo:
● Paixão por programação
● Gostar muito de ler
● Gostar de aprender
● Curiosidade
● Autodidata
● Inteligência
● Memória
● Concentração
● Paciência
● Humildade
● Ensinar
● Gostar de desafios
● Organização
● Planejar
● Projetar
● Algoritmos
● Estrutura de dados
● Design Patterns
● Boas Práticas
● Conhecer os recursos da linguagem
Java e as bibliotecas do Android
● Impaciência
● Ego
● Precisão
● Cumpridor de prazos
● disponibilidade de tempo
● Flexibilidade
● Desconfiometro
● Dedicação e perseverança
● Solucionador de problemas

Site p/ discussão
● INGLÊS
● Android Discuss - android-discuss-subscribe@googlegroups.com
● Stack Overflow - www.stackoverflow.com/questions/tagged/android (recomendo)
● Android Developers - subscribe@googlegroups.com
● Android Forums - www.androidforums.com
● BRASIL
● Portal Android - http://www.portalandroid.org/comunidade/ (recomendo)
● GUJ - http://www.guj.com.br/tag/android (fórum novo)
● Android Brasil - https://groups.google.com/forum/#!forum/androidbrasil (usuário)
● Android Dev Brasil - https://groups.google.com/forum/#!forum/androidbrasil-dev
(recomendo)

Por que desenvolver para o
Android?
A pergunta real é: “por que não desenvolver
para o Android?”. se você quiser que seu
aplicativo esteja disponível para milhões de
usuário em todo o mundo, se deseja publicar
aplicativos assim que terminar de programar e
testá-los, ou se quise desenvolver em um
plataforma aberta, ja tem a sua resposta.

Participação no mercado
Como desenvolvedor, você tem uma
oportunidade de criar aplicativos para um
mercado bem novo, e próspero. Muitos
analistas acreditam que o numero de
dipositivos Android em uso é maior que o
numero de dispositivo Android em uso é maior
que o numero de dispositivos em todos os
outros sistemas operacioais moveis

Os usuários não têm que pesquisar na internet
para encontrar um aplicativo para instalar, eles
podem simplesmente ir para a Google play
Store, pré-instalada em seus dispositivos, e ter
acesso a todos os seus aplicativos. Como a
Google play store vem pré-instalada na maioria
dos aplicativos Android, em geral, os usuários
pesquisam-na para todas as suas

Colocação no Mercado
Por causa de todas as interfaces de
programação do aplicativo(APIs) que vêm no
Android, você pode desenvolver facilmente
aplicativos cheios de recursos em um intervalo
de tempo relativamente curto. depois de se
registrar como desenvolvedor na Google play,
simplesmente faça upload de seus aplicativos
e os publique. Diferentemente de outros

Plataforma aberta
O sistema opercional Android é uma
plataforma aberta: qualquer fabricante ou
provedor de hardware pode fabricar ou vender
o dispoistivos Android.
Como voce pode imaginar, a abertura do
Android permituiu conqueistar uma
participação no mercado rapidamente. Sinta-se
à vontade paar examinar o codigo-fonte do

As raízes do Android
Embora a mairoa das pessoas não saiba, o
Google não iniciou o projeto Android. A versão
inciial do sitema operacional Android foi criada
pela Android Inc., uma pequena empersa
startup no Vale do Silício que foi comprada
pela Google em julho de 2005.

O básico do desenvolvimento
Android
Ainda bemque voce não tem que ser um
membro do Mensa para desenvolver
aplicativos Android! Desenvolver no Android é
simples qproque sua linguagem padrão é o
Java. Embora escrever aplicativos android seja
bem fácil, desenvolver sozinho pode ser um
tarefa difícil.

O básico do desenvolvimento
Android
Embora o sitema operacional Android consita
basicamente em código Java, pequenas partes
da estrutura não esto incluídas. O android usa
a linguagem Xl, assim como scripts Apache Ant
básicos para cosntruir os processos. Você
precisa cimentar sua compreensão básica do
XML.

Java: sua linguagem de
programação android
Os aplicativos Android são escritos em Java -
não a versão completa do Java, que é familiar
para os desenvolvedores que usam a
plataforma Java Enterprise Edittion(J2EE), mas
um subconjunto das bibliotecas Java que são
especificas do Android. Esse subconjunto do
Java excluior as classes que não são
adequadas para os dispostivos moveis. Se

Android dentro de você
Torna-se um desenvolvedor aAndroid não é
uma tarefa complicada. E provavelmente é
mais simples do que você pensa. Para ver do
que se trata, faça a si mesmo estas perguntas:

Eu quero desenvolver aplicativos Android?
Eu gosto das ferramentas de desenvolvimento
de software gratuitas?
Eu gosto de não pagar taxas de
desenvolvimento?
Eu tenho um computador no qual desenvolver?

Se você respondeu sim a todas as perguntas,
hoje é seu dia de sorte, você está pronto para
se tornar um desnevolvedorAndroid. Vocẽ
pode estar imaginado o que queremos dizer
com não pagar taxas de desevnvoment. voce
esta lendo a pergunta corretamente: voce não
pagara taxas para desenvelver os aplicativos
ANdroid.

Sempre há uma condição, certo? você pode
desenvolver gratuitamente o que bem
entender, mas assim que quiser publica seu
apliucativo na Google play, o local onde voce
faz upload e publica seus aplicativos,,
precisará pagar uma pequena taxa de registro
nominal. o valor da taxa custa US$ 25,00
dolares.

Google android p/ Noobs - SUPER 2014 - UPE

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Google android p/ Noobs - SUPER 2014 - UPE

Google android p/ Noobs - SUPER 2014 - UPE