Please enable JavaScript.

Coggle requires JavaScript to display documents.

Programação Orientada a Objetos com Java - Coggle Diagram

- - - - Elimina a repetição de trecho de código ao longo do programa principal
      - Delega a execução de uma ação para a classe responsável
  - - - Produto, Cliente, Triangulo
    - - ProdutoService, ClienteService, EmailService, StorageService
    - - ProdutoController, ClienteController
    - - Calculadora, Compactador
  - - - O membro é acessado por todas classes ( ao menos que ele resida em um módulo diferente que não exporte o pacote onde ele está)
    - - O membro só pode ser acessado na própria classe
    - - O membro só pode ser acessado nas classes do mesmo pacote, bem como em subclasses de pacotes diferentes
    - - O membro só pode ser acessado nas classes do mesmo pacote
  - - - Essa classe possui
        
        Atributos
        
        lados
        
        a
        
        b
        
        c
        
        Métodos
        
        area()
        
        perimetro()
      - A classe Triangulo é um tipo
    - - Atributos
        
        nome
        
        cpf
        
        email
        
        endereco
      - métodos
        
        comprarProduto()
        
        pagarFatura()
    - - Reaproveitamento de código
        
        elimina-se o código repetido no programa principal.
      - Delegação de responsabilidades
        
        quem deve ser responsável por saber como calcular a área de um triângulo é o próprio triângulo. A lógica do cálculo da área não deve estar em outro lugar.
        
        Princípio da Coesão
  - - - O comando usado para instanciar uma classe é "new"
    - - Durante a execução do programa, pode-se fazer a alocação dinâmica de memória usando o comando "new"
        
        No momento em que se faz "x = new Triangle()", um objeto é criado em outra área de memória chamada Heap
        
        Heap: área de memória aonde são criados os os objetos dinâmicos (durante a execução)
        
        A variável "x" guarda apenas a referência ao objeto que está no Heap - contém o endereço que aponta para o objeto
  - - - atributos da classe
    - - método da classe
    - - nome da classe
    - - Corpo do método
    - - pacote da classe
  - - - Nome da classe
      - Atributos da classe
      - Métodos da classe
  - - - equals - compara se o objeto é igual a outro
      - hashCode - retorna um código hash do objeto
      - toString - converte o objeto para string
      - getClass - retorna o tipo do objeto
  - - - Em oposição a membros e instância
    - - Não precisam de objeto para serem chamados.
        
        São chamados a partir do próprio nome da classe.
    - - Classes utilitárias
        
        Math.sqrt(double) - Math é o nome da classe
      - Declaração de constantes
        
        public static final double PI = 3.14159;
        
        Padrão de escrita de constantes
        
        letras maiúsculas
        
        se for composta por mais de uma palavra, usar underline entre elas (NET_SALARY).
        
        Não é possível chamar um método não estático dentro de um método estático (por exemplo, dentro do main(String[] args), se eles estiverem dentro da mesma classe; métodos não estáticos são acessados pela instância da classe).
    - - Para um método de instância, cada objeto tem o seu valor, calculado usando os atributos da própria classe (é preciso instanciar os objetos para usar seus membros).
        
        São chamadas a partir da variável de referência que guarda o endereço para o objeto
      - Já para um método estático, os resultados das chamadas do método não mudam quando os mesmos parâmetros são passados.
        
        Por exemplo, os cálculos não mudam para calculadoras diferentes (são cálculos estáticos).
        
        São chamadas a partir do nome da classe
- - - - Na chamada do método placeNewPiece, passa-se uma letra, um número e uma peça. Para a peça instanciada, passa-se uma referência à própria classe (CheesMatch); isso significa que o objeto King tem um atributo que guarda a referência ao objeto ChessMatch
- - - - Padrão JavaBeans
        
        Padrão de desenvolvimento que estabelece algumas regras básicas para construção dos objetos
        
        Exemplo
        
        Padrão para implementação de getters e setters
      - Nem todos os atributos terão métodos set (isso irá depender da regra do negócio), de forma a proteger o objeto de alterações inconsistentes
      - Comandos para gerar os métodos get e set automaticamente
        
        Botão direito -> Source -> Generate Getters and Setters
- - - - Quando instancia-se um objeto, o objeto é criado em uma área de memória chamada Heap (alocação dinâmica de memória - em tempo de execução)
        
        Esse espaço de memória contém os valores para os atributos do objeto criado
        
        Quando se fala em memória, refere-se à memória RAM
      - As variáveis declaradas são criadas em uma região da memória chamada Stack (alocação estática de memória)
        
        Quando o tipo da variável é uma classe, essa região no Stack guarda o endereço de memória do objeto (no Heap) quando o objeto é instanciado.
    - - Se uma variável recebe "null", ela é iniciada, mas não aponta para nada
  - - - Ao serem declaradas, caixas são criadas na área de memória chamada Stack e os valores atribuídos são guardados nessa caixa
    - - true or false
    - - Unicode character
    - - Inteiro
    - - inteiro
    - - inteiro
    - - inteiro
    - - ponto flutuante
    - - ponto flutuante
  - - - números: 0
      - boolean: false
      - char: caractere código 0 (Unicode character)
      - objeto: null
- - - - O garbage collector é um processo que serve para verificar o heap e desalocar os objetos que não são mais utilizados
  - - - Performático - no sentido que quando precisa-se carregar uma imagem, o uso de tipos primitivos proporciona economia de memória e maior eficiência
- - - - Homogênea (dados do mesmo tipo)
      - Ordenada (elementos acessados por meio de posições)
      - Alocada de uma vez só em um bloco contíguo de memória
  - - - Não é necessário percorrer todo array até a posição desejada
      - Acesso muito rápido
  - - - O tamanho é definido no momento da instanciação do array
    - - Por exemplo, ao remover o elemento da posição 1, todos os elementos a partir da posição 2 devem ser movidos para cobrir a posição vaga
      - Muito custoso (tempo)
  - - - Cada posição guarda o endereço de memória do objeto que foi instanciado
- - - - Isso é bom para fazer a equivalência entre as classes e o banco de dados
- - - - Para cada elemento do vetor faça
- - - - Homogênea (dados do mesmo tipo)
      - Inicia vazia, e seus elementos são alocados sob demanda
      - Cada elemento ocupa um "nó" (ou nodo) da lista
        
        O nodo armazena o valor e a referência para o nodo relacionado (seguinte)
      - Ordenada (elementos acessados por meio de posições)
  - - - ArrayList, LinkedList, etc.
  - - - Deve-se navegar em todos nodos até chegar na posição desejada
      - Dependendo do tipo de implementação da lista, a navegação pode ser otimizada
        
        O ArrayList é uma implementação otimizada de List (mistura de um vetor e lista)
  - - - size()
    - - indexOf(obj), lastIndexOf(obj)
        
        Quando o indexOf não encontra o elemento ele retorna "-1"
    - - remove(obj), remove(int), removeIf(Predicate)
        
        Predicate - função lâmbida que retorna V ou F
        
        removeIf(x -> x.charAt(0) == 'M');
    - - List<Integer> result = list.stream().filter(x -> x > 4).collect(Collectors.toList());
    - - add(obj)
      - add(int, obj) - inserção em posição específica
    - - Integer result = list.stream().filter(x -> x > 4).findFirst().orElse(null);
    - - get(position)
  - - - Não aceitas tipos primitivos
      - <Tipo> - generics
        permite parametrizar a definição de um tipo informando um tipo específico desejado
  - - - ArrayList é uma das classes que implementa a interface List
      - A especificação do tipo se tornou opcional nas últimas versões do Java
- - - - Em algumas situações, não funciona como em vetores: não é preciso deslocar os elementos para preencher os vazios causados por remoções
  - - - Matriz de ordem n
- - - - Pode-se especificar um número inteiro para cada enumerado
- - - - Views
        
        Telas do sistema
      - Services
        
        Representam funcionalidades do sistema
      - Entities
        
        Entidades de negócio: Product, Customer, Order, etc.
      - Repositories
        
        Objetos responsáveis por acessar os dados: banco dados, etc.
      - Controllers
        
        Faz o link entre a tela e o sistema
  - - - Coesão
        
        Cada objeto é responsável por uma coisa: tem uma responsabilidade simples e bem definida
      - Organização: divisão de responsabilidades
        
        Cada classe tem sua responsabilidade
      - Flexibilidade
        
        Trabalhar com alguma coisa que está bem dividida em partes é mais flexível que trabalhar com algo muito grande ou mal dividida
      - Reuso
        
        Pode ser reaproveitado em mais de um lugar
    - - O lado ligado ao diamante é o todo
        O lado sem o diamante é a parte
        
        Exemplo: um pedido (todo) tem vários itens (partes)
    - - "tem-um"
      - "tem-vários"
        
        A classe que contém os vários itens terá um atributo do tipo List
        
        A lista não é incluída no construtor
        
        Apenas inicia-se a lista na declaração de atributos da classe
        
        A inserção e remoção de elementos da lista é realizada por métodos da classe
        
        O método set não deve ser implementado para a lista: não se pode substituir a lista existente por outra
    - - Exemplo
        
        Associação do Worker com o Department
        
        Associação do Worker com os contratos por hora (HourContract)
- - - - Account é a superclasse e BusinessAccount é a subclasse
    - - A classe BusinessAccount estende a class Account, acrescenta novas característcas e métodos
    - - A classe Account é o tipo mais genérico, e a classe BusinessAccount é uma classe específica
    - - Quando uma subclasse é instanciada apenas um objeto é criado com todos os membros herdados e próprios
    - - Exemplo: uma conta empresarial (BusinessAccount) é uma conta (Account), porém com algo mais (especificidades)
  - - - Herança permite o reuso de atributos e métodos (dados e comportamentos)
  - - - Herança
  - - - O comando super(parâmetros) pode ser usado dentro do construtor da subclasse para invocar o construtor da superclasse de forma que os atributos da superclasse seja inicializados com os argumentos transmitidos.
        
        Isso evita repetição de comandos, já que a lógica de atribuição já está implementada na superclasse
  - - - Casting da subclasse para superclasse
        
        (converter um objeto da subclasse para um objeto da superclasse)
      - Uso comum: polimorfismo
      - Exemplo: como uma conta empresarial é uma conta, pode-se atribuir um objeto do tipo BusinessAccount a uma variável do tipo Account.
        
        Não há necessidade de casting explícito
    - - Casting da superclasse para subclasse
        
        (converter um objeto da superclasse para um objeto da subclasse)
      - Palavra instanceof
        
        Usado para saber se uma variável de um tipo é uma instância de outra classe
      - Uso comum: métodos que recebem parâmetros genéricos (ex: equals)
      - Exemplo: como uma conta empresarial é uma conta, mas uma conta não é uma conta empresarial, não pode-se atribuir um objeto do tipo Account a uma variável do tipo BusinessAccount.
        
        Pode-se forçar a conversão através do casting (o casting tem o tipo da variável da subclasse)
        
        Ao fazer o downcasting, pode ocorrer um erro em tempo de execução (o compilador não identifica o erro) - essa situação pode ser evitada pelo programador
  - - - Usar para definir um comportamento específico da subclasse
    - - Facilita a leitura e compreensão do código (o programador irá saber que o método é sobrescrito)
      - Avisamos ao compilador (boa prática) - o compilador é capaz de verificar se a assinatura do método está correta
    - - É possível chamar a implementação da superclasse usando a palavra super.
      - Exemplo: suponha que, na classe BusinessAccount, a regra para saque seja realizar o saque normal ente da superclasse, e descontar mais 2.0.
        
        Override
        public void withdraw(double amount) {
        
        super.withdraw(amount);
        
        balance -= 2.0;
        }
      - Reutilização do código que já foi implementado na superclasse
  - - - Exemplo: public final class SavingsAccount {
    - - Segurança: dependendo das regras do negócio, às vezes é desejável garantir que uma classe não seja herdada, ou que um método não seja sobreposto.
        
        Geralmente convém acrescentar final em métodos sobrepostos, pois sobreposições múltiplas podem ser uma porta de entrada para inconsistências
      - Performance: atributos de tipo de uma classe final são analisados de forma mais rápida em tempo de execução.
        
        Exemplo clássico: String
        
        Se uma classe for "final" a operação do tipo reflection - desserialização de um dado no formato JSON para o objeto em memória - é realizada de forma mais rápida
  - - - Recurso que permite que variáveis de um mesmo tipo mais genérico possam apontar para objetos de tipos específicos diferentes, tendo assim comportamentos diferentes conforme cada tipo específico.
      - Exemplo
        
        Account x = new Account(1020, "Alex", 1000.0);
        Account y = new SavingsAccount(1023, "Maria", 1000.0, 0.01);
        x.withdraw(50.0);
        y.withdraw(50.0);
        
        A chamada de método x.withdraw irá executar o método do objeto Account;
        A chamada do método y.withdraw irá executar o método do objeto SavingsAccount
      - O conceito é simples. O desafio está na aplicação desse recurso
        
        Soluções sofisticadas, elegantes e flexíveis utilizando esse recurso
      - Variáveis do mesmo tipo se comportando de formas diferentes, conforme os objetos para os quais ela aponta
        
        Objetos de tipos diferentes na memória, mas variáveis do mesmo tipo
      - Importante entender
        
        A associação do tipo específico com o tipo genérico é realizada em tempo de execução (é feito um upcasting)
        
        O compilador não sabe para qual tipo específico a chamada do método será feita (ele só sabe qual é o tipo da variável)
        
        O método adequado é processado em tempo de execução com base no objeto instanciado
  - - - Suponha que em um negócio relacionado a banco, apenas contas poupança e contas para empresas são permitidas. Não existe conta comum.
        
        Para garantir que contas comuns não possam ser instanciadas, basta acrescentarmos a palavra "abstract" na declaração da classe.
        
        public abstract class Account {
        (...)
    - - Se a superclasse (classe Account) não pode ser instanciada, por que simplesmente não criar somente as subclasses (SavingsAccount e BusinessAccount)?
        
        Resposta
        
        Reuso: se a superclasse não existisse, teria-se que repetir todos os atributos em todas as subclasses
        
        Polimorfismo: a superclasse classe genérica nos permite tratar de forma fácil e uniforme todos os tipos de conta, inclusive com polimorfismo se for o caso (como fizemos nos últimos exercícios). Por exemplo, você pode colocar todos tipos de contas em uma mesma coleção.
        
        Operações do tipo: totalizar o saldo de todas as contas e depositar 10,00 em todas as contas ficam mais fácil de implementar usando uma classe genérica
  - - - Por exemplo, as classes Rectangle e Circle são subclasses da classe Shape. A classe Shape é muito genérica para conter implementação de métodos (o método area() não pode ser implementado em Shape, pois a forma não é definida em Shape)
        
        Questionamento:
        
        Por que não tirar o método area() da classe Shape, e implementá-los apenas nas subclasses?
        
        Sem o método area() em Shape, não é possível usar o recurso do Polimorfismo
    - - public abstract double area();
    - - Durante a execução, é realizado o upcasting
- - - - Error
        
        OutOfMemoryError
        
        Estourou a memória
        
        O programa não deve tratar esse tipo de erro pois a memória estourou e nada poderá ser feito (o programa encerrará naturalmente)
        
        VirtualMachineError
        
        Erros que não se espera que o programador irá tratar (erros inesperados)
      - Exception
        
        IOException
        
        Erros de entrada e saída de dados disparam esse tipo de exceção
        
        RuntimeException
        
        IndexOutOfBoundsException
        
        Essa exceção ocorre quando o compilador tenta acessar uma posição do array que não existe.
        
        NullPointerException
        
        Quando tenta-se acessar uma variável que é definida como nula (null)
        
        Especifica exceções que não tem obrigatoriedade de tratamento (o compilador não obriga o programador a tratar)
        
        Erros que ocorrem na execução do programa que se espera que o programa irá tratá-los (são erros tratáveis)
      - Classe mais genérica que engloba todas as classes de exceções e erros
  - - - Trata de forma organizada (inclusive hierárquica) exceções de tipos diferentes
        
        Uma operação pode gerar vários tipos de exceções; cada exceção tem determinado tipo (classe); pode-se, então, ordenar como as exceções serão tratadas a partir do tipo de cada exceção
      - A exceção pode carregar dados quaisquer
        
        Como a exceção é uma classe, ela pode ter atributos
      - Delega a lógica do erro para a classe responsável por conhecer as regras que podem ocasionar o erro
        
        Exemplo: digamos que um saque só possa ser realizado se houver saldo na conta e se a quantidade sacada for menor que um limite de saque. A lógica de testar essas condições e gerar um erro caso elas não sejam satisfeitas não deve estar no programa principal, mas sim na classe Conta. A própria conta que deve conhecer as regras de validação das operações dela.
  - - - Contém o código que representa a execução normal do trecho de código que pode acarretar em uma exceção
    - - Contém o código a ser executado caso uma exceção ocorra
      - Deve ser especificado o tipo da exceção a ser tratada (upcasting é permitido)
        
        Upcasting (pode-se utilizar uma exceção mais genérica que captura qualquer tipo de exceção que é sua subclasse)
      - Podem existir tantos blocos catch quanto necessário
      - Captura a exceção, quando ela é lançada, e efetua uma alguma lógica
  - - - No topo da pilha está o método no qual a exceção foi lançada; na base da pilha está o primeiro método
      - O método printStackTrace() imprime a pilha de chamadas de métodos da exceção capturada pelo bloco catch (o método é invocado pela variável declarada no bloco catch)
    - - O rastreamento da pilha ajuda a identificar o que está acontecendo e qual a causa da exceção
  - - - Padrão MVC
        
        Interface com o usuário
        
        Model
        
        Além do pacote das entidades e suas regras de negócio (transformações entre elas), inclui um pacote com tipos enumerados, um pacote de exceções e um pacote de ser serviços
        
        (representa os dados do sistema e as transformações desses dados conforme as regras de negócio - é o sistema em si)
    - - Por exemplo, pode-se criar uma exceção DomainExceptions que representa um erro na entidade de domínio do sistema.
    - - DomainException
    - - Para ser serializable define-se um padrão de versão
  - - - Propaga-se a exceção na assinatura do método
    - - Sendo assim , não é necessário colocar a declaração throws na assinatura do método
      - Mesmo sendo uma RuntimeException, deve-se capturar a exceção de forma que o programa não "quebre"
    - - A declaração "throws typeException" é colocada após a assinatura do método para avisar ao compilador que o método pode lançar a exceção epecificada e o que ele não a trata, ou seja, ele propaga a exceção
    - - Lógica delegada
      - Construtores podem ter tratamento de exceções
      - É possível capturar inclusive outras exceções de sistema
      - Possibilidade de auxílio do compilador (Exception)
      - Código mais simples. Não há aninhamento de condicionais
        
        a qualquer momento que uma exceção for disparada, a execução é interrompida e cai no bloco catch correspondente.