Neste guia, estão dispostos alguns conceitos básicos da sintaxe do Java, bem como alguns conceitos de orientação a objetos, e de programação no geral. Visa ajudar aqueles que estão iniciando na programação do zero e escolheram Java como sua primeira linguagem. O conteúdo é fortemente inspirado neste thread do Gamer's Board, agradecimentos ao criador do mesmo pela inspiração.
- (O clássico) Hello World, em Java:
public class Exemplo {
public static void main(String[] args) {
// Isto é um comentário
/*
Ao inserir um "//" em alguma linha no código, o Java
irá considerar o conteúdo após o "//" como um comentário;
O mesmo se aplica ao usar "/*", porem este segundo suporta
uso em multiplas linhas
*/
System.out.println("Hello, World");
}
}- Objeto (Orientação a Objetos): Entidades que representam objetos reais, porém dentro da programação. Cada objeto possuí seus proprios atributos (Dados e informações, ficam salvos na memória durante a execução do programa) e comportamentos (Instruções de código que o computador executa, e representam comportamentos reais e/ou regras de negócio relacionadas aquele objeto, podem ter comportamentos customizados de acordo com os valores dos atributos);
- Instância de objeto: Unidade de objeto. Cada objeto no Java tem sua estrutura base definida por uma classe (Veremos à seguir), onde o programador define quais atributos aquele objeto terá e implementa os comportamentos. A instância é o objeto em si, e apesar das instâncias compartilharem da mesma estrutura base, elas podem ter valores diferentes nos atributos, o que as diferencia umas das outras.
Definida no Java pela keyword class, a classe é um recurso do Java utilizado para definir a estrutura base dos objetos. É na classe que definimos quais serão os atributos daquele objeto, na forma de variáveis, e também onde definimos o código relativos aos comportamentos daquele objeto, na forma de métodos; Como veremos mais além, Java é uma linguagem fortemente tipada, ou seja: Toda variável precisa de um tipo
Exemplo de classe que define a estrutura básica de um objeto do tipo Jogador:
/*
Usa-se a keyword class + o nome da classe para definirmos uma nova classe
As chaves ({}) são usadas para delimitar o começo e o final de um bloco de código,
e aparecem quando estamos criando classes, métodos, e outras estruturas
Por convenção, a utiliza-se PascalCase para nomear as classes no Java
*/
class Jogador {
/*
Aqui ficam os atributos do objeto, na forma de variável
Cada instrução no Java precisa terminar com um ";" no final da linha,
é o caso de quando definimos variáveis, e também quando executamos algum método
*/
String nome;
int nivel;
int xp;
long dinheiro;
/*
Aqui um exemplo de comportamento desse objeto, na forma de método
Ao ser executado, esse método irá exibir no console da aplicação
uma mensagem, como se tivesse sido dita por esse jogador.
*/
void falarNome() {
// Aqui executamos o método println, portanto ao final da linha devemos colocar um ";"
System.out.println("Olá! Meu nome é " + nome);
}
}Podemos definir um método construtor, um método especial que é executado sempre que um novo objeto é instanciado, e é neste método em que podemos definir os valores dos atributos que esse objeto possuirá.
class Jogador {
String nome;
/*
Aqui definimos um método construtor que recebe um texto, e o valor informado aqui
será usado como o nome do jogador.
O método construtor usa sempre o mesmo nome da classe, e é sempre executado logo após
o objeto ser instanciado; aqui podemos definir qualquer comportamento que queremos que
esse objeto exerça logo que ele nasça!
*/
Jogador(String nome) {
this.nome = nome;
/*
O keyword "this" é usado para dizermos que estamos interagindo com o "objeto atual"
Ou seja, quando usamos this.nome, estamos dizendo que queremos acessar a variável
"nome" deste mesmo objeto, e não de um outro objeto do tipo Jogador.
*/
}
}
/*
Aqui instanciamos dois jogadores
A estrutura padrão da instrução de instanciar é: new NomeDaClasse([parametros]);
Os parâmetros para o método construtor são passados dentro dos parênteses
*/
Jogador jogadorUm = new Jogador("Pedro");
Jogador jogadorDois = new Jogador("Paulo");
System.out.println(jogadorUm.nome); // Irá exibir no console: Pedro
System.out.println(jogadorDois.nome); // Irá exibir: Paulo Expressão que representa um dado armazenado na memória do computador durante a execução do programa, e que pode ter seu valor alterado durante a execução do mesmo. Há também a constante, que representa um valor armazenado no próprio código, e que não podem ter o valor alterado.
Java é uma linguagem de tipagem forte e estática, isso significa que uma variável no Java sempre precisará ter um tipo atrelado a ela, e só poderá armazenar dados desse único tipo. É impossível, por exemplo, ter uma variável que consegue armazenar um valor em texto e outro numérico; seria necessário ter duas variáveis diferentes, uma pra cada tipo.
/*
A estrutura básica de uma variável no Java é a seguinte:
[modificadores] <tipo> <nome>
Por padrão, utiliza-se o padrão camelCase para noemar as variáveis no Java
*/
public String nomeVariavel = "João";
/*
Uma variável com modificador final sinaliza que a variável é imutável;
uma vez que seja atribuído um valor a essa variável, o mesmo não poderá mais ser alterado.
Semelhante à constante;
*/
public final String nomeImutavel = "João";
/*
Uma constante é definida por possuir os modificadores **static** e **final** juntos.
O valor é definido apenas uma vez, no próprio código, e não é alterado durante
toda a execução do programa.
O padrão de nomenclatura para constantes é o snake_case com letras MAIÚSCULAS
*/
public static final String NOME_CONSTANTE = "João";Os modificadores serão abordados mais a frente.
São blocos de código que formam rotinas (Comportamentos) que são executados no momento em que esse método é chamado em algum lugar. São análogos às funções em outras linguagens, com a diferença de que um método é algo que está sempre ligado a uma classe e não é considerado uma entidade, enquanto que as funções podem ser entidades standalone.
/*
A estrutura padrão de um método é:
[modificadores] <tipo de dado a ser retornado> <nome>([parâmetros])
Usa-se o keyword "return" para indicar o valor resultado da execução do método
*/
public int somar(int primeiraParcela, int segundaParcela) {
return primeiraParcela + segundaParcela;
}
// O método pode ou não ter parâmetros:
public int doisMaisDois() {
return 2 + 2;
}
/*
O método pode também não retornar nenhum dado.
Quando queremos definir um método que apenas executa instruções sem ter um resultado,
usamos o keyword **void**
Em métodos void, não precisamos usar o keyword return, pois o método void não
retorna valor nenhum como resultado. No entanto, é possível ainda assim, usá-lo:
nesse caso o return servirá apenas para finalizar a execução das instruções do método,
mas seu uso não é obrigatório.
*/
public void exibirDoisMaisDois() {
System.out.println("Dois mais dois: " + doisMaisDois());
return; // Execução finalizada
System.out.println("Essa instrução será ignorada");
}São keywords usados para, justamente, modificar comportamentos dos elementos do código, como variáveis e métodos, e que devem ser colocados em frente ao tipo do elemento que se quer atribuir.
São keywords que permitem controlar o nível de acesso de um elemento específico. São eles:
- Public: Qualquer outra classe pode acessar o recurso.
- Private: Apenas a própria classe pode acessar os recursos; dois objetos de um mesmo tipo (Mesma classe) podem acessar os atributos privados um do outro, mas objetos de outros tipos não conseguirão.
- Protected: Apenas classes que estão no mesmo package ou que herdam da classe que carrega esse elemento podem acessar.
- Default: Também chamado de package-private, apenas classes que estão na mesma package podem acessar o recurso.
- Final:
- Torna uma variável imutável;
- Se usado numa classe, impede que a mesma seja herdada por outra classe (
extends); - Se usado num método, indica que o mesmo não pode ser sobrescrito numa classe que estiver herdando-a (
@Override)
- Static: Elementos com esse modificador ficam atrelados a uma classe, e não a um objeto. A principal diferença de elementos static para os convencionais, é que você não instancia uma nova classe para acessar esses elementos. Devem ser usados em quaisquer variáveis ou métodos que não necessitam interagir com o estado de um objeto, como métodos de utils ou constantes.
public Classe { public static void metodoEstatico() {} } // Não usa-se uma instancia da classe, e sim, a própria classe, para acessar o recurso. Classe.metodoEstatico();
Muito boa a explicação 👏👏👏. Parabéns por ter se dedicado a explicar.