Programando em Java - parte 11

Encapsulamento

Encapsulamento é uma técnica usada no paradigma Orientado a Objetos afim de centralizar e facilitar a busca de eventuais erros contidos no código. 

Exemplo:

public class Gato {     String raca; }

No exemplo acima, o atributo raça pode ser acessado e modificado em qualquer classe que esteja no projeto em que a classe Gato foi criada. Quando isso ocorre dizemos que o controle é descentralizado.
Para identificarmos e corrigirmos possíveis erros relacionados a raça do gato teremos que analisar todo o projeto já que a raça é visível ao projeto todo.
Vamos nos deparar muito com essa palavra "visibilidade", isso quer dizer "quem tem permissão para realizar a manipulação daquele atributo".
Para resolvermos este problema e criarmos o chamado controle centralizado devemos tornar o atributo raca privado e implementar métodos publicos que implementem toda a lógica de manipulação necessária desse atributo.
Os atributos devem ser privados porque todo atributo privado só pode ser acessado ou alterado pela classe que ele está contido, ou seja, o atributo raca só pode ser alterado por código que esteja contido na classe Gato. E o contrário nunca poderá ser feito, se alguma outra classe que não seja a Gato tentar acessar o atributo raca, um erro de compilação será gerado.
Os métodos devem ser publicos para que as demais classes consigam acessá-los. Definir todos os atributos como privado e métodos publicos que implementem a lógica de manipulação dos atributos, é praticamente uma regra em Orientação a Objetos. Isso é feito para que o controle seja centralizado, facilitando a manutenção e detecção de erros.

Gato.java public class Gato {
    private raca;
   
    public void mudarRaca(String raca) {
        this.raca = raca;
    }
}

 

Métodos Privados

Nem sempre os métodos deveram ser visíveis a todas as classes do seu projeto, às vezes o método tem papel de auxiliar outros métodos que estejam na mesma classe. Nesse caso seria um erro chamar este método fora da classe em que ele foi escrito.
No exemplo abaixo o método atribuiIp() é um método auxiliar de entrarRede(), sairRede(). Sendo assim ele não deve ser chamado diretamente, pois a atribuição de ip só deve ocorrer quando ele entrar na rede.

Rede.java
public class Rede {
    void connectar() {
        //lógica para criar conexão
    }
   
    void desconectar() {
        //lógica para desconectar da rede
    }
   
    String atribuirIp() {
        //lógica para retornar um número IP válido na rede
    }
}
Para garantir que não será possível a chamada do método atribuirIP() fora da classe Rede, devemos adicionar o modificador private. 

public class Rede {
    void connectar() {
        //lógica para criar conexão
    }
   
    void desconectar() {
        //lógica para desconectar da rede
    }
   
    private String atribuirIp() {
        //lógica para retornar um número IP válido na rede
    }
}
Agora qualquer chamada ao método atribuirIP() que não seja feita pela classe Rede, acarretará um erro de compilação garantindo assim que nosso método só será chamado dentro da classe Rede.

Métodos Públicos

Todos os métodos que devem ser acessados fora da classe de origem devem conter o modificador de acesso public. O public diz ao compilador que o método pode ser acessado por qualquer objeto que esteja no projeto em que o método chamado se encontra.

public class Rede {
    public void connectar() {
        //lógica para criar conexão
    }
   
    public void desconectar() {
        //lógica para desconectar da rede
    }
   
    private String atribuirIp() {
        //lógica para retornar um número IP válido na rede
    }
}

Porque encapsular?

Encapsular é uma das principais funcionalidades da programação orientada a objetos. Encapsular seria esconder o código de implementação e apenas mostrar a interface de uso do método.
O encapsulamento de dados nos ajuda na manutenção e no desenvolvimento do sistema, uma vez que com ele as tarefas ficam melhores divididas entre as classes e quando devemos modificar o comportamento dos objetos basta alterar a classe do objeto.
Para que você entenda melhor vamos fazer uma simples analogia ao mundo real utilizando o conceito de POO.

Imagine o controle remoto de sua televisão, a interface de uso seria os botões de: aumentar volume, abaixar volume, trocar de canal .. etc. Quando você usa o controle podemos dizer que você está usando a interface, porém, você não sabe como o serviço é feito. Você simplesmente aperta o botão e algo acontece, pois a implementação do serviço não é interessante, não é necessária conhecermos apenas queremos executar o serviço. Trazendo para a programação agora, o botão seria a assinatura do método = public void aumentarVolume(), e o serviço é o corpo do método, ou seja, o código que está escrito dentro dele. O código não deve ser visível ao objetos que vão acessar o método mais a assinatura do método deve ser visível aos demais objetos. Entendeu?

Getters e Setters

Aplicando a ideia do encapsulamento os atributos deveriam ser todos privados, com isso não seriam acessiveis por código que estivesse fora da classe em que foram definidos.
Mas na maioria dos sistemas as informações contidas nos atributos precisam ser acessadas e modificadas em qualquer parte do sistema. Nesse caso, podemos disponibilizar métodos para consulta e alteração de valores dos atributos.
Na linguagem Java, há uma convenção de nomenclatura para os métodos que tem como finalidade acessar ou alterar as propriedades de um objeto. Os métodos que tem como finalidade consultar as propiedades do objeto devem possuir o prefixo get, já os métodos que permitem a alteração das propriedades do objeto devem possuir o prefixo set.
Lembre-se bons programadores Java seguem a convenção.

public class Aluno {
    private String nome;

    public String getNome() {
        return nome;
    }
   
    public void setNome(String nome) {
        this.nome = nome;
    }
}
É isso ai pessoal! Dúvidas, sugestões, comentem ai...

Programando em Java - parte 10

Atributos e Métodos de Classe

Em um sistema muitas vezes é necessário que uma váriavel seja compartilhada por todos os objetos que venham a ser criados. Em Java temos os atributos e métodos de classe. Para criarmos métodos e atributos de classe utilizamos a palavra reservada static.  Um atributo de classe por definição é publico então é redundante colocar o modificador de acesso public, já que por definição static é public também.
Vejamos um problema em que poderiamos aplicar uma solução utilizando atributo de classe:

Problema:
Imagine que uma montadora de veículos precise armazenar o número de carros fabricados por dia. A cada novo carro criado o sistema deve contabilizar o carro para que no final do dia possa exibir a quantidade de veículos criados.

Solução:

Montadora.java
import java.util.Date;
import java.text.SimpleDateFormat;
import javax.swing.JOptionPane;

public class Montadora {
    public static void main(String[] args) {
        Carro.numCarros = 0;//inicializando o valor da variável
       
        for(int i=0; i<10;i++)
            new Carro();
           
        JOptionPane.showMessageDialog(null, "Foram fabricados " + Carro.numCarros + " carros.");
        JOptionPane.showMessageDialog(null, "Data: " + new SimpleDateFormat("dd/MM/yyyy").format(new Date()));
    }
}
Carro.java
public class Carro {
    static int numCarros;
   
    public Carro() {
        numCarros++;
    }
}
Para acessar variáveis de classe utilizamso o nome da classe, em seguida o operador ponto final (.) e o nome da variável que queremos acessar.

O correto para manipular atributos de classe é criarmos métodos de classe com a finalidade de controlar os valores contidos nesses atributos. Como a variável é publica e visível por todas as classes do nosso projeto não é explicitamente obrigatória a criação dos métodos de classe para fazer o controle dos mesmos, porém, fazer o manusei dos atributos de classe sem o uso de métodos é uma má prática de programação e consiste em um erro conceitual.

Problema 2:
Os funcionários da empresa GTi sistemas recebem vale refeição, todos os meses o valor do vale pode ser reajustado.

Solução:

Funcionario.java public class Funcionario {
    private String nome;
    static float valeRefeicao;
   
    public Funcionario(String nome) {
        this.nome = nome;
    }
   
    static void reajusteValeRefeicao(float valor) {
        valeRefeicao = valor;
    }
}
EmpresaGTi.java public class EmpresaGTi {
    public static void main(String[] args) {
        Funcionario programador = new Funcionario("Guilherme");
        Funcionario rh = new Funcionario("Débora");
        Funcionario analista = new Funcionario("Luiz");
       
        Funcionario.reajusteValeRefeicao(20);//todas as instancias de funcionário compartilham da mesma variável valeRefeicao
       
        //ERRO...
        programador.valeRefeicao = 20;//é possivel, porém, é erro conceitual
    }
}
Dúvidas , sugestões comentem...

Programando em Java - parte 9

Arrays

Quando desejamos armazenar uma grande quantidade de valores de um determinado tipo, podemos utilizar arrays. Um array é um objeto que pode armazenar muitos valores de um determinado tipo.
Podemos imaginar um array como sendo um armário com um determinado número de gavetas. E cada gaveta possui um rótulo com um número de identificação.

Criando um Array

Em Java, os arrays são criados através do comando new.

int numeros = new int[100];

Podemos ter arrays de vários tipos. Assim como podemos instanciar de várias maneiras o array, acima mostrei uma das formas de se criar um array, veja como podemos declarar um array de formas diferentes em Java:

int numeros[]; //aqui declaro meu array, porém, não instancie. Se eu tentar usá-lo irá acontecer um erro

int numeros[] = new int[] {1,23,54,19};/*Esse tipo de declaração instancia meu array e já adiciona os valores que são passados entre as chaves. Esse tipo de declaração é usado quando o programador já sabe quais valores devem sem iniciados junto com o array*/

Utilizando as Classes Arrays e Collections

Uma das vantagens de se usar a linguagem Java é que já existem muitas coisas prontas, basta o programador pesquisar a API e conhece-lá conforme suas necessidades. Quando trabalhamos com arrays podemos contar com as Classes Arrays e Collections do pacote java.util. Essas classes possuem os seguintes métodos já definidos:

• Método de pesquisa de elemento;
• Método de ordenação;
• Método de exibição de todos elementos;
• Método de inversão de ordem dos elementos contidos no array;

Exemplo:
import java.util.Arrays;
import java.util.Collections;
import javax.swing.JOptionPane;

public class ArraysExemplo {
    public static void main(String[] args) {
        String profInf[] = new String[] {"Renata", "Luiz", "Edilson", "Ednilson", "Janaina", "Gislaine", "Fábio", "Eduardo", "Francisco", "José Arnaldo"};
       
        //método bynarySearch retorna um int que condiz com a posição do elemento buscado no array
        //método sort organiza o array em de forma crescente
        //método toString imprime o array converte o array em String e exibe o completo na tela
        //método reverse inverte a ordem do array
       
        JOptionPane.showMessageDialog(null,"Posição: " + Arrays.binarySearch(profInf, "Janaina"));
       
        Arrays.sort(profInf);
        JOptionPane.showMessageDialog(null, "Array de forma organizada crescente : " + Arrays.toString(profInf));
       
        Collections.reverse(Arrays.asList(profInf));
        JOptionPane.showMessageDialog(null, "Array de forma organizada invertida : " + Arrays.toString(profInf));
    }
}
PS = Todo bom programador deve conhecer os recursos que sua linguagem já oferece pronta, para que ele não fique "reinventando a roda". A API do completa e atualizado Java pode ser encontrada no site da Oracle.

Comparando a utilização de array em um programa Java

Abaixo temos 3 versões de um mesmo programa Java. A função desse programa é ler três valores informados pelo usuário referentes a peso. Ao termino da entrada de dados o programa deve exibir qual  o maior, menor e a lista de todos os pesos lidos.

Programadores que não sabem utilizar array, ou acha que é perda de tempo escreve códigos Java assim:

import javax.swing.JOptionPane;

public class ArraysExemplo1 {
    public static void main(String[] args) {
        float peso, x, y;
        /*
        * a variável peso irá armazenar o peso fornecedo pelo usuário durante a execução do programa
        * a variável x irá armazenar a pessoa mais pesada
        * a variável y irá armazenar a pessoa mais leve
        */
       
        //inicializando x e y com valores impossíveis... Lembrando que essa é uma técnica não aconselhável
        x = -1000;
        y = 10000;
       
        for(int i=0; i<3; i++) {
        //diferentemente de C, o comando for em Java pode conter a declaração e inicialização de variáveis em sua primeira parte
            peso = Float.parseFloat(JOptionPane.showInputDialog("Informe o peso"));
           
            if(peso > x)
                x = peso;
           
            if(peso < y)
                y = peso;
        }
       
        JOptionPane.showMessageDialog(null, "Mais pesado = " + x + "kg");
        JOptionPane.showMessageDialog(null, "Mais leve = " + y + "kg");
        //não tem como mostrar todos os pesos lidos   :(
    }
}

Programadores que sabem utilizar array, porém, não conhecem os recursos que a API os oferecem. Irá desenvolver um código Java semelhante a este:

import javax.swing.JOptionPane;

public class ArraysExemplo2 {
    public static void main(String[] args) {
        float peso[] = new float[3];
        float x, y;
        /*
        * a variável peso irá armazenar o peso fornecedo pelo usuário durante a execução do programa
        * a variável x irá armazenar a pessoa mais pesada
        * a variável y irá armazenar a pessoa mais leve
        */
        for(int i=0; i<3; i++) {
            peso[i] = Float.parseFloat(JOptionPane.showInputDialog("Informe o peso"));
        }
       
        //inicializando os valores de x e y, com o primeiro valor lido
        x = peso[0];
        y =  x;
       
        for(int i=1; i<3; i++) {
        //diferentemente de C, o comando for em Java pode conter a declaração e inicialização de variáveis em sua primeira parte
       
            if(peso[i] > x)
                x = peso[i];
               
            if(peso[i] < y)
            y = peso[i];
        }
       
        JOptionPane.showMessageDialog(null, "Mais pesado = " + x + "kg");
        JOptionPane.showMessageDialog(null, "Mais leve = " + y + "kg");
        JOptionPane.showMessageDialog(null, "Todos os pesos lidos = " + peso[0] + ", " + peso[1] + ", " + peso[2]);
    }
}

Bons programadores, escrevem códigos assim:

import javax.swing.JOptionPane;
import java.util.Arrays;

public class ArraysExemplo3 {
    public static void main(String[] args) {
        float peso[] = new float[3];

        for(int i=0; i<3; i++) {
            try {
                peso[i] = Float.parseFloat(JOptionPane.showInputDialog("Informe o peso"));
            } catch(NumberFormatException e) {
                JOptionPane.showMessageDialog(null, "Erro ao coverter o valor digitado!", "Erro", JOptionPane.ERROR_MESSAGE);
            }
        }
       
        Arrays.sort(peso);//ordena os valores digitados
       
        JOptionPane.showMessageDialog(null, "Mais pesado = " + peso[2] + "kg");
        JOptionPane.showMessageDialog(null, "Mais leve = " + peso[0] + "kg");
        JOptionPane.showMessageDialog(null, "Todos os pesos informados = " + Arrays.toString(peso));
    }
}

Bom pessoal, duvidas e sugestões comentem...

1ª lista de exercícios EDA

Fala galera, acho que vcs já estavam com saudades ... ou não, mas enfim vamos ao que interessa, coma a volta das aulas na faculdade voltaram também as listas de exercicíos, e como muitos adoram verificar e corrigir exercicíos alheios deixo para vcs a resolução dos 29 exercicíos da lista de ETA.


 #include <stdio.h> int main() { printf("\nÉ preciso fazer todos os algoritmos para aprender!"); return 0; }

#include <stdio.h> int main() { printf("\nGuilherme Carvalho!"); return 0; }
#include <stdio.h> int main() { printf("%d", 28*43); return 0; }
#include <stdio.h> <stdio.h> int main() { printf("%d", (9+8+7)/3); return 0; }

#include <stdio.h> int main() { int i; printf("\nInforme um numero inteiro: "); scanf("%d", &i); printf("%d", i); return 0; }
#include <stdio.h> int main() { int i, ii; printf("\nInforme dois numeros inteiro: "); scanf("%d%d", &i, &ii); printf("%d \n%d", i,ii); return 0; } 


 #include <stdio.h>  int main() { int i, s, a; printf("\nInforme um numero: "); scanf("%d", &i); s = i + 1; a = i - 1; printf("Sucessor: %d \nAntecessor: %d", s, a); return 0; }


 #include <stdio.h>  int main() { char nome[80]; char endereco[80]; char telefone[20]; printf("\nInforme o nome: "); gets(nome); printf("\nInforme o endereço: "); gets(endereco); printf("\nInforme o telefone: "); gets(telefone); printf("\nNome: %s \nEndereço: %s \nTelefone: %s", nome, endereco, telefone); return 0; } 


#include <stdio.h>  int main() { int x, y; printf("\nInforme 2 numeros inteiros: "); scanf("%d%d", &x, &y); printf("Soma = %d", x+y); return 0; }


 #include <stdio.h> int main() { int x, y; printf("\nInforme 2 numeros inteiros: "); scanf("%d%d", &x, &y); printf("Produto = %d", x*y); return 0; }

#include <stdio.h> <stdio.h> int main() { int x; printf("\nInforme um numero: "); scanf("%d", &x); printf("Terça parte de %d = %d", x, x/3); return 0; }

#include <stdio.h>  int main() { int x, y; printf("\nInforme 2 numeros inteiros: "); scanf("%d%d", &x, &y); printf("Media = %d", (x+y)/2); return 0; }


#include <stdio.h> int main() { float v; printf("\nInforme valor: "); scanf("%f", &v); v *= 1.01; printf("\n%f", v); return 0; }


#include <stdio.h> int main() { int a, h; printf("\nárea: "); scanf("%d", &a); printf("\nbase: "); scanf("%d", &h); printf("\narea=%d \nperimetro=%d", h*a, (h*2)+(a*2)); return 0; }


#include <stdio.h> #define PI 3.1415 int main() { int r; printf("\nRaio: "); scanf("%d", &r); printf("\nPerimetro = %f, Area = %f", 2*PI*r, PI*r*r); return 0; }


#include <stdio.h> int main() { int a, h; printf("\nlado: "); scanf("%d", &a); printf("\narea=%d \nperimetro=%d", a*a, (a*2)+(a*2)); return 0; }


#include <stdio.h> int main() { int b, a; printf("\naltura: "); scanf("%d", &a); printf("\nbase: "); scanf("%d", &b); printf("\narea=%d ", (b*a)/2); return 0; }


#include <stdio.h> int main() { float x; printf("\nvalor: "); scanf("%f", &x); printf("\nnovo valor = %f", x*0.91); return 0; }


#include <stdio.h> int main() { int x; printf("\nnumero: "); scanf("%d", &x); if(x >= 20 && x <= 90) { printf("\nNro está compreendido entre o intervalo!"); } else { printf("\nNro não está compreendido entre o intervalo!"); } return 0; }


#include <stdio.h> int main() { char nome[100]; int idade; char sexo; printf("\nInforme o nome: "); gets(nome); printf("\nInforme a idade: "); scanf("%d", &idade); __fpurge(stdin); printf("\nInforme sexo [M/F]: "); scanf("%c", &sexo); sexo = toupper(sexo); if(sexo == 'F' && idade < 25) { printf("\nNome: %s \nAceito (a)", nome); } else { printf("\nNome: %s \nNão aceito (a)", nome); } return 0; }


#include <stdio.h> int main() { int x, y, z; printf("\nInforme 3 valores: "); scanf("%d%d%d", &x, &y, &z); if((x + y > z) && (x + z > y) && (y + z > x)) { printf ("É triangulo"); } else { printf("\nNão é triangulo"); } return 0; }


#include <stdio.h> int main() { int x, y, z; printf("\nInforme 3 valores: "); scanf("%d%d%d", &x, &y, &z); if((x + y > z) && (x + z > y) && (y + z > x)) { printf("\nTriângulo "); if((x == y) && (z == x) && (y == z)) printf("Equilátero"); else if((x != y) && (z != x) && (y != z)) printf("Escaleno"); else printf("Isóceles"); } else { printf("\nNão é triangulo"); } return 0; }


#include <stdio.h> int main() { int x; printf("\nInforme um numero: "); scanf("%d", &x); if(x % 4 == 0) { printf("\nMultiplo de 4!"); } else if(x % 7 == 0) { printf("\nMultiplo de 7!"); } else { printf("\nNão é multiplo de 4 nem de 7!"); } return 0; } 


#include <stdio.h> int main() { int x; printf("\nInforme um numero: "); scanf("%d", &x); if(x <= 1) { x = 1; } else if(x > 1 && x <= 2) { x = 2; } else if(x > 2 && x <= 3) { x = x*x; } else { x = x*x*x; } printf("\nValor de x = %d", x); return 0; }


#include <stdio.h> int main() { int i; for(i = 1; i <= 600; i++) { if(i % 2 == 0) { printf("%d\t", i); } } return 0; }


#include <stdio.h> int verificaPrimo(int n) { int i; for(i = 2; i < n; i++) { if(n % i == 0) { return 1;//não é primo break; } } return 0;//primo } int main() { int i; for(i = 1; i < 2001; i++) { if(!verificaPrimo(i))//nega condição printf("%d\t", i); } return 0; } 


#include <stdio.h> int main() { float v; printf("\nInforme o valor do produto: "); scanf("%f", &v); if(v < 20) v *= 1.45; else v *= 1.3; printf("\nValor de venda: %5.2f", v); return 0; } 


#include <stdio.h> int main() { int nBg, nBm;//número do boi gordo e boi magro respectivamente float pBg, pBm;//peso do boi gordo e boi magro respectivamente int i = 1; int n; float p; printf("\nInforme o numero do %dº boi: ", i); scanf("%d", &nBg); printf("\nInforme o peso do %dº boi: ", i); scanf("%f", &pBg); nBm = nBg; pBm = pBg; for(i = 2; i <= 90; i++) { printf("\nInforme o numero do %dº boi: ", i); scanf("%d", &n); printf("\nInforme o peso do %dº boi: ", i); scanf("%f", &p); if(p > pBg) { pBg = p; nBg = n; } else { pBm = p; nBm = n; } } printf("\nBoi + gordo = %dº %3.2f \nBoi + magro = %dº %3.2f", nBg, pBg, nBm, pBm); return 0; } 


#include <stdio.h> #include <stdio.h> <stdio.h> int main() { char sexo; char olhos[9]; char cabelos[9]; float porcentagem = 0; int idade, i, mIdade = -1; for(i = 1; i <= 200; i++) { __fpurge(stdin); printf("\nSexo [M/F]: "); scanf("%c", &sexo); sexo = toupper(sexo); __fpurge(stdin); printf("\nOlhos: "); gets(olhos); __fpurge(stdin); printf("\nCabelos: "); gets(cabelos); printf("\nIdade: "); scanf("%d", &idade); if(idade > mIdade) mIdade = idade; if(sexo == 'F') { if(idade > 17 && idade < 36) { if(strcasecmp("castanho", olhos) == 0 && strcasecmp("preto", cabelos) == 0) porcentagem++; } } } printf("\nMaior idade = %d", mIdade); printf("\nPorcentagem = %3.2f", porcentagem/2); return 0;}

Estrutura de dados - Vetor

Em C existem vetores unidimensionais e bidimensionais, ambos são estruturas homogenias ordenadas e que podem assumir um número de elementos finitos.

Para declarar um vetor, usa-se o a seguinte notação:

tipo nome_vetor [intervalo]

O menor elemento do vetor é chamado limite mínimo e, em C, é sempre 0, e o maior elemento é chamado limite máximo. O número de elementos no vetor é chamado de faixa, a faixa pode ser obtida com limite máximo - limite mínimo - 1 = faixa. 

Em C os limites não podem serem alterados durante a execução do programa, o limite mínimo é sempre fixado em 0, o limite máximo é fixado quando é escrito. Uma técnica que muitos programadores utilizam para simplificar a manutenção do código, é o emprego de um identificador de constante.

//sem idenficador
int main() {
   
    int vetor[100];
   
    return 0;
}#define LIM 100

int main() {

    int vetor[LIM];

    return 0;
}

Vetores como parâmetros

Como uma variável vetor em C é um ponteiro, os parâmetros vetores são passados por referência em vez de por valor. O conteúdo de um vetor não é copiado quando passado como um parâmetro, em vez disso é passado o seu endereço de memória.

A passagem por referência é muito mais eficiente, já que ela poupa espaço e tempo. Espaço porque não há necessidade de uma segunda cópia do vetor, já que este será modificado diretamente, com isso há um ganho de tempo.


#include <stdio.h>
#define SIZE 10

//PERCEBA QUE NÃO É NECESSÁRIO A PASSAGEM DO TAMANHO DE MEU VETOR
void _preencheVetor(int []);

void _preencheVetor(int v[]) {
    int i;

    for(i = 0; i < SIZE; i++) {v[i] = 1;}
}

void _exibeVetor(int v[]) {
    int i;

    for(i = 0; i < SIZE; i++) {printf("%d\t", v[i]);}
}

int main() {

    int v[SIZE];

    _preencheVetor(v);

    _exibeVetor(v);

    return 0;
}

Cadeia de caracteres (String) em C

Em C uma string é definida como um vetor de caracteres. O carácter NULL é responsável por encerrar uma string, esse caractere é inserido automaticamente ao final de toda string. O caractere NULL é representado pela sequencia de escape \0.
Uma string tem limite minimo igual a 0 e seu limite máximo é o número de caracteres na string. Exemplo:
"Guilherme" é um vetor de 10 elementos (a tecla de escape é contada).

Operações com Strings

Agora vamos implementar algumas operações para manipular Strings.

1. Encontrar o tamanho da string (strlen);
2. Concatenar strings (strcat).


int strlen(char []);

int strlen(char array[]) {
    int i;

    for(i = 0; array[i] != '\0'; i++)
        return i;
}

int main() {

    char array[100];

    printf("\nNúmero de elementos = %d", strlen("GUILHERME"));

    return 0;
}
#include <stdlib.h>

char *concat(char *s1, const char *s2)
{
    char *ps1 = s1;

    while(*ps1)
        ps1++;

    while(*ps1++ = *s2++);

    return s1;
}

int main(int argc, char *argv[])
{
    char nome[10] = "Guilherme";
    char sobrenome[10] = " Carvalho";
    char *resultado = concat(nome, sobrenome);
   
    printf("%s\n\n", resultado);
 
    return 0;
}

Vetores bidimensionais

O tipo dos componentes de um vetor pode ser outro vetor. Por exemplo, podemos definir:

int m[3][5];

Isso define um novo vetor contendo três elementos. Cada um desses elementos é em si mesmo um vetor contendo cinco inteiros. Um elemento desse vetor é acessado especificando-se dois índices: um número de linha e um número de coluna.

Próximo assunto -> Lista

Estrutura de dados - Ponteiros

O ponteiro nada mais é do que uma variável que guarda o endereço de memória, ou seja, ela aponta para um determinado espaço que foi alocado na memória. A declaração de ponteiros é feita das três seguintes formas:

1. permitem a modificação de argumentos de funções: Permite que as funções altere valores de variáveis não globais e não locais e ela através da referência ao endereço de memória da variável passada como parâmetro para a função;
   
#include <stdio.h>

void _f_modifica(int *); ///assinatura da função

void _f_modifica(int *p) {
    *p = 5;
}

int main() {

    int i;

    i = 10;

    printf("\nValor de i = %d", i);

    _f_modifica(&i); //passando o endereço de meḿória da variável i

    printf("\nValor de i = %d", i);

    return 0;
}
   
2. Permitem o uso de rotinas de alocação dinâmica de memória: alocação e desalocação de memória em tempo de execução conforme a necessidade do programa;
   
char *ptr;
ptr = malloc (1);
   
3. Aumento de eficiência em determinadas rotinas. A forma de declaração de uma variável ponteiro é:
   
   tipo *nome_variável
   Onde tipo é o tipo de variável apontada pela variável ponteiro.

Próximo assunto -> Vetor

Tipo de dado abstrato TDA

TDA ou tipo de dado abstrato significa um conjunto de valores e uma sequencia de operações sobre estes valores. Isto é um modelo matemático pelo par (V, O), onde V é um conjunto de valores e O é um conjunto de operações sobre estes valores.

Exemplo:

Dicionário Inglês-Português

• V: conjunto de pares de palavras;
• O: inserção de um novo par, remoção de um par, consulta palavra, alteração de palavra.

Um TDA permite definir, além dos dados que serão manipulados por uma estrutura de dado, as operações a executar nos dados representados. Diferentes operações podem ser executadas, tais como operações para criar e eliminar estruturas de dados, operações para inserir, alterar e eliminar elementos das estruturas de dados, e operações para acessar elementos na estrutura de dados.

Não é necessário conhecer ou depender da implementação de um TDA para utilizá-lo, mas, apenas sua interface (conjunto de operações válidas). O TDA é uma técnica muito útil para os programadores que queiram usar certas propriedades matemáticas que não existam na linguagem que eles usam ou usar um tipo de dado de maneira correta.

Próximo assunto -> Ponteiro

Estrutura de dados - Introdução

O que são Estrutura de dados?

Estruturas de dados são estruturas que tem o propósito de armazenar os dados de forma inteligente no computador, fazendo que tais estruturas sejam utilizadas eficientemente na resolução de um problema. Existem inúmeras estruturas que podem ser usadas, porém dependendo do problema a ser solucionado algumas estruturas serão mais indicadas do que outras.

Por que estudar Estruturas de dados?

Essa pergunta é feita com muita frequência já que hoje as linguagens de alto nível oferecem essas estruturas todas prontas, porém, se você é um desenvolvedor que se limita apenas a conhecer as estruturas presentes na API da linguagem que você trabalha infelizmente você estará amarrado a ela, pois você adquiriu conhecimento em uma linguagem e não nas estruturas que compõem a linguagem. Supomos que você tenha que mudar de linguagem de programação e essa nova linguagem não oferece nenhuma estrutura de dados pronta, e ai? E se você não conhece o funcionamento da estrutura como você estará apto a tomar a decisão de qual a melhor estrutura utilizar em um determinado problema? São nessas horas que o conhecimento se faz necessário!

Próximo assunto -> Tipo de dado abstrato (TDA).

Estrutura de dados - Apresentação

Olá pessoal, conheça a nova seção do blog programando onde iremos aprender sobre estrutura de dados. Será utilizada a linguagem C no decorrer deste mini-curso, podendo haver exemplos em Java e Python, porém, C é a linguagem que utilizaremos como padrão.

Abaixo está descrita a grade de nossa seção, aproveitem para se orientar em seus estudos e boa sorte.

1. O QUE É ESTRUTURA DE DADOS
2. TDA
3. PONTEIRO
4. VETOR
5. LISTA
6. PILHA
7. FILA
8. ÁRVORE
9. ÁRVORES ORDENADAS
10. ÁRVORES ORIENTADAS
11. ÁRVORE LIVRE
12. PROGRESSÃO DE ÁRVORES
13. REPRESENTAÇÃO LIGADA DE ÁRVORES
14. ÁRVORE BINÁRIA
15. FUNÇÃO MALLOC
16. FUNÇÃO CALLOC
17. FUNÇÃO FREE

PS: Devido a falta de tempo o mini-curso de banco de dados foi adiado para o mês que vem, abraços.

Programando em Java - parte 8

Construtor

Um construtor permite que um determinado trecho de código seja executado toda vez que um objeto é criado, ou seja, toda vez que o operador new é chamado. Assim como os métodos, os construtores podem receber parâmetros. Contudo, diferentemente dos métodos, os construtores não devolvem resposta.

Em Java, um construtor deve ter o mesmo nome da classe na qual ele foi definido:
class CartaoDeCredito {
    int numero ;
    CartaoDeCredito ( int numero ) {
        this . numero = numero ;
    }
}

Na criação de um objeto com o comando new, os argumentos passados devem ser compatíveis com a lista de parâmetros de algum construtor definido na classe que está sendo instanciada. Caso contrário, um erro de compilação ocorrerá para avisar o desenvolvedor dos valores obrigatórios que devem ser passados para criar um objeto.


CartaoDeCredito c = new CartaoDeCredito(736723672);

Construtor Padrão

Toda vez que um objeto é criado, um construtor da classe correspondente deve ser chamado. Mesmo quando nenhum construtor for definido explicitamente, há um construtor padrão que será inserido pelo próprio compilador. O construtor padrão não recebe parâmetros e será inserido sempre que o desenvolvedor não definir pelo menos um construtor explicitamente.
Portanto, para instanciar uma classe que não possui construtores definidos no código fonte, devemos utilizar o construtor padrão, já que este é inserido automaticamente pelo compilador.

class Conta() {}

Lembrando que o construtor padrão só será inserido pelo compilador se nenhum construtor for definido no código fonte. Dessa forma, se você adicionar um construtor com parâmetros então não poderá  utilizar o comando new sem passar argumentos, pois um erro de compilação ocorrerá.

Sobrecarga de Construtores

O conceito de sobrecarga de métodos pode ser aplicado para construtores. Dessa forma, podemos definir diversos construtores na mesma classe.

class Pessoa {
    String rg ;
    int cpf ;
    Pessoa ( String rg ) {
        this . rg = rg ;
    }
    Pessoa ( int cpf ) {
        this . cpf = cpf ;
   }
}
Quando dois construtores são definidos, há duas opções no momento de utilizar o comando new.

// Chamando o primeiro construtor
Pessoa p1 = new Pessoa ( " 123456 X " ) ;
// Chamando o segundo construtor
Pessoa p2 = new Pessoa (123456789) ;

Construtores chamando construtores

Assim como podemos encadear métodos, também podemos encadear construtores.

class Conta {
    int numero ;
    double limite ;
    Conta ( int numero ) {
        this . numero = numero ;
    }
    Conta ( int numero , double limite ) {
        this ( numero ) ;
        this . limite = limite ;
    }
}


Programando em Java - parte 7

Sobrecarga (Overloading)

Java nos permite criar vários métodos com o mesmo nome desde que tenham parâmetros diferentes. Isso é o que chamamos de sobrecarga de métodos.

A sobrecarga de métodos consiste em criarmos o mesmo método com possibilidades de entradas diferentes. Essas entradas, caracterizadas como parâmetros, devem sempre ser de tipos diferentes, quantidades de parâmetros diferentes ou posições dos tipos diferentes.

Os clientes dos bancos costumam consultar periodicamente informações relativas às suas contas. Geralmente, essas informações são obtidas através de extratos. No sistema do banco, os extratos podem ser gerados por métodos da classe Conta.

class Conta {
    double saldo ;
    double limite ;
    void imprimeExtrato ( int dias ) {
        // extrato
    }
}

O método imprimeExtrato() recebe a quantidade de dias que deve ser considerada para gerar o extrato da conta. Por exemplo, se esse método receber o valor 30 então ele deve gerar um extrato com as movimentações dos últimos 30 dias.

Em geral, extratos dos últimos 15 dias atendem as necessidades dos clientes. Dessa forma, poderíamos acrescentar um método na classe Conta para gerar extratos com essa quantidade fixa de dias.

class Conta {
    double saldo ;
    double limite ;
    void imprimeExtrato () {
        // extrato dos últimos 15 dias
    }
    void imprimeExtrato ( int dias ) {
        // extrato
    }
}
O primeiro método não recebe parâmetros pois ele utilizará uma quantidade de dias padrão
definida pelo banco para gerar os extratos (15 dias).

O segundo recebe um valor inteiro como parâmetro e deve considerar essa quantidade de dias
para gerar os extratos.

Os dois métodos possuem o mesmo nome e lista de parâmetros diferentes. Quando dois ou mais
métodos são definidos na mesma classe com o mesmo nome, dizemos que houve uma sobrecarga
de métodos. Uma sobrecarga de métodos só é válida se as listas de parâmetros dos métodos são
diferentes entre si.

No caso dos dois métodos que geram extratos, poderíamos evitar repetição de código fazendo
um método chamar o outro.

class Conta {
    void imprimeExtrato () {
        this . imprimeExtrato (15) ;
    }
    void imprimeExtrato ( int dias ) {
        // extrato
    }
}