Comentários
Esses conceitos auxiliam de forma direta, na modelagem de problemas do mundo real, trazendo uma grande flexibilidade na manipulação de classes e objetos.
Fonte: Shutterstock.
Deseja ouvir este material?
Áudio disponível no material digital.
Prezado estudante, bem-vindo à segunda unidade do livro Linguagem Orientada a Objetos. Nesta unidade, estudaremos as principais estruturas do desenvolvimento Orientado a Objetos (OO), bem como estabeleceremos as ideias por trás de atributos e métodos estáticos, construtores, sobrecarga e sobreposição de métodos, assim, após a leitura, você será capaz de identificar quando declarar atributo e método de forma estática. Além disso, mostraremos como fazer a criação de diversos construtores em uma única classe e as formas como esses construtores são invocados, como se criar a sobrecarga e a sobreposição de métodos e uma comparação entre esses conceitos. As estruturas de controle, como tomada de decisão e repetição, também serão estudadas, assim como as teorias por trás da herança, polimorfismo e encapsulamento. Entenderemos, por fim, o quanto esses conceitos auxiliam, de forma direta, na reutilização de código e o tornam mais organizado.
Após a leitura desta unidade, espera-se que o leitor seja capaz de criar os seus primeiros programas Java dentro de um Ambiente de Desenvolvimento Integrado (IDE) poderoso, sendo que um bom IDE provê um local de trabalho em que os aspectos de produtividade são acelerados. Espera-se, também, que o leitor comece a se familiarizar com as plataformas de compartilhamento de código, como o GitHub, e este livro apresenta uma série de exemplos práticos que auxiliam na compreensão da teoria. A capacidade de reflexão, modelagem e abstração será treinada ao longo do estudo.
Esta unidade o ajudará na compreensão da OO dentro da linguagem Java a partir das seguintes seções: a Seção 2.1 apresentará os conceitos por trás dos atributos e métodos estáticos, métodos construtores, sobrecarga e sobreposição de métodos. A Seção 2.2 trará as estruturas de controle como estruturas de decisão e repetição, bem como apresentará os operadores aritméticos, lógicos e relacionais. A Seção 2.3, por fim, mostrará as ideias relacionadas à reutilização de código, como encapsulamento, herança e polimorfismo em programação orientada a objetos.
Sendo esta uma unidade prática, convido você a implementar as atividades aqui propostas. Lembre-se: a prática leva à perfeição.
Bons estudos!
Caro estudante, bem-vindo à primeira seção da segunda unidade dos estudos sobre linguagem orientada a objetos. Qual desenvolvedor nunca se perguntou como construir uma aplicação que tenha grande flexibilidade na invocação de atributos, construtores e métodos? Pois bem, a ideia-chave aqui é a modelagem a partir dos conceitos por trás da Orientação a Objetos (OO). Nesta seção, você terá a oportunidade de aprender os conceitos e as ideias sobre atributos e métodos estáticos, construtores, sobrecarga e sobreposição de métodos. Esses conceitos, por sua vez, o auxiliarão, de forma direta, na modelagem de problemas do mundo real, trazendo uma grande flexibilidade na manipulação de classes e objetos.
Como forma de contextualizar sua aprendizagem, tenha em mente a startup pela qual você foi contratado. O seu chefe deseja dar continuidade à modelagem do robô que você iniciou na primeira seção da primeira unidade; ele acredita que a modelagem desenvolvida pode ser melhorada ao se incorporar novos recursos que embasem, cada vez mais, o simulador de robô que você deve construir. Assim, após o seu chefe revisar todo o código que você desenvolveu, ele pediu a você que criasse quatro novos construtores para a classe robô, bem como definisse alguns atributos como constantes, argumentando que isso impedirá eventuais erros no código.
Quanto ao método move que você criou, ele gostou muito, por isso, quer que você faça a sua sobrecarga, criando novas opções para que seu robô se desloque no cenário. O seu chefe percebeu que você colocou o ponto de entrada da aplicação (método main) dentro da classe robô, no entanto, ele não gostou disso e quer que você o coloque em outra classe. Além disso, ele também percebeu que você está programando a sua aplicação na nuvem (internet), utilizando compilador web, porém, sabendo que a sua aplicação crescerá muito ao longo do tempo, pediu para que instalasse algum IDE em seu computador local, justificando que o IDE instalado localmente lhe dará um suporte melhor durante o seu desenvolvimento.
Diante do desafio que lhe foi apresentado, como você criará esses construtores para o seu robô? Como fará para tornar alguns de seus atributos constantes? Como irá fazer a sobrecarga do método move? O que é um construtor? O que é sobrecarga de método? Como você colocará a aplicação principal em outra classe? Qual IDE você irá instalar?
Esta seção o auxiliará nas respostas de tais perguntas.
Muito bem, agora que você foi apresentado à sua nova situação-problema, estude esta seção e compreenda como a OO pode auxiliá-lo na modelagem de diferentes construtores, constantes e sobrecarga de métodos. Esses conceitos serão fundamentais na OO e trarão uma maior sofisticação à construção do simulador de robô que você deve fazer. E aí, vamos juntos compreender esses conceitos para resolver esse desafio?
Bom estudo!
Uma Linguagem Orientada a Objetos (OO) utiliza diversas abstrações para representar modelos do mundo real ou imaginário. Na unidade anterior, aprendemos como se dá a construção de aplicações básicas em Java a partir do site jdoodle, bem como a de animações tridimensionais a partir da ferramenta Alice e de jogos bidimensionais com a ferramenta Greenfoot. As ferramentas Alice e Greenfoot, na verdade, são mais do que ferramentas, são Ambientes de Desenvolvimento Integrado (IDE).
O ambiente de programação online jdoodle atende bem às necessidades do programador quanto à construção de um programa ou sistema simples e pequeno. Imagine, agora, que desejamos desenvolver um sistema grande com diversas classes e com muitas linhas de código. Apesar de ser possível desenvolvê-lo por meio do jdoodle, ele não é tão adequado, sendo necessária a utilização de um IDE mais poderoso.
IDE é um ambiente que auxilia muito a vida do programador, e um bom ambiente de desenvolvimento colabora com diversos recursos, como:
Pesquise mais sobre os IDEs Eclipse, IntelliJ IDEA e NetBeans e selecione e instale o IDE que mais se adequa ao seu perfil. Todos são igualmente bons.
Imagine que você gostaria de modelar uma classe chamada Matematica para resolver problemas relacionados a essa área do conhecimento. Nessa classe, você gostaria que houvesse as seguintes constantes: número pi (PI), número de Euler (E) e número de ouro (PHI). A constante PI é famosa na matemática e representa a razão entre o comprimento da circunferência e o seu diâmetro; já a constante E representa a base dos logaritmos naturais; e a constante PHI representa uma proporção encontrada em diversas aplicações na natureza. Além disso, você também gostaria que houvesse dois métodos: um para a soma e outro para a multiplicação de inteiros, logo, decide implementar o Código 2.1.
public class Matematica {
double PI = 3.1415926535;
double E = 2.7182818284;
double PHI = 1.6180339887;
int soma(int a, int b){
return a + b;
}
int mult(int a, int b){
return a * b;
}
public static void main(String[] args) {
Matematica mat = new Matematica();
System.out.println("Numero Pi: " + mat.PI);
System.out.println("Numero E: " + mat.E);
System.out.println("Numero Phi: " + mat. PHI);
System.out.println("Soma: " + mat.soma(5, 3));
System.out.println("Mult: " + mat.mult(5, 3));
}
}
As linhas 2, 3 e 4, do Código 2.1, possuem a declaração das constantes matemáticas mencionadas acima; já as linhas 5 a 10 possuem a declaração dos métodos de soma e de multiplicação; por fim, nas linhas de 11 a 18, temos a função main, em que fizemos a utilização da classe Matematica. Você deve ter reparado que tivemos que criar um objeto da classe Matematica para a invocação das constantes (PI, E e PHI) e dos métodos soma e mult.
Os códigos aqui apresentados devem ser implementados em algum IDE que você escolheu e salvou utilizando-se a extensão .java; já o nome do arquivo deve ser o mesmo nome da classe.
A forma como modelamos a classe Matematica não ficou boa, pois, toda vez que tivermos de invocar uma constante ou método dessa classe, teremos de criar um objeto. Repare que essas constantes e os métodos devem ter o mesmo comportamento, independentemente da instância de que fazem parte (eles não manipulam atributos específicos da classe). A melhor forma, neste caso, de implementação das constantes e dos métodos é declará-los como estáticos, evitando-se a construção de um objeto para a invocação de constantes e métodos. Considere o Código 2.2 abaixo.
public class Matematica {
static final double PI = 3.1415926535;
static final double E = 2.7182818284;
static final double PHI = 1.6180339887;
static int soma(int a, int b){
return a + b;
}
static int mult(int a, int b){
return a * b;
}
public static void main(String[] args) {
System.out.println("Numero Pi: " + Matematica.PI);
System.out.println("Numero E: " + Matematica.E);
System.out.println("Numero Phi: " + Matematica. PHI);
System.out.println("Soma: " + Matematica.soma(5, 3));
System.out.println("Mult: " + Matematica.mult(5, 3));
}
}
Nas linhas 2 a 4 foi acrescentada a palavra reservada static, que modifica o comportamento das constantes PI, E e PHI. Devido a essa modificação, as constantes são, agora, acessadas sem que se tenha que declarar um objeto da classe Matematica, escrevendo apenas Matematica.PI, Matematica.E e Matematica.PHI, respectivamente. Repare também que, nas linhas 2 a 4, foi acrescentada a palavra reservada final, que transforma, de fato, os atributos PI, E e PHI em constantes. Essa modificação é importante, uma vez que tais valores nunca deveriam ser alterados, evitando-se possíveis tentativas de mudanças. A palavra reservada final em Java tem algumas semelhanças com a palavra reservada const em C.
A tentativa de atribuição de um valor a um atributo constante gera um erro de compilação. Lembre-se: um valor constante nunca pode ser modificado. Assim, o seguinte código gera um erro de compilação.
final int ID = 1000;
ID = 1001; //Erro. Atribuição não permitida. Ainda em relação ao Código 2.2, as linhas 5 a 10 redefiniram os métodos soma e mult como estáticos, tornando-os, assim, métodos da classe. Dessa maneira, a forma de acesso a esses métodos foi alterada e não é mais necessária a criação de objetos. Nas linhas 15 e 16, a chamada é feita com o nome da própria classe, como Matematica.soma(...) e Matematica.mult(...); os métodos estáticos são também designados de métodos da classe ou, simplesmente, funções, e a principal diferença entre métodos e funções está relacionada a quem faz a invocação: se invocado por um objeto (instância da classe), trata-se de método, se invocado pelo nome da Classe, então, é uma função (método estático). Talvez, o exemplo mais importante de classe composta por apenas métodos estáticos seja a classe Math (veremos mais exemplos dessa classe adiante).
A linguagem Java possui uma série de convenções de nomes de variáveis, constantes, métodos, classes, objetos e pacotes. Lembre-se: a linguagem Java é case-sensitive, ou seja, os nomes utilizados são sensíveis a letras maiúsculas e minúsculas. As variáveis são convencionalmente nomeadas com letras minúsculas (exceto quando começar com _ ou $), e caso sejam compostas por mais uma palavra, esta deverá começar com letra maiúscula, notação chamada de lowerCamelCase. Já as constantes são nomeadas com todas as letras maiúsculas, mas em caso de mais de uma palavra, estas deverão ser separadas por underline, notação designada por SCREAMING_SNAKE_CASE.
Os métodos seguem o mesmo padrão de nomeação de variáveis (lowerCamelCase); já as classes são nomeadas com a primeira letra de cada palavra maiúscula e as demais minúsculas, notação chamada de UpperCamelCase. Os objetos, por sua vez, seguem o mesmo padrão de nomeação de variáveis (lowerCamelCase); já os pacotes devem possuir letras minúsculas, não sendo recomentada a utilização de caracteres especiais, mas, se necessário, fazer o uso do underline. Por exemplos, os seguintes nomes são adequados:
Variáveis: i, _x, $y, maximo, nomeRobo, idadePessoa, areaQuadradoMaior.
Constantes: PI, E, PHI, INDEX, ID_PESSOA, VALOR_CONST_ARRASTO.
Métodos: soma, mult, convertString, calculaQuadrado, calculaMaiorValor.
Classes: Robo, Animal, SimulacaoRobo, CadastraPessoaBancoDados.
Objetos: meuRobo, bob, simRobo, cadastraPessoBD.
Pacotes: src, util, view, window, resources, operadores, src_imgs.
O próximo assunto que iremos tratar diz respeito aos métodos construtores. Toda classe em Java possui um método construtor padrão que possui o mesmo nome da classe e não recebe nenhum argumento. O código 2.1, apesar de não ter sido escrito a classe Matematica, possui um construtor padrão da seguinte forma:
public Matematica(){
}
Esse construtor sempre existirá de forma explícita (como mostrado acima) ou implícita (como no Código 2.1). É importante reparar que a declaração de um construtor deve sempre possuir o mesmo nome da classe; que não existe nenhum tipo de retorno, nem mesmo a palavra void pode ser especificada; e que alguns outros modificadores de acesso são possíveis, além do public, mas veremos isso nas seções seguintes.
A fim de que entenda melhor os métodos construtores, vamos criar uma nova classe em Java que modela a entidade Triangulo. O Código 2.3 nos mostra como podemos modelar essa classe, para isso, nas linhas 2 a 4 foram definidos três atributos que representam os lados do triângulo. Da linha 5 até a 9, temos o primeiro construtor, que recebe uma medida de lado de um triângulo e atribui esse valor a todos os lados. Como esse construtor possui parâmetro, o chamamos de construtor não padrão. Dessa forma, repare que esse construtor será chamado quando o nosso triângulo for isósceles, pois os três lados serão iguais. Da linha 10 até a 14, temos um segundo construtor, que recebe três argumentos, representando os lados a, b e c. As linhas 15 até 19 não serão explicadas por enquanto, apenas assuma que elas auxiliam na impressão da informação na tela. Por fim, temos o método main, que é o ponto de entrada da aplicação. Nele, temos a construção de dois objetos do tipo triângulo, em que o primeiro é do tipo isósceles (com lados iguais a 5) e o segundo do tipo escaleno (com lados iguais a 3, 25 e 26). Neste exemplo, criamos dois construtores, porém podemos ter quantos construtores quisermos em nossa aplicação.
public class Triangulo {
double ladoA;
double ladoB;
double ladoC;
public Triangulo(double lado) {
this.ladoA = lado;
this.ladoB = lado;
this.ladoC = lado;
}
public Triangulo(double a, double b, double c) {
this.ladoA = a;
this.ladoB = b;
this.ladoC = c;
}
@Override
public String toString() {
return String.format("a: %.2f\nb: %.2f\nc: %.2f",
this.ladoA, this.ladoB, this.ladoC);
}
public static void main(String[] args) {
Triangulo trianIsosceles = new Triangulo(5);
Triangulo trianEscaleno = new Triangulo(3, 25, 26);
System.out.println(trianIsosceles);
System.out.println(trianEscaleno);
}
}
Os construtores são sempre invocados utilizando-se a palavra reservada new seguida do nome da classe. O construtor, como o nome já sugere, constrói a classe inicializando-a de forma implícita ou explícita aos atributos dela, bem como aloca a quantidade de memória necessária para utilização do objeto. Caso seja especificado algum tipo de processamento, este pode ser feito dentro do construtor, apesar de não muito indicado. O retorno do operador new é uma referência para o objeto criado.
A Figura 2.1 sintetiza algumas das características dos métodos construtores. Conforme dito, os construtores são classificados em dois tipos: padrão e não padrão, podendo, também, ser classificados como implícitos e explícitos. Os construtores explícitos devem ser codificados, de fato; já os construtores não padrão têm que possuir algum tipo de argumento em sua assinatura.
Uma observação importante sobre construtores é que, quando um construtor não padrão é declarado, automaticamente, o construtor padrão implícito deixa de existir. Assim, caso seja necessária a existência do construtor padrão, é imprescindível a sua declaração explícita.
Outro assunto muito importante dentro da orientação a objetos é a sobrecarga e sobreposição de métodos.
A sobrecarga caracteriza-se por haver mais de um método em uma mesma classe com o mesmo nome, no entanto, com diferentes tipos de dados ou diferentes quantidades de parâmetros.
Analise o Código 2.4, em que o método mult (responsável pela multiplicação) foi sobrecarregado. Nas linhas 2 a 4, temos o método mult com dois argumentos (a, b) do tipo inteiro como entrada e o resultado, um número inteiro, como saída. Nas linhas 5 a 7, temos o método mult com também dois argumentos (a, b), no entanto, do tipo double, e o resultado como um número do tipo double. Por fim, nas linhas 8 a 10, temos o método mult com três argumentos (a, b, c) do tipo double, sendo a saída um número do tipo double.
public class Matematica {
static int mult(int a, int b){
return a * b;
}
static double mult(double a, double b){
return a * b;
}
static double mult(double a, double b, double c){
return a * b * c;
}
public static void main(String[] args) {
System.out.println("Mult: " + Matematica.mult(5, 3));
System.out.println("Mult: " + Matematica.mult(3.2, 4.1));
System.out.println("Mult: " + Matematica.mult(1.4, 2));
System.out.println("Mult: " + Matematica.mult(2, 3.5);
System.out.println("Mult: " + Matematica.mult(4.5, 5.2, 2));
}
}
Ainda no Código 2.4, nas linhas 11 a 17, temos o método principal da aplicação. Na linha 12, foi chamado o método mult com dois argumentos do tipo inteiro (5 e 3), dessa forma, qual dos três métodos mult você acha que será executado? Bem, a resposta é o primeiro (das linhas 2 a 4), porque os argumentos são inteiros e o primeiro método recebe argumentos do tipo inteiro. Na linha 13, foi invocado o método mult com dois argumentos do tipo double (3.2 e 4.1), frente a isso, qual dos métodos mult será executado? A resposta é o segundo (das linhas 5 a 7), pois, como os argumentos são do tipo double, então, a única assinatura de método que casa com esse padrão é a segunda. As linhas 14 e 15 também executam chamadas para o segundo método mult, e nesse caso, como apenas um dos argumentos é do tipo double e o outro é do tipo inteiro, então, nenhum método definido acima casa exatamente com esse padrão, porém, como o tipo int é um caso particular do tipo double, logo, o segundo mult será executado. Por fim, na linha 16, temos uma invocação do método mult com três argumentos do tipo double. Nesse caso, o único método mult que casa com esse padrão é o terceiro (das linhas 8 a 11).
Uma pergunta que você pode fazer relacionada à sobrecarga de métodos é: em qual momento o compilador irá decidir qual método executar? Bem, a resposta é que o compilador fará tal decisão em tempo de compilação. Um leitor atento deve ter reparado que o que fizemos com os construtores no código 2.3 foi um tipo de sobrecarga, só que não de métodos, mas sim de construtores. Assim, o construtor Triangulo(double lado) e Triangulo(double a, double b, double c) foram sobrecarregados, pois o que muda de um para o outro é a quantidade de parâmetros.
No texto acima, mostramos uma série de exemplos de atributos estáticos e métodos estáticos, bem como de sobrecarga de métodos. Acesse o conteúdo Class Math, do site Oracle, cujo link está no tópico Referências, e reflita sobre como foram declaradas as constantes; o porquê de todos os métodos dessa classe serem estáticos; da maioria dos métodos dessa classe possuir sobrecarga; do método abs (que calcula o valor absoluto) possuir quatro assinaturas, que são: static double abs(double a), static float abs(float a), static int abs(int a) e static long abs(long a); do método cos (que calcula o cosseno) possuir apenas uma assinatura, que é: static double cos(double a); de não existirem as assinaturas static int cos(int a), static long cos(long a) e static float cos(float a); e, por fim, repare na padronização dos nomes de constantes e métodos presentes nessa classe. Repare que eles seguem a mesma padronização de nomes sugerida neste livro.
Vamos, agora, estudar a sobreposição de métodos.
A sobreposição também chamada de sobrescrita de métodos, se caracteriza por possuir mais uma classe, em que a primeira herda a segunda.
Neste momento, vamos abstrair alguns detalhes da herança, que será melhor abordada na seção 3 desta unidade. Analise o Código 2.5 abaixo, em que temos duas classes.
public class Geom2D {
double perimetro;
double calcPerimetro(){
return 0;
}
}
public class Triangulo extends Geom2D {
...
@Override
double calcPerimetro() {
super.perimetro = this.ladoA + this.ladoB + this.ladoC;
return super.perimetro;
}
public static void main(String[] args) {
Triangulo trian = new Triangulo(3, 25, 26);
System.out.println("Perimetro: " + trian.calcPerimetro());
}
}
A primeira classe, nomeada de Geom2D, está descrita nas linhas 1 a 6. Aqui, é importante destacarmos que esse código deve estar em um arquivo chamado Geom2D.java e que a segunda classe nomeada de Triangulo está descrita nas linhas 8 a 19. Essa classe também deve estar em um arquivo separado, chamado Triangulo.java. A primeira classe cria um atributo chamado perímetro e um método que calcula o perímetro (calcPerimetro). Esse método, inicialmente, retorna zero, mas essa não é a melhor forma de criação deste método, veremos depois como transformá-lo em um método abstrato. A segunda classe herdou a classe Geom2D (utilizando a palavra reservada extends) e, em seguida, algumas linhas de códigos foram omitidas (podemos ver essas linhas no Código 2.3). Das linhas 10 a 14, temos a sobreposição do método calcPerimetro. O método sobrescrito possui a mesma assinatura (double calcPerimetro()) do método da sua superclasse (Geom2D). Repare a utilização do recurso de anotações do Java em que temos a palavra @Override escrita acima do método sobreposto.
Nas linhas 15 a 18, temos o método principal, que, basicamente, constrói um triângulo e chama o método calcPerimetro(). A pergunta que devemos fazer aqui é: qual método será executado: o método calcPerimetro em Geom2D ou calcPerimetro em Triangulo? Bem, a resposta para essa pergunta é o método da classe Triangulo. A sobrecarga ficará mais clara quando explicarmos com mais detalhes a herança.
Você deve ter observado no Código 2.5, na linha 12, a utilização das palavras reservadas this e super; mas o que elas fazem? A palavra this é utilizada para fazer referência a elementos da própria classe em que estamos. Por exemplo: os atributos ladoA, ladoB e ladoC foram declarados na classe Triangulo, assim, ao nos referirmos a eles dentro de Triangulo, podemos utilizar o this, como em this.ladoA. A referenciação utilizando-se o this é opcional; em muitos casos, ele ajuda a tornar mais legível o software. Por sua vez, a palavra super é utilizada para se fazer referência a elementos da superclasse. Por exemplo: o atributo perimetro não foi declarado em Triangulo, mas sim em Geom2D, logo, para nos referirmos ao perímetro, podemos utilizar o super, como em super.perimetro. A referenciação utilizando-se o super é opcional; em muitos casos, ele ajuda a tornar mais legível o código. Às vezes, o this é utilizado para desambiguizar a variável a qual estamos nos referindo. Considere o seguinte exemplo:
public class Ponto2D {
double x;
double y;
public Ponto2D(double x, double y) {
this.y = x; //retira a ambiguidade de x = x;
this.x = y; //retira a ambiguidade de y = y;
}
}
No exemplo acima, o construtor Ponto2D recebe dois parâmetros x e y. Queremos atribuir os valores desses argumentos aos atributos x e y da classe, dessa forma, precisamos utilizar o this para evitarmos ambiguidade, senão, teremos uma linha de código da seguinte forma x=x, não deixando claro a qual x nos referimos: se ao x do argumento ou ao x da classe.
Vamos, agora, fazer um breve comparativo entre a sobrecarga e a sobreposição de métodos. O Quadro 2.1 sintetiza algumas características presentes na sobrecarga e na sobreposição.
| Característica |
Sobrecarga |
Sobreposição |
|---|---|---|
| Argumentos | Devem ser trocados | Não devem ser trocados |
| Tipo de Retorno | Pode ser trocado | Não pode ser trocado |
| Tipo de Acesso | Pode ser trocado | Pode ser trocado por um modificador menos restritivo |
| Tipo de Exceção | Pode ser trocado | Pode ser trocado por uma exceção menos restritiva |
| Classe | Ocorre em uma classe | Ocorre entre duas classes |
| Herança | Não envolve herança | Envolve herança |
| Invocação | Ocorre em tempo de compilação | Ocorre em tempo de execução |
Você deve ter reparado que os códigos aqui desenvolvidos estão em português, mas, mesmo assim, evitamos a utilização de acentos e cê-cedilha. Por exemplo: escrevemos Matematica e Triangulo sem acentuação. A linguagem Java utiliza a codificação unicode, sendo assim, ela dá suporte a nomes de classes, métodos e variáveis com acentos e cê-cedilha, porém, evitamos o uso desses símbolos pois a utilização desses códigos em diferentes arquiteturas de computador e sistemas operacionais pode gerar problemas.
Considere os seguintes exemplos abaixo.
int númeroDeInterações = 1000; //os acentos são aceitos em Java
int numeroDeInteracoes = 1000; //prefira assim, pois evita erros
double π = 3.141592; //letras gregas são aceitas em Java
double pi = 3.141592; //prefira assim, pois evita erros
O ideal é utilizar os símbolos presentes na tabela ASCII, a não ser que se tenha a certeza de que o código nunca será executado em uma arquitetura diferente, como, por exemplo, Raspberry Pi, BeagleBone Pi ou Intel Edison.
Figura 2.2 | Síntese sobre atributos
Para visualizar o objeto, acesse seu material digital.
Atributos
Classificação
Volatilidade: Constantes (palavra-reservada: final) e Variáveis ((palavra-reservada: nenhuma).
Nível de acesso: Público (palavra-reservada: public), Protegido (palavra-reservada: protected), Privado (palavra-reservada: private) e Público no pacote (palavra-reservada: nenhuma).
Tipos de dados: Inteiro (palavra-reservada: int / long), Real (palavra-reservada: float / double), Caracter (palavra-reservada: char) e ...
Tipo de chamada: Estático (palavra-reservada: static) / Método da classe e Não-estático (palavra-reservada: nenhuma) / Método do objeto.
Regra de nomeação: Variáveis (lowerCamelCase) Constantes (SCREAMING_SNAKE_CASE).
Fonte: elaborada pelo autor.
Foram apresentadas algumas regras para nomeação de variáveis, constantes, métodos, classe, objetos e pacotes. A utilização de bons nomes padronizados auxilia diretamente na legibilidade e no entendimento dos programas. Pesquise mais sobre convenção de nomes nos seguintes materiais:
GEEKSFORGEEEKS. Java Naming Conventions.
HOWTODOINJAVA. Java Naming Conventions.
ORACLE. 9 - Naming conventions.
Caro estudante, nesta seção, você estudou os conteúdos relacionados a atributos e métodos estáticos, a construtores, à sobrecarga e à sobreposição de métodos, bem como analisou diversos exemplos sobre como esses conceitos são implementados na linguagem Java. Nas seções seguintes, estudaremos melhor como funcionam as estruturas de controle e os operadores relacionais e lógicos, avançando ainda mais no entendimento da linguagem Java.
ARANTES, J. da S. Github. 2020. Disponível em: https://bit.ly/3eiUMcF. Acesso em: 20 mai. 2020.
CAELUM. Java e orientação a objetos: curso FJ-11. [S.l.]: Caleum, [s.d.]. Disponível em: https://bit.ly/3iJX34d. Acesso em: 17 mai. 2020.
CURSO de Java #01 - História do Java - Gustavo Guanabara. [S.l.: s.n.], 2015. 1 vídeo (36 min). Publicado pelo canal Curso em Vídeo. Disponível em: https://bit.ly/2YvIJDZ. Acesso em: 22 jul. 2020.
DEITEL, P. J.; DEITEL, H. M. Java: como programar. 10. ed. São Paulo: Pearson Education, 2016.
ECLIPSE FOUNDATION. The 2020 Jakarta Developer Survey Results are Now Available. 2020. Disponível em: https://bit.ly/2EknQVi. Acesso em: 20 jul. 2020.
GEEKSFORGEEEKS. Java Naming Conventions. [s.d.]. Disponível em: https://bit.ly/2El7pIs. Acesso em: 20 jul. 2020.
HOWTODOINJAVA. Java Naming Conventions. 14 jun. 2020. Disponível em: https://bit.ly/2ExL9uw. Acesso em: 20 jul. 2020.
INTELLIJ IDEA. 2020. Disponível em: https://bit.ly/3gwC0A0. Acesso em: 20 jul. 2020.
NETBEANS. [s.d.]. Disponível em: https://bit.ly/2FTW56z. Acesso em: 20 jul. 2020.
ORACLE. 9 - Naming Conventions. [s.d.]. Disponível em: https://bit.ly/2Qj3wWH. Acesso em: 20 jul. 2020.
ORACLE. Class math. [s.d.] Disponível em: https://bit.ly/32iL725. Acesso em: 21 jul. 2020.
SIERRA, K.; BATES, B. Use a cabeça! Java. 2. ed. Rio de Janeiro: Alta Books, 2005.