Pesquisar neste blog

13/11/2019

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());
        
    }
    
}

06/11/2019

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));
    }
 
}

04/11/2019

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
    }
}

25/10/2019

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:[F2.end] }
{ se T.tipo != inteiro então
         cwd
se F2.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:[T1.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:[T2.end] }
{ se Exps.tipo != inteiro então
    cwd
se T2.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 = Exps1.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:{Exps2.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: }

10/10/2019

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