Programação de Soluções Computacionais

Seite 1

Recados- Calendário e Critérios

Encontro ao vivo com Docente

Encontros / Datas

Encontro - Plenária - 16/03/24 - 09h às 11:50h

Encontro - Conecta - 23/03/24 - 09h às 11:50h

Encontro - Talk - 06/04/24 - 09h às 11:50h

Avaliação

Duração do Bloco: 19/02 até 27/04

A1: 11/03 até 01/04

Solicitação para recursos A1: 05/04 até 08/04

Solicitação para 2° oportunidade A1: 05/04 até 08/04

A2: 02/04 até 07/04

Solicitação para recursos A2: 05/04 até 09/04

Solicitação para 2° oportunidade A2: 05/04 até 09/04

A3: 13/03 até 12/04

Aplicação de 2° oportunidade A1: 12/04 até 15/04

Aplicação de 2° oportunidade A2: 16/04 até 18/04

Avaliação Integrada (AI): 24/04 até 25/04

Seite 2

E SE O USUÁRIO QUISER ESCOLHER OU REPETIR AÇÕES

Resumo do conteúdo

Diferenciar estruturas de seleção e suas possibilidades de aplicação;

Compreender as possibilidades de uso de estruturas de repetição para resolução de problemas;

Combinar diferentes tipos de estruturas de controle para implementar algoritmos otimizados e com adequada estruturação

Algoritmos sequenciais

Esses blocos contêm três elementos: entrada, processamento e saída

Operadores aritméticos

+ - * / %

Operadores racionais

> que representa maior que.

< que representa menor que.

>= que representa maior ou igual.

<= que representa menor ou igual.

== que representa igual.

!= que representa diferente.

=== que representa estritamente igual.

!== que representa estritamente diferente.

Operadores lógicos

AND

NAND

OR

XOR

NOT

Seite 3

Uma coisa de cada vez e cada coisa no seu lugar

Introdução

Compreender as formas de estruturar soluções computacionais a partir de procedimentos e funções;

Estruturar procedimentos e funções utilizando parâmetros de diferentes tipos;

Desenvolver blocos de códigos com entrada dados, através de parâmetros, e retorno de dados, através do comando return.

Método main, tipo de retorno, lista de parâmetros

Essencialmente, um programa de computador é uma sequência de instruções. Cabe ao desenvolvedor especificar qual delas é a primeira, ou seja, onde o programa começa. Em Java, isso é feito especificando-se um método chamado main, veja.

public class ExemploMetodoMain {

public static void main(String[ ] args) {

System.out.println('Método main executando...');

}

}

Chamada do método

public class HelloWorldMetodos {

static void olaMetodos (){

System.out.println ('Sou um novo método!');

}

public static void main(String[] args) {

System.out.println ('Começando a execução do programa.');

olaMetodos();

System.out.println ('Terminando a execução do programa.');

}}

Método soma

import javax.swing.JOptionPane;

public class ListaDeParametros {

public static void main(String[] args) {

int x = 2, y = 3; soma(x, y); }

public static void soma(int a, int b) {

int resultado = a + b; JOptionPane.showMessageDialog(null, resultado); }

}

Tipo de retorno

public class TipoDeRetorno {

public static void main(String[] args) {

int x = 2, y = 3, w = 4, z = 5; int resultado1 = soma(x, y); int resultado2 = soma(w, z); System.out.println(resultado1); System.out.println(resultado2); }

static int soma(int a, int b) {

int resultado = a + b; return resultado;

}}

Seite 4

ORGANIZANDO E PROTEGENDO O CÓDIGO

Organizando e protegendo o código

Atributos e métodos;

Membros de instância e de classe modificadores this e static;

Alta coesão e baixo acoplamento;

Encapsulamento;

Modificadores de acesso;

Métodos de acesso e modificadores;

Construtores.

Resumo do conteúdo

Diferenciar tipos de métodos e aplicabilidade através de diferentes níveis de acesso;

Constituir classes e objetos que utilizem construtores em sua estrutura;

Implementar soluções com encapsulamento bem aplicado.

Classes e objetos

classe = descrição

Para desenvolver um programa de computador em alguma linguagem orientada a objetos, é necessário criar um modelo que descreve as partes de interesse do mundo real. Essa descrição dá origem ao que alguns autores chamam de minimundo

Atributos

Cada classe descreve as características (atributos) de seus objetos, que por sua vez definem seu estado.

Veja alguns exemplos:

Um carro possui cor, ano de fabricação, modelo, fabricante, número de portas, informações sobre seus acessórios etc.

Uma casa possui cor, número de cômodos, medida de cada cômodo, número de andares, valor venal, tipo de telhado etc.

Uma pessoa tem cor de olhos, cor de pele, altura, peso, número que calça, sexo, idade etc.

Variáveis de instância e variáveis de classe

Quando criamos uma classe, definimos suas características por meio de seus atributos, também chamados variáveis de instância. Como o próprio nome revela, cada objeto pode ter um valor diferente para cada um desses atributos.

Em determinados modelos, pode ser interessante definir alguma característica comum a todas as instâncias daquela classe, isso significa que ao mudar o valor dessa característica em um objeto membro automaticamente muda o valor para todos os objetos membros da classe. Nesse caso, temos uma variável de classe. Para declarar uma variável de classe, acrescenta-se a palavra-chave static.

Métodos

As classes também descrevem os comportamentos de seus objetos que são implementados por métodos. Os exemplos a seguir podem deixar o conceito mais claro.

Princípios da alta coesão e baixo acoplamento

alta coesão : O princípio conhecido como alta coesão define que uma classe tenha propósito único, uma única razão de ser, que resolva um único problema.

baixo acoplamento : Já baixo acoplamento indica que duas classes que interagem entre si devem saber poucos detalhes de implementação uma da outra, o que quer dizer que, se uma tiver sua implementação alterada, a outra pode continuar funcionando sem precisar ser alterada também.

Encapsulamento e modificadores de acesso

Na programação orientada a objetos, o encapsulamento refere-se ao agrupamento dos atributos com os métodos que operam sobre eles, ou seja, à restrição de acesso direto aos elementos da classe. Isso mantém os dados e o código protegidos contra interferências externas. O encapsulamento é implementado utilizando-se os modificadores de acesso tanto para atributos quanto para métodos. Normalmente as variáveis de instância são marcadas com o modificador de acesso private. Ele indica que aquela variável somente pode ser acessada pelos métodos da classe em que foi declarada

*clientes manipulem indiretamente suas variáveis de instância, uma classe pode oferecer métodos de acesso e métodos modificadores.*

Construtores

Quando inicializamos um objeto, dizemos que estamos construindo esses objeto da classe envolvida na instrução. Isso é feito por um bloco denominado construtor.

Podemos utilizar um construtorpadrãoda classe, que o compilador nos entrega gratuitamente. Esse construtor zera todas as variáveis da classe, seja qual for seu tipo:

0 para valores numéricos;

false para boolenas;

null para referências.

Seite 5

REUTILIZANDO CÓDIGO E DELEGANDO TAREFAS

Introdução

Compreender aplicações e formas de utilização de herança de classes;

Implementar classes como relação tem-um (composição);

Diferenciar o uso de heranças e interfaces;

Utilizar recursos de polimorfismo na estruturação de soluções computacionais.

Relacionamento É-um (herança)

Considere o sistema acadêmico da sua instituição de ensino. Ele possui diversas características que retratam o "minimundo" que foi definido para a sua elaboração. Professores ministram disciplinas e lançam notas e faltas. Estudantes cursam disciplinas que pertencem a cursos e são matriculados em turmas.

Professores, cursos, alunos, disciplinas, turmas etc. são "coisas" do mundo real de interesse para a implementação deste sistema. A implementação das classes que representam professores e alunos pode ser feita da seguinte forma:\

class Professor {

private int matricula; private String nome; private String endereco; private int idade;

}

class Aluno {

private int ra; private String nome; private String endereco; private int idade;

}

Embora a implementação esteja correta, note que há repetição de código: as classes possuem atributos iguais e eles foram escritos duas vezes. Para enxergar a razão pela qual isso é muito ruim, considere a seguinte nova necessidade: todas as pessoas do sistema devem ter registrados o seu sexo, RG e CPF. Além disso, o nome deve ser, a partir de agora, armazenado em duas variáveis: uma para o primeiro nome e outra para o sobrenome. Veja:

class Professor {

private int matricula;

private String primeiro =Nome;

private String sobrenome;

private String endereco;

private int idade;

private String rg;

private String cpf;

private char sexo;

}

class Aluno {

private int ra;

private String primeiroNome;

private String sobrenome;

private String endereco;

private int idade;

private String rg;

private String cpf;

private char sexo;

}

No cenário descrito, podemos dizer que professores e alunos têm diversas coisas em comum, pois ambos são pessoas. O que eles têm em comum todas as pessoas têm. Assim, escrevemos uma classe para abrigar as características em comum e fazemos a herança acontecer. Note que extends é a palavra-chave utilizada na linguagem Java para representar a herança. Veja:

class Pessoa {

private String primeiroNome;

private String sobrenome;

private String endereco;

private int idade;

private String rg;

private String cpf;

private char sexo;

}

class Professor extends Pessoa{

private int matricula;

}

class Aluno extends Pessoa {

private int ra;

}

Relacionamento tem-um (composição)

Outro tipo de relacionamento entre classes chama-se "TEM-UM". O nome "composição" também é bastante comum para ele. Como de costume, seu uso e aplicações baseiam-se em observações no mundo real: observamos "coisas" que naturalmente têm um relacionamento desse tipo e fazemos a implementação por meio da especificação de variáveis de instância. Veja alguns exemplos a seguir. Usamos a expressão "TEM-UM" como um termo técnico mesmo.

Como mencionado, a implementação do relacionamento TEM-UM é feita por meio da especificação de variáveis de instância. Veja os exemplos a seguir:

class Motor{ }

class Veiculo{ //Veiculo TEM-UM Motor private Motor motor;

}

class Emprego{ }

class Pessoa {

//Pessoa TEM-UM Emprego private Emprego emprego;

}

Em um exemplo mais elaborado, considere uma instituição de ensino que possui diversos professores e diversas disciplinas que precisam ser ministradas por eles. Uma atribuição é uma "coisa" do mundo real que envolve um professor e a disciplina a que ele pode ser vinculado. Um professor pode estar associado a diversas disciplinas. Uma disciplina, por sua vez, pode estar associada a diversos professores. Temos, assim, uma lista de atribuições. Veja o exemplo a seguir.

class Professor {

private String nome;

private String titulacao;

public Professor (String nome, String titulacao)

{

this.nome = nome; this.titulacao = titulacao; }}

class Disciplina {

private String nome; private String descricao; public Disciplina (String nome, String descricao) {

this.nome = nome; this.descricao = descricao; }}

class Atribuicao {

//Atribuição TEM-UM Professor private Professor professor; //Atribuição TEM-UM Disciplina private Disciplina disciplina; public Atribuicao (Professor professor, Disciplina disciplina) {

this.professor = professor; this.disciplina = disciplina; }}

class Universidade {

//Universidade TEM-UM lista de atribuições private List atribuicoes = new ArrayList <> (); public void adicionarAtribuicao (Atribuicao atribuicao) { this.atribuicoes.add(atribuicao); }}

public class TesteAtribuicao {

public static void main (String... args) { Universidade universidade = new Universidade(); Professor p1 = new Professor ('José', 'Doutor'); Professor p2 = new Professor ('Maria', 'Doutora'); Disciplina d1 = new Disciplina ('Matemática', 'Matemática Elementar'); Disciplina d2 = new Disciplina ('Compiladores', 'Construção de compiladores'); universidade.adicionarAtribuicao(new Atribuicao (p1, d1)); universidade.adicionarAtribuicao(new Atribuicao (p2, d1)); universidade.adicionarAtribuicao(new Atribuicao (p2, d2)); }}

Voltando ao desenvolvimento de software, teríamos, neste exemplo, uma classe chamada Pessoa e algumas classes para representar veículos diferentes. Dizemos que há um contrato entre Pessoa e tudo aquilo que for um Veículo: Esse contrato estabelece a existência do método acelerar. Para acelerar seu veículo, uma pessoa somente chama esse método, sem saber dos detalhes de implementação da classe que o implementa. Estamos falando do recurso conhecido como interface. Uma interface é um contrato entre classes cujo principal objetivo é promover o baixo acoplamento para as suas interações. Veja o exemplo a seguir:

interface Veiculo{ public void acelerar();

}

class Fusca implements Veiculo{ @Override public void acelerar() {

System.out.println('Fusquinha acelerandooo....'); }}

class Ferrari implements Veiculo{ @Override public void acelerar() {

System.out.println('Ferrraariiii aceleraaaaandooooooo....'); }}

class Pessoa {

private Veiculo veiculo; public void dirigir () {

//dar partida //soltar o freio de mão veiculo.acelerar(); } public void setVeiculo(Veiculo veiculo) { this.veiculo = veiculo; }}

public class Contrato {

public static void main(String[] args) {

Pessoa p = new Pessoa (); p.setVeiculo(new Fusca()); p.dirigir(); p.setVeiculo(new Ferrari()); p.dirigir(); }}

Polimorfismo

- A sobrecarga de métodos é um tipo de polimorfismo, pois, do ponto de vista do código-cliente, um mesmo método pode ser chamado de formas diferentes, embora saibamos que, na verdade, tratam-se de vários métodos com nome igual. Esse tipo de polimorfismo é, geralmente, chamado de polimorfismo estático. Estático no sentido de ser realizado pelo compilador.

Quando se fala somente de polimorfismo, é comum que se esteja referindo ao polimorfismo dinâmico. Esse é o assunto desta seção.

A fim de ilustrar o polimorfismo, precisamos de uma hierarquia de classes, como essa:

public class Animal {

public void fazerBarulho () {

System.out.println('Animal fazendo barulho'); }}

public class Gato extends Animal{

}

public class Cachorro extends Animal{

}

Note que, devido à herança, ambas as classes Gato e Cachorro têm acesso ao método "fazerBarulho". Veja o exemplo a seguir:

public class TesteSemVariaveisPolimorficas {

public static void main(String[] args) {

Gato gato = new Gato (); Cachorro cachorro = new Cachorro (); gato.fazerBarulho(); cachorro.fazerBarulho(); }}

No exemplo a seguir, as duas variáveis de referência utilizadas são polimórficas. Note que elas são capazes de fazer referência a qualquer subtipo de Animal.

public class TesteComPolimorfismo {

public static void main(String[] args) {

Animal a1 = new Gato(); Animal a2 = new Cachorro(); a1.fazerBarulho(); a2.fazerBarulho();

}

}

A seguir, precisamos entender que métodos herdados podem ter seu comportamento personalizado pelas classes que os herdam. Neste exemplo, é de interesse que cada subtipo de Animal faça a implementação do método fazerBarulho de acordo com o tipo que representa. Gatos e Cachorros miam e latem, por exemplo. Veja a nova definição delas:

public class Gato extends Animal{ public void fazerBarulho() {

System.out.println('miau'); }}public class Cachorro extends Animal{ public void fazerBarulho() {

System.out.println('au au'); }}

Assim, podemos ter uma coleção de animais na qual cabem animais de quaisquer tipos. Quando iterarmos sobre ela, podemos chamar o método fazerBarulho sem saber, de fato, qual método será chamado. Em tempo de execução, em função do tipo do objeto (e não da variável de referência) a JVM decide qual colocar em execução. Note que esse mecanismo substitui uma estrutura de seleção que o programador poderia ter de manter. Veja o exemplo a seguir:

import java.util.ArrayList;

import java.util.List;

class Animal{ public void fazerBarulho () {

System.out.println('Animal fazendo barulho'); }}

class Gato extends Animal{ public void fazerBarulho() {

System.out.println('miau'); }}class Cachorro extends Animal{ public void fazerBarulho() {

System.out.println('au au'); }}

public class Polimorfismo {

public static void main(String[] args) {

List animais = new ArrayList<>(); animais.add(new Gato()); animais.add(new Gato()); animais.add(new Cachorro()); for (Animal animal : animais) //polimorfismo dinâmico aqui //em tempo de execução, a JVM decide qual //método chamar em função do tipo do objeto animal.fazerBarulho(); }

}

Seite 6

BOAS FERRAMENTAS TRAZEM EFICIÊNCIA

Vetores (Arrays)

Um dos primeiros problemas que surgem, quando estamos programando, é a necessidade de processar listas de valores. Se a lista for pequena o bastante, você declara algumas variáveis e resolve como temos feito até agora. Mas, e se a lista for muito grande? Como fazer?

Vetores (ou arrays) são usados para armazenar vários valores em uma única variável, ao invés de declarar variáveis separadas para cada valor. É a forma mais simples de organizar listas de dados na memória, pois são armazenados em sequência, um após o outro, o que permite que qualquer valor de qualquer posição seja acessado livremente.

Métodos fundamentais de ordenação

Alguns algoritmos utilizam técnicas bem simples, como condições e laços. Outros exigem técnicas mais elaboradas. Vamos estudar agora alguns fundamentos dos algoritmos chamados elementares.

Ordenação por Inserção - Insertion Sort

Ordenação por Seleção - Selection Sort

Ordenção pelo Método da Bolha - Bubble Sort

Ordenação por Inserção (vetor v, inteiro n)

para j de 1 até n-1

x = v[j]

i = j−1

enquanto i ≥ 0 e v[i] > x

v[i+1] = v[i]

i = i−1

v[i+1] = x

Nem tudo é vetor, quase tudo

Vimos que os vetores são estruturas muito eficientes, pois alocam-se em espaços contíguos de memória. Isso permite acessar qualquer posição a partir do seu endereço inicial, ou seja, podemos fazer acesso randômico aos seus elementos.

No entanto, vetores não são flexíveis quanto à definição do seu tamanho. Na maioria das vezes, ele é dimensionado para suportar o número máximo previsível de elementos para a resolução de um problema.

Vetores dinâmicos amenizam esse problema, pois realocam novos espaços de memória.

Tipos abstratos:

Um tipo abstrato de dados (TAD) trata-se de um conjunto de dados estruturados e um conjunto de operações que podem ser executadas sobre esses dados.

Alguns tipos são muito utilizados em computação: pilha e fila. Nesses tipos, a inserção e a retirada de elementos seguem regras bem definidas. A pilha segue LIFO (last in, first out): o último elemento a ser inserido é o primeiro disponível para remoção. Já a fila segue FIFO (first in, first out): o primeiro que é inserido deve ser o primeiro que é removido.

Seite 7

NÃO QUEREMOS PERDER NADA, TUDO DEVE FICAR ARMAZENADO! (DL)

Introdução

Diferenciar as operações CRUD para armazenamento de dados permanentes;

Utilizar sistemas gerenciadores de bancos de dados para desenvolvimento de sistemas;

Projetar modelos de dados relacionais no contexto de programação de soluções computacionais;

Analisar arquiteturas cliente e servidor para direcionar a implementação de sistemas;

Implementar soluções que utilizem linguagem SQL.

Operações CRUD (Create, read, update e delete) e Sistemas gerenciadores de bancos de dados (SGBD)

O armazenamento de dados em arquivos comuns (como simples arquivos .txt) no sistema de arquivos (na sua pasta Documentos, por exemplo) é muito utilizado por diversas aplicações. Porém, seu uso é trabalhoso, e as principais operações desejadas já possuem implementações eficientes e convenientes que podem ser simplesmente reutilizadas.

O modelo de dados relacional

Um dos modelos de dados mais utilizados nos dias de hoje para bases de dados é o modelo relacional. A palavra relacional vem de relação, que é sinônimo de tabela, ou seja, todos os dados que o sistema gerenciador de bancos de dados manipula são representados como tabelas. Estas possuem colunas, cada qual com o seu nome. Veja um exemplo na Figura 2. Trata-se de uma tabela capaz de armazenar dados de pessoas. Neste minimundo, pessoas têm nome, telefone e e-mail.

A linguagem SQL

Para lidar com as tabelas do modelo relacional, utilizamos uma linguagem chamada SQL. Mais precisamente, SQL é simplesmente um padrão que é implementado por diversos fabricantes de SGBDs. Por exemplo, a Microsoft possui a sua versão de SQL que é denominada Transact SQL. A Oracle, por sua vez, possui a sua versão de SQL, que é denominada PL/SQL. E assim por diante.

Seite 8

UM TRATO NO LOOK DO SOFTWARE

Introdução

Conhecer bibliotecas para implementação de interfaces gráficas em soluções computacionais;

Diferenciar os tipos de tratamentos de eventos;

Avaliar a necessidade da utilização de padrões de projeto como o MVC.

Hello, world!

O pacote javax.swing e seus subpacotes possuem classes úteis para a criação de interfaces gráficas para o usuário (GUI: Graphical User Interface). A criação de uma interface gráfica (uma tela) envolve o uso da classe JFrame, que faz parte dele. A palavra frame significa moldura. A ideia é construirmos uma moldura e, então, adicionarmos conteúdo a ela, como botões, campos textuais, tabelas, menus etc. Um JFrame possui um painel de conteúdo (do inglês content pane). Trata-se de um objeto capaz de armazenar outros objetos. Não adicionamos conteúdo diretamente a um JFrame. Uma vez que tenhamos um JFrame em mãos, obtemos uma referência ao seu painel de conteúdo e adicionamos conteúdo a ele.

Nome da classe:

Finalidade

JLabel - Exibir texto não editável pelo usuário.

JTextField - Exibir uma caixa textual onde o usuário possa inserir conteúdo.

JButton -Exibir um botão.

public class HelloSwingTela{

public static void criarTela() {

JFrame tela = new JFrame ('Hello, Swing!!!');

tela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//constroi um JLabel

JLabel helloSwingLabel = new JLabel ('Hello, Swing!!!!!!!');

//obtem o painel de conteúdo

Container painelDeConteudo = tela.getContentPane();

//adiciona o JLabel ao painel de conteúdo

painelDeConteudo.add(helloSwingLabel);

//ajusta largura e altura da tela conforme seu conteúdo

tela.pack();

//torna a tela visível

tela.setVisible(true);

}

public static void main(String[] args) {

SwingUtilities.invokeLater(() -> {

criarTela();

});

}

}

Tratamento de eventos

Quando o usuário interage com um componente visual dizemos que um evento acontece. Um clique no botão, um caractere digitado em um campo textual, uma opção selecionada em um menu são todos exemplos de eventos. O framework Swing utiliza o padrão de projeto chamado Observer para fazer o tratamento de eventos. O tratamento de um evento consiste em especificar uma ação que deve ser realizada quando ele ocorrer. Por exemplo, quando um professor que utiliza um sistema acadêmico clica um botão para salvar as notas que acabou de digitar, a ação a ser realizada é o armazenamento delas no banco de dados do sistema.

O padrão de projeto Observer consiste essencialmente em duas partes: um objeto Observable e um objeto Observer. O primeiro é quem dá origem aos eventos. No exemplo do sistema acadêmico, o botão que o professor usa para enviar as notas é um Observable. Cabe ao desenvolvedor do sistema especificar um objeto que desempenhará o papel de Observer. Ele é notificado toda vez que o evento acontece (o botão é clicado, nesse caso) e executa um método previamente definido.