Java com Orientação a Objetos

Texto

(1)

(2)

(3) JAVA com Orientação a Objetos ©

(4)

(5)

(6)

(7)

(8)

(9)

(10)

(11)

(12)

(13)

(14)

(15) !"#$% #!&'&#!!(% )

(16)

(17) * +

(18) %

(19)

(20)

(21)

(22)

(23) % ,

(24) , -% .% / 0

(25) %

(26) 1

(27)

(28) +

(29) 23% %

(30)

(31) 4

(32) 14

(33) ,

(34) 5

(35)

(36) ,

(37)

(38)

(39)

(40)

(41) 4

(42) 5 )

(43)

(44) 6

(45)

(46) 5

(47)

(48) )

(49) 5*

(50)

(51)

(52)

(53) ,

(54) /

(55) , 7

(56) 23%

(57)

(58)

(59)

(60) %

(61)

(62)

(63) +

(64)

(65)

(66)

(67)

(68)

(69) /

(70) % 8 / 7

(71)

(72)

(73)

(74)

(75) % 23 /

(76)

(77)

(78) +

(79) 239

(80) , )

(81) 2

(82) 0

(83) *

(84) :

(85) !"#$ . JAVA com Orientação a Objetos 6

(86) ;

(87) :

(88)

(89)

(90) %'$#'. #Informática, 2. Programação de Computador – Programas e Dados < =>;!?(@(A@B!!@$'36@1 $01.642 $$A. % !& & ' () * + ,' , * - ./&01/231/ 4.35 ../32))).6 7 4.35 ../32)80) 2! !9!&"&- :::&!&"&- /363..

(91) Agradecimento Inicialmente agradeço a Deus por me dar forças e condições de realizar este trabalho. Agradeço ainda a meus amigos, todos esses anos trabalhando com vocês só me fizeram uma pessoa melhor. Em especial, a minha família, a minha querida esposa Fernanda, a meu pai Alexandre, a minha mãe Leonidia, a meus irmãos e a meus queridos sobrinhos. Obrigado a todos pelo apoio tão importante que me fornecem..

(92)

(93) Introdução Caro leitor, é um prazer apresentar para vocês a tecnologia Java e os conceitos vinculados à programação orientada a objetos. A ideia central deste livro é garantir aos estudantes da área de Ciência da Computação e afins uma forma alternativa de conhecer essa tecnologia e o paradigma que atualmente dominam parte do mercado. O livro é resultado de anos de experiência trabalhando com disciplinas ligadas à área de programação, no qual foram aplicados conhecimentos da tecnologia Java, assim como a prestação de serviços que envolviam tais elementos. Ao final da leitura deste livro, espera-se que o leitor tenha conhecimento suficiente para desenvolver e entender as aplicações que utilizam as diversas características que norteiam a tecnologia Java. Nos últimos anos, a programação Java tornou-se uma das mais populares do mercado e tem feito com que os profissionais, que dominam seus preceitos, passem a ser mais valorizados e até mesmo disputados por empresas, considerando a carência existente para tais nichos de mercado. Tal fatia de mercado, dominada pela tecnologia Java, deve-se em sua maioria às suas potencialidades, uma vez que são aplicações que podem estar presentes em desde eletrodomésticos, aparelhos celulares, carros até as mais simples, tais como as existentes na Web. Assim, a linguagem Java tem características que a tornam diferenciada, sendo de grande importância no que tange a criação de software. Diante disso, foi montado um roteiro neste livro, no qual se priorizou garantir ao leitor uma visão ampla de todos os conceitos importantes para sua iniciação na programação com a tecnologia Java. No Capítulo 1, são apresentados os fundamentos da programação com a linguagem Java, considerando elementos importantes, como, por exemplo, as palavras reservadas, estrutura básica de um programa Java e as vantagens e desvantagens de utilizar a tecnologia mantida atualmente pela Oracle. No segundo capítulo, começaremos a ver os fundamentos do paradigma de programação orientada a objetos, considerando passo a passo cada conceito, fazendo com que o leitor entenda os aspectos básicos e necessários para a continuidade no aprendizado, como, por exemplo, a ideia de classe e objetos na tecnologia Java. Continuando, no Capítulo 3, são trabalhadas.

(94) VI t JAVA com Orientação a Objetos. as estruturas mais avançadas da programação orientada a objetos, fazendo com que o leitor consiga dar mais um passo no aprendizado do paradigma e da tecnologia Java, sendo considerados conceitos, tais como construtores, destrutores e outros. Assim como no Capítulo 3, no Capítulo 4 continuaremos a trabalhar com os elementos mais avançados da programação orientada a objetos, tais como os importantíssimos conceitos de herança e polimorfismo, que devem ser vistos e tratados como elementos-chave da tecnologia Java e do paradigma de programação orientada a objetos. Claro que devemos lembrar sempre do conceito de portabilidade oriundo da estruturação muito bem pensada da tecnologia Java como um importante diferencial. Em nosso quinto capítulo, será apresentado a você, leitor, outros elementos da tecnologia Java, no qual iremos lidar com ferramentas úteis para o dia a dia de um programador. Trabalharemos nesse capítulo com bibliotecas matemáticas, números randômicos ou ainda veremos como lidar com datas, manipular strings e assim por diante. Logo, serão consideradas diversas possibilidades e vantagens que podem ser exploradas, o que com certeza irá auxiliar os programadores a dominarem tais conceitos. O Capítulo 6 tem por objetivo apresentar o trabalho de tratamento de exceções, sendo de extrema importância seu entendimento, já que se trata de um elemento central nas atividades que exigem a manipulação de dados, seja em arquivos texto, seja mesmo em um banco de dados. Este tema é de grande importância, pois a tecnologia Java possibilita, em sua programação, que sejam tratados eventuais problemas ou erros antes que estes venham a realmente ocorrer, permitindo que sejam tomadas as devidas providências para uma autorrecuperação do software durante a execução. Podemos enxergar isso como uma prevenção para os possíveis erros nos trechos mais suscetíveis a problemas. Finalizando, em nosso sétimo capítulo, começaremos a trabalhar com a manipulação de arquivos, lidando com o processo de criação, persistência de dados e leitura de dados utilizando classes e interfaces disponibilizadas pela tecnologia Java. Amigo leitor, em todo o livro tentarei manter uma linguagem mais simples, clara e cotidiana, na qual o principal objetivo e descomplicar o entendimento dos diversos conteúdos mencionados. Recomendo que sejam feitos os exemplos disponibilizados, que foram pensados considerando os aspectos que devem acompanhá-lo em sua jornada. Logo, vamos ao que interessa e tenha uma ótima leitura..

(95) Sumário Capítulo 1 Conceitos básicos da tecnologia Java..........................1 1.1 Fundamentos da tecnologia Java ....................................................1 1.2 Estrutura e conceitos básicos da programação Java .......................5 1.3 Entrada de dados ........................................................................... 13 1.4 Estruturas de controle................................................................... 15 1.5 Arrays e matrizes ........................................................................... 21 1.6 Funções. ......................................................................................... 25. Capítulo 2 Programação orientada a objetos.............................29 2.1 Conceitos da programação orientada a objetos ........................... 30 2.1.1 Classe .......................................................................................... 32 2.1.1.1 Qualificadores de acesso ......................................................... 33 2.1.1.2 Pacotes ..................................................................................... 35 2.1.1.3 Import...................................................................................... 36 2.1.1.4 Comentários ............................................................................ 37 2.1.2 Atributos ..................................................................................... 38 2.1.3 Métodos ...................................................................................... 39 2.1.3.1 Identificador this ..................................................................... 40 2.1.4 Mensagem e modularização de código ...................................... 41 2.1.5 Objeto ou instanciação............................................................... 44. Capítulo 3 Construtores, destrutores e encapsulamento............51 3.1 Construtores .................................................................................. 51 3.2 Destrutores e Garbage Collector (Coletor de Lixo) ...................... 54 3.2.1 Garbage Collector ....................................................................... 55 3.3 Encapsulamento ............................................................................ 56.

(96) VIII t JAVA com Orientação a Objetos. Capítulo 4 Herança, polimorfismo e interface...........................63 4.1 Herança .......................................................................................... 63 4.2 Polimorfismo ................................................................................. 69 4.2.1 Sobrecarga .................................................................................. 70 4.2.2 Cast ............................................................................................. 71 4.2.3 instanceof ................................................................................... 73 4.2.4 Sobrecarga de construtores ....................................................... 74 4.2.5 Redefinição ................................................................................. 74 4.3 Interface ......................................................................................... 76 4.3.1 Herança múltipla ........................................................................ 83. Capítulo 5 Ferramentas úteis para o dia a dia............................85 5.1 Manipulação de strings ................................................................. 85 5.1.1 Construtores da classe String .................................................... 86 5.1.2 Outros métodos.......................................................................... 86 5.2 Data e hora ..................................................................................... 88 5.3 Operações matemáticas ................................................................ 93 5.4 Trabalho com vetores especiais .................................................... 95 5.4.1 Classe Vector............................................................................... 96 5.4.2 Classe HashMap ......................................................................... 98 5.4.3 Classe Arrays .............................................................................. 99. Capítulo 6 Tratamento de exceções e entrada de dados............101 6.1 Tratadores de exceções ................................................................ 102 6.1.1 Throws....................................................................................... 106 6.2 Entrada de dados ......................................................................... 107.

(97) SumáriotIX. Capítulo 7 Manipulação de arquivos de texto ..........................111 7.1 Arquivos ....................................................................................... 111 7.2 Entradas ....................................................................................... 112 7.3 Saídas ........................................................................................... 114 7.4 Streams ........................................................................................ 116 7.5 Acessos aleatórios em arquivos .................................................. 118. Referências Bibliográficas................121 Apêndice I Instalação do Sdk e Configuração das Variáveis de Ambiente (Windows Xp) .................................................................................... 123. Apêndice II JAVADOC ........................................................................................... 129.

(98)

(99) Capítulo 1 Conceitos básicos da tecnologia Java Quando falamos em programação, não há como deixar de vislumbrar tal atividade como sendo um elemento central na vida de um profissional ligado à área de Ciência da Computação e afins. No cotidiano, o mínimo que se espera de um profissional de TI é que este domine os elementos e os conceitos básicos, aplicados a uma determinada linguagem de programação. O mercado atualmente oferta uma infinidade de possibilidades de linguagens de programação para a construção de softwares, indo das mais complexas e trabalhosas até as mais simples. Existem, entre essas linguagens de programação, várias que são bem aceitas no mercado, que consideram obviamente variáveis estratégicas, tais como preço, velocidade da curva de aprendizagem e desenvolvimento. Entre tais, a linguagem e a plataforma de desenvolvimento de aplicações Java vêm no decorrer dos anos tornado-se uma das mais utilizadas e aceitas no mercado. Isso, graças ao seu potencial tecnológico combinado ao paradigma de orientações a objetos, além de considerar os custos envolvidos. O Java é uma tecnologia que foi originalmente desenvolvida pela Sun Microsystem em meados de 1995, sendo regida pela GPL (General Public License). A Oracle Corporation adquiriu todos os direitos pela Sun e obviamente, também sobre a tecnologia Java. Para a maioria dos autores e desenvolvedores, a tecnologia Java pode ser definida como: “simples, distribuída, interpretada, robusta, segura, de arquitetura neutra, portátil, multifunções e dinâmica“. Ao considerar tais perspectivas, o objetivo deste capítulo é apresentar e preparar o leitor para compreender e aplicar os fundamentos básicos da tecnologia Java. Estes são úteis e de extrema importância para a compreensão dos demais conceitos vinculados à plataforma de desenvolvimento mantida pela Oracle e que serão considerados nos próximos capítulos de nosso livro. 1.1 Fundamentos da tecnologia Java A maioria dos autores restringe-se a citar que o Java consiste em uma.

(100) 2 t JAVA com Orientação a Objetos. linguagem de programação orientada a objetos baseada na sintaxe da linguagem de programação C. Porém, podemos ir além disso ao citar que o Java é uma plataforma tecnológica que possui diversas características que o mercado considera como importante e que devido a isto, tem garantido uma fatia considerável das aplicações desenvolvidas com essa tecnologia. Com certeza, pode-se afirmar que a característica que mais se destaca neste processo e a torna diferenciada diante das demais linguagens consiste na portabilidade dos sistemas desenvolvidos com o Java. Entende-se portabilidade como, nada mais nada menos, a independência de plataforma - no caso, o sistema operacional (Windows, Linux, Solaris, MAC OS) e o hardware, no qual os softwares serão executados. Tal característica nasce do fato da estrutura das aplicações desenvolvidas com a tecnologia Java ser inicialmente compilada e depois, interpretada. Indo um pouco mais além no entendimento, o ponto central desse processo esta na geração do bytecode, também conhecido como arquivo com extensão “.class”. Este é obtido ou gerado por meio da compilação do código-fonte dos arquivos “java puros” ou de extensão “.java”, que serão interpretados futuramente. É importante mencionar que com isso, graças ao fato da tecnologia Java possuir para cada plataforma (sistema operacional + hardware) uma Máquina Virtual Java, também conhecida como Java Virtual Machine (JVM), este processo torna todas as aplicações Java portáveis entre si. Assim, quem irá preocupar-se com as especificidades de cada plataforma não é mais o programador, mas sim a JVM fornecida. Essa máquina virtual é capaz de interpretar os arquivos compilados (“.class”), iniciando a execução do software, independentemente da plataforma na qual o programa foi construído. Por exemplo, uma vez compilado nosso programa utilizando o sistema operacional Windows em uma estrutura de hardware da família x86, caso queiramos que nosso programa rode em uma máquina com o sistema operacional Linux, não será necessário realizar uma nova compilação para este software, como acontece com as outras tecnologias e linguagens de programação. Neste contexto, será apenas necessária a presença da JVM para o Linux instalado, o que hoje é algo natural nas máquinas comercializadas. Como o leitor pode reparar, esta característica ímpar só é possível graças à existência da JVM, que é fornecida pela tecnologia Java e na qual cada sistema operacional possui uma específica, distribuída pela mantenedora da tecnologia. A JVM pode ser vista como sendo uma camada intermediária.

(101) Capítulo 1 - Conceitos básicos da tecnologia Javat3. entre sua aplicação e a plataforma que executará seu programa. A maioria dos computadores atuais já é vendida com algum tipo de Máquina Virtual Java e isso tem garantido uma popularização ainda maior das aplicações Java, o que nos faz crer que, em sua maioria, qualquer aplicação Java funcionará corretamente nos computadores obtidos atualmente no mercado. Para uma melhor visualização do processo citado como portabilidade, a Figura 1 demonstra o modelo computacional definido pela tecnologia Java e suas aplicações. Vamos conferir?. Figura 1: Estrutura de compilação e execução de programas no Java.. Como definição, podemos mencionar que um programa Java consiste em um conjunto de instruções, que a JVM é responsável por interpretar e dessa forma, garantir a independência de plataforma na qual o programa foi construído e será executado. Isto é, basta que haja uma implementação de uma máquina virtual para a plataforma ser utilizada. O termo plataforma, como já vimos, normalmente no meio computacional é definido como a combinação de sistema operacional mais hardware. Porém, para a plataforma Java, ela é definida somente com o software, por isso o conceito de máquina virtual. A plataforma Java possui dois componentes que precisamos conhecer quando a adquirimos, sendo:.

(102) 4 t JAVA com Orientação a Objetos. Máquina Virtual Java (JVM): A máquina imaginária que é implementada por meio da emulação em um software executado em uma máquina real e que fornece as especificações da plataforma de hardware para a qual todo o código Java está compilado. A JVM faz parte do ambiente de execução Java, mais popularmente conhecido como JRE (Java Run-Time Environment); Interface para Desenvolvimento de Aplicações (API Java): Trata-se das interfaces de desenvolvimento para a utilização na criação de aplicações Java, no caso são as bibliotecas para a criação de programas que a própria linguagem Java fornece, disponibilizados por meio do JDK (Java Development Kit) ou como vem sendo disponibilizado nos últimos anos como SDK (Source Development Kit). Para o desenvolvimento de aplicações Java, é necessário que se tenha instalado no computador o SDK. Desta forma, obtenha uma cópia na página oficial da Oracle e instale em seu computador. O Apêndice deste livro contém mais informações sobre o processo de instalação do pacote SDK, assim como a configuração das variáveis de ambiente necessárias para a correta utilização do conjunto de ferramentas da tecnologia Java.. Após a correta instalação e configuração das variáveis de ambiente do SDK, podemos usar um editor de texto qualquer para a construção do código de nosso programa Java. Porém, existem diversos ambientes de desenvolvimento, também conhecidos como IDE (Integrated Development Environment), para a programação Java, sendo que os mais utilizados no mercado são: Eclipse, NetBeans e JBuilder. Como nossa intenção consiste no aprendizado da linguagem Java, não nos apegaremos a nenhuma IDE, o que deixa você, leitor, livre para a utilização ou não de uma dessas ferramentas de desenvolvimento, sendo que apenas um editor de texto será suficiente para concluir o aprendizado deste livro. Um aspecto importante a ser citado aqui é que a linguagem Java possui diferentes tipos de programas, sendo que a classificação é feita por meio da modalidade X localização de execução dos mesmos. Assim, esses programas podem ser definidos como: applications, applets e servlets. Nesta unidade, somente trabalharemos com as applications no console, ou seja, prompt de comando, seja Windows, seja Linux..

(103) Capítulo 1 - Conceitos básicos da tecnologia Javat5. 1.2 Estrutura e conceitos básicos da programação Java Agora, vamos ao que interessa. Nesta seção do livro, vamos aprender como são construídas as estruturas básicas para os programas escritos na linguagem Java, além de conhecer os conceitos mais básicos da programação com a tecnologia. O primeiro detalhe que deve ser considerado na linguagem consiste no fato de que todo programa Java é uma classe, independentemente das três possíveis modalidades dos programas Java citadas anteriormente (Applications, Applets e Servlets). A estrutura básica é sempre a mesma: “uma classe”. Um programa Java é organizado em arquivos de texto com a extensão “.java” e cada arquivo pode conter várias classes, mas usualmente teremos apenas uma. Aqui, temos uma consideração importante e que você não deve esquecer jamais: O nome do arquivo da classe java deve possuir exatamente o mesmo nome que foi dado internamente à classe, pois a máquina virtual procura a classe por meio do nome do arquivo.. Uma metodologia que pode auxiliá-lo a entender a tecnologia Java neste momento consiste na utilização de analogias com outras linguagens de programação, das quais você já tenha conhecimento e domínio. Então, vamos a elas! Se fôssemos realizar uma comparação básica, poderíamos dizer que as classes no Java podem ser comparadas às famosas units do Pascal. Já para os adeptos do C e C++, a estrutura de nossos programas praticamente será a mesma, uma vez que a tecnologia Java está baseada em tais linguagens. Ainda, veremos mais à frente em nossos capítulos que os atributos no Java são como as variáveis existentes em Pascal e C, e os métodos das classes Java seriam os procedimentos e as funções da linguagem C e Pascal. Vários destes aspectos citados serão considerados quando estivermos tratando do conceito de orientação a objetos. Outro detalhe a ser considerado é a definição de blocos de código que, no Java, são definidos com a utilização de “{“ e “}”, assemelhando-se assim ao C ou C++, diferentemente dos elementos em Pascal, que utilizam no caso, “BEGIN” e “END”. Por enquanto, preocupe-se apenas em entender como os blocos são definidos, sendo de extrema importância para começarmos a.

(104) 6 t JAVA com Orientação a Objetos. entender os conceitos fundamentais para a construção de programas simples com a tecnologia Java. Então, diante disso, vamos ao que interessa. Chegou a hora de desenvolvermos nosso primeiro programa em Java. Transcreva o conteúdo abaixo para um editor de texto simples, tal como o ‘notepad’ do Windows ou mesmo o ‘Vi’ do Linux. Por enquanto, siga o exemplo conforme é apresentado, digitando como pode ser observado na primeira coluna, visto que a linguagem Java é case sensitive, ou seja, existem diferenças entre as letras maiúsculas e minúsculas em sua compilação e interpretação. A seguir, faremos uma análise do que foi feito em nosso primeiro programa.. //Classe PrimeiroPrograma.java class PrimeiroPrograma{ public static void main (String arg []){ System.out.println(“Olá leitor”); } }. Agora que você já construiu seu primeiro programa em Java e considerando o que já foi citado anteriormente neste capítulo, salve seu programa lembrando que o nome do arquivo Java deve ser necessariamente igual ao nome de declaração da classe - no caso específico, o arquivo deve ser salvo como “PrimeiroPrograma.java”. Salve o arquivo tomando o cuidado necessário para assegurar que a extensão “.java” seja garantida por seu editor de textos, uma vez que eles podem manter a extensão “.txt” e isso impedirá a compilação e a interpretação de seu programa. Feito isso, vamos à explicação de nosso programa, entendendo o código apresentado. Para que você tenha um programa executável construído com a linguagem Java, sua classe deve sempre possuir um método específico, que caracteriza a classe como uma aplicação que a Máquina Virtual Java deverá interpretar no momento da execução do programa. Todo programa/ classe Java que possuir a função executável ou, como veremos nos capítulos seguintes, o método executável com a assinatura “public static void main (String[] args){ }” apresentada na linha 3 de nosso código anterior, será considerado um programa executável pela JVM..

(105) Capítulo 1 - Conceitos básicos da tecnologia Javat7. Logo, este trecho será executado automaticamente quando for encontrado no programa submetido à maquina virtual. Um detalhe importante que deve ser comentado nesse trecho trata-se do vetor (array) “String[] args”. Esse trecho presente na assinatura de nossa função executável pode conter parâmetros, que foram passados pela linha de comando na execução de nosso programa. Demonstraremos isso a seguir. Outro detalhe a ser destacado e que você deve reparar no código apresentado, está no fato de que, por convenção, ou seja, algo aceito por todos os programadores Java, os nomes das classes no Java são sempre iniciados com letra maiúscula e, caso venham a ser compostos, cada nova palavra será iniciada novamente com uma letra maiúscula, definindo seu início. Note que isso é feito em nosso código anterior e, diante disso, passe a adotar em seus programas Java. Na quarta linha de nosso primeiro programa, é apresentada a linha System.out.println(“Olá leitor”);, que nada mais faz do que realizar a impressão em console. Esse comando informa ao sistema (System) que será realizada uma operação de saída (out), sendo que tal operação consiste em uma impressão com quebra de linha (println). Existem outras possibilidades de realizar a impressão em console Java e estaremos lidando com elas no momento certo. Então, memorize a linha demonstrada, pois sempre iremos utilizar essa linha de código quando quisermos realizar a impressão em console em nossos próximos programas. Certo pessoal, até aqui conseguimos vencer uma parte importante de nosso primeiro capítulo, considerando que os aspectos citados são comuns a qualquer programa Java que você venha a construir de agora em diante. Mas, está faltando visualizarmos o resultado de nosso primeiro programa. Para isso. teremos de compilar e interpretar nosso programa e, logo, necessitamos de outras ferramentas. Existem dois comandos básicos que a tecnologia Java fornece por meio do JDK para tais funções, sendo: javac e java, respectivamente. Tais comandos só funcionarão em seu prompt de comando, como, por exemplo, o DOS do Windows, depois de definidas as variáveis de ambiente, para que os comandos estejam disponíveis em qualquer caminho de seu sistema operacional, sendo: t. JAVA_HOME: Deve conter o caminho da pasta, na qual foi instalado o SDK, ou seja, o local onde possui todas as ferramentas e APIs básicas fornecidas pela tecnologia Java em seu computador;.

(106) 8 t JAVA com Orientação a Objetos. t. CLASSPATH: Deve conter o caminho no qual estão localizadas as bibliotecas dos programas que você está utilizando. Por padrão, o valor desta variável é apenas “.”, que significa que as bibliotecas utilizadas estão na mesma pasta da aplicação que você está desenvolvendo. Caso seja necessário, incremente a essa variável os caminhos nos quais existam outras APIs importantes para o desenvolvimento de sua aplicação, que podem ter sido adquiridas na Internet, por exemplo.. Para que você obtenha maiores informações sobre a criação de variáveis de ambiente, disponibilizamos, ao final deste livro, no ANEXO I, um tutorial sobre o assunto. Além disso, podem ser encontrados na Internet diversos tutoriais sobre o assunto, sendo que sempre devemos levar em consideração o sistema operacional a ser utilizado no momento do desenvolvimento e da configuração. Uma vez que o JDK está instalado corretamente e foram definidas as variáveis de ambiente, estamos prontos para compilar e executar nosso primeiro programa. Assim, digite os comandos apresentados abaixo em um prompt de comando do seu sistema operacional, considerando que no prompt, devemos estar no diretório no qual são mantidas nossas classes. Em nosso exemplo, a classe PrimeiroPrograma.java está no diretório c:/>programas.. javac PrimeiroPrograma.java java PrimeiroPrograma. O primeiro comando apresentado consiste no javac que irá realizar a compilação de sua classe. Já o segundo comando apresentado, java, irá realizar a interpretação do bytecode gerado por meio da compilação, conforme a estrutura apresentada na Figura 1. Certo! Se tudo ocorreu conforme o esperado, será impresso o texto “Olá leitor”, como é apresentado na imagem a seguir..

(107) Capítulo 1 - Conceitos básicos da tecnologia Javat9. Caso o leitor tenha dúvidas sobre como realizar a navegação nos diretórios de seu computador, indicamos a leitura de qualquer tutorial que auxilie na manipulação de comandos na linha de comando de seu sistema operacional. Mas, outro ponto importante na construção de uma aplicação no Java, ou seja, na construção das classes e que deve ser considerado para darmos um passo adiante em nosso aprendizado consiste na definição das variáveis de uma classe Java. Em muitos momentos, conforme já mencionamos, as variáveis na linguagem Java aparecerão nos textos, livros e tutoriais, sendo tratadas como atributos. Logo, qual a diferença entre atributos e variáveis? A diferença entre eles é que um atributo está intrinsecamente ligado às características da classe, ou seja, descreve algo ligado ao contexto ou à ideia central à qual a classe está relacionada ou preocupa-se em descrever. Um exemplo seria um atributo para manter os dados de RG de uma pessoa. Já as variáveis não precisam ser aplicadas necessariamente a um contexto da classe, como, por exemplo, em uma variável auxiliar para o comando de repetição FOR ou mesmo uma constante. Por enquanto, não se preocupe com isso, pois no decorrer da disciplina, essa diferença se tornará mais clara e logo você saberá diferenciar tais elementos de programação com base nos paradigmas da orientação a objetos. Em continuidade ao nosso aprendizado sobre os conceitos básicos da tecnologia Java, vamos por a mão na massa e criar nosso segundo programa, utilizando o armazenamento em memória com variáveis. Transcreva o código a seguir para um editor de texto, assim como fizemos em nosso primeiro programa. Depois disso, compile e execute-o por meio dos comandos javac e java, respectivamente, em um prompt de comando de seu sistema.

(108) 10 t JAVA com Orientação a Objetos. operacional, conforme realizado no exemplo anterior. Não se esqueça: Para que você consiga executar tais comandos seguido do nome de seu programa, aqui SegundoPrograma.java, você deve estar localizado no diretório no qual a classe se encontra, no caso onde foi salva. Fique atento também ao fato mencionado de que o nome de nosso arquivo Java deve ser igual ao da classe - neste exemplo, nosso arquivo Java deve ser nomeado como SegundoPrograma.java.. // SegundoPrograma.java class SegundoPrograma{ public static void main (String arg []){ int a = 5; a = 5+10; System.out.println(“O valor é:”+a); } }. No código de nosso segundo programa, começamos a manipular o armazenamento na memória volátil, ou seja, a criação de variáveis. No programa, foi inicialmente criada uma variável do tipo inteiro ‘a’, que recebe uma atribuição de valor, no caso o valor ‘5’. Depois, na quarta linha de nosso segundo programa, é feita uma operação cujo resultado é armazenado na mesma variável ‘a’, que é impressa na linha seguinte. Note que, em regra, quando se quer definir variáveis, constantes e mesmo atributos no Java, como veremos nos conceitos de orientação a objetos, em primeiro lugar você deve informar o tipo de dado que será mantido, no caso String, int ou qualquer outro tipo de dados, sendo ele primitivo ou não. Depois, é dado o nome de acesso à variável e finalmente, atribuímos um valor inicial ou não, conforme é apresentado a seguir.. Tipo variável = ValorInicial; final tipo CONSTANTE = Valor;.

(109) Capítulo 1 - Conceitos básicos da tecnologia Javat11. Na segunda linha de nossa caixa anterior, a palavra reservada final determina que tal variável não sofrerá alterações, sendo mantido o valor atribuído no momento de sua declaração, consistindo assim em uma constante para todo o programa, enquanto este estiver em execução. Outro detalhe importante que você deve saber e nunca mais esquecer é que o Java é uma linguagem de programação fortemente orientada a objetos e com exceção dos tipos primitivos, “qualquer” coisa no Java consiste em uma classe/objeto. Devemos destacar que existem várias palavras que são reservadas pela linguagem Java e elas não podem ser utilizadas em vários momentos em seu programa, como, por exemplo, na definição de nome dos atributos, classes ou outros elementos. Tais palavras reservadas são apresentadas na Tabela 1 a seguir. Tabela 1. Palavras reservadas. abstract. double. int. strictfp. boolean. else. interface. super. break. extends. long. switch. byte. . native. synchronized. case. . new. this. catch. . package. throw. char. for. private. throws. class. goto. protected. transient. const. if. public. try. continue. implements. return. void. default. import. short. volatile. do. instanceof. static. while. Várias dessas palavras reservadas são elementos naturais em outras linguagens de programação, principalmente na linguagem C. Assim, o leitor que já possui algum domínio do C ou C++, não terá dificuldades com a manipulação das palavras reservadas no Java. Outro ponto importante no Java é que devem ser considerados, uma vez que são extremamente necessários, os operadores matemáticos. No caso, utilizamos os operadores +, -, * e / para realizarmos as operações matemáticas básicas, ou seja, soma, subtração, multiplicação e divisão, respectivamente. No Capítulo 5, iremos trabalhar com a API Math, que possibilitará a você realizar operações matemáticas mais complexas. Devemos ainda considerar.

(110) 12 t JAVA com Orientação a Objetos. outros operadores que são de suma importância para a linguagem Java, estando relacionados principalmente ao processo lógico dentro de nossos programas, como no caso dos testes condicionais, sendo que os mais utilizados são listados no quadro da Tabela 2. Tabela 2. Operadores no Java. OPERADORES. DESCRIÇÃO. ==. Igualdade. !=. Diferente. >. Maior. <. Menor. >=. Maior igual. <=. Menor igual. !. Negação. &&. E lógico. ||. Ou lógico. Entre as várias considerações que podem ser feitas quanto ao uso dos operadores, devemos destacar ainda a outra funcionalidade atribuída ao operador “+”, que consiste na concatenação de Strings, como pode ser observado em nosso próximo exemplo. Conforme mencionado anteriormente e como pode ser vislumbrado na Tabela 1, uma String não é um tipo primitivo, mas sim uma classe. Logo, você deve estar perguntando-se: “Então, qual a diferença entre um tipo primitivo e uma classe”? Existem várias diferenças que poderiam ser citadas, mas como diversas delas estão relacionadas ao conceito de orientação a objetos, do qual ainda não tratamos, vamos prender-nos inicialmente à diferença de que uma classe geralmente agrega funcionalidades das quais os tipos primitivos não dispõem. Essas funcionalidades, no caso, são denominadas de métodos e que conheceremos mais profundamente no Capitulo 2. Um exemplo que demonstra essa diferença com a utilização de uma funcionalidade pode ser observado no exemplo a seguir, no qual é realizada a conversão de uma String em um inteiro, sendo de extrema importância para os vários programas que iremos construir. Logo, tente memorizar tal funcionalidade da classe Integer..

(111) Capítulo 1 - Conceitos básicos da tecnologia Javat13. // TerceiroPrograma.java public class TerceiroPrograma { public static void main(String args[]){ String entrada = “1”; entrada = entrada+”1”; Integer numero = Integer.parseInt(entrada); System.out.println(entrada); System.out.println(numero); }. }. Note que no exemplo anterior, é criada uma variável do tipo String denominada entrada, que recebe o caractere “1”. Note que não é um número, mas sim um caractere. Em nossa segunda linha do exemplo, o valor existente na variável de entrada é concatenado a um novo caractere, no caso “1”. Note que o resultado dessa operação matematicamente seria o valor 2, mas, no caso, por se tratar de manipulação, em específico uma concatenação, o valor mantido na variável será “11”, pois não estamos lidando com uma operação matemática. Na terceira linha é feita a transformação desse conjunto de caracteres em um tipo número, que possibilitará as operações matemáticas. Nas duas últimas linhas do exemplo são realizadas as impressões em console dos valores existentes nas duas variáveis do programa. 1.3 Entrada de dados Bom pessoal, um importante aspecto de qualquer programa computacional consiste na entrada de dados. Pois bem, a primeira coisa a ser feita é conhecer a classe Scanner do pacote java.util. A classe Scanner possibilita que seja realizada a leitura dos dados procedentes tanto do teclado quanto de outras fontes como arquivos de texto. A Scanner passou a ser disponibilizada a partir da distribuição Java 5, na qual se buscou simplificar todo o trabalho com a manipulação de dados oriundos de fontes de dados, no caso as streams vindas do sistema (System.in) ou mesmo de arquivos de texto. Pois bem, nada como um exemplo para que possamos memorizar todos os conceitos e detalhes vinculados à classe Scanner. Assim, transcreva o código a seguir e execute, observando a utilização de nossa nova funcionalidade..

(112) 14 t JAVA com Orientação a Objetos. //QuartoPrograma.java import java.util.Scanner; class QuartoPrograma{ public static void main(String[] arg){ Scanner entrada = new Scanner(System.in); System.out.println(“Digite um numero “); //lendo o número digitado no teclado int valor = entrada.nextInt(); System.out.println(“o numero digitado “ + valor); } }. Repare que em nosso exemplo anterior, surgiu um novo elemento que está relacionado à importação de uma classe para sua utilização. Este conceito ficará mais claro em nosso próximo capítulo quando estivermos falando sobre os conceitos relacionados à mensagem entre as classes por meio de métodos. Mas, voltando ao exemplo, repare que na quarta linha é criada uma variável denominada entrada do tipo Scanner, que é inicializada ‘escutando’ as entradas do sistema (System.in). Repare que na sexta linha de nosso programa, por meio da função ou do método nextInt( ) da variável de entrada, o valor digitado pelo usuário será atribuído à variável valor, que será impressa na linha seguinte. No momento da execução do programa, você irá reparar que logo após ser impressa a mensagem solicitando que o usuário digite um número, o programa aguardará a entrada do valor. Isso se deve às características do método nextInt( ) da classe Scanner. Um ponto importante a ser citado está no fato de que, assim como no caso das impressões no console, existem outras possibilidades para realizar a entrada de dados no Java, porém, com certeza, a utilização da classe Scanner é a mais simples. Portanto, em nossos exemplos iniciais, a utilização da classe Scanner será o suficiente até que conheçamos as outras possibilidades e você escolha qual a mais adequada para seus programas..

(113) Capítulo 1 - Conceitos básicos da tecnologia Javat15. 1.4 Estruturas de controle Certo pessoal, chegamos a um ponto importante de sua leitura, no qual iremos aprender a trabalhar com uma das características mais importantes em um programa, que consiste nas estruturas de controle. Agora, comentaremos sobre os famosos if/else, switch, while, do-while e for. Podemos mais uma vez considerar a relação de analogia para entender estes comandos. Essencialmente, a única diferença desses comandos no Java para a programação em Pascal está nos indicadores de bloco “{” e “}”, sendo, porém, semelhantes em C ou C++. Então, vamos trabalhar com cada um deles. O primeiro consiste no comando de seleção if que possibilita que um programa analise se uma expressão lógica é verdadeira ou falsa e a partir disto, direcione a execução de seu programa. A estrutura do if trabalha com a perspectiva de acontecimentos, logo, realiza o que sua tradução do inglês, que é “Se”, se propõe. Sendo mais detalhista, trata-se de uma estrutura na qual, “Se” a expressão lógica do comando for verdadeira, a sequência natural do if será executada. Porém, “Se” a expressão lógica for falsa, surgirá um novo elemento na estrutura, que consiste na cláusula else (então). Essa cláusula será executada na sequência do if, obviamente se ela tiver sido implementada. if (expressão_lógica){ Sequência 1; }else{ Sequência 2; }. Para que não existam dúvidas, vamos a um pequeno exemplo de fixação dos conceitos do comando de seleção if/else..

(114) 16 t JAVA com Orientação a Objetos. //Classe ExemploIf.java class ExemploIf{ public static void main (String[] args){ if (args.length > 0){ System.out.println(“Dentro do if”); }else{ System.out.println(“Dentro do else”); } } }. Assim como fizemos em nossos exemplos anteriores, salve sua classe com o nome “ExemploIf.java” e utilize os comandos javac e java, respectivamente, para a compilação e a execução de seu programa, conforme é apresentado na figura a seguir.. Repare que em nossa figura anterior, junto ao comando java e ao nome da classe, consta um conjunto de valores “Teste do if/else”. Estes, por sua vez, são os argumentos passados para o programa durante a execução, que podem ser acessados por meio do vetor de String “args”, presente na assinatura do método principal void main. No exemplo apresentado no código java, o código dentro do bloco definido pela cláusula if só será realizado caso, pelo menos, um argumento seja passado no momento da execução do programa, do contrário, o vetor args estará vazio e o bloco da cláusula else será executado..

(115) Capítulo 1 - Conceitos básicos da tecnologia Javat17. Outra interessante estrutura de seleção que deve ser mencionada consiste na cláusula switch. A switch é equivalente de maneira lógica a um conjunto de cláusulas if organizadas de forma encadeada e isso é usualmente mais eficiente durante uma execução de um programa. A expressão utilizada pelo switch deve retornar necessariamente um resultado ordinal, ou seja, classificado em um dos possíveis blocos da cláusula, mais conhecidos como “case”. As diretivas encontradas a partir do caso escolhido são executadas até o final da cláusula switch ou até uma ordem de “break” que encerra a cláusula. Se o valor a ser testado não possuir um caso específico, então será executada a diretiva default, que é opcional, sendo colocada ao final da cláusula switch, após todos os casos de classificação possíveis. Assim, para um melhor entendimento do mencionado, vamos a mais um exemplo.. /Classe ExemploSwitch.java class ExemploSwitch{ public static void main (String args[]){ switch(args[0].charAt(0)) { case ‘A’:System.out.println(“Vogal A”); break; case ‘E’:System.out.println(“Vogal E”); break; default:System.out.println(“Não é vogal”); } }. } Repare que, em nosso exemplo, trabalhamos mais uma vez com a utilização do vetor args, ao qual os valores são passados durante a execução, conforme feito no exemplo para a cláusula if. Aqui, nosso programa faz uma verificação se a vogal presente na primeira posição do vetor é a vogal ‘A’ ou ‘E’, ou seja, realiza a classificação dos valores testados. É interessante mencionarmos a existência da diretiva default no exemplo, que será executada se nenhum dos casos for realizado. Então, salve seu programa e execute, conforme apresentado a seguir..

(116) 18 t JAVA com Orientação a Objetos. Veja que neste exemplo, fizemos uso mais uma vez dos argumentos para passar valores para que sejam verificados em nosso programa, em específico a vogal ‘A’. Prosseguindo, outra estrutura a ser mencionada no Java é a estrutura de repetição condicional while. O while consiste em uma cláusula na qual seu bloco será executado durante ou ‘ENQUANTO’ a expressão lógica a ser testada for verdadeira. A execução do bloco só será realizada desde que a expressão lógica analisada seja verdadeira. A síntaxe para a estrutura de repetição while é descrita a seguir. while ( expressão lógica ){ Sequência; }. Assim, mais uma vez iremos recorrer a um exemplo para a fixação desta estrutura de controle de fluxo. No programa abaixo, iremos imprimir os valores menores que o passado no argumento durante a execução para nosso programa. //Classe ExemploWhile.java class ExemploWhile{ public static void main (String args[]){ int j = 10;.

(117) Capítulo 1 - Conceitos básicos da tecnologia Javat19. while (j > Integer.parseInt(args[0])){ System.out.println(«»+j); j--; } } }. Outra possibilidade na linguagem de programação Java para a estrutura de repetição while consiste na estrutura do-while, que pode ser utilizada como uma condição ao final do loop. Essa estrutura está intrinsecamente ligada à tradução dos termos, que é: “faça/enquanto”. Isso faz com que tenhamos a garantia de que o bloco de código definido será executado ao menos uma vez. No caso, ambas as estruturas apresentadas, while e do-while são repetições baseadas em condições lógicas. Observe a seguir a síntaxe da estrutura do-while. do{ Sequência; } while (expressão_lógica);. Vamos brincar com a estrutura do-while? Então, transcreva o código abaixo, compile e execute-o.. //ExemploDoWhile.java public class ExemploDoWhile { public static void main (String args[]) { int min, max; Scanner entradas = new Scanner(System.in); System.out.print(“Digite o valor minimo:”); min = entradas.nextInt(); System.out.print(“Digite o valor maximo:”); max = entradas.nextInt(); do { System.out.println(“” + min + “ < “ + max); min++;.

(118) 20 t JAVA com Orientação a Objetos. max--; } while (min < max); System.out.println(“” + min + “ < “ + max + “ Condicao invalida.”); } }. No exemplo, são capturados dois valores vindos do teclado. O mais importante de nosso exemplo está na cláusula do-while, que irá imprimir os valores mínimo e máximo passados, e que serão impressos em tela e decrementados, pois fazem parte do bloco “do”, ou seja, o bloco será executado ao menos uma vez. Diante disso, outras impressões só ocorrerão caso a condição existente na diretiva while seja satisfeita. Repare, na figura a seguir, a execução do código proposto.. Porém, existem situações nas quais a repetição necessita ser apenas incremental e decremental, obviamente com uma condição de parada para ambos os casos. Para estes momentos, a estrutura ‘for’ executará a sequência do comando enquanto a expressão lógica for verdadeira. Um fato interessante que deve ser comentado sobre essa estrutura é a possibilidade da criação e da inicialização da variável de controle na entrada do comando. Ela será utilizada para o controle da condição, sendo incrementada ou decrementada a cada repetição. A seguir observe a estrutura de repetição ‘for’..

(119) Capítulo 1 - Conceitos básicos da tecnologia Javat21. for(inicialização; condição; incremento/decremento){ Sequência; }. Assim como nos exemplos anteriores, vejamos uma aplicação dessa estrutura.. //Classe ExemploFor.java class ExemploFor{ public static void main (String args[]){ for (int j=0; j<10; j++){ System.out.println(j); } } }. Repare que na condição a ser satisfeita, foi inicializada uma variável ‘j’ que irá auxiliar no processo de controle com o seu incremento. O mesmo poderia ser feito com o decremento do valor atribuído a ‘j’. No caso, no Java, assim como em C ou C++, o incremento e o decremento podem ser obtidos apenas com a utilização dos comandos ‘j++’ ou ‘j- -’. 1.5 Arrays e matrizes Agora, em nosso primeiro capítulo, trabalharemos com os arrays ou também conhecidos como vetores e matrizes, que nada mais são que vetores multidimensionais. No caso, os arrays são vistos como estruturas homogêneas e estáticas, ou seja, mantêm uma estrutura regular que não muda de tamanho. Logo, o espaço destinado aos armazenamentos de valores, bem como o tipo de dado, é sempre do mesmo tipo do início ao fim da vida do programa. A primeira posição de um vetor no Java consiste na posição 0. A.

(120) 22 t JAVA com Orientação a Objetos. linguagem disponibiliza diversas propriedades que podem ser úteis na manipulação de vetores, uma vez que sua criação é muito simples, como veremos no exemplo a seguir. Uma das propriedades mais importantes de um array é length, que representa o tamanho de seu vetor. Ela se torna útil, pois além de verificar qual o tamanho do vetor, auxilia no acesso a determinadas posições, como, por exemplo, a última, que iremos acessar como (length – 1). Mas, vamos ao que realmente interessa, que é conhecer a sintaxe de criação de nossos vetores, bem como verificar sua manipulação. Para isso, o código abaixo demonstra a utilização dos arrays no Java. //Classe ExemploArray.java class ExemploArray{ public static void main(String[] args){ int[] vetor = new int[ 10 ]; System.out.println(“Tamanho vetor:”+vetor. length); for (int i = 0; i < vetor.length; i++) { vetor[i] = i; System.out.println(vetor[i]); } } }. Uma vez executado como feito anteriormente, nosso exemplo define um vetor com 10 posições do tipo inteiro. Repare que a definição do espaço de memória para tal vetor depende da utilização da sintaxe ‘[ ]’. Várias podem ser as possibilidades de utilização dos vetores, que, como mencionado, consistem em um espaço de memória destinado ao armazenamento de valores durante a execução, auxiliando na organização de nossos programas, como exemplificado com a utilização do comando for. Eles serão muito úteis em exemplos nos quais não são utilizados conceitos relacionados ao banco de dados, pois auxiliam na manutenção dos valores durante a execução. No caso, teremos acesso sempre a uma determinada posição, sendo que podemos considerar um vetor como uma linha na qual iremos acessar um endereço de memória mantido em sequência, como demonstrado abaixo..

(121) Capítulo 1 - Conceitos básicos da tecnologia Javat23. 0 10. 1 20. 2 50. 3 70. 4. 5. 6. 7. 8. 9. Assim, se acessarmos o vetor em sua segunda posição, obteremos o valor 50. Outro detalhe a ser mencionado na definição de valores para um vetor é que estes podem ser inseridos no vetor no momento da definição de seu tamanho, no momento de sua criação. No caso, execute o exemplo a seguir e observe seu funcionamento.. //Classe NovoVetor.java class VetorInicializado{ public static void main(String[] args){ double[] nota = {7,8, 8,4, 4,2, 1,8, 6,4}; for(int i=0; i < nota.length-1;i++) System.out.println(“Valor no vetor:”+nota[i]); } }. Repare que no exemplo, o tamanho do vetor apresentado é definido pelos valores que serão armazenados e passados entre { }. No caso, teremos um vetor com 5 posições, no qual sua instanciação é realizada no momento de sua definição com valores do tipo double. Ainda no exemplo anterior, é importante mencionar que devido à nossa estrutura de repetição ‘for’ possuir apenas uma linha definida em seu bloco, no caso a impressão dos valores do vetor, não é necessária a delimitação do bloco de escopo da estrutura com os caracteres “{” “}”. Certo, mas e quanto às matrizes? Quando falamos sobre matrizes no Java, devemos ter em mente um aspecto importante que, porém, não impedirá ou dificultará seu trabalho. O fato é que a linguagem Java possui somente arrays unidimensionais, sendo que para a criação de arrays multidimensionais, ou seja, matrizes, o que podemos fazer é criar ou simular “pseudomatrizes” por meio da definição de um array de arrays..

(122) 24 t JAVA com Orientação a Objetos. Obviamente que isso passa de maneira despercebida na construção de suas matrizes, sendo apenas uma estruturação interna da linguagem e que, como mencionado, não irá interferir em seu programa de maneira significativa. Você deve ter em mente apenas a constante necessidade de duas estruturas de repetições para percorrer todo o vetor, assim como em qualquer outra linguagem de programação. Para entender melhor o processo, vamos a um exemplo.. //Classe Matrizes.java class Matrizes{ public static void main(String[] args){ int [][]matriz = new int[2][3]; for(int i=0; i< matriz.length; i++){ System.out.println(“Linha: “+i); for(int j=0; j< matriz[i].length; j++){ matriz[i][j]= i+1; System.out.println(“Valores da coluna”); System.out.println(matriz[i][j]); } } } }. Após executar o programa, teremos como resultado a impressão da coluna, da qual cada uma das posições faz parte no momento. Como mencionamos, são necessárias duas estruturas de repetição para percorrer toda a matriz, lembrando que uma é responsável por fazer referência à linha e a outra estrutura a um novo vetor, no caso, uma pseudocoluna, conforme é impresso no programa anterior. No Java, existem outras estruturas de vetores que, no caso, são classes que fornecem mais ferramentas e funcionalidades, agregando valor ao programa. Em nosso sexto capítulo, iremos analisar mais e apresentar essas estruturas adicionais para o trabalho com vetores, tais como as classes Array, HashMap e Vector. Então, para a definição de vetores e matrizes, sempre estaremos envolvidos em três etapas:.

(123) Capítulo 1 - Conceitos básicos da tecnologia Javat25. 1-Declaração do vetor ou matriz: Ocorre da mesma forma como em uma variável, porém basta acrescentar antes ou depois da variável um par de colchetes. Exemplo:

(124) double posicao[][], controle[][]; int []indice;. 2- Reservar o espaço de memória: No caso, é necessário definir o tamanho do espaço de memória que será mantido para a estrutura. Para isso, é utilizado o operador new. Exemplo:

(125) posicao = new double[10][20]; indice = new int[5];. 3- Armazenar valores nas posições: Para armazenar um valor ou informação em um dos elementos do vetor ou matriz, é necessário informar o índice, ou seja, o local no qual iremos manter os dados. Exemplo: nota[3] = 7.8; posição[4][6] = 3365; double[] nota = {7,8, 8,4, 4,2, 1,8, 6,4};. A manipulação de vetores e matrizes é essencial para o trabalho com as estruturas de dados. Diante disso, fica como sugestão que seja dada uma especial atenção ao trabalho com vetores e matrizes, refazendo os exemplos sugeridos e memorizando sua sintaxe. 1.6 Funções Caro leitor, chegamos ao último tema que será analisado neste capítulo, que se trata do trabalho com funções. Assim como nas demais linguagens, uma função consiste em uma rotina ou sub-rotina automatizada. As funções.

(126) 26 t JAVA com Orientação a Objetos. são interessantes para as atividades que serão utilizadas rotineiramente, ou seja, que se repetirão várias vezes e com isso, evitam que tenhamos de reimplementar tal trecho a cada momento de necessidade. Resumidamente, sempre que se quiser usar um mesmo trecho de código que realiza uma tarefa específica repetidamente, o melhor a fazer é criar uma função. O entendimento deste conceito é primordial para que, em nosso próximo capítulo, possamos lidar com o conceito de métodos. O primeiro passo para criar uma função gira em torno do fato de que a função deve ser sempre global, ou seja, deve ser enxergada por todo o código da classe e para tanto, também deve ser estática, sendo definida pela palavra reservada static. A palavra reservada static é responsável por garantir que ao ser realizada a execução de uma instância da classe mais de uma vez, somente haverá uma única referência para determinada variável ou função existente na memória em seu computador. Ou seja, ao declarar uma função como static, todas as instâncias de uma determinada classe irão acessar e compartilhar o mesmo endereço de memória da função. Outro detalhe ao qual devemos ficar atentos é que ao declararmos algum trecho, variável ou função como static, isso nos permitirá que sejam acessados diretamente sem a necessidade de criar uma instância da classe. Esses conceitos ficarão mais claros ao trabalharmos com a orientação a objetos, porém é importante saber que existem diversos padrões de projetos que fazem referência à utilização da palavra reservada static, como, por exemplo, o Singleton. As funções podem ser tanto sem argumentos quanto parametrizadas, porém a estrutura padrão que deve ser digitada dentro da classe, mas fora da função main, como é apresentada a seguir. static void nomeDaFunção(lista de parametros){ // código da função }. Em nosso exemplo, a estrutura apresentada faz referência a uma lista de parâmetros, que pode ou não ser declarada. Assim, como mencionado, existem funções nas quais não existem argumentos, mas necessariamente devem existir os parênteses. Para ter uma melhor fixação da sintaxe, vamos a um exemplo da utilização de funções. Digite o código a seguir e verifique seu funcionamento, assim como nos demais exemplos averiguados até aqui..

(127) Capítulo 1 - Conceitos básicos da tecnologia Javat27. // Classe ExemploFuncao.java public class ExemploFuncao{ public static void mostrarMensagem() { System.out.println(“Chamei minha função”); } public static void main(String[] args) { // chamando a função dentro do // programa principal mostrarMensagem(); } }. Em nosso exemplo, foi criada uma função chamada mostrarMensagem( ), que apenas imprime na tela. Nossa função é chamada dentro do método principal main( ), ou seja, poderíamos realizar a chamada quantas vezes fossem necessárias sem ter de reescrever todo o código novamente. Este exemplo é um bom começo para o entendimento da ideia de mensagens, mas isso é um assunto para o nosso próximo capítulo. É importante mencionar que a ideia de função em java muitas vezes é confundida com o conceito de métodos, sendo que iremos saber mais sobre eles em nosso segundo capítulo Bom pessoal, assim finalizamos nosso primeiro capitulo e espero que todos tenham assimilado, aprendido e gostado do fascinante e, ao mesmo tempo, importante mundo Java. Um detalhe que deve ser mencionado e deve fazer parte de sua rotina como programador é que a atividade de programação torna-se cada vez mais clara com a prática. Desta forma, sempre que possível, refaça todos os exemplos sugeridos neste capitulo. Nos vemos no próximo capítulo..

(128)

(129) Capítulo 2 Programação orientada a objetos A tecnologia Java ganhou espaço nos últimos anos considerando diversos aspectos. Vários deles já comentamos, como, por exemplo, a ideia de máquina virtual que possibilita a portabilidade entre os programas desenvolvidos com o Java ou mesmo o fato da tecnologia Java ser regida pela GPL. Porém, outro aspecto deve ser mencionado neste contexto. Ele consiste no fato da linguagem Java trabalhar sobre os conceitos oriundos do paradigma da programação orientação a objetos. Neste capítulo, trabalharemos com os conceitos básicos relacionados a este paradigma de programação, obviamente baseados na tecnologia Java. Fica como dica que é muito importante que os temas abordados em nosso primeiro capítulo tenham sido assimilados de maneira satisfatória, garantindo assim um melhor aproveitamento dos tópicos que virão a ser tratados não só neste capítulo, como nos seguintes também. Certo! Vamos ao que realmente interessa. O paradigma de programação orientada a objetos trata de uma forma diferente o enfoque até então trabalhado na maioria das linguagens de programa, que se sustentavam no paradigma de programação estruturada. A ideia por trás do paradigma da programação orientada a objetos baseia-se em uma contextualização mais humana e próxima da realidade, isso considerando que quase tudo o que temos e lidamos em nosso dia a dia são objetos. Por exemplo, o carro que você anda, a casa onde você mora. Poderíamos, então, imaginar que até mesmo as pessoas, animais e qualquer outro tipo de entidade podem ser vistos grosseiramente como objetos. Claro que existem situações nas quais esses “objetos” podem não ser concretos e palpáveis, tal como o veículo que mencionamos, mas no caso abstrato, como, por exemplo, os softbots (robôs de software), também podemos imaginar que eles existem e possuem elementos que os diferenciam, assim como atitudes e funções que possibilitam que possamos imaginar que estes podem servir de modelos computacionais. O paradigma de programação orientada a objetos é relativamente novo na concepção e na implementação de sistemas de software, considerado.