Banco de Dados com Java 1 / Conexão

Conexão com o Banco de Dados no Postegres / PgAdmin

package apps;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

public class Conexao1 {

    public static void main(String[] args) {

        // TODO code application logic here

        Connection conexao;

        String url = "jdbc:postgresql://localhost:5432/produto";

        String usr = "postgres", pass = "aluno123";

        

        try{

            Class.forName("org.postgresql.Driver");//site do driver no postgre

            conexao = DriverManager.getConnection(url, usr, pass);

            System.out.println("Conexão estabelecidada");

            conexao.close();

            System.out.println("Conexão encerrada");

        } catch (ClassNotFoundException cnf){

            System.out.println("Classe do driver não encontrado - "+cnf.getMessage());

        }catch (SQLException sqle){

            System.out.println("Conexão não estabelecidade - "+sqle.getMessage());

        }

    }

    

}

____________________ / / ___________________

package apps;

import java.sql.*;

import org.postgresql.Driver;

public class Conexao2 {

    public static void main(String[] args) {

        // TODO code application logic here

        Connection conexao;

        String url = "jdbc:postgresql://localhost:5432/produto";

        String usr = "postgres", pass = "aluno123";

        

        try{

            DriverManager.registerDriver(new Driver());

            conexao = DriverManager.getConnection(url, usr, pass);

            System.out.println("Conexão estabelecida");

            conexao.close();

            System.out.println("Conexão fechada");

        }catch (SQLException sqle) {

            System.out.println("Conexão não estabelecida - "+sqle.getMessage());

        }

    }

    

}

Saída gerada

Clique aqui para fazer o download do material completo

Palavras chave:

Persistência de Dados com a API JDBC do Java

Data Persistence with the Java JDBC API

Persistencia de datos con la API JDBC de Java

जावा जेडीबीसी API सह डेटा पर्सिस्टन्स

Java JDBC APIを使用したデータの永続性

Adatperzisztencia a Java JDBC API-val

התמדה בנתונים עם ממשק ה- API של JDBC Java

Persistência de Dados com e API JDBC do Java

Persistência de Dados com iyo API JDBC waxay sameeyaan Java

Persistência de Dados com a API JDBC do Java

Dados com ve API JDBC’nin Java kullanması

Persistência de Dados com og API JDBC gør Java

Herança em Java

Exemplo de herança em java

package pessoa;
public class Aluno extends Pessoa{
 
    private String curso;
    private double[] notas;

    public Aluno() {
        super();
    }

    public Aluno(String nome, String endereco, String telefone, String curso) {
        super(nome, endereco, telefone);
        this.curso = curso;
        this.notas = notas;
    }

    public boolean verificarAprovado(){
        return true;
    }
    public void metodoQualquer(){
        super.setCpf(1234567-99);
        this.setCpf(00000000-99);
    }
 
    public String getCurso() {
        return curso;
    }
    public double[] getNotas() {
        return notas;
    }

    public void setCurso(String curso) {
        this.curso = curso;
    }
    public void setNotas(double[] notas) {
        this.notas = notas;
    }
}

___________ / / _____________

package pessoa;
public class Pessoa {
 
    private String nome, endereco, telefone;
    private String telefoneCelular;
    int cpf;

    public Pessoa(){}
 
    public Pessoa(String nome, String endereco, String telefone) {
        this.nome = nome;
        this.endereco = endereco;
        this.telefone = telefone;
    }
 
 
 
    public String getNome() {
        return nome;
    }
    public String getEndereco() {
        return endereco;
    }
    public String getTelefone() {
        return telefone;
    }
    public String getTelefoneCelular() {
        return telefoneCelular;
    }
    public int getCpf() {
        return cpf;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }
    public void setEndereco(String endereco) {
        this.endereco = endereco;
    }
    public void setTelefone(String telefone) {
        this.telefone = telefone;
    }
    public void setTelefoneCelular(String telefoneCelular) {
        this.telefoneCelular = telefoneCelular;
    }
    public void setCpf(int cpf) {
        this.cpf = cpf;
    }
 
    public String obterEtuiqueta(){
        return endereco;
    }
 
}

___________ / / __________

package pessoa;

public class Professor extends Pessoa{

    

    private double salario;

    private String nomeCurso;

    public double getSalario() {

        return salario;

    }

    public String getNomeCurso() {

        return nomeCurso;

    }

    public void setSalario(double salario) {

        this.salario = salario;

    }

    public void setNomeCurso(String nomeCurso) {

        this.nomeCurso = nomeCurso;

    }

    public double calcularSalarioLiquido(){

        return 0;

    }

    

    public String obterEtiquetaEndereco(){

        String s = "Endereço do professor: ";

        s += super.getEndereco();

        //ou s += this.getEndereco();

        return s;

    }

}

_____________ / / ______________

package execucao;

import pessoa.Pessoa;

import pessoa.Aluno;

import pessoa.Professor;

public class Aplicacao1 {

    public static void main(String[] args) {

        

        Aluno aluno = new Aluno();

        Pessoa pessoa = new Pessoa();

        Professor prof = new Professor();

        

        pessoa.setEndereco("Rua 1 quadra 2");

        aluno.setEndereco("Rua 2 quadra 3");

        prof.setEndereco("Rua 3 quadra 4");

        

        System.out.println(pessoa.obterEtuiqueta());

        System.out.println(aluno.obterEtuiqueta());

        System.out.println(prof.obterEtiquetaEndereco());

        

        aluno.setCpf(8888888-99);

        System.out.println(aluno.getCpf());

        

    }

    

}

Atividade LP2

1. Qual a justificativa/vantagem do uso de enumerações, ao invés de usar valores literais ou constantes do tipo String ou Inteiro ?

- define um domínio de valores

- define um tipo em tempo de compilação

- toda manipulação pelo enum é validada pelo compilador

- diminui a chance do compilador parar

- legitimidade 

2. Qual o papel das classes VO’s na implementação fornecida ?

- ENTIDADE: endereco, Aluno, Enuns =: abstracao de classes / X

- DAO: Conexao => reuni o papel de banco de dados / ABSTRACAO DE PERSISTENCIA / quem ficar isolado nesta expressão encapsula os campos

- EXCEÇÕES => Persisntencia, Negocio / X - não reuni um conjunto de ações 

- NEGOCIO => Validação de dados / ABSTRACAO de mooder 

- EXECUCAO: Principal- Visao/Intidade=> Faz o papel de interação com o usuário / fazer a interface com o usurário para fornecer dados

3. Caso não seja usado VO, como seriam passados valores entre as classes da visão, negócio e persistência ?

- Por Lista de parâmetros

4. Que tipo de relação existe entre o VO de Aluno e Endereço ?

- Agregação de endereçosVO

5. O que justifica o uso do EnderecoVO na implementação, haja visto que no banco de dados existe apenas uma tabela (Aluno) ? 

- Complexidade nas classes

- Fazer um registro com chave primaria que referencia 2 ou + tabelas

6. Aponte exemplos de uso da classe PersistenciaException. 

7. Qual o benefício de criar uma classe para tratar a conexão com o banco de dados, como a classe ConexaoBD ? 

- é uma classe de apoio utilitária

- encapsulamento de um local da conexão

- diminui o uso de código com repetição

8. Qual o papel/responsabilidade da classe DAO ?

- DAO reunir todos

 9. Qual o papel/responsabilidade da classe AlunoNegocio ? 

- Consistência da regra de negocio

- envolve validação de dados

10. Caso tenha que inserir uma nova entidade/conceito na aplicação, quais seriam as classes a serem implementadas ?

- Construir um professorDAO

- AlunoDAO e assim sucessivamente

- AlunoNegocio 

Strings em java

/**
 *
 * @author HENRIQUE
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args){
        // TODO code application logic here
        String var = "variavel / ? : + ;: letras", aux = "";
     
        System.out.println("--- "+var+" ---");
        LinkedList lista = new LinkedList();
     
        System.out.println("Posicao do[/] => "+var.indexOf("/"));
        System.out.println("Termina com [letras] => "+var.endsWith("letras"));
        System.out.println("Começa com [variavel] => "+var.startsWith("variavel"));
        System.out.println("Se a posição 9 == [/] => "+var.startsWith("/", 9));
        System.out.println("");
        for(byte s : var.getBytes()){
            System.out.println("byte: "+s);
        }
        System.out.println("\nCódigo da String [var] => "+var.hashCode());
        System.out.println("Convertendo para String maíuslas => "+var.toUpperCase());
        System.out.println("Trunca a na posição [4] => "+var.substring(4));
        System.out.println("Trunca em [2, 9] => "+var.substring(2, 9));
     
        System.out.println("\n");
        String[] auxSplit = var.split(":");
        for(String s : auxSplit){
            System.out.println(s);
        }
     
        System.out.println();
        String valor = "TESTE -java - Engenharia - Comp";
        String[] auxS = valor.split("-",3);//limite de 3
        for(String a : auxS){
            System.out.println(a);
        }
     
        String result = String.format("Hoje nós processamos [ %s ] transções", var);
        System.out.println(""+result);
     
        result = String.format("10 / 3 = %.2f", 10.0 / 3.0);
        System.out.println(result);
     
        char d[] = {'a','b','c'};
        String str = new String(d);
        System.out.println(str);
     
        String test = "TESTE VARIAVEL - java";
        System.out.println(test.charAt(0));
    }
 
}

Buscar elementos iguais em java

import javax.swing.JOptionPane;

/**

 *

 * @author HENRIQUE

 */

public class Lista {

    

    private Object[] objeto;

    private int tamanho;

    

    public Lista(){

    }

    public Lista(int capacidade){

        this.objeto = new Object[capacidade];

        this.tamanho = 0;

    }

    public boolean adicionar(Object elemento){

        if(tamanho < objeto.length){

            objeto[tamanho] = elemento;

            tamanho++;

            return true;

        }return false;

    }

    

    public int buscarElemento(Object elemento){

        for(int i = 0; i < this.tamanho; i++){

            if(this.objeto[i].equals(elemento)){

                return i;

            }

        }return -1;

    }

    

    public Object buscarElem(Object elemento){

        for(int i = 0; i < this.tamanho; i++){

            if(this.objeto[i].equals(elemento)){

                return elemento;

            }

        }return false;

    }

    

    public void erro(String elemento){

        JOptionPane.showMessageDialog(null,"ERRO SEMÂNTICO !", "inteiro "+elemento,JOptionPane.ERROR_MESSAGE);

        throw new IllegalArgumentException("Variável duplicata");

    }

       

    public boolean addIguais(Object elemento){

        if((tamanho < objeto.length)&& (this.contem(elemento)== false)){

            objeto[tamanho] = elemento;

            tamanho++;

            return true;

        }

        System.out.println(elemento+" => Variáveis iguais");

        this.erro((String) elemento);

        return false;

    }

    

    public boolean contem(Object elemento){

        return buscarElemento(elemento) >= 0;

    }

    public int tamanho(){

        return this.tamanho;

    }

    

    public void removerElemento(Object elemento){//esta removendo apenas um elemento

        for(int i = 0; i < this.tamanho -1; i++){

            this.objeto[i] = this.objeto[i+1];

        }

        tamanho--;

    }

    

    public void removerElemPosicao(int posicao){

        if(!(posicao >= 0 && posicao < tamanho)){//se a posição é válida

            throw new IllegalArgumentException("\n\nPOSIÇÃO DE REMOÇÃO INVÁLIDA");

        }else{

            for(int i =0; i < this.tamanho -1; i++){

                this.objeto[i] = this.objeto[i+1];//atualiza a posicao

            }

            tamanho--;

        }

    }

    

    public String toString(){

        StringBuilder s = new StringBuilder();

        

        for(int i =0; i < this.tamanho; i++){

            s.append(this.objeto[i]);

            s.append("\n");

        }

        return s.toString();

    }

}

EXEMPLO : 

/**

 *

 * @author HENRIQUE

 */

public class Main {

    public static void main(String[] args) throws Exception {

        

        Lista listar = new Lista(1000);

        listar.addIguais("palavras");

        listar.addIguais("abacaxi");

        listar.addIguais(9);

        listar.addIguais("FRASES");

        listar.addIguais("abacaxi"); // dará um erro aqui porque já existe este elemento

    }

}

SAP1

Clique aqui para fazer o download do arquivo feito no Logisim 2.7

Gramática no Gals

Gramática 1
Clique aqui para fazer o download do arquivo feito no Gals
Autor: Tales - IFMT - Eng. da Computação

Gramática 2
Clique aqui para fazer o download do arquivo feito no Gals
Autor: Henrique - IFMT - Eng. da Computação

Gramática 3
Clique aqui para fazer o download do arquivo feito no Gals
Autor: Luis Fernando Sampaio - IFMT - Eng. da Computação
Arquivos disponível em: https://github.com/lsfs/compilador

Gramática 4
Clique aqui para fazer o download do arquivo feito no Gals

Gramática 5
Clique aqui para fazer o download do arquivo feito no Gals
Autor: Adriano - IFMT - Engenharia da Computação
Arquivos disponível em: https://drive.google.com/open?id=1w0kj_-NU27WJ_w6yTzLEIS-bOw0rFqED

Gramatica 6
Clique aqui para fazer o download do arquivo feito no Gals
Autor: Lucas  - IFMT - Engenharia da Computação
Arquivos disponivel em: https://drive.google.com/file/d/11VqWv7g5nSnwSKajY-bq7lFArNoGPNQi/view?usp=sharing

Arquitetura para Assembly

S → DB

D → final id “=“ [“-”] const”;” [1][5] |

Tipo id1 [6] [“=“ [“-”[15]] const [16][7]] [2] {“,” id2 [6][“=“ [-[15]] const[16][7]] [3]}* “;”

Tipo → int [8]| byte [9]| string [10]| boolean[11]

B → begin {C}* end

C → id[4] = Exp [12]“;” [15]| while [16] Exp [13] [17] ( C | B )[18] |

If [19]Exp [13] [20] ( C | B ) [else [21]( C | B ) ] [22]| “;” |

readln”,” id[4] [14]“;” | (write | writeln)”,” Exp [17]{“,” Exp [17] }* “;”

Exp → ExpS1 [18] [12] [ ( “<“ [20][13.1]| “>“ [20][13.2]| “<=“ [20][13.3]| “>=“ [20][13.4]| “==“ [21][13.5]| “!=“ [20][13.6]) ExpS2 [19] [22] [14]]

ExpS → [ “-”[8]] T1 [23][9]{ ( “+” [27][10.1]| “-” [28][10.2]| or [28][10.3]) T2 [24][30][11]}*

T → F1 [25][5]{ ( “*” [29][6.1]| “/” [29][36][6.2]| and [29][6.3]) F2 [26][31][7]}*

F → “(“ Exp [32]“)” [3]| not F1 [33][4] | const[34][2] | id [4][35][1]

[1] {se id.classe != vazio então ERRO

senao id.classe = classe_const }

[2] { se id1.classe != vazio então ERRO

senao id1.classe = classe_var}

[3] { se id2.classe != vazio então ERRO

senao id2.classe = classe_var}

[4] { se id.classe = vazio então ERRO}

[5] { id.tipo := const.tipo }

[6] { id.tipo = Tipo.t }

[7] { se id1.tipo != const.tipo E (id1.tipo != inteiro E const.tipo != byte OU id1.tipo != byte E const.tipo != inteiro) então ERRO }

[8] { Tipo.t = inteiro }

[9]{ Tipo.t = byte }

[10] { Tipo.t = string }

[11]{ Tipo.t = boolean }

[12] { se id1.tipo != exp.tipo E (id1.tipo != inteiro E exp.tipo != byte OU id1.tipo != byte E exp.tipo != inteiro) então ERRO }

[13] { se exp.tipo != logico então ERRO }

[14] { se id.tipo != inteiro E id.tipo != byte E id.tipo != string então ERRO }

[15] { D.neg = true }

[16] { se D.neg = true

então id.tipo = inteiro }

[17] { se exp.tipo != inteiro E exp.tipo != byte E exp.tipo != string então ERRO }

[18] { Exp.tipo = Exps.tipo }

[19] { se Exp.tipo != inteiro E ExpS.tipo != inteiro E Exp.tipo != byte E ExpS.tipo != byte E (Exp.tipo != inteiro E Exps.tipo != byte OU Exp.tipo != byte E Exps.tipo != inteiro)

então ERRO }

[20] { se Exps1.tipo = string então ERRO }

[21] { se Exps1.tipo != string E Exps1.tipo != inteiro E Exps1.tipo != byte então ERRO}

[22] { Exp.tipo = logico }

[23] { Exps.tipo = T1.tipo }

[24] { se Exps.tipo != T2.tipo E (Exps.tipo != inteiro E T2.tipo != byte OU Exps.tipo != byte E T2.tipo != inteiro) então ERRO }

[25] { T.tipo = F1.tipo }

[26] { se T.tipo != F2.tipo E (T.tipo != inteiro E F2.tipo != byte OU T.tipo != byte E F2.tipo != inteiro) então ERRO }

[27] { se T1.tipo != string E T1.tipo != inteiro E T1.tipo != byte então ERRO}

[28] { se T1.tipo = string então ERRO }

[29] { se F1.tipo = string então ERRO }

[30] { se T1.tipo = inteiro E T2.tipo = byte OU se T1.tipo = byte E T2.tipo = inteiro

então ExpS.tipo = inteiro }

[31] { se F1.tipo = inteiro E F2.tipo = byte OU se F1.tipo = byte E F2.tipo = inteiro

então T.tipo = inteiro }

[32] { F.tipo = Exp.tipo }

[33] { se F1.tipo = string então ERRO

senão F.tipo = F1.tipo}

[34] { F.tipo = const.tipo }

[35] { F.tipo = id.tipo }

[36] { se (F1.tipo != inteiro) então F1.tipo = inteiro

        se (F2.tipo != inteiro) então F2.tipo = inteiro }

[1] { F.end := id.end }

[2] {se const.tipo=string então

                dseg SEGMENT PUBLIC

                byte "const.lex$"

                dseg ENDS

                F.end := cont_dados

                cont_dados+= 256

senão

                F.end:=NovoTemp

                mov regA, const.lex

                mov F.end, regA }

[3] { F.end := Exp.end }

[4] { F.end := NovoTemp }

{ mov regA, Fi.end }

{ not regA }

{ mov F.end, regA}

[5] { T.end := F1.end }

[6.1] {T.op = *}

[6.2] {T.op = /}

[6.3] {T.op = and}

[7] { mov ax, DS:[T.end] }

{mov bx, DS:[F₂.end] }

{ se T.tipo != inteiro então

         cwd

se F₂.tipo != inteiro entao

         mov cx, DS:[ax]

         mov ax, DS:[bx]

         cwd

         mov DS:[bx], ax

         mov DS:[ax], cx}

{se T.op = “*” então

         imul bx

senao se T.op = “/” então

         idiv bx

senao

       and ax, bx}

{ T.end := NovoTemp }

{ mov DS:[T.end], ax }

[8] { Exps.neg = true }

[9] { se Exps.neg = true

        Exps.end = NovoTemp

        mov ax, DS:[T₁.end]

                neg ax

                mov DS:[Exps.end], ax}

{ ExpS.end := T1.end }

[10.1] { Exps.op =  + }

[10.2] { Exps.op =  - }

[10.3] { Exps.op =  or }

[11]  { mov ax, DS:[Exps .end] }

{ mov bx, DS:[T₂.end] }

{ se Exps.tipo != inteiro então

    cwd

se T₂.tipo != inteiro entao

    mov cx, DS:[ax]

         mov ax, DS:[bx]

         cwd

         mov DS:[bx], ax

         mov DS:[ax], cx}

{se Exps.op = “+” então

         imul bx

senao se Exps.op = “-” entao

         idiv bx

senao

         and ax, bx}

{ Exps.end := NovoTemp }

{ mov DS:[Exps.end], ax }

[12] { Exp.end = Exps₁.end }

[13.1] { Exp.op = “<” }

[13.2] { Exp.op = “>” }

[13.3] { Exp.op = “<=” }

[13.4] { Exp.op = “>=” }

[13.5] { Exp.op = “==” }

[13.6] { Exp.op = “!=” }

[14] { mov ax, DS:[Exp.end]

mov bx, DS:{Exps₂.end]

cwd

mov cx, DS:[ax]

mov ax, DS[bx]

cwd

mov DS:[bx],ax

mov DS:[ax],cx }

{ cmp ax, bx }

{ RotVerdadeiro = NovoRot }

{ se Exp.op = “=” então

      je RotVerdadeiro

senao se Exp.op = “!=” então

      jne RotVerdadeiro

senao se Exp.op = “<” então

      jl RotVerdadeiro

senao se Exp.op = “>” então

      jg RotVerdadeiro

senao se Exp.op = “>=” então

      jge RotVerdadeiro

senao

      jle RotVerdadeiro }

{ mov al, 0 }

{ RotFim = NovoRot }

{ jmp RotFim }

{ RotVerdadeiro: }

{ mov AL, 0FFh }

{ RotFim: }

{ Exp.end:=NovoTemp }

{ Exp.tipo:=TIPOLÓGICO }

{ mov Exp.end, AL }

[15] { mov ax, DS:[Exp.end] }

{ se id.tipo != Exp.tipo então

      cwd }

{ mov DS:[id.end], ax }

[16] { RotInicio:=NovoRot }

{ RotFim:=NovoRot }

{ RotInicio: }

[17] { mov ax, DS:[Exp.end] }

{ cmp ax, 0

      je RotFim }

[18] { jmp RotInicio }

{ RotFim: }

[19] { RotFalso:=NovoRot }

{ RotFim:=NovoRot }

[20] { mov ax, DS:[Exp.end] }

{ cmp ax, 0

      je RotFalso }

[21] { jmp RotFim }

{ RotFalso: }

[22] { RotFim: }

Encontrar Strings em Java

package lexica;
import java.util.ArrayList;
public class Main{
    public static void main(String[] args ){
     
        ArrayList<String> al = new ArrayList<String>();
     
        al.add("Java");
        al.add("linguagem C");
        al.add("Networking");
     
        if(al.contains("Networking")){//string procurada
            System.out.println("Networking encontrado na Lista");
        }else{
            System.out.println("Não encontrado");
        }
     
        String str = "   www.Voleichut-dow+Carlin~ klk ";//nova string
        char[] s = str.toCharArray();
        boolean t = false;
        for (char c : s){
            if(str.contains("ei")== true){//se verdadeiro
                t = true;
                System.out.println("achei: ei");
                break;//para o loop, senao imprimi muitas vezes
            }
            System.out.println(c);
        }
        System.out.println("____//____");
        System.out.println(str);
        System.out.println("indexOf [lei] = "+str.indexOf("lei", 0));//lei procurada, retorna a posição inicial que se encontra
        System.out.println("substring1 [8] = "+str.substring(8));//trunca a string a partir da posição 8
        System.out.println("substring2 [2,10] = "+str.substring(2, 10));//trunca a string a partir da pos 2 até a 10
        System.out.println("substring3 subSequence[0,5] = "+str.subSequence(0, 5));//trunca .. 0 ate 5
        System.out.println("Removendo i , o: "+str.replace('i', 'o'));//remove i e o
        System.out.println("Trim   : "+str.trim());
        StringBuilder a = new StringBuilder(str);
        System.out.println("Reverso: "+a.reverse());//string invertida
    }
}

saída gerada

Palavras chave:

contains no Java
indexOf no Java
substring no Java
subSequence no Java
trim no Java
reverse no Java