Comentários
Um paradigma de programação que aproxima a manipulação das estruturas de um programa ao manuseio das coisas do mundo real.
Fonte: Shutterstock.
Deseja ouvir este material?
Áudio disponível no material digital.
Prezado aluno, bem-vindo à primeira unidade do livro de Linguagem Orientada a Objetos. Nesta unidade, os conceitos e fundamentos da orientação a objetos (OO) serão apresentados. Vamos estabelecer as ideias que estão por trás das classes e dos objetos. Os conceitos de atributos e métodos de uma classe também serão elucidados, permitindo que você, aluno, seja capaz de analisar um problema do mundo real e consiga fazer as primeiras modelagens dentro do universo da OO. Você terá, também, o primeiro contato com o ambiente de desenvolvimento para fazer os primeiros programas. Ao final da unidade você poderá desenvolver a primeira aplicação em Java com classes, objetos, atributos e métodos. Você aprenderá, ainda, a desenvolver as primeiras aplicações com as ferramentas Alice e Greenfoot, que são fantásticas e alcançam resultados bem legais com pouco tempo de uso.
Através de exemplos de aplicações práticas e atuais, você vai aprender a pensar a orientação a objetos. O livro apresenta uma série de ilustrações que o auxiliam a compreender o papel de cada elemento dentro da OO. A reflexão é incentivada ao longo do texto de forma que você se sinta convidado a participar também da modelagem do problema. A capacidade de abstração será treinada de forma que consigamos efetuar uma boa modelagem de diversas aplicações do mundo real.
Esta unidade vai ajudá-lo a ter uma visão geral da OO e da construção de aplicações em Java. Ela está dividida nas seguintes seções:
Por ser uma unidade bastante prática, você, a partir de agora, passará a colocar a mão na massa com a instalação dos softwares aqui apresentados e o desenvolvimento das atividades propostas. A prática é a principal forma de consolidar os conhecimentos em qualquer linguagem de programação – e isso não é diferente com o Java. Vamos lá?
Caro estudante, começamos aqui a primeira seção dos estudos sobre desenvolvimento de softwares orientado a objetos. Quem nunca se perguntou como podemos construir um robô inteligente? Talvez, uma questão ainda mais importante para os profissionais da computação seja “de que forma podemos modelar um robô que execute comportamentos inteligentes, como mover-se autonomamente, dentro de um simulador em um computador?”.
Pois bem, a ideia-chave aqui é como fazer essa modelagem do robô. E, nesse sentido, a orientação a objetos (OO) fornece uma forma poderosa de organizar o código para solucionar essa questão. Nesta seção você terá a oportunidade de aprender os conceitos e as ideias por trás da OO, como classes, objetos, atributos e métodos. Esses conceitos auxiliarão de forma direta na modelagem não só de robôs, mas também de diversos problemas presentes no mercado de trabalho.
Para contextualizar sua aprendizagem, imagine que você foi aprovado como estagiário em uma startup que atua no ramo de alta tecnologia. Essa startup presta serviços para diversas empresas diferentes. Recentemente, seu chefe fechou um projeto com um grande portal de e-commerce (portal de venda pela internet). Uma vez que esse portal efetua as vendas de diversos produtos distintos, e uma vez que o volume de vendas dele é muito grande, é necessário um sistema automatizado para auxiliar no transporte dos produtos comprados. O seu chefe, inicialmente, propôs desenvolver um robô móvel inteligente para efetuar o transporte autonomamente dos produtos vendidos até uma determinada área destinada ao setor de carregamento da mercadoria.
Diante desse grande desafio, o seu chefe escalou você para trabalhar com uma equipe multidisciplinar a fim de resolver esse problema. A equipe com que você trabalha é composta, principalmente, por: engenheiros, cientistas da computação, profissionais de marketing e equipe de vendas. O seu chefe designou a equipe para desenvolver as estruturas de dados do sistema robótico e a demonstração da aplicação, dando apoio ao marketing e à equipe de vendas, enquanto o produto físico (hardware do robô) está em desenvolvimento pelos engenheiros. Essa demonstração da aplicação será feita por um simulador para esse robô móvel inteligente que demostre as funcionalidades deste. Foi solicitado a você desenvolver esse simulador em Java com a utilização das boas práticas da OO. Será que a orientação a objetos o ajudará na construção desse simulador? Ou será que a programação procedural é mais adequada para a construção dele?
Agora que você foi apresentado ao desafio, como você vai modelar o seu robô? Que estruturas de dados e abstrações você vai criar? Quais comportamentos e ações o seu robô precisa executar a fim de ajudar a equipe de vendas? Que ferramentas poderão ser utilizadas para o desenvolvimento do simulador? Como você vai organizar, documentar e divulgar o código? Este livro vai auxiliá-lo a responder perguntas como essas.
Muito bem, agora que você já foi apresentado à situação-problema a ser resolvida, estude esta seção e compreenda como a OO pode ajudá-lo a modelar classes, construir objetos, definir atributos e métodos. Esses elementos são a base de OO e fornecem a estrutura fundamental para a construção de um simulador como o que foi solicitado a você. Vamos compreender a OO para poder resolver esse desafio?
Ótimo estudo!
A programação orientada a objetos (POO) é um paradigma de programação que utiliza abstrações para representar modelos baseados no mundo real. Uma forma de entender a orientação a objetos (OO) é pensar nela como uma evolução da programação procedural.
A programação procedural é uma forma de desenvolvimento de código que se caracteriza por utilizar, principalmente, funções e procedimentos como núcleo de organização estrutural.
Atualmente, existem diversos paradigmas de programação. Um paradigma nada mais é do que uma filosofia que guia todo o desenvolvimento de código. Os paradigmas de programação podem ser divididos em duas vertentes principais, que são: imperativo e declarativo.
Imperativo: a programação imperativa declara comandos dizendo exatamente como o código deve executar algo.
Declarativo: por sua vez, a programação declarativa descreve o que deve ser feito, mas não como deve ser feito.
A Figura 1.1 mostra um organograma que esquematiza os principais paradigmas de programação.
Podemos subdividir ainda mais o paradigma imperativo em: programação procedural e programação orientada a objetos.
Dois exemplos de linguagem orientadas a objetos são Java e C++. De forma semelhante, quando programamos em C ou Pascal estamos seguindo a estrutura de programação procedural. O paradigma declarativo pode ser subdividido em programações lógica e funcional, formas de programação que são objetos de estudo em cursos específicos, os quais fogem ao escopo deste material.
Embora este livro focalize os conceitos e modelos de desenvolvimento OO na linguagem de Java, os exemplos aqui apresentados podem ser facilmente adaptados para outras linguagens OO, como C++ e Python.
Um dos elementos mais básicos da OO é a ideia de organizar o código em classes que representam algo do mundo real ou imaginário. Um outro elemento básico dentro da OO é a ideia de objeto, que nada mais é do que a manifestação concreta, também chamado de instância, da classe.
A fim de entender melhor o conceito de classe, vamos pensar na entidade robô. Caso você tenha apenas imaginado um robô abstrato, sem forma física, que é uma máquina capaz de tomar decisões por si mesma, então você agiu corretamente. Se você imaginou um robô físico, como um robô na cor azul que anda sobre esteira, com dois braços e uma antena, então você não pensou no conceito de robô, mas sim em uma manifestação física possível de robô.
Lembre-se: a ideia de robô é abstrata, assim como são as classes em Java.
Uma boa forma de compreender uma classe é pensar nela como o projeto ou a modelagem de algo. Caso tenha imaginado algo concreto, então você pensou em um objeto, que é uma manifestação possível da ideia de robô, semelhantemente à ideia de objeto em Java.
Ainda com base nesse exemplo, considere a Figura 1.2, que ilustra o relacionamento entre a classe robô, que é apenas uma ideia ou projeto, e os objetos robôs, que são manifestações da ideia de robô.
Repare que temos quatro objetos do tipo robô:
Podemos perceber que todos os objetos modelam de forma diferente a entidade robô – em computação, dizemos que esses objetos são instâncias da classe robô.
Embora os conceitos classe e objeto já tenham sido estabelecidos anteriormente, eles ainda estão muito abstratos, pois não definimos do que é composta uma classe nem como funcionam os objetos.
Os principais elementos que compõem uma classe são os atributos e os métodos.
Um atributo é um elemento que representa as características intrínsecas da classe.
Vamos, então, retornar à nossa ideia de robô: suponhamos que, para caracterizarmos alguns robôs, os seguintes atributos possam ser criados: nome, cor, velocidade máxima, nível atual da bateria, peso da carga máxima suportada, tipo de tração, e presença ou não de antena.
Analise a Figura 1.3, em que são acrescentados, dentro da estrutura de classe e objeto, os atributos mencionados.
Essa figura mostra que:
Quais são os valores para os atributos nome, cor, velocidade máxima, nível atual da bateria, peso da carga máxima suportado, tipo de tração e presença ou não de antena que o leitor atribuiria aos robôs da Figura 1.2 (objeto 3 e objeto 4)? Dê valores para esses atributos conforme os apresentados pela Figura 1.3. Reflita também sobre quais tipos de dados (inteiro, real, literal ou lógico) são utilizados em cada um dos atributos mencionados.
A ideia de classe, até onde foi apresentada aqui, é semelhante à ideia de registro (struct) na linguagem C, uma vez que esses atributos da classe são semelhantes aos campos (variáveis) de um registro. Os diversos campos de um registro são acessados por um único ponteiro, assim como os atributos da classe são acessados por um único objeto.
Um outro elemento importante de uma classe são os métodos. Um método dá ao objeto da classe a capacidade de executar algum tipo de ação, comportamento ou processamento. Um robô é capaz de executar uma série de ações – o nosso robô modelado é capaz de se mover, pegar caixas, entregar as caixas e até mesmo falar.
A Figura 1.4 mostra como o conceito de método está relacionado aos conceitos de classe e objeto.
Vamos imaginar que o método mover o robô R-801 foi chamado para a localização prateleira 3. Dessa forma, o robô executa a ação de se mover até o local indicado. De forma semelhante, imagine que o método falar do robô R-801 foi invocado com o argumento nome: nesse caso, a ação executada é dizer o próprio nome, razão pela qual o robô falará “O meu nome é R-801”.
Imagine agora que o método falar do robô R-701 foi chamado a ser executado com o argumento objeto transportado, dessa maneira, o robô dirá “Carrego uma caixa de livros”. Até esse ponto, peço que você abstraia o funcionamento interno dos métodos, assumindo, assim, que eles são comportamentos de altíssimo nível. Ao longo do livro vamos incorporar mais elementos aos métodos, tornando-os capazes de realizar operações semelhantes às imaginadas aqui.
A criação de métodos em linguagens orientadas a objetos é semelhante à criação de funções em linguagens procedurais. Uma função nas linguagens procedurais apenas processa entradas em saídas. Por sua vez, um método pode ser entendido como uma função particular que dita o comportamento de todos os objetos daquela classe, normalmente interagindo com os seus atributos, modificando-os, utilizando-os ou apenas retornando o valor de um deles.
Até aqui foram apresentados os quatro pilares da orientação a objetos: classe, objeto, atributo e método. Vamos agora ver na prática como construir nossa primeira aplicação em Java.
A fim de desenvolver os códigos, você vai precisar de um ambiente no qual possa inseri-los, como um bloco de notas ou, ainda, um ambiente de desenvolvimento integrado (IDE – do inglês integrated development environment).
Um IDE é um editor de códigos robusto que auxilia muito o programador durante todo o desenvolvimento, permitindo-lhe codificar, executar e debugar o código.
Existem diversos IDEs no mercado, entre os quais podemos destacar: o NetBeans, o Eclipse e o IntelliJ IDEA. Os três ambientes citados são multiplataformas, ou seja, podem ser executados em sistemas operacionais Windows, Linux e macOS. Graças ao avanço da internet e, em especial, da web, existem atualmente diversos sites em que você pode escrever o seu programa em Java. Alguns exemplos de sites que permitem a programação em Java são: jdoodle.com e onlinegdb.com.
Para esta primeira seção do livro sugerimos a utilização do ambiente de desenvolvimento on-line Jdoodle, por ter utilização simples, prática e direta. Dessa forma, abra o site www.jdoodle.com/online-java-compiler/. Depois disso, você, estará em uma tela semelhante à tela da Figura 1.5, mostrada a seguir.
Esse ambiente de desenvolvimento mostrado na Figura 1.5 possui alguns elementos principais, que são:
Observe, na Figura 1.5, o primeiro código em Java. Vamos destacar esse código a seguir para discutirmos cada um dos elementos principais dele.
public class MinhaPrimeiraClasse {
public static void main(String args[]) {
System.out.println("Bem-vindo, a aula de POO com Java");
}O Código 1.1 define uma classe pública chamada MinhaPrimeiraClasse (linha 1). As palavras reservadas public e class foram utilizadas para fazer essa definição da classe. O modificador de acesso public será estudado nas seções seguintes. Em seguida, é aberta uma estrutura de blocos, de forma semelhante à linguagem C, utilizando as chaves “{” e “}”. Dentro desse bloco, há uma função pública que não retorna nenhum valor (void) chamada main (linha 2). Em Java, quando há um método estático, às vezes, chamamo-lo de função, o que ficará mais claro nas seções seguintes. Essa função main recebe um vetor de strings como argumento. Em seguida, há mais um bloco de chaves que define o escopo da função main. Por fim, temos uma linha de código que invoca uma função (método estático), chamada System.out.println, para imprimir uma mensagem na tela (linha 3). A mensagem de boas-vindas é passada como argumento dessa função entre aspas por ser do tipo literal.
Ao executar esse código, simplesmente é impresso na saída padrão a mensagem “Bem-vindo à aula de POO com Java”.
O código a seguir, em Java, mostra como é o formato da função main que é o ponto de entrada de toda aplicação Java, ou seja, é por meio dela que a sua aplicação iniciará a execução.
public static void main(String[] args) {
//conjunto de comandos da função principal.
}O código a seguir, em C, mostra como é o formato da função main que é o ponto de entrada de toda aplicação C.
int main(int argc, char *argv[]){
//conjunto de comandos da função principal.
return 0;
}É importante reparar que existem algumas diferenças entre essas funções. A função main em C retorna um inteiro; por sua vez, a função main em Java não retorna nenhum tipo de valor (void). Em C, existem dois argumentos principais que são argc e argv. A linguagem Java sintetiza esses dois argumentos em apenas um, chamado args. A função principal da linguagem C pode também ser desenvolvida pela omissão dos argumentos argc e argv com a seguinte simples escrita: int main(). A linguagem Java, por sua vez, não permite que se omita o argumento args.
Vamos agora modelar uma classe chamada Robô com os atributos especificados na Figura 1.3. Dessa maneira, analise o Código 1.2 apresentado.
public class Robo {
String nome;
String cor;
float velocidadeMax;
int nivelBateriaAtual;
float pesoCargaMax;
String tipoTracao;
boolean temAntena;
public static void main(String[] args) {
Robo obj1 = new Robo();
obj1.nome = "R-801";
obj1.cor = "azul";
obj1.velocidadeMax = 6;
obj1.nivelBateriaAtual = 78;
obj1.pesoCargaMax = 10;
obj1.tipoTracao = "esteira";
obj1.temAntena = true;
System.out.println("Meu nome: " + obj1.nome);
System.out.println("Cor do Robô: " + obj1.cor);
System.out.println("Vel Max: " + obj1.velocidadeMax);
System.out.println("Bat: " + obj1.nivelBateriaAtual);
System.out.println("Carga Max: " + obj1.pesoCargaMax);
System.out.println("Tipo Tração: " + obj1.tipoTracao);
System.out.println("Tem Antena: " + obj1.temAntena);
}
}Implemente o Código 1.2 e analise a saída que será impressa.
O atributo nível da bateria, na linha 5, possui o tipo de dados inteiro (int). O tipo int em Java é semelhante ao tipo int na linguagem C. Os atributos velocidade máxima e peso da carga máxima são do tipo float, igual ao tipo float em C. O atributo tem antena é do tipo lógico ou boolean. Na linguagem C não existe esse tipo de dado nativamente. Por fim, os atributos nome, cor e tipo de tração foram definidos como tipo String, o qual será mais bem explicado posteriormente no livro. Por ora, vale lembrar que é um tipo literal ou o equivalente a um vetor de caracteres em linguagem C. Na linha 10, há a construção do robô chamado obj1, construído a partir da classe Robo. A construção de um objeto utiliza a palavra reservada new, que será mais bem discutida nas seções seguintes. Dizemos que obj1 é uma instância de Robo.
Repare que todos os atributos podem ser acessados com a utilização do ponto, como em obj1.nome (linha 11). O acesso aos atributos é semelhante à forma como a linguagem C acessa os campos (variáveis) de um registro.
Você estudou a forma básica de impressão de uma mensagem na tela utilizando o System.out.println, que imprime e pula de linha. Você também pode utilizar o comando System.out.print para fazer a impressão sem pular linhas. Existe ainda a opção System.out.printf que recebe dois argumentos: o primeiro, um literal, para formatação da impressão, e, outro, uma lista com os objetos a serem impressos. O System.out.printf é semelhante ao comando printf em C. Um operador muito comum utilizado na concatenação de literais (Strings) em Java é o operador ‘+’. Dessa forma, ao fazer “olá” + “mundo”, estaremos concatenando o valor de “olá” com o conteúdo de “mundo” e então retornamos o literal “olá mundo”.
Uma melhoria que pode ser feita no Código 1.2 é criar um método que imprime o status da classe robô em vez de deixar isso a cargo da função main. Esse tipo de modificação deixa na classe robô a responsabilidade de imprimir o seu status. Essa melhoria é mostrada no Código 1.3.
public class Robo {
String nome;
String cor;
float velocidadeMax;
int nivelBateriaAtual;
float pesoCargaMax;
String tipoTracao;
boolean temAntena;
public void printStatus(){
System.out.println("-------------------------------");
System.out.println("Meu nome: " + nome);
System.out.println("Cor do Robô: " + cor);
System.out.println("Velocidade Max: " + velocidadeMax);
System.out.println("Bateria: " + nivelBateriaAtual);
System.out.println("Carga Max: " + pesoCargaMax);
System.out.println("Tipo de Tração: " + tipoTracao);
System.out.println("Tem Antena: " + temAntena);
System.out.println("-------------------------------");
}
public static void main(String[] args) {
Robo objeto1 = new Robo();
objeto1.nome = "R-801";
objeto1.cor = "azul";
objeto1.velocidadeMax = 6;
objeto1.nivelBateriaAtual = 78;
objeto1.pesoCargaMax = 10;
objeto1.tipoTracao = "esteira";
objeto1.temAntena = true;
objeto1.printStatus();
Robo objeto2 = new Robo();
objeto2.nome = "R-701";
objeto2.cor = "laranja";
objeto2.velocidadeMax = 3;
objeto2.nivelBateriaAtual = 51;
objeto2.pesoCargaMax = 15;
objeto2.tipoTracao = "esteira";
objeto2.temAntena = false;
objeto2.printStatus();
}
}Repare que agora criamos dois objetos, os chamados objeto1 (linha 21) e objeto2 (linha 30), que representam os robôs T-801 e T-701, respectivamente.
Um outro ponto a ser destacado aqui é a forma pela qual chamamos o método printStatus, nas linhas 29 e 38, também utilizando o ponto como se fosse um atributo da classe robô.
As plataformas de hospedagem de código github e gitlab são dois grandes repositórios que milhões de desenvolvedores no mundo utilizam para fazer a divulgação de seus códigos. Além de auxiliar na divulgação dos códigos, esses ambientes possibilitam fazer o gerenciamento do controle de versão utilizando a ferramenta git. Pesquise mais sobre: Github (2020), Gitlab (2020) e Git (2020). Este livro divulga os todos seus códigos no Github, que pode ser acessado em Arantes (2020).
Caro estudante, nesta seção você estudou os conceitos de classe, objeto, atributos e métodos. Além disso, aprendeu a construir a sua primeira aplicação Java. Em seguida, aprendeu a declarar uma classe que modela a entidade robô. Por isso, criou dois objetos da classe, que são os robôs R-801 e R-701. Foi mostrada também a estrutura básica dos atributos e métodos da classe robô. Nas seções seguintes, vamos nos aprofundar cada vez mais nesse universo do desenvolvimento orientado a objetos.
ARANTES, J. da S. Desenvolvimento orientado a objetos. Github: on-line, [2020]. Disponível em: https://bit.ly/3eiUMcF . Acesso em: 20 abr. 2020.
BHATNAGAR, A. The complete History of Java Programming Language. Geeks for geeks, 2019. Disponível em: https://bit.ly/2BXvfJ9 . Acesso em: 30 abr. 2020.
CAELUM (org.). Java e orientação a objetos. Apostila do Curso FJ-11. Disponível em: https://bit.ly/3iJX34d . Acesso em: 17 abr. 2020.
DEITEL, P. J; DEITEL, H. M. Java: como programar. 10. ed. São Paulo: Pearson Education, 2016.
GEEKSFORGEEKS. History of Java. [2020]. 1 cartaz, color. Disponível em: https://bit.ly/31YNBEc . Acesso em: 30 abr. 2020.
GIR. Página inicial. [2020]. Disponível em: https://bit.ly/38IXzLq . Acesso em: 27 maio 2020.
GITHUB. Página inicial. [2020]. Disponível em: https://bit.ly/2ZSr1ud . Acesso em: 27 maio 2020.
GITLAB. Página inicial. [2020]. Disponível em: https://bit.ly/2ZNOmNG . Acesso em: 27 maio 2020.
JAVA version history. In: Wikipedia: the free encyclopedia. [San Francisco, CA: Wikimedia Foundation, 2020]. Disponível em: https://bit.ly/2W5b96q . Acesso em: 14 abr. 2020.
JDOODLE. Disponível em: https://bit.ly/2Zd2qky . Acesso em: 16 abr. 2020.
TIOBE. TIOBE index for may 2020. [2020]. Disponível em: https://bit.ly/2WjGJhd . Acesso em: 27 maio 2020.