Baixe História e Aplicabilidade da Linguagem Java na Orientação a Objetos em Universidades e outras Manuais, Projetos, Pesquisas em PDF para Engenharia Informática, somente na Docsity!
Índice
Introdução
- Introdução.................................................................................................................
- História.....................................................................................................................
- Padronização........................................................................................................
- Aquisição pela Oracle..........................................................................................
- Características..........................................................................................................
- Sintaxe similar a C/C++.......................................................................................
- Exemplos de código.............................................................................................
- Interfaces..................................................................................................................
- Programação funcional.............................................................................................
- Framework...............................................................................................................
- Hibernate ferramenta para ORM..............................................................................
- Comunidade.............................................................................................................
- Objetivos do Trabalho..............................................................................................
- Situação problema:...............................................................................................
- Identificação de objectos:.....................................................................................
- Conclusão...............................................................................................................
- Referências Bibliográficas......................................................................................
Este trabalho visa demonstrar uma porção da história da linguagem java e bem como podemos aplicar a linguagem para a orientação de objectos para realização de uma gestão acadêmica numa universidade.
História
Em 1991, na Sun Microsystems, foi iniciado o Green Project, o berço do Java, uma linguagem de programação orientada a objectos. Os mentores do projeto eram Patrick Naughton, Mike Sheridan, e James Gosling. Eles acreditavam que, eventualmente, 1
Padronização
Em 1997 a Sun Microsystems tentou submeter a linguagem a padronização pelos órgãos ISO/IEC e ECMA, mas acabou desistindo.[3][4][5] Java ainda é um padrão de fato, que é controlada através da JCP Java Community Process.[6] Em 13 de novembro de 2006, a Sun lançou a maior parte do Java como Software Livre sob os termos da GNU General Public License (GPL). Em 8 de maio de 2007 a Sun finalizou o processo, tornando praticamente todo o código Java como software de código aberto, menos uma pequena porção da qual a Sun não possui copyright.
Aquisição pela Oracle
Em 2008 a Oracle Corporation adquire a empresa responsável pela linguagem Java, a Sun Microsystems, por US$ 7,4 bilhões, com o objetivo de levar o Java e outros produtos da Sun ao dispor dos consumidores.
Características
A linguagem Java foi projetada tendo em vista os seguintes objetivos: Orientação a objectos - Baseado no modelo de Simular; Portabilidade - Independência de plataforma - "escreva uma vez, execute em qualquer lugar" ("write once, run anywhere"); Recursos de Rede - Possui extensa biblioteca de rotinas que facilitam a cooperação com protocolos TCP/IP, como HTTP e FTP; Segurança - Pode executar programas via rede com restrições de execução. Além disso, podem-se destacar outras vantagens apresentadas pela linguagem:
Sintaxe similar a C/C++
Facilidades de Internacionalização - Suporta nativamente caracteres Unicode; Simplicidade na especificação, tanto da linguagem como do "ambiente" de execução (JVM); É distribuída com um vasto conjunto de bibliotecas (ou APIs); Possui facilidades para criação de programas distribuídos e multitarefa (múltiplas linhas de execução num mesmo programa); Desalocação de memória automática por processo de coletor de lixo; Carga Dinâmica de Código - Programas em Java são formados por uma coleção de classes armazenadas independentemente e que podem ser carregadas no momento de utilização. Licença[editar | editar código-fonte] A Sun disponibiliza a maioria das distribuições Java gratuitamente e obtém receita com programas mais especializados como o Java Enterprise System. Em 13 de novembro de 2006, a Sun liberou partes do Java como software livre, sob a licença GNU General Public License.[7] A liberação completa do código fonte sob a GPL ocorreu em maio de 2007.[8]
Exemplos de código
Método main 3
O método main é onde o programa inicia. Pode estar presente em qualquer classe. Os parâmetros de linha de comando são enviados para o array de Strings chamado args. public class OláMundo { /**
- Método que executa o programa
- public = É visto em qualquer lugar da aplicação. É o modificador de acesso
- static = é iniciado automaticamente pela JVM, sem precisar de uma instância
- void = Método sem retorno (retorno vazio)
- main = Nome do método, que é obrigatório ser este para que seja executado como o método principal da aplicação. A aplicação só pode ter um método denominado main. Recebe como parâmetro um array de String.
- String[] args = Array de argumentos que podem ser repassados na chamada do programa.
- / public static void main(String[] args) { System.out.println("Olá, Mundo!"); //Imprime na tela a frase } } Classes[editar | editar código-fonte] Exemplo: public abstract class Animal { public abstract void fazerBarulho(); } public class Cachorro extends Animal { public void fazerBarulho() { System.out.println("AuAu!"); } } public class Gato extends Animal { public void fazerBarulho() { System.out.println("Miau!"); } } O exemplo acima cria a classe Animal e duas classes derivadas de Animal. É importante observar que nas classes derivadas temos a redefinição do método fazerBarulho(). Esta redefinição é classificada como uma sobreposição (override) de métodos. O conceito de sobreposição somente pode ser identificado e utilizado quando temos classes dispostas em um relacionamento de herança. Java não suporta herança múltipla, devido a possibilidade de uma classe pai ter um método com o mesmo nome de outra classe pai, e gerar possíveis falhas ao chamar o método, e todas as classes em Java derivam da classe Object. A única possibilidade 4
new Animal() { public void fazerBarulho() { System.out.println("QUAC!"); } }.fazerBarulho(); } }
Programação funcional
A partir da versão 8, o Java adiciona aspectos de linguagem funcional, permitindo utilizar técnicas funcionais, como mapeamento, redução, bem como tratar funções como variáveis. Para tanto, a linguagem utiliza interfaces para esse tipo de manipulação, quase que eliminando a necessidade do uso das chamadas classes anônimas. [9] Exemplo: import java.util.ArrayList; import java.util.List; public class Main { public static void main(String[] args) { // Lista de paradigmas List paradigmas = new ArrayList<>(); // Adiciona paradigmas paradigmas.add("Genérico (1.5)"); paradigmas.add("Funcional (8)"); // Abre uma stream paradigmas.stream() // Faz todos os textos na lista ficarem em maiúsculo .map(String::toUpperCase) // Faz loop em todos paradigmas em maiúsculo. .forEach(paradigma -> System.out.println(paradigma)); // ou .forEach(System.out::println); } } 6
Framework
É possível utilizar frameworks para facilitar o desenvolvimento de aplicações, dos quais os mais utilizados podem-se destacar:
Hibernate ferramenta para ORM
Junit ferramenta para auxiliar na criação de testes unitários Log4j ferramenta para facilitar a criação de logs na aplicação Spring ferramenta que auxilia principalmente implementação de injeção de dependências e inversão de controle Struts controlador MVC (Model 2) web Ambientes de desenvolvimento[editar | editar código-fonte] É possível desenvolver aplicações em Java através de vários ambientes de desenvolvimento integrado (IDEs). Dentre as opções mais utilizadas pode-se destacar: BlueJ — um ambiente desenvolvido por uma faculdade australiana (considerado muito bom para iniciantes) JCreator — (gratuito/shareware) — um ambiente desenvolvido pela Xinox (recomendado para programadores iniciantes) jEdit — (recomendado para programadores iniciantes) Eclipse — (recomendado para programadores fluentes) Emulador do Android no Eclipse, exibindo um simples "Hello World", escrito em JAVA e XML IDEs completas (recomendado para programadores profissionais) Eclipse — um projeto aberto iniciado pela IBM IntelliJ IDEA (comercial) — uma IDE desenvolvida pela JetBrains JBuilder — um ambiente desenvolvido pela empresa Borland JDeveloper (gratuito OTN) — uma IDE desenvolvida pela empresa Oracle NetBeans (software livre) — uma IDE desenvolvida pela Sun Microsystems Outras IDEs (menos populares) Gel (IDE) — open source Greenfoot — bem parecido com o BlueJ JGRASP — bom para intermediários, feito pela equipe do Projeto GRASP Java Studio Creator/Enterprise (gratuito SDN) um ambiente criado pela empresa Sun Microsystems Workshop for WebLogic (comercial/desenvolvedor) um ambiente criado pela empresa Oracle WebSphere Studio Application Developer um ambiente criado pela empresa IBM Extensões[editar | editar código-fonte] Extensões em Java: Java ME (Micro-Edition for PDAs and cellular phones) Java SE (Standard Edition) J3D (A high level API for 3D graphics programming) JAAS (Java Authentication and Authorization Service) 7
Objetivos do Trabalho Modelar um sistema orientado a objectos simples a partir de uma situação problema (domínio do problema). Exercitar a extração e reconhecimento de objectos existentes no mundo real, seus atributos e seus métodos, propondo uma solução para o problema. Iniciar o uso do ambiente BlueJ para implementar a solução.
Situação problema:
- Domínio do problema: Gestão acadêmica
- Descrição do problema: Uma universidade necessita de um sistema que facilite a sua gestão acadêmica. Deseja-se um controle de quais disciplinas são ministradas por cada professor e em qual curso. Também é necessário um controle de quais disciplinas são cursadas por um aluno. Sabe-se que um professor é um funcionário. Além de professores, tem-se funcionários que são técnicos administrativos. Para cada funcionário, independente de ser professor ou técnico, é necessário saber seu nome, endereço, telefone, cpf, número da CTPS e salario. Especificamente para professores, é necessário saber sua titulação e sua área de pesquisa. Para cada curso é necessário registrar seu código, nome e duração. Para cada disciplina é necessário registrar seu código, nome e carga horária.
Identificação de objectos:
- Definição: Objectos são essencialmente componentes de software reutilizáveis que modelam itens do mundo real. Ou seja, um objecto é uma entidade representativa que pode caracterizar algo concreto ou abstrato do mundo real. Atributos são informações que caracterizam um objecto.
- Extraindo objectos a partir da descrição do problema: Vamos marcar de vermelho os objectos do problema e em azul os atributos:
- Uma universidade necessita de um sistema que facilite a sua gestão acadêmica. Deseja-se um controle de quais disciplinas são ministradas por cada professor e em qual curso. Também é necessário um controle de quais disciplinas são cursadas por um aluno. Sabe-se que um professor é um funcionário. Além de professores, tem-se funcionários que são técnicos administrativos. Para cada funcionário, independente de ser professor ou técnico, é necessário saber seu nome , endereço , telefone , cpf, número da CTPS e salario. Especificamente para professores , é necessário saber sua titulação e sua área de pesquisa. Especificamente para técnicos , é necessário saber seu cargo e departamento. Para cada curso é necessário registrar seu código , nome e duração. Para cada disciplina é necessário registrar seu código , nome e carga horária. Para cada aluno , deve-se armazenar seu nome, matrícula, cpf e curso. 3)
Criação de classes de objectos no BlueJ:
- Definição: Uma classe é uma matriz (modelo ou forma) a partir da qual os objectos são criados (instanciados). Cada objecto tem a mesma estrutura e comportamento da classe a partir da qual ele foi instanciado.
- Implementação:
- Abra o BlueJ
- Acesse o menu Project → New Project
- Selecione o diretório onde deseja criar o projeto e nomeie-o como “Pratica01”
- Clique em “New Class” e nomeie a nova classe como “Disciplina”. Façao mesmo para as demais classes do sistema (marcadas em vermelho no item anterior) resultando em: Vamos criar os atributos das classes. Para isto é necessário editar o código fonte das classes. De um clique duplo na classe “Funcionario”. Apague os comentários e demais códigos, deixando apenas a declaração da classe, conforme ilustrado a seguir:
byte: 8 bits (-128 até 127) short: 16 bits (-32. até 32.767) int: 32 bits (-2.147.483.648 até 2.147.483.647) long e double: 64 bits (-9223372036854775808 até 9223372036854775807) boolean: false, true char: qualquer caracter. Dentre outros... Declare todas as demais classes de objectos encontradas no domínio problema. Agora, compile o sistema clicando em “Compile” na barra de ferramentas lateral. Caso haja erros de sintaxe, eles serão apresentados. Note que após a compilação, um arquivo .class é gerado para cada arquivo .java no diretório do projeto. Os arquivos .class são as classes compiladas, em bytecodes, passíveis de serem executados pela JVM. Uma característica importante do problema descrito é a necessidade de se registrar qual professor é responsável por uma disciplina e em qual curso ela é ministrada. Ou seja, é importante relacionar um objecto disciplina com o professor que a ministra, e com o curso a qual pertence. Para isto, podemos modificar a classe “Disciplina” para conter estes atributos, resutando na seguinte declaração:
Observe que foram inseridos dois atributos na classe “Disciplina” além dos atributos já mencionados pela descrição do problema: – um atributo curso do tipo Curso e
- um atributo professor do tipo Professor. Note que Curso e Professor são classes que criamos em nosso projeto e que podem ser usados como tipos na declaração de atributos. Na programação orientada a objectos, toda classe que criamos é um tipo de dado. Em nosso exemplo, agora estamos aptos a armazenar um curso e um professor em cada disciplina que criarmos. Além disto, é importante que se relacione cada aluno com o curso o qual está matriculado. Para isto, criamos um relacionamento entre as classes Aluno e Curso, da mesma forma que foi feito com Disciplina e Professor (no item anterior): colocamos um atributo curso do tipo Curso na classe Aluno. Por exemplo: public class Aluno{ String nome; String matricula; String cpf; Curso curso; } Agora vamos criar um método na classe “Funcionario” que permita ler a partir do teclado (dispositivo de entrada padrão) os valores dos atributos do funcionário. Para isto, implemente o código apresentado a seguir na classe “Funcionario”, logo após a declaração de seus atributos: public void lerDados() { Scanner s = new Scanner(System.in); System.out.println("Digite o nome do funcionário:"); this.nome = s.nextLine(); System.out.println("Digite o endereço do funcionário:"); this.endereco = s.nextLine(); System.out.println("Digite o telefone do funcionário:"); this.telefone = s.nextLine(); System.out.println("Digite o CPF do funcionário:"); this.cpf = s.nextLine(); System.out.println("Digite a CTPS do funcionário:"); this.ctps = s.nextLine();
Agora implementa-se o método lerDados() para as demais classes do sistema. Ao se instanciar e ler os dados de um objecto que se relaciona com outro objecto, por exemplo, aluno e curso, uma instância de Curso deve ser atribuída ao atributo curso da classe Aluno. Uma solução plausível é que tivéssemos uma lista de objectos do tipo curso onde poder-se-ia buscar um curso através de seu código e atribuir o objecto encontrado ao atributo curso de Aluno. Mas isto será feito posteriormente. Por exemplo: class Aluno { ….atributos public void lerDados() { Scanner s = new Scanner(System.in); System.out.println("Digite o nome do aluno:"); this.nome = s.nextLine();
System.out.println("Digite a matricula do aluno:"); this.matricula = s.nextLine(); System.out.println("CPF do aluno:"); this.CPF = s.nextLine(); System.out.println("Digite o curso do aluno:"); this.curso = new Curso(); this.curso.lerDados(); } Implemente também um método mostrarDados() em cada classe. O código a seguir ilustra a implementação do método mostrarDados() para a classe funcionário. Teste os métodos implementados. public void mostrarDados() { System.out.println("Nome: "+this.nome); System.out.println("Endereço: "+this.endereco); System.out.println("Telefone: "+this.telefone); System.out.println("CPF: "+this.cpf); System.out.println("CPF: "+this.ctps); System.out.println("CPF: "+this.salario); } Agora crie uma classe principal com um método main para testar suas classes. Exemplo: class Principal { public static void main(String args[]){ Aluno a = new Aluno(); a.lerDados(); a.mostrarDados(); ….teste as demais classes.... } } A linha de código: Aluno a = new Aluno();
Conclusão
Mostrando como um breve resumo concluindo o presente trabalho, percebe-se que os semáforos como um conjunto ou sequências de instruções, são no nosso dia-a-dia, implementado em quase todos os sectores, visto que tanto em questões urgentes como em questões mais simples, nos vemos devidamente em situações de espera por qualquer que seja qual for a razão. Os programas e funcionamento deles assim como o dos semáforos, são detalhados de acordo com os impasses da nossa vida, deadlock e starvation não se distanciam muito dos casos de relação estudante/docente, comprador/cliente, utilizador/fabricante e outros exemplos, visto que quanto melhor for o atendimento ou relação entre ambos, mais congestionamentos relacionais destacam-se, contudo, mais impasses para relacionamentos do gênero. De um modo geral, referir que impasses fazem parte da vida dos seres.
Referências Bibliográficas
Harvey M. Deitel (2005). Java: Como Programar 6 ed. São Paulo: Pearson education do Brasil. 1097 páginas Apostila Java e Orientação a Objetos, licença Creative Commons, 7ª edição, pela Caelum Ensino e Inovação. Patrick Naughton, Dominando o Java, Guia Autorizado da Sun Microsystems, Editora Makron Books, 1997, Osborne, ISBN 80025- Brian Jepson, Java Database Programming Master Next Generation Web Database Techniques, 1997, Editora: Wiley Computer Publishing, ISBN 0-471-16518- Décio Heizelman Luckow, Alexandre Altair de Melo, Programação Java para a Web: Aprenda a desenvolver uma aplicação financeira pessoal com as ferramentas mais modernas da plataforma Java, ano 2010, Editora Novatec, ISBN 978-85-7522-238-
