OLX Vagas

Pessoal, a OLX e o blog boladão oferecem algumas vagas na área de tecnologia. Você gostaria de trabalhar no maior site de Classificados do Brasil, ajudando milhões de pessoas a comprar e vender pelas nossas plataformas?

Business PartnerLocalização: Rio de Janeiro
http://goo.gl/KemjkO

Coordenador de Fraude e Risco
Localização: Rio de Janeiro
http://goo.gl/nWSKDW

Líder de Relacionamento
Localização: Rio de Janeiro
http://goo.gl/W5OLT5

Estagiário Desenvolvimento do Negócio
Localização: Rio de Janeiro
http://goo.gl/nWSKDW

Designer UX
Localização: Rio de Janeiro
http://goo.gl/qEw8si

Analista de Faturamento
Localização: Rio de Janeiro
http://goo.gl/t6FMAI

Analista Comercial - Pós Vendas
Localização: São Paulo
http://goo.gl/eCLl5I

Coordenador de Treinamento - Vendas e Pós Vendas
Localização: São Paulo
http://goo.gl/kgjdEK

JMenuBar()

https://drive.google.com/file/d/0B0Vuu9ZWyhdyQmJIU0dwMFlFcVE/view?usp=sharing

GST0070 Aula 7 Inteligência Artificial

O uso da tecnologia da informação no contexto empresarial cada dia mais se torna uma realidade, principalmente se considerarmos o contexto atual em que a concorrência acirrada e a necessidade por uma gestão otimizada de recursos como Intranet, Extranet e OLAP possibilitam não somente um diferencial, mas requerem uma exigência por parte das organizações que desejam prevalecer no seu segmento, utilizando-se principalmente da sua base de conhecimento no desenvolvimento de Inteligência Artificial e Sistemas Especialistas.

Assim, escolha uma aplicação (domínio) da IA e pesquise uma empresa que faça uso da mesma. Sua postagem deve conter: segmento de mercado da empresa; tecnologia utilizada e descrição da utilização desta aplicação. Comente também o sucesso ou fracasso desta aplicação.

Polimorfismo | Exercício 9 | Resolução

package comum;

public class Contribuinte {

   private String nome;    
   private String endereco;
   private String telefone;
   private Double rendimentos;
   
   public void setNome(String nome) { this.nome = nome; }
   
   public String getNome() { return this.nome; }

   public String getEndereco() { return endereco; }

   public void setEndereco(String endereco) { this.endereco = endereco; }

   public String getTelefone() { return telefone; }

   public void setTelefone(String telefone) { this.telefone = telefone; }

   public double getRendimentos() {  return rendimentos; }

   public void setRendimentos(double rendimentos) { this.rendimentos = rendimentos;}
   
   public double calcularImposto() { return 0.0; }
    
}


package tipo;

import comum.Contribuinte;

public class PessoaFisica extends Contribuinte{

  private String cpf;

  public String getCpf() { return cpf; }

  public void setCpf(String cpf) { this.cpf = cpf; }
  
  @Override
  public double calcularImposto() {
        
        double r = getRendimentos(); 
        double i = 0;
        
        if ( r >= 0 && getRendimentos() <= 1000) 
        i = r * 0 / 100;    
        else if ( r > 1000 && getRendimentos() <= 2500) 
        i = r * 10 / 100; // R * 0.1;        
    
        return i;
    }
    
}


package tipo;

import comum.Contribuinte;

public class PessoaJuridica extends Contribuinte{

   private String cnpj;

  public String getCnpj() {  return cnpj;  }

  public void setCnpj(String cnpj) {  this.cnpj = cnpj; }
   
   @Override
    public double calcularImposto() {
        
        return 0.0;
    }
}

Polimorfismo

 

Exercício 1: Implemente a classe Funcionario e a classe Gerente.

a. crie a classe Assistente, que também é um funcionário, e que possui um número de matrícula (faça o método GET). Sobrescreva o método exibeDados().

b. sabendo que os Assistentes Técnicos possuem um bônus salarial e que os

Assistentes Administrativos possuem um turno (dia ou noite) e um adicional

noturno, crie as classes Tecnico e Administrativo.

Exercício 2: Implemente os diagramas de classe abaixo:

Exercício 3: Crie uma classe chamada Ingresso que possui um valor em reais e um método

imprimeValor().

a. crie uma classe VIP, que herda Ingresso e possui um valor adicional. Crie um

método que retorne o valor do ingresso VIP (com o adicional incluído).

b. crie uma classe Normal, que herda Ingresso e possui um método que imprime:

"Ingresso Normal".

c. crie uma classe CamaroteInferior (que possui a localização do ingresso e métodos

para acessar e imprimir esta localização) e uma classe CamaroteSuperior, que é

mais cara (possui valor adicional). Esta última possui um método para retornar o

valor do ingresso. Ambas as classes herdam a classe VIP.

Exercício 4: Crie a classe Imovel, que possui um endereço e um preço.

a. crie uma classe Novo, que herda Imovel e possui um adicional no preço. Crie

métodos de acesso e impressão deste valor adicional.

b. crie uma classe Velho, que herda Imovel e possui um desconto no preço. Crie

métodos de acesso e impressão para este desconto.

Exercício 5: Crie uma classe de Teste com o método main. Neste método:

a. crie um assistente administrativo e um técnico. Imprima o número de matrícula e o

nome de cada um deles.

b. crie um animal do tipo cachorro e faça-o latir. Crie um gato e faça-o miar. Faça os

dois animais caminharem.

c. teste (como quiser) as classes Rica, Pobre e Miseravel.

d. crie um ingresso. Peça para o usuário digitar 1 para normal e 2 para VIP.

Conforme a escolha do usuário, diga se o ingresso é do tipo normal ou VIP. Se for

VIP, peça para ele digitar 1 para camarote superior e 2 para camarote inferior.

Conforme a escolha do usuário, diga se que o VIP é camarote superior ou inferior.

Imprima o valor do ingresso.

e. crie um imóvel. Peça para o usuário digitar 1 para novo e 2 para velho. Conforme a

definição do usuário, imprima o valor final do imóvel.

ENADE ESTÁCIO

Os alunos concluintes terão acesso ao ambiente PROENADE Estácio. Segundo os critérios do MEC, são elegíveis:

Graduação: Que no final de agosto do ano da prova, tiverem 80% da carga horária cumprida ou tenham expectativa de formatura até julho do ano seguinte.

Graduação Tecnológica. Que no final de agosto do ano da prova, tiverem 75% da carga horária cumprida ou tenham expectativa de formatura até Dezembro do ano da prova.

Impactam nessa conta, portanto, o período de colação de grau da instituição, o tempo total do curso entre outros critérios da vida acadêmica do aluno, que devem estar com histórico em dia em relação a lançamentos de notas e equivalências de disciplinas extracurriculares.

A inscrição definitiva dos alunos acontece em agosto. Assim, os alunos que deverão estar na condição de elegíveis: são considerados aptos a participarem das ações do PROENADE os alunos dos 3 últimos períodos dos cursos de graduação e dos 2 últimos períodos dos cursos de graduação tecnológica observando a carga horária cursada pelo aluno.

Para acessar o ambiente PROENADE:

simulado.estacio.br/enade/

login: matrícula do aluno

Senha: senha do aluno

GST0070 ADM SIST INF TRABALHO #maisum

Boas-vindas EaD 2016.1

Jantar dos Filósofos - Resolução

package jantardosfilosofos;

import javax.swing.JFrame;

/**
 * Pós-Java PGN0060
 *
 * @Monteiro
 */
public class JantarDosFilosofos extends JFrame {

    public JantarDosFilosofos() {
        // Janela
        add(new Grade());

        // Titulo
        setTitle("Jantar dos Filósofos");

        // Operação ao fechar a janela
        setDefaultCloseOperation(EXIT_ON_CLOSE);

        // Tamanho do frame
        setSize(500, 500);

        // Local
        setLocationRelativeTo(null);

        // Visibilidade
        setVisible(true);

        // Bloqueia o redimensionamento
        setResizable(false);

    }

    public static void main(String[] args) {
        new JantarDosFilosofos();
    }

}

package jantardosfilosofos;

/**
 * Pós-Java PGN0060
 * @Monteiro 19/03/2016
 */

public class Filosofo extends Thread {
    // Cria um código privado para o filósofo
    private int ID;

    // Cria padrões de comportamento do filósofo
    final int PENSANDO = 0;
    final int FAMINTO  = 1;
    final int COMENDO  = 2;

    // Método construtor que recebe um nome para a classe e um código de
    // identificação do filósofo
    public Filosofo (String nome, int ID)
    {
        super(nome);
        this.ID = ID;
    }

    // Método para definir que o filósofo está com fome
    public void ComFome ()
    {
        // Seta o estado deste filósofo na classe Grade para FAMINTO
        Grade.estado[this.ID] = 1;
        // Exibe uma mensagem de controle na tela
        System.out.println("O Filósofo " + getName() + " está FAMINTO!");
    }

    // Método para definir que o filósofo está comendo
    public void Come ()
    {
        // Seta o estado deste filósofo na classe Grade para COMENDO
        Grade.estado[this.ID] = 2;
        // Exibe uma mensagem de controle na tela
        System.out.println("O Filósofo " + getName() + " está COMENDO!");

        // Será criado um controle para o filósofo permanecer comendo
        // durante certo período de tempo
        try
        {
            // Fica parado neste estado por 1000 milisegundos
            Thread.sleep(1000L);
        }
        catch (InterruptedException ex)
        {
            // Exibe uma mensagem de controle de erro
            System.out.println("ERROR>" + ex.getMessage());
        }
    }

    // Método para definir que o filósofo está pensando
    public void Pensa ()
    {
        // Seta o estado deste filósofo na classe Grade para PENSANDO
        Grade.estado[this.ID] = 0;
        // Exibe uma mensagem de controle na tela
        System.out.println("O Filósofo " + getName() + " está PENSANDO!");

        // Será criado um controle para o filósofo permanecer pensando
        // durante certo período de tempo
        try
        {
            // Fica parado neste estado por 1000 milisegundos
            Thread.sleep(1000L);
        }
        catch (InterruptedException ex)
        {
            // Exibe uma mensagem de controle de erro
            System.out.println("ERROR>" + ex.getMessage());
        }
    }

    // Método para o filósofo soltar um garfo que ele pegou
    public void LargarGarfo ()
    {
        // Decrementa o semáforo mutex principal da classe, isso permite
        // informar que o atual método está operando na mesa dos filósofos
        Grade.mutex.decrementar();

        // Coloca o filósofo para pensar determinado tempo
        Pensa();

        // Após o filósofo pensar, ele vai informar para os seus vizinhos
        // que podem tentar pegar os garfos que já estão disponíveis
        Grade.filosofo[VizinhoEsquerda()].TentarObterGarfos();
        Grade.filosofo[VizinhoDireita()].TentarObterGarfos();

        // Após operar, volta o semáforo mutex para o estado normal
        // indicando que já realizou todos procedimentos na mesa
        Grade.mutex.incrementar();
    }

    // Método para o filósofo pegar um garfo na mesa
    public void PegarGarfo ()
    {
        // Decrementa o semáforo mutex principal da classe, isso permite
        // informar que o atual método está operando na mesa dos filósofos
        Grade.mutex.decrementar();

        // Deixa o filósofo faminto por determinado tempo
        ComFome();

        // Após o filósofo o período de fome, ele vai verificar com seus
        // vizinhos se ele pode pegar os garfos
        TentarObterGarfos();

        // Após operar, volta o semáforo mutex para o estado normal
        // indicando que já realizou todos procedimentos na mesa
        Grade.mutex.incrementar();
        // Decrementa seu semáforo
        Grade.semaforos[this.ID].decrementar();
    }

    // Método para verificar se o filósofo pode pegar um garfo disposto na mesa
    public void TentarObterGarfos()
    {

        // Verifica se este filósofo está com fome, e se o vizinho da esquerda
        // e da direita não estão comendo
        if (Grade.estado[this.ID] == 1 &&
            Grade.estado[VizinhoEsquerda()] != 2 && 
            Grade.estado[VizinhoDireita()] != 2)
        {
            // Então este filósofo pode comer
            Come();
            // E incrementa o seu semáforo
            Grade.semaforos[this.ID].incrementar();
        }

    }

    // Método de execução da classe, onde o ambiente do filósofo será rodado
    @Override
    public void run ()
    {

        try
        {
            // Coloca o filósofo para pensar
            Pensa();

            // Então realiza uma vida infinita para o filósofo onde inicialmente
            // ele executa os procedimentos de pergar os garfos da mesa, posteriormente
            // ele descansa um pouco, e por fim, ele largar os garfos que ele pegou
            do
            {
                PegarGarfo();
                Thread.sleep(1000L);
                LargarGarfo();
            }
            while (true);
        }
        catch (InterruptedException ex)
        {
            // Exibe uma mensagem de controle de erro
            System.out.println("ERROR>" + ex.getMessage());
            // E da um retorno de cancelamento
            return;
        }

    }

    // Método para obter o filósofo vizinho da direita
    public int VizinhoDireita ()
    {
        // Rationa o valor em 5 posições, ou seja, se o ID deste filósofo acrescentado
        // de um for maior que quatro, passa a ser zero
        return (this.ID + 1) % 5;
    }

    // Método para obter o filósofo vizinho da esquerda
    public int VizinhoEsquerda ()
    {
        if (this.ID == 0)
        {
            // Retorna a ultima posição
            return 4;
        }
        else
        {
            // Rationa o valor em 5 posições, ou seja, se o ID deste filósofo decrescido
            // de um for menor que zero, passa a ser quatro
            return (this.ID - 1) % 5;
        }
    }

}

package jantardosfilosofos;

/**
 *
 * @author aluno
 */
public class Semaforo {
    // Criação de um contador protegido para esta classe
    protected int contador;

    // Método construtor da classe que não recebe nenhum valor
    public Semaforo ()
    {
        this.contador = 0;
    }

    // Método construtor da classe que recebe um valor para setar no
    // contador
    public Semaforo (int valor)
    {
        this.contador = valor;
    }

    // Método de sincronização da classe onde será decrescido o contador
    public synchronized void decrementar ()
    {

        // Enquanto o contador for igual a 0, ele aguarda e trata a exceção
        while (this.contador == 0)
        {
            try
            {
                // Espera uma nova solicitação
                wait();
            }
            catch (InterruptedException ex)
            {
                // Exibe uma mensagem de controle de erro
                System.out.println("ERROR>" + ex.getMessage());
            }
        }

        // Caso tenha saído do while acima, então decrementa o
        // contador da classe
        this.contador--;

    }

    // Método de sincronização da classe onde será incrementado o contador
    public synchronized void incrementar ()
    {
        // Incrementa o contador da classe
        this.contador++;
        // Notifica que a solicitação já foi executada
        notify();
    }

}

package jantardosfilosofos;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Toolkit;
import javax.swing.JPanel;

/**
 *
 * @author aluno
 */

public class Grade extends JPanel implements Runnable{
    
    // Cria padrões de comportamento dos filósofos
    final int PENSANDO = 0;
    final int FAMINTO  = 1;
    final int COMENDO  = 2;

    // Mensagem para cada um dos estados
    String mensagem = "";

    // Thread principal da aplicação
    Thread animador;

    // Criação dos semáforos da aplicação

    // O semáforo mutex que recebe o valor incial 1 para o contador
    // e é o semáforo principal da nossa aplicação
    public static Semaforo mutex = new Semaforo(1);

    // O vetor semáforos são normais e existe um semáforo para cada filósofo
    // que será criado, esses semafóros não recebem valores de inicialização
    // portanto iniciando o contador em 0
    public static Semaforo semaforos[] = new Semaforo[5];

    // Define um vetor para o estado de cada um dos filósofos presentes
    // na aplicação
    public static int estado[] = new int[5];

    // Cria 5 filósofos em um vetor para a aplicação
    static Filosofo filosofo[] = new Filosofo[5];

    // Método construtor da Grade da aplicação
    public Grade ()
    {
        // Define o foco para este JPanel
        setFocusable(true);

        // Define um tamanho para a tela
        setSize(400, 400);
        
        // Seta a cor do fundo
        setBackground(Color.white);
        
        init();
    }

    // Método para inicializar tudo o que é preciso dentro da classe
    public void init ()
    {
        // Inicializa todos estados para zero
        for (int i = 0; i < estado.length; i++)
        {
            estado[i] = 0;
        }

        // Verifica se o Thread de animação é vazio
        if(animador == null)
        {
            // Então cria um novo Thread
            animador = new Thread(this);
            // Inicia sua execução
            animador.start();
        }

        // Define a prioridade principal para este atual Thread
        Thread.currentThread().setPriority(1);

        // Inicializa todos filósofos
        filosofo[0] = new Filosofo("Platao", 0);
        filosofo[1] = new Filosofo("Socrates", 1);
        filosofo[2] = new Filosofo("Aristoteles", 2);
        filosofo[3] = new Filosofo("Tales", 3);
        filosofo[4] = new Filosofo("Sofocles", 4);

        // Inicializa todos semáforos
        semaforos[0] = new Semaforo(0);
        semaforos[1] = new Semaforo(0);
        semaforos[2] = new Semaforo(0);
        semaforos[3] = new Semaforo(0);
        semaforos[4] = new Semaforo(0);

        // Inicia a execução de todos filósofos
        filosofo[0].start();
        filosofo[1].start();
        filosofo[2].start();
        filosofo[3].start();
        filosofo[4].start();
    }

    // Método para desenhar os objetos na tela da aplicação
    @Override
    public void paint(Graphics g)
    {
        super.paint(g);
        
        // Define a cor azul
        g.setColor(Color.blue);
        // Cria um circulo na posição (50,50) do plano cartesiano com tamanho
        // 300x300
        g.drawOval(50, 50, 300, 300);

        // Para cada um dos filósofos será feito um desenho
        for(int i = 0; i < 5; i++)
        {            
            // Define a cor para cara tipo de estado
            if(estado[i] == 0)
            {
                g.setColor(Color.gray);
                mensagem = "PENSANDO";
            }
            if(estado[i] == 1)
            {
                g.setColor(Color.yellow);
                mensagem = "FAMINTO";
            }
            if(estado[i] == 2)
            {
                g.setColor(Color.green);
                mensagem = "COMENDO";
            }
            
            // Desenha o filósofo, sua carinha e seu nome na tela
            // Define os planos (x,y) e posteriormente o tamanho do objeto a ser desenhado
            g.fillOval((int)(200D - 100D * Math.cos(1.2566370614359172D * (double)i)) - 15, (int)(200D - 100D * Math.sin(1.2566370614359172D * (double)i)) - 15, 30, 30);
            g.setColor(Color.black);
            g.drawLine((int)(200D - 100D * Math.cos(1.2566370614359172D * (double)i)) - 5, (int)(200D - 100D * Math.sin(1.2566370614359172D * (double)i)) + 5, (int)(200D - 100D * Math.cos(1.2566370614359172D * (double)i)) + 5, (int)(200D - 100D * Math.sin(1.2566370614359172D * (double)i)) + 5);
            g.drawLine((int)(200D - 100D * Math.cos(1.2566370614359172D * (double)i)) - 2, (int)(200D - 100D * Math.sin(1.2566370614359172D * (double)i)) - 3, (int)(200D - 100D * Math.cos(1.2566370614359172D * (double)i)) + 2, (int)(200D - 100D * Math.sin(1.2566370614359172D * (double)i)));
            g.drawLine((int)(200D - 100D * Math.cos(1.2566370614359172D * (double)i)) - 2, (int)(200D - 100D * Math.sin(1.2566370614359172D * (double)i)), (int)(200D - 100D * Math.cos(1.2566370614359172D * (double)i)) + 2, (int)(200D - 100D * Math.sin(1.2566370614359172D * (double)i)));
            g.drawLine((int)(200D - 100D * Math.cos(1.2566370614359172D * (double)i)) - 8, (int)(200D - 100D * Math.sin(1.2566370614359172D * (double)i)) - 8, (int)(200D - 100D * Math.cos(1.2566370614359172D * (double)i)) - 3, (int)(200D - 100D * Math.sin(1.2566370614359172D * (double)i)) - 8);
            g.drawLine((int)(200D - 100D * Math.cos(1.2566370614359172D * (double)i)) + 3, (int)(200D - 100D * Math.sin(1.2566370614359172D * (double)i)) - 8, (int)(200D - 100D * Math.cos(1.2566370614359172D * (double)i)) + 8, (int)(200D - 100D * Math.sin(1.2566370614359172D * (double)i)) - 8);
            g.drawString(filosofo[i].getName(), (int)(200D - 100D * Math.cos(1.2566370614359172D * (double)i)) - 15, (int)(200D - 100D * Math.sin(1.2566370614359172D * (double)i)) + 25);
            g.drawString(mensagem, (int)(200D - 100D * Math.cos(1.2566370614359172D * (double)i)) - 15, (int)(200D - 100D * Math.sin(1.2566370614359172D * (double)i)) + 40);
        }

        // ATIVA A SINCRONIA
        Toolkit.getDefaultToolkit().sync();
        // PAUSA
        g.dispose();

    }

    // Método de execução da classe, onde o ambiente será rodado
    public void run ()
    {        
        // Uma execução infinita
        do
        {
            // Redesenha a tela
            repaint();

            // Dorme durante um tempo para redesenhar novamente
            try
            {
                Thread.sleep(1000L);
            }
            catch (InterruptedException ex)
            {
                // Exibe uma mensagem de controle de erro
                System.out.println("ERROR>" + ex.getMessage());
            }
        }
        while (true);
    }

}

Palavras cruzadas

1. Tipo primitivo que armazena valores de ponto flutuante.

2. Palavra reservada, cuja função é instanciar dinamicamente um novo objeto.

3. instância de uma classe, uma variável do tipo de dados definida pela classe.

4. Palavra-chave que indica que um método realizará uma tarefa, mas não retornará nenhuma informação ao completar sua tarefa. 

5. Em geral está intimamente ligado ao conceito de “esconder informação.

6. Atributos e métodos com esse modificador de acesso, só são visíveis a própria classe e demais classes do mesmo pacote.

7. Empacotadores de tipos primitivos, também chamados de classes...?
8. Modificador de acesso onde apenas a própria classe tem acesso.

9. Representação estática, também chamada de molde ou protótipo.
10. Estrutura utilizada para inicializar um objeto de uma classe quando o objeto for criado. 

11. Espelho do tipo primitivo char.

12. Conceito da programação orientada à objetos, onde temos Métodos com o mesmo nome, mas assinatura diferente.

13. Função em Java, proveniente da biblioteca Math, cujo objetivo é retornar um número aleatório.

14. Matriz unidimensional.

15.  Método, para permitir acesso a dados privados, em outra classe, tendo como proposta o retorno de valores.

X Semana de Tecnologia

http://prezi.com/mp_scywuan8f/?utm_campaign=share&utm_medium=copy

Boas-vindas 100% EaD | Estácio | Nova Iguaçu

Boas-vindas 2016.1 EaD 100% | Estácio Campus Nova Iguaçu

X Semana de Tecnologia/Campus Nova Iguaçu

JRadioButton()

Fonte: javaprogressivo.net

http://www.javaprogressivo.net/2014/05/JRadioButton-Botao-Radio-Opcao-Tutorial-de-Java-GUI.html

Threads | Código Exercício | #posJava

Link da aula: https://prezi.com/2kzsdcr901gt/threads/?utm_campaign=share&utm_medium=copy
Resolução: Threads Syncronized

package br.com.estacio.threads;

public class ContaConjunta {
    
    private int saldo = 100;

    public int getSaldo() {
        return saldo;
    }
    
    public synchronized void sacar(int valor, String cliente) {
        if (saldo >= valor) {
            int sO = saldo;
            System.out.println(cliente+" vai sacar");
            try {
                
                System.out.println(cliente+" esperando...");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                
            }
            saldo -= valor;
            String msg = cliente + " SACOU "+valor+
                         " [Saldo Original "+sO+
                         " Saldo final "+saldo+" ]";
            System.out.println(msg);
        } else {
            System.out.println("Saldo insuficiente");
        }
    }
    
}


package br.com.estacio.threads;

public class ComprasEmFamilia implements Runnable{
    
    ContaConjunta conta = new ContaConjunta();
    
    public static void main (String[] args) {
        
        ComprasEmFamilia irAsCompras = new ComprasEmFamilia();
        new Thread(irAsCompras, "Pai").start();
        new Thread(irAsCompras, "Mãe").start();
        new Thread(irAsCompras, "Filha").start();
        new Thread(irAsCompras, "Babá").start();
    }

    @Override
    public void run() {
         String cliente = Thread.currentThread().getName();
         for (int i=0; i <5; i++){
             conta.sacar(20,cliente);
             if (conta.getSaldo() <=0) {
                 System.out.println("Estourou");
             }
         }
    }
}

Polimorfismo | Exercício 7 | Resolução

package Exercicio5;

public abstract class Professor {

   protected String nome;
   private String matricula;
   private int idade;
   private double salarioBruto;
   private int desconto;

    /**
     * @return the nome
     */
    public String getNome() {
        return nome;
    }

    /**
     * @param nome the nome to set
     */
    public void setNome(String nome) {
        this.nome = nome;
    }

    /**
     * @return the matricula
     */
    public String getMatricula() {
        return matricula;
    }

    /**
     * @param matricula the matricula to set
     */
    public void setMatricula(String matricula) {
        this.matricula = matricula;
    }

    /**
     * @return the idade
     */
    public int getIdade() {
        return idade;
    }

    /**
     * @param idade the idade to set
     */
    public void setIdade(int idade) {
        this.idade = idade;
    }

    /**
     * @return the salarioBruto
     */
    public double getSalarioBruto() {
        return salarioBruto;
    }

    /**
     * @param salarioBruto the salarioBruto to set
     */
    public void setSalarioBruto(double salarioBruto) {
        this.salarioBruto = salarioBruto;
    }

    /**
     * @return the desconto
     */
    public int getDesconto() {
        return desconto;
    }

    /**
     * @param desconto the desconto to set
     */
    public void setDesconto(int desconto) {
        this.desconto = desconto;
    }
    
    public double calcularSalario() {
       
        return this.salarioBruto - (this.salarioBruto * this.desconto /100);
    }
    
    public void exibirProfessor() {
        
    }
}

package Exercicio07;

import Exercicio5.Professor;

public class ProfHorista extends Professor{

   private int horasTrabalhadas;
   private double valorHora;

    /**
     * @return the horasTrabalhadas
     */
    public int getHorasTrabalhadas() {
        return horasTrabalhadas;
    }

    /**
     * @param horasTrabalhadas the horasTrabalhadas to set
     */
    public void setHorasTrabalhadas(int horasTrabalhadas) {
        this.horasTrabalhadas = horasTrabalhadas;
    }

    /**
     * @return the valorHora
     */
    public double getValorHora() {
        return valorHora;
    }

    /**
     * @param valorHora the valorHora to set
     */
    public void setValorHora(double valorHora) {
        this.valorHora = valorHora;
    }
   
   @Override
   public double calcularSalario() {
           
        return this.valorHora * this.horasTrabalhadas; 
    }
    
    public void exibirProfessor() {
        
    }
}

import Exercicio5.Professor;

public class ProfDedicado extends Professor{

}

package Exercicio5;

import Exercicio07.ProfDedicado;
import Exercicio07.ProfHorista;

public class AppProfessor {

    public static void main(String[] args) {
        
        ProfDedicado profD = new ProfDedicado();
        ProfHorista profH = new ProfHorista();
    }
}

Mais Herança...... e Polimorfismo

#CompartilheGoogleApps

A Google lançou uma campanha mundial de divulgação do seu pacote de aplicativos: "Compartilhe jeitos flexíveis de trabalhar #CompartilheGoogleApps", com intuito de oferecer a pequenas empresas um registro de domínio, Com isso, terão acesso ao seu canivete suíço office. Podendo utilizar emails personalizados, ferramentas colaborativas e muito mais. 

O mais interessante é que a cada novo domínio indicado registrado, você receberá US$ 15,00, podendo chegar a US$ 1500 ! Será? Na dúvida, eu já fiz minha inscrição !

Para resgatar a oferta:

1. Inscreva-se no Google Apps

2. Acesse suas configurações de faturamento

3. Escolha o plano de pagamento


4. Insira o código promocional: 93PUWFHP4CMFTD4QTRPVT3W3KA97

Saiba mais: https://goo.gl/xUJgwh

CCT0314 Resolução Exercícios 1 a 4 - Contribuição aluna Nicole Barbosa

package exercicio01;

public class Professor {

    private String nome;
    private String matricula;
    private int idade;
    private double salarioBruto;
    private int desconto;
    
    public double calculaSalario(){
        return salarioBruto - (salarioBruto*desconto/100);
    }
    
    public void setNome(String nome){
        this.nome = nome;
    }
    
    public String getNome(){
        return this.nome;
    }
    
    public void setMatricula(String matricula){
        this.matricula = matricula;
    }
    
    public String getMatricula(){
        return this.matricula;
    }
    
    public void setIdade(int idade){
        this.idade = idade;
    }
    
    public int getIdade(){
        return this.idade;
    }
    
    public void setSalarioBruto(double salarioBruto){
        this.salarioBruto = salarioBruto;
    }
    
    public double getSalarioBruto(){
        return this.salarioBruto;
    }
    
    public void setDesconto(int desconto){
        this.desconto = desconto;
    }
    
    public int getDesconto(){
        return this.desconto;
    }
}


package exercicio02;

import exercicio03.Professor;
import javax.swing.JOptionPane;
public class UsaProfessor {
    public static void main(String[] args) {
        Professor x = new Professor();
        x.setNome("Teste");
        x.setMatricula("123123");
        x.setIdade(Integer.parseInt(JOptionPane.showInputDialog("Insira a idade: ")));
        x.setSalarioBruto(5000);
        x.setDesconto(30);
        System.out.println(x.calculaSalario());
    }
}

package exercicio03;
import javax.swing.JOptionPane;
public class Professor {

    private String nome;
    private String matricula;
    private int idade;
    private double salarioBruto;
    private int desconto;
    
    public double calculaSalario(){
        return salarioBruto - (salarioBruto*desconto/100);
    }
    
    public void setNome(String nome){
        this.nome = nome;
    }
    
    public String getNome(){
        return this.nome;
    }
    
    public void setMatricula(String matricula){
        this.matricula = matricula;
    }
    
    public String getMatricula(){
        return this.matricula;
    }
    
    public void setIdade(int idade){
        this.idade = idade;
    }
    
    public int getIdade(){
        return this.idade;
    }
    
    public void setSalarioBruto(double salarioBruto){
        this.salarioBruto = salarioBruto;
    }
    
    public double getSalarioBruto(){
        return this.salarioBruto;
    }
    
    public void setDesconto(int desconto){
        this.desconto = desconto;
    }
    
    public int getDesconto(){
        return this.desconto;
    }
    
    public void exibirProfessor(){
       JOptionPane.showMessageDialog(null, "Nome: " + this.nome + "\n Matricula: " + this.matricula + "\n Idade: " + this.idade + "\n Salario Bruto: " + this.salarioBruto + "\n Desconto: " + this.desconto); 
    }
}

Herança #sqn

JCheckBox() | ItemListener | itemStateChanged()

#dicas

- O componente JCheckBox() responde a uma ação de mudança de estado;
- Para que a seleção seja reconhecida, não esqueça do addListener();
- O método precisa verificar qual objeto gerou o evento e.getSource();
- deve-se comparar o estado e.getStateChange() com o ItemEvent.SELECTED;
- crie uma variável interna no método para receber as propriedades da fonte;

Resolução itemStateChanged()

@Override
    public void itemStateChanged(ItemEvent e){
        if(e.getSource() == b1){
            if(e.getStateChange() == ItemEvent.SELECTED){
                N = Font.BOLD;
            }else{
                N = Font.PLAIN;
            }
        }
        if(e.getSource() == b2){
            if(e.getStateChange() == ItemEvent.SELECTED){
                I = Font.ITALIC;
            }else{
                I = Font.PLAIN;
            }
        }
        l1.setFont(new Font("Arial", N+I, 14));
    }

Text Mining - Extraindo informação de dados não estruturados

O mundo hoje é orientado à informação. As evoluções de Big Data, Social Media, Mobile e Cloud

Computing contribuem para que o volume de dados na web cresça exponencialmente, mas se engana

quem relaciona a quantidade de dados à qualidade de informação. Extrair informações estruturadas

para orientação de análises é um verdadeiro desafio. Quem deseja estar à frente no mundo da Internet

das Coisas, e não apenas seguir as tendências como também predizê-las, 

precisa aplicar a Inteligência Artificial. A Mineração de Texto (Text Mining), em especial, 

auxilia na constituição, por meio de dados não estruturados, de padrões, associações, mudanças

e anomalias úteis para a produção de conhecimento.

Estudos da EMC, líder mundial de armazenamento de dados, afirmam que até 2020 teremos aproximadamente 44 ZetaBytes (ou 44 trilhões GBs) de dados armazenados. Portanto, a Mineração de Texto se tornará indispensável.

O processo de Mineração de Texto não é simples, mas possui pilares que direcionam qualquer projeto ao êxito: objetivo bem definido, profissionais qualificados, softwares emetodologia são a base do sucesso.

Definição do objetivo

Tenha um objetivo claro e sucinto. De preferência, tenha um problema a ser solucionado com KDT (Knowledge Discovery in Text) dentro de um desses tipos de respostas do algoritmo:

• Classificação;
• Valor numérico;
• Regra de negócio.
• 
  

Para alcançar essas respostas, é importante traçar metas plausíveis e estar ciente de que o modelo obtido – nome dado ao produto final de mineração – pode ser constantemente refinado. Há 2 fatores-chave que determinam a conclusão do refinamento: tempo e recurso. Quando o projeto impactar um desses 2 indicadores, é hora de finalizá-lo. Comece determinando seu fim.

Equipe necessária

É necessário ter conhecimento em diversas áreas de estudo para construir um modelo de Mineração de Texto. Para construir modelos eficientes, é desejável que esse conhecimento seja dividido entre profissionais de suas respectivas áreas para extrair o máximo de informação de cada uma. O analista de negócio é necessário para direcionar os objetivos dos estudos às necessidades do cliente; o engenheiro de dados deve trabalhar em conjunto com um estatístico e um linguista para determinar, processar e testar a eficácia dos algoritmos. Por fim, o gerente de projeto é necessário para garantir que os profissionais sigam a metodologia proposta.

Softwares, técnicas e algoritmos

Para criar um modelo é necessário ter uma base de dados de histórico com as “respostas” que o seu projeto atual busca encontrar. Esses dados são imputados nas ferramentas de modelagem, para treinamento dos algoritmos. Atualmente o mercado tecnológico tem oferecido uma vasta gama de opções para a construção de um modelo preditivo, sejam elas pagas ou open source, visando maior facilidade de implementação e eficiência. A linguagem R permite bastante flexibilidade por ser uma linguagem de programação estatística; a ferramenta Weka também é comumente utilizada e difundida no mercado, ambas as opções oferecem algoritmos prontos como K-Means, Naive Bayes, Árvores de Decisão e afins, que dependendo do projeto alcançam bons resultados. Outra opção em destaque é o Orange, em Python, que oferece uma rica interface gráfica, além de código aberto.

Algumas ferramentas pagas, como o Google Prediction, dispensam algumas etapas de pré-processamento por executarem técnicas como Filtering (remoção de caracteres especiais e acentuação de palavras), Steaming (sintetização de palavras para seu radical) e Stop Words (exclusão de palavras irrelevantes) de forma oculta, diretamente nos seus algoritmos. Os softwares concorrentes como Amazon ML, Microsoft Azure ML e IBM Watson também são boas opções, oferecendo inclusive técnicas de validação para o preditivo.

Metodologia

A metodologia é um guia que direciona os profissionais envolvidos no projeto à conclusão de um modelo satisfatório. O CRISP-DM (Cross Industry Standard for Data Mining) é a metodologia referência no mercado de Data Mining e é comumente utilizado em projetos de Text Mining. Elaborado por diversos profissionais da área, na década de 90, e hoje sob os direitos da IBM, o documento lista 6 fases que devem constar em quaisquer projetos de mineração, cada fase contendo tarefas genéricas designadas a profissionais específicos. Apesar de sequencial, a metodologia não é linear, permitindo a equipe refazer etapas para o refinamento do modelo. Suas fases são:

• Entendimento do Negócio;

• Entendimento dos Dados;

• Preparação dos Dados;

• Modelagem;

• Avaliação;

• Entrega.
• 
  

Seguindo a metodologia, tendo profissionais qualificados, um objetivo bem definido entre o grupo de trabalho e com os softwares adequados, certamente você terá um modelo satisfatório.

Bruno Mercadante Delbuono Dos Anjos

InMarketing Digital

http://www.dp6.com.br/text-mining-extraindo-informacao-de-dados-nao-estruturados/