Pesquisar neste blog

13/11/2019

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

30/09/2019

Somador, subtrator, divisor e multiplicador no Logisim



Circuito de um microprocessador e seus comandos com mmemônico

CPU de uma ULA no Logisim 2.7














CI_Ula_Nova


















CPU_Ev2




















































Créditos para o professor Giuliano - IFMT - Microprocessadores

Clique aqui para fazer o download do arquivo feito no Logism

Palavras chave:

Adder, subtractor, divisor and multiplier in Logisim
Opteller, aftrekker, verdeler en vermenigvuldiger in Logisim
Bộ cộng, phép trừ, số chia và số nhân trong Logisim
Логисим дахь холбогч, хасагч, хуваагч ба үржүүлэгч
ตัวบวก, ตัวหาร, ตัวหารและตัวคูณใน Logisim
Adder, subtraherare, divisor och multiplikator i Logisim
Logisim'de toplayıcı, çıkartıcı, bölen ve çarpan
Sommatore, sottrattore, divisore e moltiplicatore in Logisim
Adder, изваждане, делител и умножител в Logisim

16/09/2019

Divisão binária no Logisim

Objetivo:
Fazer um circuito de divisão binária, onde para fazer a divisão é subtraído n vezes o divisor até chegar no resultado. Se n vezes subtraído e o resto = 0 então divisão binária OK.
Divisão no Logisim 2.7