ECN>> Programacao-Orientada-A-Objetos>> 返回
项目作者： GuilhermeEsdras

项目描述 ：
Engenharia de Computação - Programação Orientada à Objetos
高级语言： Java
项目地址: git://github.com/GuilhermeEsdras/Programacao-Orientada-A-Objetos.git


Programação Orientada à Objetos



Programando Orientado à Objetos!!


Com Java
·
Com Kotlin
·
Com Python


Glossário

Introdução

Repositório criado com a finalidade de armazenar códigos e projetos referentes à disciplina de Programação Orientada à Objetos do curso de Engenharia de Computação.

O curso é passado na linguagem Java. Os conteúdos produzidos em outras linguagens são de autoria própria. :)

Material Utilizado

Estes são os materiais usados por mim para desenvolver e rodar meus programas em Java.

Sistema Operacional

Programando em Java

O que foi necessário para criar e rodar meus programas em Java

Pré-Requisitos

Para executar programas em Java é necessário ter o Java (JRE) instalado no computador.
Para desenvolver programas em Java é necessário ter o compilador JAVAC - incluso em um dos pacotes JDK (SE, EE, ME) - instalado no computador.

  • Para verificar se o java e o javac estão instalados no PC, basta executar os comandos no CMD:

    > java --version
    > javac --version
    • Se os comandos não forem reconhecidos, não está instalado! (ver Links Úteis para instalá-los)
    • Caso exiba a versão, está instalado!

Executando .java pelo CMD

Criando e executando um programa simples em Java pelo CMD

  1. Para executar arquivos .java pelo terminal deve-se ter o Java JDK (Java Development Kit) devidamente instalado no PC.

    Para instalar, visitar o site oficial e seguir as intruções. (ver Links Úteis)

  2. Após ter baixado e configurado o JDK, já será capaz de criar e executar programas Java no Windows.

  • Para compilar programas “.java” e executá-los no terminal/cmd:

    • Abrir pasta onde se localiza o arquivo main (principal) .java:

      > cd "pasta do programa"
    • Compilar o programa:

      > javac "nome do programa".java

    • Para executar:

      > java "nome do programa"

    • Exemplo:

      > cd "C:\Users\Guilherme\Documentos\Meus Programas\Java\Programa Hello World\main" // Para ir até a pasta do arquivo main .java

      > javac HelloWorld.java // Para compilar o programa"

      > java HelloWorld // Para executar este programa

Empacontando arquivos .class em um .jar

  1. Compilar o arquivo .class onde se encontra o main:

    > javac "main".java
  2. Executar o comando:

    > jar --create --file "nome desejado para o jar".jar --main-class "nome do class principal" "class principal".class "outras classes".class
  3. Para executar o jar:

    > java -jar "nome do jar".jar

Organizando em pastas:

  1. Suponhando que existam 3 pastas:
    • bin (Para armazenar os bytecodes .class)
    • dist (Para armazenar o(s) .jar)
    • src (Onde ficam os arquivos .java)
  2. Para compilar todos os arquivos .java da pasta src e enviar os bytecodes (.class) compilados para a pasta bin, executar o comando:

    > javac -cp src -d ./bin src/*.java
  3. Para empacotar todas classes da pasta bin e gerar um .jar na pasta dist:

    > jar --verbose --create --file dist/"nome desejado para o jar".jar --main-class HelloWorld -C bin .
  4. Para verificar os arquivos dentro do jar:

    > jar -tf dist/"nome desejado para o jar".jar
  5. Para executar o jar:

    > java -jar dist/"nome desejado para o jar".jar

Criando e Rodando Projetos com Maven

  1. Criar a arquitetura de diretórias usando Maven CLI:

    > mvn archetype:generate -DgroupId="nome do package" -DartifactId="nome do app"² -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false

    • “nome do package” - Aqui fica o nome do diretório dos arquivos .java do projeto. (Exemplo: br.com.br)
    • “nome do app” - Aqui fica o nome da classe principal (main) e também da pasta principal do projeto (onde ficará o arquivo main). (Exemplo: Conta)
    • Exemplo de arquitetura de diretórios:

      C:\Users\Guilherme\"nome do app"\src\main\java\"nome do package"\"nome do app".java <- Classes principais

      C:\Users\Guilherme\"nome do app"\src\test\java\"nome do package"\ContaTeste.java <- Classes de Testes (Bateria de Testes)

  2. Renomear arquivos App e AppTest para os nomes desejados usando Refactor / Do Refactor (no intelliJ IDEA IDE)

  3. Editar o pom.xml:

    1. Acrescentar variáveis: 

      1.   <description>A very important project here</description>
      3.   <packaging>jar</packaging>

    2. Trocar a versão:

      de: 

      1.   <properties>
      2.       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      3.       <maven.compiler.source>1.7</maven.compiler.source>
      4.       <maven.compiler.target>1.7</maven.compiler.target>
      5.   </properties>

      para: 

      1.   <properties>
      2.       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      3.       <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      4.       <java.version>11</java.version>
      5.       <maven.compiler.source>${java.version}</maven.compiler.source>
      6.       <maven.compiler.target>${java.version}</maven.compiler.target>
      7.   </properties>

      1. Editar o plugin do jar, incluindo o main, para poder compilar:

        Para isso, alterar as linhas

        de: 

        1. <plugin>
        2.    <artifactId>maven-jar-plugin</artifactId>
        3.    <version>3.0.2</version>
        4. </plugin>

        para: 

        1. <plugin>
        2.    <groupId>org.apache.maven.plugins</groupId>
        3.    <artifactId>maven-jar-plugin</artifactId>
        4.    <version>3.0.2</version>
        5.    <configuration>
        6.        <archive>
        7.            <manifest>
        8.                <addClasspath>true</addClasspath>
        9.                <mainClass>br.com.bb.MainClass</mainClass>
        10.            </manifest>
        11.        </archive>
        12.    </configuration>
        13. </plugin>

        Onde “br.com.bb.MainClass“ é o caminho (separado por .) da pasta onde se localiza o arquivo principal (main) do programa.

      2. Adicionar os plugins Sources:

        1. <plugin>
        2.    <groupId>org.apache.maven.plugins</groupId>
        3.    <artifactId>maven-javadoc-plugin</artifactId>
        4.    <version>3.0.1</version>
        5.    <executions>
        6.        <execution>
        7.            <id>attach-my-javadocs</id>
        8.            <phase>verify</phase>
        9.            <goals>
        10.                <goal>jar</goal>
        11.            </goals>
        12.        </execution>
        13.    </executions>
        14. </plugin>
        16. <plugin>
        17.    <groupId>org.apache.maven.plugins</groupId>
        18.    <artifactId>maven-source-plugin</artifactId>
        19.    <version>3.0.1</version>
        20.    <executions>
        21.        <execution>
        22.            <id>attach-my-sources</id>
        23.            <phase>verify</phase>
        24.            <goals>
        25.                <goal>jar-no-fork</goal>
        26.            </goals>
        27.        </execution>
        28.    </executions>
        29. </plugin>

  4. Para compilar o programa:

    • Usando plugin/extensão do Maven no intelliJ:
      Maven -> Compile
    • ou usando o terminal:
      > mvn compile
  5. Para gerar o .jar:
    • Usando plugin/extensão do Maven no intelliJ:
      Maven -> Package
    • ou usando o terminal:
      > mvn package
  6. Forma mais fácil e rápida para compilar e gerar o jar de uma só vez usando o terminal:
    • > mvn compile package
  7. Para rodar o programa, executar o jar gerado na pasta target:
    • > java -jar target/"app"-1.0-SNAPSHOT.jar

      Onde “app” é o nome do arquivo/classe principal do programa.

Criando projeto Multi-Modular com Maven e intelliJ

  1. Criar um projeto normalmente usando o Maven
    (ver)
  2. Apagar a pasta src
  3. Ir até “Project Structure” no intelliJ
  4. Navegar até a guia “Modules”
  5. Remover as pastas apagadas na lista de pastas no lado direito da janela

  6. Clicar no símbolo “+”, em seguida “New Module”:

    1. Next;
    2. Clicar nos “…” no lado superior direito;
    3. Selecionar o parent (pasta raiz do projeto);
    4. Digitar nome do Package e do Módulo, separando as palavras por “-“.

  7. Editar o pom.xml pai:

    1. Certificar-se de deixar este pom.xml com a seguinte estrutura: 

      1. <?xml version="1.0" encoding="UTF-8"?>
      3. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      4. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      5.   <modelVersion>4.0.0</modelVersion>
      7.   <groupId>xx.xx.xx</groupId> <!-- Pacote principal do projeto -->
      8.   <artifactId>"Nome do Projeto"</artifactId> <!-- Nome da past raiz do projeto -->
      9.   <version>1.0-VERSÃO</version> <!-- Nome desejado para os .jar gerados -->
      10.   <description>Descrição do Projeto - Guilherme Esdras</description> <!-- Descrição do projeto -->
      11.   <packaging>pom</packaging> <!-- Necessário para o pom pai (parent) -->
      13.   <!-- Módulos (Essa parte é criada automaticamente durante o processo) -->
      14.   <modules>
      15.       <!-- Todos os módulos criados do projeto -->
      16.       <module>"modulo-tal"</module>
      17.   </modules>
      19.   <!-- Versão Local do java -->
      20.   <properties>
      21.       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      22.       <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      23.       <java.version>11</java.version>
      24.       <maven.compiler.source>${java.version}</maven.compiler.source>
      25.       <maven.compiler.target>${java.version}</maven.compiler.target>
      26.   </properties>
      28.   <!-- Plugins, Reports e Dependencias -->
      29.   <build>
      30.       <plugins>
      31.           <plugin>
      32.               <groupId>org.apache.maven.plugins</groupId>
      33.               <artifactId>maven-javadoc-plugin</artifactId>
      34.               <version>3.0.1</version>
      35.               <executions>
      36.                   <execution>
      37.                       <id>attach-my-javadocs</id>
      38.                       <phase>verify</phase>
      39.                       <goals>
      40.                           <goal>jar</goal>
      41.                       </goals>
      42.                   </execution>
      43.               </executions>
      44.           </plugin>
      46.           <plugin>
      47.               <groupId>org.apache.maven.plugins</groupId>
      48.               <artifactId>maven-source-plugin</artifactId>
      49.               <version>3.0.1</version>
      50.               <executions>
      51.                   <execution>
      52.                       <id>attach-my-sources</id>
      53.                       <phase>verify</phase>
      54.                       <goals>
      55.                           <goal>jar-no-fork</goal>
      56.                       </goals>
      57.                   </execution>
      58.               </executions>
      59.           </plugin>
      61.           <plugin>
      62.               <groupId>org.apache.maven.plugins</groupId>
      63.               <artifactId>maven-surefire-report-plugin</artifactId>
      64.               <version>3.0.0-M3</version>
      65.           </plugin>
      67.           <plugin>
      68.               <groupId>org.apache.maven.plugins</groupId>
      69.               <artifactId>maven-site-plugin</artifactId>
      70.               <version>3.7.1</version>
      71.           </plugin>            
      72.       </plugins>
      73.   </build>
      75.   <reporting>
      76.       <plugins>
      77.           <plugin>
      78.               <groupId>org.apache.maven.plugins</groupId>
      79.               <artifactId>maven-surefire-report-plugin</artifactId>
      80.               <version>3.0.0-M3</version>
      81.           </plugin>
      82.       </plugins>
      83.   </reporting>
      85.   <dependencies>
      86.       <dependency>
      87.           <groupId>junit</groupId>
      88.           <artifactId>junit</artifactId>
      89.           <version>4.12</version>
      90.           <scope>test</scope>
      91.       </dependency>
      92.   </dependencies>
      93. </project>
      95. </project>
  8. Editar os pom.xml filhos:
    1. Se por acaso um módulo importar outro, adicionar o módulo nas dependências do pom que o importa:
      1. <dependencies>
      2.   <dependency>
      3.       <groupId>br.edu.ifpb</groupId> <!-- Pacote principal -->
      4.       <artifactId>modulo-tal</artifactId> <!-- Módulo dependente/importado -->
      5.       <version>1.0-GUILHERME</version>
      6.   </dependency>
      7. </dependencies>
      1. Para o módulo que contém o main, adicionar o plugin gerador de fat jar (jar contendo vários módulos dependentes):
        1. <build>
        2. <plugins>
        3.    <plugin>
        4.        <groupId>org.apache.maven.plugins</groupId>
        5.        <artifactId>maven-shade-plugin</artifactId>
        6.        <version>2.4.3</version>
        7.        <executions>
        8.            <execution>
        9.                <id>create-fat-jar</id>
        10.                <phase>package</phase>
        11.                <goals>
        12.                    <goal>shade</goal>
        13.                </goals>
        14.                <configuration>
        15.                    <transformers>
        16.                        <!-- add Main-Class to manifest file -->
        17.                        <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
        18.                            <!-- Substituir pelo caminho e nome da classe Main -->
        19.                            <mainClass>br.edu.ifpb.cli.MainCLI</mainClass>
        20.                        </transformer>
        21.                    </transformers>
        22.                    <!-- Nome desejado para o .jar final principal -->
        23.                    <finalName>CLI</finalName>
        24.                </configuration>
        25.            </execution>
        26.        </executions>
        27.    </plugin>
        28. </plugins>
        29. </build>
  9. Para compilar e gerar os pacotes, seguir o mesmo processo de um projeto comum.
  10. Para executar o projeto, gerar o .jar do main seguindo o passo 8.2 e executá-lo usando o comando java -jar.

Criando Bateria de Testes com intelliJ

  1. Criar os métodos vazios apenas definindo os parâmetros
  2. Criar a bateria de testes no “AppTest” (renomear) (localizado na pasta test) de determinado método:
    • Code -> Generate… -> Test…

      ou
    • Botão direito -> Generate… -> Test…
  3. Ir rodando testes primeiro, alterando e modificando os métodos depois.

Exemplo de Hello World

  1. public class HelloWorld {
  3.     public static void main(String[] args) {
  4.         String mensagem1 = new HelloWorld().retornaMsg1();
  5.         String mensagem2 = new HelloWorld().retornaMsg2();
  6.         System.out.println(mensagem1 + mensagem2 + "=)");
  7.     }
  9.     public String retornaMsg1() {
  10.         return "Hello, ";
  11.     }
  13.     public String retornaMsg2() {
  14.         return "Gui! ";
  15.     }
  17. }

Saída:

> Hello, Gui! =)

Programando em Kotlin

Ver repositório principal de Kotlin!

Programando em Python 3

Ver repositório principal de Python 3!

Autor

Licença

Distributed under the MIT License. See LICENSE for more information.

Questão 5 Respostas_1648890803273.pdf
lista01 - Praticando a Sintaxe Java_1648890803706.pdf
pratica_01_1648890803780.pdf
pratica_02_1648890803884.pdf
pratica_03_1648890804127.pdf
pratica_04_1648890804475.pdf
pratica_05_1648890804585.pdf
pratica_06_1648890804671.pdf
pratica_07_1648890805235.pdf
pratica_08_1648890805289.pdf
pratica_09_1648890805354.pdf