Pessoa Java

//Principal

====================================================

import java.util.*;
public class Principal{

    public static Pessoa Popula(Pessoa p){
        Scanner scan = new Scanner(System.in);
        System.out.println("Informe o nome da Pessoa: ");
        p.setNome(scan.nextLine());
        scan = new Scanner(System.in);
        System.out.println("Informe a idade da Pessoa: ");
        p.setIdade(scan.nextInt());
        scan = new Scanner(System.in);
        System.out.println("Informe o telefone da Pessoa: ");
        p.setTelefone(scan.nextLine());
        scan = new Scanner(System.in);
        System.out.println("Informe o RG da Pessoa: ");
        p.setRG(scan.nextLine());

        System.out.println();
        return p;
    }

    public static Aluno Popula(Aluno p){
        Scanner scan = new Scanner(System.in);
        System.out.println("Informe o nome do Aluno: ");
        p.setNome(scan.nextLine());
        scan = new Scanner(System.in);
        System.out.println("Informe a idade do Aluno: ");
        p.setIdade(scan.nextInt());
        scan = new Scanner(System.in);
        System.out.println("Informe o telefone do Aluno: ");
        p.setTelefone(scan.nextLine());
        scan = new Scanner(System.in);
        System.out.println("Informe o RG do Aluno: ");
        p.setRG(scan.nextLine());
        System.out.println("Informe o série do Aluno: ");
        p.setSerie(scan.nextLine());
        System.out.println("Informe a matricula do Aluno: ");
        p.setMatricula(scan.nextDouble());
      
        System.out.println();
        return p;
    }
  
    public static void imprimePessoa(Pessoa p){
        System.out.println("Nome: " + p.getNome());
        System.out.println("Idade: " + p.getIdade());
        System.out.println("Telefone: " + p.getTelefone());
        System.out.println("RG: " + p.getRG());

        }
    public static void imprimeAluno(Aluno p){
        System.out.println("Nome: " + p.getNome());
        System.out.println("Idade: " + p.getIdade());
        System.out.println("Telefone: " + p.getTelefone());
        System.out.println("RG: " + p.getRG());
        System.out.println("Série: " + p.getSerie());
        System.out.println("Matrícula: " + p.getMatricula());

        }

    public static void main(String[] args){

    Pessoa p = new Pessoa();
      
        Pessoa listaPessoa[] = new Pessoa[1];
        for (int i=0; i<1; i++){
            p = Popula(p);
            listaPessoa[i] = p;
            p = new Pessoa();
        }
      
        for(int j=0; j<1; j++){
            p = listaPessoa[j];
            imprimePessoa(p);
            System.out.println();
        }

    Aluno  a = new Aluno();

        Aluno listaAluno[] = new Aluno[1];
        for (int i=0; i<1; i++){
            a = Popula(a);
            listaAluno[i] = a;
            a = new Aluno();
        }
      
        for(int j=0; j<1; j++){
            a = listaAluno[j];
            imprimeAluno(a);
            System.out.println();
        }
    }
}

//Pessoa

===================================================

public class Pessoa{
  
    private String nome;
    private int idade;
    private String telefone;
    private String RG;
  
    public String getNome(){
        return nome;
    }
    public void setNome(String n){
        nome = n;
    }
    public int getIdade(){
        return idade;
    }
    public void setIdade(int i){
        idade = i;
    }
    public String getTelefone(){
        return telefone;
    }
    public void setTelefone(String t){
        telefone = t;
    }
    public String getRG(){
        return RG;
    }
    public void setRG(String r){
        RG = r;
    }
}

//Aluno

===================================================
public class Aluno extends Pessoa{
    private String serie;
    private int matricula;

    public String getSerie(){
        return serie;
    }
    public void setSerie(String s){
        serie = s;
    }
    public int getMatricula(){
        return matricula;
    }
    public void setMatricula(int m){
        matricula = m;
    }
}

Relogio Java

//Principal
====================================================
 import java.util.*;
public class Principal{
    public static void main(String[] args){
    int i = 0;
    int h1 = 0;
    int m1 = 0;
    int s1 = 0;
   
    Relogio r = new Relogio();
    Scanner scan = new Scanner(System.in);

    System.out.println("Informe Hora");
    h1 = scan.nextInt();
    r = new Relogio(h1);

    System.out.println("Informe Minuto");
    m1 = scan.nextInt();
    //r = new Relogio(m1);

    System.out.println("Informe Segundo");
    s1 = scan.nextInt();
    //r = new Relogio(s1);

                                                                System.out.println("Informe Contador");
                                                                a = scan.nextInt();
                                                                c = new Contador(a);

    while(i<3600){
        r.imprimeHora();
        r.incrementarRelogio();
        i++;
        }
    }
}

//Relogio
====================================================
public class Relogio{
    private int h, m, s;
    public Relogio(){
        s = 0;
        m = 0;
        h = 0;
    }
    public Relogio(int h1, int m1, int s1){
        s = s1;
        m = m1;
        h = h1;       
    }
    public void incrementarRelogio(){
        s++;       
    if(s>59){
        s=0;
        m++;
    }
        if(m>59){
            m=0;
            h++;
        }
            if(h>24){
                h=0;
            }
    }
    public void imprimeHora(){
        System.out.println(h + ":" + m + ":" + s);       
    }
}

Contador Java

//Principal.java
=================================================
 import java.util.*;
public class Principal{
    public static void main(String[] args){
    int op = 1;
    int a = 1;
    Contador c = new Contador();
    Scanner scan = new Scanner(System.in);

    while(op !=0){
        System.out.println("1 - Incrementar");
        System.out.println("2 - Decrementar");
        System.out.println("3 - Exibir");
        System.out.println("4 - Definir");

        op = scan.nextInt();
        if(op==1){
            c.incrementarContador();
            System.out.println("Contador Incrementado");
        }
        else{
                    if(op==2){
                                    c.decrementarContador();
                                    System.out.println("Contador Decrementado");
                    }
                    else{
                            if(op==3){
                                        System.out.println("Valor do contador " + c.obterContador());
                            }
                                                else{
                                                        if(op==4){
                                                                System.out.println("Informe Contador");
                                                                a = scan.nextInt();

                                                                c = new Contador(a);
                                                        }
                                                        else{
                                                            System.out.println("Opção Invalida");
                                                        }
                    }
                }
            }
        }
    }
}

//Contador.java
================================================= public class Contador{
    private int cont = 0;
    public Contador(){
        cont = 0;
    }
    public Contador(int a){
        cont = a;
     }
    public void incrementarContador(){
        cont++;
    }
    public void decrementarContador(){
        cont--;
    }
    public int obterContador(){
        return cont;
    }
  
}

Java Calculadora Visual

//Calculadora Visual
========================================
import java.util.*;
public class CalculadoraVisual {
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        Calculadora calc = new Calculadora("Sharp");
        float a, b, resultado, op = 1;
        int resultint;
        double resultDouble;

        System.out.println("Informe dois numeros");
        a = scan.nextFloat();
        b = scan.nextFloat();

        while (op !=5){
        System.out.println("1 - Somar");
        System.out.println("2 - Subtrair");
        System.out.println("3 - Multiplicar");
        System.out.println("4 - Dividir");
        System.out.println("5 - Sair");
        op = scan.nextFloat();
      
            if(op==1){
            resultado = calc.Somar(a,b);
            System.out.println("O resultado é: " + resultado);
            }
                else{
                if(op==2){
                resultado = calc.Subtrair(a,b);
                System.out.println("O resultado é: " + resultado);
                }
                    else{
                    if(op==3){
                    resultado = calc.Multiplicar(a,b);
                    System.out.println("O resultado é: " + resultado);
                    }
                        else{
                        if(op==4){
                        resultado = calc.Dividir(a,b);
                        System.out.println("O resultado é: " + resultado);
                        }
                            else{
                            if(op==5){
                            System.out.println("Saindo do Programa");
                            }
                                else{
                                        System.out.println("Opção Invalida");

                                        /*resultInt = calc.Somar(9,9);

                                        System.out.println(resultInt);
                                        resultDouble = calc.Somar(9.456987,8.12354789);
                                        System.out.println(resultDouble);

                                        resultInt = calc.Subtrair(9,9);
                                        System.out.println(resultInt);
                                        resultDouble = calc.Subtrair(9.456987,8.12354789);
                                        System.out.println(resultDouble);

                                        resultInt = calc.Multiplicar(9,9);
                                        System.out.println(resultInt);
                                        resultDouble = calc.Multiplicar(9.456987,8.12354789);
                                        System.out.println(resultDouble);

                                        resultInt = calc.Dividir(9,9);
                                        System.out.println(resultInt);
                                        resultDouble = calc.Dividir(9.456987,8.12354789);
                                        System.out.println(resultDouble);*/
                            }
                        }
                    }
                }
            }
        }
    }
}

Media com (Estrutura de repetição + Estrutura de controle)

import java.util.*;

public class Principal{
    public static void main(String[] args){
   
    Scanner scan = new Scanner(System.in);
    String fim;
    fim = "N";

    while (!fim.equals("S")){

    Float bim1;
    System.out.print("Informe primeiro bimestre:");
    bim1 = scan.nextFloat();

    Float bim2;
    System.out.print("Informe segundo bimestre:");
    bim2 = scan.nextFloat();

    Float bim3;
    System.out.print("Informe terceiro bimestre:");
    bim3 = scan.nextFloat();

    Float bim4;
    System.out.print("Informe quarto bimestre:");
    bim4 = scan.nextFloat();

    Float resultado;

    resultado = ((bim1 + bim2 + bim3 + bim4)/4);

    System.out.println(resultado);
   
    if (resultado>=7){
        System.out.println("Aprovado com média: " + resultado);
    }
    else{
        if (resultado>=4){
        System.out.println("Recuperação com média: " + resultado);
        }
        else{
        System.out.println("Reprovado com média: " + resultado);   
                }
            }
           
            scan = new Scanner(System.in);
            System.out.print("verificar novamente (S / N):");
            fim = scan.nextLine();

        }
    }   
}

Estrutura de controle IF

//Principal.java

import java.util.*;

public class Principal{
    public static void main(String[] args){
    int a,b;

    Scanner scan = new Scanner(System.in);

    System.out.println("Informe dois inteiros");
    a = scan.nextInt();
    b = scan.nextInt();
    System.out.println("Os numeros informados são: " + a + "," + b);
    if (a>b){
    System.out.println("Primeiro numero é o maior");
        }
        else{
        if (b>a){
        System.out.println("Segundo numero é o maior");
            }
            else{
            System.out.println("São iguais");
            }
        }

    scan = new Scanner(System.in);
    String nome;
    System.out.print("Digite seu nome:");
    nome = scan.nextLine();

    if (!nome.equals("Everaldo")){
        System.out.println("Você não é meu mestre");
    }
    else{
        System.out.println("As suas ordens mestre");
        }
    scan = new Scanner(System.in);
    String nome1;
    System.out.print("Digite primeiro nome:");
    nome1 = scan.nextLine();

    scan = new Scanner(System.in);
    String nome2;
    System.out.print("Digite segundo nome:");
    nome2 = scan.nextLine();  
  
    if (nome1.equals(nome2)){
        System.out.println("Registro Duplicado");
    }
    else{
        System.out.println("Registro Correto");
        }
              
    }      
}

Terceira Aula de Java

//Principal.java

import java.util.*;

public class Principal{
    public static void main(String[] args){
  
    Scanner scan = new Scanner(System.in);
  
    String nome;
    System.out.print("Informe seu nome:");
    nome = scan.nextLine();

    int telefone;
    System.out.print("Informe o numero do seu telefone:");
    telefone = scan.nextInt();

    Double idade;
    System.out.print("Informe sua idade:");
    idade = scan.nextDouble();

    Boolean disponivel;
    System.out.print("Informe se esta disponivel (True ou False):");
    disponivel = scan.nextBoolean();  
  
    scan = new Scanner(System.in);
    String niver;
    System.out.print("Informe seu Aniversario:");
    niver = scan.nextLine();

    System.out.println("Usuario:"+ nome + " Idade:" + idade + " Telefone:" + telefone + " Disponivel:" + disponivel + " Aniversario:" + niver );  
    }

}

Problemas éticos da atualidade

Trabalho

De

Ética e legislação

Problemas éticos da atualidade.

Nome: Rosicléia G. Teodoro

Tatiane da Silva.

IFPR – Instituto Federal do Paraná.

Introdução

Diante dessa variedade de aspectos que envolvem não somente questões de natureza ética, política e religiosa, por um lado, mas também sócio-econômicas, psicológicas, e, sobretudo, de saúde pública, por outro, é que o aborto coloca-se como problema cuja existência concreta não pode ser ignorada na atualidade exigindo uma discussão pela sociedade brasileira.

Tal discussão deverá oferecer diretrizes gerais ao estabelecimento de uma política social e de saúde para o setor que considere, não somente, as implicações dessa prática em termos concretos, mas também, as questões de natureza ético-jurídicas.

Apresentação dos objetivos

Esta grande polêmica só existe por causa da questão ideológica que é produzida por nossa sociedade, demasiadamente influenciada por princípios religiosos, intolerantes. Ao analisarmos o relativismo histórico percebemos claramente que algumas culturas, incluindo algumas tribos aqui mesmo no Brasil, eliminam seus bebês que nascem deficientes. Isso parece acontecer de forma normal entre elas, dada à cultura dessas tribos em questão. Embora a morte de tais bebês não seja algo natural, é feita de modo deliberado e aceito. Isto demostra que eles não têm a mesma concepção ideológica adotada pela nossa sociedade, no geral.

Pró-aborto – A definição

Pró-aborto é a crença no direito de optar por dar um fim a um feto (embrião fertilizado). Pró-aborto é também um movimento que luta pelos direitos das mulheres de terem a escolha de interromper uma gravidez indesejada. Só permitiram o aborto em casos de estupro, incesto, graves anomalias fetais ou para proteger a vida da mãe. O movimento pró-aborto foi desacelerado e muitos apelos foram acionados para inverter estas políticas legislativas.

A maior vitória dos defensores do aborto foi vencida em "Roe versus Wade". Através deste processo, o Supremo Tribunal legalizou o aborto em todos os 50 estados em 22 de janeiro de 1973. Embora o voto popular tenha sido contra o aborto, "Roe versus Wade" se tornou a base do movimento pró-aborto.

Pró-aborto – Hoje

O movimento pró-aborto tem amadurecido muito, de abortos clandestinos a clínicas especializadas em todos os 50 estados, interrompendo a vida de fetos de até 24-25 semanas após a fecundação, e até mesmo ao ponto de permitir o aborto de nascimento parcial. Os defensores do aborto acreditam no direito de optar por interromper a gravidez. Há até mesmo leis americanas agora que defendem o direito ao aborto para adolescentes e seus pais. A lei está ou não está do lado do pró-aborto?

Pró-aborto – O problema

Pró-aborto - O veredicto está pronto? O aborto é legal em todos os 50 estados americanos. Por outro lado, o assassinato é ilegal em todos os 50 estados. Aqui reside o problema - Como é que podemos dizer que é contra a lei matar e permitir que a taxa de aborto de 1 em cada 4 gestações continue? Quando é que a origem da vida começa? Fomos criados na concepção, formados no ventre da mãe desde o início? Ou é o ar em nossos pulmões que muda o nosso status de um feto para uma vida formada? Evidentemente, a posição pró-aborto deve defender que a vida não começa até algum tempo no final do processo de gestação. No entanto, a posição de Deus sempre tem sido de que somos criados por Ele para um fim especial a partir do momento da concepção. Recentes descobertas em bioquímica confirmam o que a Bíblia tem declarado durante séculos, que cada um de nós é assombrosamente e maravilhosamente formado. A partir do momento em que o espermatozoide milagrosamente fertiliza o óvulo, Deus começa o processo de criação de nosso íntimo e nos forma no ventre de nossa mãe (Salmo 139:13-14).

A questão do aborto não é, nem nunca foi questão religiosa, senão na medida em que é questão humana e da natureza humana. Não é, pois, necessário fazer apelo a princípios religiosos para repudiar vivamente tanto a prática como a despenalização do aborto. O aborto é, de maneira cientificamente indiscutível, um atentado direto à vida humana, à vida de um ser humano procriado, em gestação e indefeso. Representa, pois, uma hipocrisia o uso da expressão "interrupção voluntária da gravidez", que só significa morte de um novo ser, como a discussão entre os patrocinadores do aborto, contra todas as conclusões da Medicina, sobre se o crime deve ser cometido com mais ou menos dias, com mais ou menos meses de gestação.

Todos os argumentos apresentados numa perspectiva humanitária e de bem social para admitir o aborto são meios de iludir gravemente a questão. Não são razões que podem justificar, como regra, a supressão, de natureza racista, que o nazismo usou para fundamentar o direito de matar velhos e doentes.

Não ignoramos nem queremos esconder os graves problemas sociais que estão na base do aborto clandestino. Para combatê-los, não é admissível mascará-los com o direito ao crime, em vez de ir às suas causas. Urge a continuação de tomada de medidas positivas de natureza humana, social e ética (planejamento familiar, apoio à mãe solteira, o desenvolvimento da instituição da adoção, o incremento de correta assistência social, atenção construtiva aos fatores de desagregação moral na família e na educação etc.).

Também é lamentável a confusão que se faz enumerando o aborto como um dos meios possíveis de limitação da natalidade. Não é. É, sim, um meio sofisticado de condenar à morte um ser inocente. Isso não quer dizer que não alertamos também para a necessidade de proibir o comércio de anti-conceptivos que são de natureza abortiva.

A legalização do aborto é também um dos mais graves atentados contra a mulher - quando pugna pelos seus direitos e é ludibriada a julgar que naqueles se contém o de abortar -, pois a torna um objeto da irresponsabilidade masculina e é impelida a ser autora do crime em que terá a menor culpa. Atribuir-lhe o direito de amputar o corpo é duplamente falso: ninguém deve-se considerar com direito a cortar um braço, e o seu filho não é o seu corpo mas um novo ser com direito à vida.

Finalmente queremos deixar bem claro que a nossa condenação absoluta do aborto nada tem a ver com a condenação de pessoas concretas. Desde sempre, e com muito mais razão com o aperfeiçoamento do nosso ordenamento jurídico, cada pessoa merece ser considerada como tal, quer no plano da moral quer no do Direito. O crime pode existir e, não obstante, pode-se absolver quem o praticou, dadas as circunstâncias que envolvam tal prática.

Conclusão

Veja que a diferença entre os dois aspectos que formam o conjunto daquilo que se pode chamar de ética é bem sensível. Para que uma atitude seja considerada ética ela deve conter estes dois aspectos, ou seja, que seja aceita como valor assumido de uma sociedade e ao mesmo tempo respeite a individualidade do sujeito que se torna objeto de uma ação.

Tomado desta forma, um aborto pode ser legal e até moral, mas nunca será ético. A lei do país pode deixar de considerar o aborto como crime e até a sociedade pode considerá-lo aceitável, mas nunca ético. O fato de haver uma aceitação por parte da sociedade e de ser juridicamente possível somente torna o aborto aceitável do ponto de vista moral. No aspecto ético, a individualidade do nascituro é desrespeitada.

A pena de morte infligida ao nascituro, independente da circunstância, ataca frontalmente a ética. Para clarear o leitor é possível fazer uma analogia que de certa forma nos é bem próxima. A escravidão no Brasil até o século XIX era legal. A moral vigente também não via nem um mal em se ter escravos. Pelo contrário, possuir escravos era sinal de status, era uma marca de alguém bem sucedido na vida.

Ética Hacker

Tem-se a Ética como a ciência da conduta. Entretanto, enfaticamente, não determina o modo de agir; este faz parte do campo Moral.

Muitos sabem, ou pelos menos intuem o que seja Ética; todavia, explicá-la é tarefa difícil. Além do mais, tentar defini-la seria nos privar de toda a amplitude de seu significado que pode ainda advir, fruto do desenvolvimento do pensamento humano.

Para que exista a conduta ética, é necessário que o agente seja consciente, quer dizer, que possua capacidade de discernir entre o bem e o mal (cabe observar agora que agir eticamente é ter condutas de acordo com o bem. Todavia, definir o conteúdo desse bem é problema à parte, pois é uma concepção que se transforma pelos tempos). A consciência moral possui a capacidade de discernir entre um e outro e avaliar, julgando o valor das condutas e agir conforme os padrões morais. Por isso, é responsável pelas suas ações e emoções, tornando-se responsável também pelas suas consequências.

Os valores podem se entendidos como padrões sociais ou princípios aceitos e mantidos por pessoas, pela sociedade, dentre outros. Assim, cada um adquire uma percepção individual do que lhe é de valor; possuem pesos diferenciados, de modo que, quando comparados, se tornam mais ou menos valiosos. Tornam-se, sob determinado enfoque, subjetivos, uma vez que dependerão do modo de existência de cada pessoa, de suas convicções filosóficas, experiências vividas ou até, de crenças religiosas. Do que foi dito, as pessoas, a sociedade, as classes, cada qual têm seus valores, que devem ser considerados em qualquer situação.

O que é ética Hacker?

Ética hacker é a ética que orienta as atividades de hackering. Um dos seus grandes criadores foi o finlandês Pekka Himanen.

No que consiste a ética hacker?

O ethos hacker consiste basicamente em:

·        Acreditar que o compartilhamento de informações beneficia a sociedade como um todo. Portanto os hackers compartilham suas experiências e programam software livre, facilitando o acesso à informação e os recursos disponíveis para computadores sempre que possível. A máxima hacker é "A informação quer ser livre". Este conjunto de crenças deriva em parte do pensamento de Buckminster Fuller, o qual proferiu certa vez que "A verdadeira riqueza é a informação e saber como utilizá-la".

·        Acreditar que penetrar em sistemas por diversão e exploração é eticamente aceitável, desde que não cometa roubo, vandalismo ou quebre a confidencialidade. (Esse princípio não é unânime, alguns consideram a simples invasão como uma ação não ética).

Hackes ou Crackers?

Himanen, em sua obra A ética do hacker e o espírito da era da informação (que contém um prólogo de Linus Torvalds e um epílogo de Manuel Castells), propõe resgatar o sentido original do termo 'hacker'. Segundo Himanen, um hacker não é (como se acredita comumente) um delinquente, vândalo ou um pirata da informática com grandes conhecimentos técnicos (este é o cracker), mas sim todo aquele que trabalha com grande paixão e entusiasmo pelo que faz. Podendo o termo hacker ser utilizado para outras áreas, por exemplo, a da ciência.

Quem é o hacker white hat (chapéu branco)?

O hacker white hat (chapéu branco), por vezes chamado de "hacker ético", é aquele que ajuda corporações a verificar se os sistemas de informação e as redes são efetivamente seguros.

Quais são os princípios da ética hacker?

·        Compartilhamento

·        Abertura

·        Descentralização

·        Livre acesso aos computadores

·        Melhoria do mundo

O acesso a computadores - e qualquer outro meio que seja capaz de ensinar algo sobre como o mundo funciona deve ser ilimitado e total.

Esse preceito sempre se refere ao imperativo "mão na massa". Isto é, se um hacker precisa enviar várias mensagens para celulares sem pagar, ao invés de entrar várias vezes na interface web e enviar uma mensagem por vez, ele descobrirá como a interface web funciona e fará um programa automático para o envio de mensagens de forma mais ágil e com menos desperdício de tempo.

·        Toda a informação deve ser livre.

Na sociedade de consumo de hoje, tudo é transformado em mercadoria e vendido. Isso inclui a informação. Mas a informação, só existe na mente das pessoas. Como não se possui a mente de outra pessoa, não podemos comercializar informações. Uma analogia semelhante é a do velho índio Chefe Touro-Sentado ao dizer "a terra não pode ser possuída". O hacker busca a informação diariamente e tem prazer em passá-la para quem quer "pensar" e "criar" coisas novas.

·        Desacredite a autoridade e promova a descentralização.

Um hacker não aceita os famosos argumentos de autoridade e não acredita na centralização como forma ideal de coordenar esforços.

Hierarquia Hacker.

Hackers acreditam que devem ser julgados segundo seu hacking, e não segundo critérios sujeitos a vieses tais como graus acadêmicos, raça, cor, religião ou posição.

Essa é à base da meritocracia. Se você é bom mesmo, faça o que você sabe fazer e os demais o terão em alta conta. Não apareça com diplomas e certificados que para nada mais servem além de provar que você não sabe do que está falando e tenta esconder esse fato. Isso também pode ser visto num dos documentos de maior expressão da cultura hacker de todos os tempos:

O "Manifesto Hacker", publicado no e-zine Phrack 7 , em 1986, por The Mentor, logo após ele ter sido preso:

·        Por "The Mentor"

“Mais um foi pego hoje, está em todos os jornais”.

“Adolescente Preso em Escândalo de Crime de Computador”

“Hacher preso depois de trapaça em Banco”

“Crianças malditas”

“Crianças imbecis”

“Eles são todo semelhantes”

Mas você em sua psicologia de três ângulos hacker?

Você já imaginou o que faz ele agir, quais forças o motivam, o que o tornou assim?

Eu sou um hacker, entre no meu mundo.

Meu mundo é aquele que começa na escola.

Eu sou mais inteligente que a maioria das crianças, esta besteira que nos ensinam me chateia.

"Maldição"

Eles são todos iguais. Eu estou na escola primária ou secundária. Eu escutei os professores explicarem pela quinquagésima vez como reduzir uma fração. Eu entendo isto.

 “Não, Sra. Smith, eu não mostrei meu trabalho. Eu o fiz em minha cabeça”.

"Criança maldita"

"Provavelmente copiou isto. Eles são todos semelhantes”.

Eu fiz uma descoberta hoje encontrei um computador.

Espere um segundo, isto é legal, faz o que eu quero.

Se cometer um engano, é porque eu estraguei isto. Não porque não gosta de mim, ou sente atração por mim, ou pensa que sou inteligente, ou não gosta de ensinar e não deveria estar aqui.

“Criança maldita”

Tudo que ele faz é jogar jogos.

Eles são todos semelhantes.

E então aconteceu...

Uma porta se abriu para um mundo

Surfando rapidamente pela linha telefônica como heroína pelas veias de um viciado, uma pulsação eletrônica é enviada, um refúgio para a incompetência do dia-a-dia.

Encontramos uma BBS.

É isto, este é o mundo ao qual pertenço, eu conheço todos aqui, até mesmo se eu nunca tenha falado com eles, mesmo que nunca mais vá ter notícias novamente deles, eu conheço todos.

”Criança malditas”

Prendendo a linha telefônica novamente. Eles são todos semelhantes, você acertou seu babaca nós somos todos semelhantes, na escola nós comíamos comida de bebê quando nós tínhamos fome de bife.

Os pedaços de carne que você deixou passar foram pré-mastigado e sem gosto.

Nós fomos dominados por sádicos, ou ignorados pelos apáticos.

Os poucos que tiveram algo a nos ensinar quando crianças, acharam os alunos dispostos a tudo, mas esses poucos são como gotas d'agua no deserto.

Agora este é o nosso mundo, o mundo eletrônico, a beleza da transmissão eletrônica.

Nós fazemos uso de um serviço que já existe, sem pagar, o que poderia ser muito caro se não fosse usado por gulosos aproveitadores, e você nos chama os criminosos.

Nós exploramos, e você nos chama de criminosos.

Nós buscamos por conhecimento, e você nos chama de criminosos.

Nós existimos sem cor de pele, sem nacionalidade, sem preconceito religioso e você nos chama de criminosos.

Você constrói bombas atômicas, você empreende guerras, você assassina, engana, e mente para nós e tenta nos fazer acreditar que é para nosso próprio bem, contudo nós somos os criminosos.

Sim, eu sou um criminoso.

Meu crime é a curiosidade.

Meu crime é o de julgar as pessoas pelo que eles dizem e pensam não pelo que elas parecem.

Meu crime é desafiar e enganar você, algo que você nunca me perdoará.

Eu sou um hacker, e este é meu manifesto.

Você pode parar um de nós, mas você não pode parar todos nós, afinal de contas, nós somos todos semelhantes.

Ø  Este foi o último arquivo publicado por "The Mentor".

Os prós

O conhecimento passa a lhe dar poder

Facilidade de profissionalização

Os contras

O poder pode corromper

Falta de confiança no seu trabalho

Conclusão

A consciência se manifesta na capacidade de decidir diante de possibilidades variadas, decorrentes de alguma ação que será realizada. No processo de escolha das condutas, avalia-se os meios em relação aos fins, pesa-se o que será necessário para realizá-las, quais ações a fazer, e que conseqüências esperar.

Assim, para poder deliberar, realizar constantemente as escolhas, é condição básica a liberdade. Para isso, não se pode estar alienado, ou seja, destituído de si, privado por outros, preso aos instintos e às paixões.

Ao longo da história o parâmetro da discussão ética sempre passou pela questão da busca pelo Bem. Entretanto, nos dias em que se passam, se pergunta: o que é que hoje serve ou não ao "bem" da humanidade? Ampliando o debate, a quem é dado definir, para todos nós, o que o avanço tecnológico nos trará de bom? Qual opção que temos?

É necessário que a humanidade reflita sobre o princípio da responsabilidade científica e social e que a racionalidade ética caminhe a passos largos, disputando palmo a palmo, um espaço junto ao progresso científico e tecnológico.

Segunda Aula de Java

//Cliente.java

==================================================
public class Cliente{
    int cod;
    String nome;
    String telefone;

    public Cliente(){
        cod = 0;
        nome = "";
        telefone = "";
    }
    public void setCod(int c){
        cod = c;
    }
    public int getCod(){
        return cod;
    }

    public void setNome(String n){
        nome = n;
    }
    public String getNome(){
        return nome;
    }

    public void setTelefone(String t){
        telefone = t;
    }

    public String getTelefone(){
        return telefone;
    }
}

//Vendedor.java

================================================== 

public class Vendedor{
    int codVendedor;
    String nome;
    String setor;
    String ramal;
   
    public Vendedor(){
        codVendedor = 0;
        nome = "";
        setor = "";
        ramal = "";
    }
   
    public void setCodVendedor(int c){
        codVendedor = c;
    }
   
    public int getCodVendedor(){
        return codVendedor;
    }

    public void setNome(String n){
        nome = n;
    }
   
    public String getNome(){
        return nome;
    }

    public void setSetor(String s){
        setor = s;
    }
   
    public String getSetor(){
        return setor;
    }

    public void setRamal(String r){
        ramal = r;
    }
   
    public String getRamal(){
        return ramal;
    }
}

//Produto.java

================================================== 
public class Produto{
    int codProduto;
    String nome;
    String fabricante;
    int quantidade;
   
    public Produto(){
        codProduto = 0;
        nome = "";
        fabricante = "";
        quantidade = 0;
    }
   
    public void setCodProduto(int c){
        codProduto = c;
    }
   
    public int getCodProduto(){
        return codProduto;
    }

    public void setNome(String n){
        nome = n;
    }
   
    public String getNome(){
        return nome;
    }

    public void setFabricante(String f){
        fabricante = f;
    }
   
    public String getFabricante(){
        return fabricante;
    }

    public void setQuantidade(int q){
        quantidade = q;
    }
   
    public int getQuantidade(){
        return quantidade;
    }
}

//Principal.java

================================================== 
public class Principal{
    public static void main(String[] args){
       
    Vendedor v = new Vendedor();
        v.setCodVendedor(1);
        v.setNome("Paulo");
        v.setSetor("Eletrodomesticos");
        v.setRamal("123");

    Cliente c = new Cliente();
        c.setCod(1);
        c.setNome("Joana");
        c.setTelefone("3037-3564");
       
    Produto p = new Produto();
        p.setCodProduto(3);
        p.setNome("Batedeira");
        p.setFabricante("Britania");
        p.setQuantidade(1);

        System.out.println("");
        System.out.println("");

        System.out.println("Vendedor: " + v.getNome());
        System.out.println("Código: " + v.getCodVendedor());
        System.out.println("Setor: " + v.getSetor());
        System.out.println("Ramal: " + v.getRamal());

        System.out.println("Cliente: " + c.getNome());
        System.out.println("Código: " + c.getCod());
        System.out.println("Telefone: " + c.getTelefone());

        System.out.println("Produto: " + p.getNome());
        System.out.println("Codigo: " + p.getCodProduto());
        System.out.println("Fabricante: " + p.getFabricante());
        System.out.println("Quantidade: " + p.getQuantidade());

        System.out.println("");
        System.out.println("");

        System.out.println("O vendor " + v.getNome() + ", código " + v.getCodVendedor() + ", do setor " + v.getSetor() + ", ramal  " + v.getRamal() + ", vendeu para a cliente " + c.getNome() + ", código " + c.getCod() + ", telefone " + c.getTelefone() + "  " + p.getQuantidade() + " produto " + p.getNome() + ", fabricado por " + p.getFabricante());

        System.out.println("");
        System.out.println("");

    }
}

Tutorial Java - ?????

http://www.dm.ufscar.br/~waldeck/curso/java/

Introdução

Tendo sido originalmente concebida para o desenvolvimento de pequenos aplicativos e programas de controle de aparelhos eletrodomésticos e eletroeletrônicos, Java mostrou-se ideal para ser usada na rede Internet. O que a torna tão atraente é o fato de programas escritos em Java poderem ser executados virtualmente em qualquer plataforma, mas principalmente em Windows, Unix e Mac. Em meio a essa pluralidade, Java é um idioma comum, falado por todos. Isto significa que Java é ideal para expressar idéias em forma de programas universalmente aceitos. Soma-se a isso o fato de programas Java poderem ser embutidos em documentos HTML, podendo assim ser divulgados pela rede. Diferente da linguagem C, não é apenas o código fonte que pode ser compartilhado pela rede, mas o próprio código executável compilado, chamado bytecodes.
Em contraste com a letargia de documentos tradicionais, Java acrescenta a interatividade entre o usuário e o documento que está sendo consultado, tornando-o mais expressivo, agradável e surpreendente. Java é ideal para a elaboração de material educacional, pois permite ilustrar claramente os conceitos enquanto possibilita um ensino individualizado.
Um exemplo excelente para ilustrar a utilidade da Java no ensino de matemática é o livro eletrônico de geometria euclideana, Elementos de Euclides na qual, a ilustração da demonstração é iterativa graças à Aplet Java.
Java foi desenvolvida por um grupo de pesquisadores da SUN Microsystems por volta de 1990, pouco antes da explosão da Internet. Essa linguagem possui estrutura muito semelhante à da linguagem C, da qual descende imediatamente. Java tem em comum com a linguagem C++ o fato de ser orientada a objetos e mantém com esta uma alto grau de semelhança. Esse paradigma de programação consiste de um grau a mais na abstração da programação, em comparação com a programação estruturada, e tem se mostrado extremamente útil na produção de programas cada vez mais sofisticados, em menor tempo e com maior qualidade. A programação orientada a objetos (OOP) é hoje universalmente adotada como padrão de mercado, e muitas linguagens tradicionais foram aperfeiçoadas para implementar esse paradigma, como C++, Object Pascal, etc.
Há uma certa curiosidade por detrás do nome dado a essa linguagem de programação. Java é o nome de uma ilha do Pacífico, onde se produz uma certa variedade de café homônimo. A inspiração bateu à equipe de desenvolvimento ao saborear esse café em uma lanchonete local. Deram-se conta de como era extremamente apreciado por profissionais da área de software (ao menos nos Estados Unidos), de modo que não foi menos justo fazer-lhe homenagem ao batizar uma nova linguagem de programação. Atualmente, o site JavaSoft mantém informações atualizadas sobre o desenvolvimento da linguagem Java e suas relações com o mercado, assim como utilitários e ferramentas disponíveis para serem baixados gratuitamente.

Como Java é executado

Um programa fonte escrito em linguagem Java é traduzido pelo compilador para os bytecodes, isto é, o código de máquina de um processador virtual, chamado Java Virtual Machine (JVM). A JVM é um programa capaz de interpretar os bytecodes produzidos pelo compilador, executando o programa cerca de 20 vezes mais lento do que C. Pode parecer ruim, mas é perfeitamente adequado para a maioria das aplicações. Com isto, um programa Java pode ser executado em qualquer plataforma, desde que esteja dotada de uma JVM. É o caso dos programas navegadores mais populares, como o Netscape Navigator e o Internet Explorer, que já vêm com uma JVM. A vantagem desta técnica é evidente: garantir uma maior portabilidade para os programas Java em código-fonte e compilados. Porém, as JVM tendem a ser programas extensos que consomem muitos recursos, restringindo assim o tamanho das aplicações escritas em Java.
Atualmente, já existem compiladores capazes de traduzir bytecodes para instruções de máquina nativas, como o Just In Time compiler (ou JIT), tornando os programas ainda mais rápidos. Este compilador requer uma versão específica para cada plataforma onde se pretende que o programa Java seja executado. Em contrapartida à maior velocidade de execução está também uma maior necessidade de memória, pois os bytecodes compilados, em geral, ficam três vezes maiores do que o original. Uma alternativa bem mais interessante, e talvez muito mais viável, é a implementação da JVM em hardware na forma de uma placa ou microchip. A primeira iniciativa neste sentido é da Sun Microelectronics, que está produzindo os chips picoJava I^TM, microJava^TM e UltraJava^TM. Estes são capazes executar diretamente bytecodes, acelerando em milhares de vezes a velocidade de execução. Isto permitirá o desenvolvimento viável de aplicativos cada vez mais complexos, abrangentes e funcionais. Espera-se que estas soluções sejam brevemente empregadas na fabricação de telefones celulares, pagers, jogos, organizadores pessoais digitais, impressoras e eletrodomésticos de consumo, além aplicações mais sérias como estações de trabalho dotadas do sistema operacional JavaOS^TM. Trata-se certamente do futuro das soluções para aplicações de rede.

Já se tornou clássica a idéia de que para aprender uma nova linguagem de programação não se deve ir direto à descrição sua formal. Ao invés disso, é melhor examinar cuidadosamente um pequeno programa escrito nessa linguagem, o mais simples possível, mas que permita "quebrar o gelo". Isso faz sentido pois, por exemplo, quando vamos aprender Inglês, ou outro idioma qualquer, não iniciamos com a leitura compenetrada de um livro de gramática, mas aprendemos algumas estruturas simples e procuramos exercitá-las, adiando o estudo rigoroso para quando estivermos suficientemente maduros. Ao compreender as diversas partes componentes do exemplo, já teremos dado um grande passo para podermos escrever qualquer programa.

Seguindo essa linha, apresentamos nosso primeiro programa, o clássico "Alô pessoal!". O objetivo deste programa é simplesmente escrever na tela a frase "Alô pessoal!". Vejamos como é o código fonte:

public class AloPessoal {
  public static void main(String args[]) {
    System.out.println("Alo pessoal!");
  }
}

Digitando o programa

Que tal colocarmos a mão na massa e digitarmos esse programinha? Para isso, é recomendável utilizar um editor de texto simples como o Notepad ou Bloco de Notas do Windows. Se estiver no Unix, use preferencialmente o TextEdit ou o vi. O nome do arquivo deve ser exatamente igual ao nome que aparece após a palavra class na primeira linha do programa e dever ter .java como sufixo. Assim sendo, o nome deverá ser "AloPessoal.java". Cuidado para digitar corretamente as maiúsculas e minúsculas, pois a linguagem Java é sensível ao tipo de caixa das letras.

Compilando o código fonte

Para criar o código binário, chamamos o compilador Java através da linha de comando, do seguinte modo:

javac AloPessoal.java 

Com isso, será criado um arquivo binário (desde que tudo corra bem) com mesmo nome do arquivo original, mas com sufixo .class no lugar de .java. No nosso caso, teríamos um arquivo AloPessoal.class. Entre as (muitas) coisas que poderiam dar errado nesse momento, o código fonte pode conter erros. Esse não deverá ser o caso, se tiver digitado o programa exatamente como aparece acima. Se, porém, o compilador emitir mensagens de erro, será preciso identificar as linhas que estão incorretas, corrigí-las no editor, e chamar o compilador novamente. As linhas que contém algum tipo de incorreção são listadas pelo compilador juntamente com seu número, facilitando sua localização no editor.

Executando o código

Para podermos executar o programa é necessário chamar o interpretador Java, pois, como vimos, os bytecodes foram feitos para rodar em uma Java Virtual Machine. Podemos fazê-lo do seguinte modo:

java [nome da classe]

onde [nome da classe] é o nome do arquivo sem o sufixo .class. Em nosso caso, este será AloPessoal. Ao executar o programa, ele deverá exibir na tela a frase:

Alo pessoal!

Se isto não ocorrer, volte atrás e verifique se o programa foi digitado exatamente como aparece na listagem acima.

Este é um programa muito simples. Porém, a boa compreensão das estruturas presentes nele deverá permitir a programação fluente em Java em pouco tempo.

Entendendo a estrutura do programa

Todo programa Java, deve conter ao menos uma declaração da forma

public class [nome] {
  public static void main(String args[]) {
    ...
  }
}

Onde [nome] é o nome da classe e a parte "..." é o código Java válido, a ser executado no programa. O nome de uma classe é um identificador, como qualquer outro presente no programa, porisso não deve conter espaços ou outros caracteres gráficos, isto é, deve ser um nome composto de uma seqüência de caracteres que seja válida para um identificador. Outros exemplos de identificadores são nomes de variáveis, nomes de comandos, etc.

Vamos adiar um pouco a complicação sobre o que vem a ser uma classe, pois isso depende de alguns conceitos da programação orientada a objetos. Por hora, vamos apenas aceitar que todo programa Java deve conter ao menos uma classe, e que é dentro de uma classe que vão os dados e os procedimentos. Notemos ainda que todo programa Java (mas não as applets) deve ter uma classe dotada de um procedimento chamado main. Os procedimentos em Java são chamados métodos. Os métodos encerram um conjunto de declarações de dados e de comandos que são executados mediante a chamada do método por seu nome. Vamos estudar os métodos em detalhe mais adiante. O método main é o ponto onde se dá o início da execução do programa, isto é, um método chamado automaticamente pela JVM.

Voltando ao nosso programinha AloPessoal, o código a ser executado é

System.out.println("Alo pessoal!");

System.out.println é o nome de uma função que serve para escrever informações textuais na tela. Os dados a serem escritos, devem estar delimitados entre os parênteses "(" e ")". "Alo pessoal!" é uma frase. Em computação, uma palavra ou uma frase que tenha função literal é denominada string. Em Java, a representação de uma string constante se dá colocando os caracteres entre aspas, por exemplo:  "Imagem", "Rio de Janeiro", "Brasília", etc, são strings constantes.

Note que existe um ; (ponto e vírgula) no final da linha, logo após o ")". Em Java, é obrigatório colocar um ponto e vírgula após cada comando. Isso porque um comando pode ser quebrado em múltiplas linhas, sendo necessário sinalizar de algum modo onde é que o comando termina.

Java é sensível ao tipo de caixa, isto é, distingue caixa alta (maiúsculo) da caixa baixa (minúsculo). Os programadores acostumados a linguagem C e C++ vão certamente sentir-se em casa; porém os programadores acostumados à linguagem PASCAL devem ficar mais atentos.

Mais exemplos

Podemos escrever "Alo pessoal!" escrevendo primeiro, "Alo " e depois, "pessoal!". Para isso, o programa deve ser alterado da seguinte forma:

public class Alo {
  public static void main(String args[]) {
    System.out.print("Alo ");
    System.out.println("pessoal!");
 }
}

Para escrever dados genéricos na tela, existe o comando System.out.print que escreve o dado e mantém o carro na mesma linha. Há também o System.out.println que escreve dados e muda o carro para a próxima linha.

Podemos concatenar dois ou mais strings usando o operador "+". Por exemplo,

"Alo " + "pessoal!"

é o mesmo que "Alo pessoal!". Para escrever um número, basta escrever [string]+n onde [string] é um string qualquer e n é um número. Por exemplo:

public class Numero {
  public static void main(String args[]) {
    System.out.println("O valor é " + 29);
 }
}

Como o lado esquerdo da expressão é um string, 29 é convertido para string "29" e é concatenado com "O valor é ". Compilando e executando esse exemplo como fizemos anteriormente, devemos obter na tela:

O valor é 29

Observemos que os comandos System.out.print e System.out.println escrevem uma informação de cada vez. Desta forma, precisamos usar "+" para unir "O valor e " com 29 para formar uma única string. No exemplo acima, nada impede que os dados sejam escritos em duas etapas: primeiro, "O valor e " e depois, 29. Neste caso, teríamos:

public class Numero {
  public static void main(String args[]) {
    System.out.print("O valor e ");
    System.out.println(29);
 }
}

Entretanto, a primeira abordagem parece mais razoável pois torna a programação mais clara e concisa, além de economizar comandos.

Usando variáveis

Uma variável é simplesmente um espaço vago, reservado e rotulado para armazenar dados. Toda variável tem um nome que a identifica univocamente e um valor, que corresponde à informação a ela atribuida. Por exemplo, int n; especifica que n é o nome de uma variável que pode armazenar um número inteiro como valor. Em geral, num contexto onde aparece o nome de uma variável ocorre a substituição por seu valor. O valor de uma variável pode mudar muitas vezes durante a execução de um programa, por meio de atribuições de valor.

Há diversos tipos de variáveis em Java, correspondendo aos vários tipos de dados aceitos. A discussão sobre esses tipos de dados será feita no próximo capítulo. Antes porém, vamos fazer um pequeno programa que declara uma variável interira, atribui a ela uma constante, e imprime seu valor na tela.

public class Numero {
  public static void main(String args[]) {
    int n;
    n = 17+21;
    System.out.println("O valor numérico é " + n);
 }
}

O local onde uma variável está declarada é extremamente importante. Uma variável é conhecida apenas dentro de algum escopo. Por exemplo, uma variável declarada no escopo de uma classe (fora de um método) é conhecida por qualquer método que esteja declarado dentro dessa mesma classe, enquanto uma variável declarada no escopo de um procedimento é conhecida apenas por esse procedimento. Há ainda outros tipos de escopo, como veremos mais adiante.

O sinal "=" é um operador, utilizado para atribuir um valor a uma variável. Por exemplo, n = 1; faz com que o valor 1 seja armazenado na variável n. Há também os operadores usuais de adição, subtração, multiplicação e divisão de números. Estes são representados pelos símbolos  "+ ", "-", "*" e "/", respectivamente.

Ao executar o programa acima (claro, depois de compilá-lo), ele escreve

O valor numerico é 38

Introduzindo comentários no código

Um comentário é uma porção de texto que não tem função para o compilador Java, mas é útil ao leitor humano. Assim sendo, um comentário é identificado mas ignorado completamente pelo compilador Java. A utilidade dos comentários é óbvia: deve conter explicações sobre um particular desenvolvimento do código, permitindo ao leitor compreender claramente o que se deseja realizar.

Os comentários são introduzidos no código Java de duas formas distintas:

• Colocado em qualquer parte do programa e delimitado entre "/*" e "*/".
• Escrevendo "//" antes do comentário, que se estenderá até o final da linha.

Por exemplo, o código:

//
// Este é um exemplo de como somar dois numeros
// public class Numero {
  public static void main(String args[]) { /* Método principal */    double x,y; // estes sao numeros reais de dupla precisao
    // System.out.print("x = 2.0"); /* inicializando o "x" */    x = 2;
    y = 3.0; /* iniciando o y, e fazendo y = y+x; */ y = y + x;
    // escrevendo a soma    System.out.println("x+y = " + (x+y));
 }
} /* fim de Numero */

é equivalente ao código:

public class Numero {
  public static void main(String args[]) { 
    double x,y; 
 
    x = 2;
    y = 3.0;  y = y + x;

   System.out.println("x+y = " + (x+y));
 }
}

double é um tipo de dado que indica um número real de dupla precisão. Veja a tabela no início da próxima seção.

No próximo capítulo, vamos estudar detalhadamente os tipos de dados aceitos pela linguagem Java.

[anterior, índice, seguinte]

O trabalho com computadores, desde os mais simples como escrever mensagens na tela, até os mais complexos como resolver equações ou desenhar imagens tridimensionais em animação, consiste essencialmente em manipulação de dados. Os dados representados em um computador podem ser números, caracteres ou simples valores.

A linguagem Java oferece diversos tipos tipos de dados com os quais podemos trabalhar. Este capítulo cobrirá os tipos de dados mais importantes. Na verdade há basicamente duas categorias em que se encaixam os tipos de dados: tipos primitivos e tipos de referências. Os tipos primitivos correspondem a dados mais simples ou escalares e serão abordados em detalhe no que segue, enquanto os tipos de referências consistem em arrays, classes e interfaces. Estes serão vistos em capítulos subseqüêntes.

Eis uma visão geral dos tipos que serão abordados neste capítulo:

Tipo	Descrição
boolean	Pode assumir o valor true ou o valor false
char	Caractere em notação Unicode de 16 bits. Serve para a armazenagem de dados alfanuméricos. Também pode ser usado como um dado inteiro com valores na faixa entre 0 e 65535.
byte	Inteiro de 8 bits em notação de complemento de dois. Pode assumir valores entre -27=-128 e 27-1=127.
short	Inteiro de 16 bits em notação de complemento de dois. Os valores possívels cobrem a faixa de -2-15=-32.768 a 215-1=32.767
int	Inteiro de 32 bits em notação de complemento de dois. Pode assumir valores entre -231=2.147.483.648 e 231-1=2.147.483.647.
long	Inteiro de 64 bits em notação de complemento de dois. Pode assumir valores entre -263 e 263-1.
float	Representa números em notação de ponto flutuante normalizada em precisão simples de 32 bits em conformidade com a norma IEEE 754-1985. O menor valor positivo represntável por esse tipo é 1.40239846e-46 e o maior é 3.40282347e+38
double	Representa números em notação de ponto flutuante normalizada em precisão dupla de 64 bits em conformidade com a norma IEEE 754-1985. O menor valor positivo representável é 4.94065645841246544e-324 e o maior é 1.7976931348623157e+308

Ao contrário do que acontece com outras linguagens de programação, as características dos tipos de dados listados acima idependem da plataforma em que o programa deverá ser executado. Dessa forma, os tipos de dados primitivos são realmente únicos e garantem a capacidade de intercâmbio de informações entre diversos tipos de computadores, aliviando o programador da preocupação e da árdua tarefa de converter dados em formatos apropriados para a portagem.

Tipo Boolean

Este é o tipo de dado mais simples encontrado em Java. Uma variável booleana pode assumir apenas um entre dois valores: true ou false. Algumas operações possíveis em Java como a<=b, x>y, etc têm como resultado um valor booleano, que pode ser armazenado para uso futuro em variáveis booleanas. Estas operações são chamadas operações lógicas. As variáveis booleanas são tipicamente empregadas para sinalizar alguma condição ou a ocorrência de algum evento em um programa Java. Por exemplo:

boolean fim_do_arquivo = false;

é a declaração de uma variável do tipo boolean, cujo nome é fim_do_arquivo. O valor false à direita do sinal "=" indica que a variável recebe esse valor como valor inicial. Sem essa especificação o valor de uma variável é impredicável, podendo ser qualquer um dos valores possíveis para seu tipo (neste caso true ou false).

Aproveitando o ensejo, há nessa linha a essência da declaração de qualquer variável em Java:

1. Informar o tipo de dado que deseja declarar (boolean)
2. Informar o nome que será usado para batizar a variável (fim_do_arquivo)
3. Atribuir à variável um valor inicial (= false)
4. Terminar a declaração com um ponto-e-vírgula ";".

Uma palavra sobre identificadores

Na declaração acima usamos o nome fim_do_arquivo para designar a variável. Um nome de variável, assim como nome de um método, classe, rótulo e dezenas de outros itens lexicográficos, constitui o que é chamado um identificador. Uma vez criado, um identificador representa sempre o mesmo objeto a ele associado, em qualquer contexto em que seja empregado.

As seguintes regras regem a criação de identificadores:

• O primeiro caracter de um identificador deve ser uma letra. Os demais caracteres podem ser quaisquer seqüências de numerais e letras
• Não apenas os numerais e letras latinas podem ser empregadas, como também letras de quaisquer outro alfabeto
• Devido a razões históricas, o underscore  "_" e o sinal de dolar "$" são considerados letras e podem ser usados nos identificadores
• Assim como em outras linguagens, como C e C++, os identificadores distinguem o tipo de caixa das letras, isto é, as maiúsculas são consideradas distintas das minúsculas. Isso significa que fim_de_arquivo é um identificador diferente de Fim_De_Arquivo
• Os identificadores não podem ser palavras chave, como: class, for, while, public, etc

Tipos de dados inteiros

Os tipos de dados primitivos byte, int, char, short e long constituem tipos de dados inteiros. Isso porque variáveis desses tipos podem conter um valor numérico inteiro dentro da faixa estabelecida para cada tipo indiivdual. Por exemplo, um byte pode conter um inteiro entre -128 e 127, enquanto um short pode conter um valor entre -32.768 e 32.767. Já o tipo long é suficiente para contar todos os mosquitos do Pantanal Matogrossense.

Há diversas razões para se utilizar um ou outro dos tipos inteiros em uma aplicação. Em geral, não é sensato declarar todas as variáveis inteiras do programa como long. Raramente os programas necessitam trabalhar com dados inteiros que permitam fazer uso da máxima capacidade de armazenagem de um long. Além disso, variáveis grandes consomem mais memória do que variáveis menores, como short.

Obs: Se alguma operação aritmética cria um resultado que excede um dos limites estabelecidos para o tipo inteiro empregado, não há qualquer indicação de erro para avisar sobre essa ocorrência. Ao invés disso, um complemento de dois do valor obtido será o resultado. Por exemplo, se a variável for do tipo byte, ocorrem os seguintes resultados: 127+1 = -128, 127+9=-120 e 127+127=-2. Entretanto, uma excessão do tipo ArithmeticException é levantada caso ocorra uma divisão por zero. As excessões e seus mecanismos serão abordados no Capítulo 8. Vejamos o seguinte código:

public class Arith
{
   public static void main(String args[])
   {
      byte a = 127;
      short b = 32767;
      int c = 2147483647;
      long d = 9223372036854775807L;
      int e = 0;
      a += 1;
      b += 1;
      c += 1;
      d += 1;
      System.out.println("Valor de a = " + a);
      System.out.println("Valor de b = " + b);
      System.out.println("Valor de c = " + c);
      System.out.println("Valor de d = " + d);
      d /= e;   // Vai dar erro porque e = 0
    }
}

com seu respectivo resultado de execução:

C:\Usr\Waldeck>java Arith
Valor de a = -128
Valor de b = -32768
Valor de c = -2147483648
Valor de d = -9223372036854775808
java.lang.ArithmeticException: / by zero
        at Arith.main(Arith.java:18)

C:\Usr\Waldeck>

Seguem abaixo alguns exemplos de declarações de variáveis de tipo inteiro:

byte Contador = 1;

int AnguloEmGraus = -45;

char Indice = 6;

A diferença entre essas declarações e a declaração de dados booleanos vista acima está no tipo de dado especificado e no valor atribuído a cada variável.

Operações com inteiros

Podemos realizar uma série de operações com os dados do tipo inteiro. A tabela seguinte mostra uma lista completa.

Operação	Descrição
=, +=, -=, *=, /=, %=	Operadores de atribuição
==, !=	Operadores de igualdade e diferença
<, <=, >, >=	Operadores de desigualdade
+, -	Operadores unários
+, -, *, /, %	Adição, subtração, multiplicação, divisão e módulo
+=, -=, *=, /=, %=	Operadores de atribuição com adição, subtração, multiplicação, divisão e módulo
++, --	Incremento e decremento
<<, >>, >>>	Operadores de deslocamento de bits
<<=, >>=, >>>=	Operadores de atribuição com deslocamento de bits
~	Operador lógico de negação
&, |, ^	Operadores lógicos E, OU e OU-exclusivo
&=, |=, ^=	Operadores de atribuição com operação lógica E, OU e OU-exclusivo

Muitos das operações que aparecem na lista acima são familiares e praticamente não requerem explicação. Há outros, porém, que pode ser um tanto quanto ambíguos. É o caso dos operadores de atribuição aritméticos. Estes consistem de atalhos para atribuir um novo valor a uma variável onde esse novo valor depende do valor anterior lá armazenado. Por exemplo: += adiciona um valor ao valor antigo de uma variável e a soma passa a ser o novo valor. Esse padrão também é obedecido para as operações -=, *=, /= e %=. Temos assim as seguintes correspondências:

x += 5	x=x+5
x -= y	x = x - y
x *= 2	x = x * 2
z /= 4	z = z / 4

etc.

Os operadores de incremento e decremento referem-se a apenas uma variável (logo são chamados de unários). Por exemplo, o operador de incremento soma um ao operando conforme o exemplo:

x++;

é uma maneira muito mais concisa de se escrever x = x + 1. Mas não só, esses operadores se comportam de modo diferente quando seguem ou precedem o nome de uma variável. Se o operador precede o nome da variável, então o incremento (ou decremento) ocorre antes que o valor da variável seja tomado para a expressão aritmética. No seguinte exemplo, o valor das variáveis x e y será 6:

int x = 5;
int y = ++x;

Porém, no próximo exemplo o valor de x será 6 enquando que o valor de y será 5:

int x = 5;
int y = x++;

Vejamos alguns exemplos de declarações e de utilizações de operações envolvendo tipos inteiros:

byte j = 60;
short k = 24;
int l = 30;
long m = 12L;
long resuldato = 0L;

resultado += j; // resultado = 60 (0 mais 60)
resultado += k; // resultado = 84 (60 mais 24)
resultado /= m; // resultado = 7 (84 dividido por 12)
resultado -= l; // resultado = -23(7 menos 30)
resultado = -resultado; // resultado = 23 ( -(-23) )

resultado = %= m;       // resultado = 11 (resto de 23 div. 12)

Tipo caracter

Uma variável do tipo char armazena um caractere Unicode. Um caractere Unicode é um caractere de 16 bits, sendo que de 0 a 225 correspondem aos caracteres do código ASCII (a tabela ASCII é uma tabela padronizada internacionalmente de associações entre caractere e a sua representação numérica no computador). Uma constante do tipo caractere é representada colocando-se entre apóstrofos, ou pelo valor numérico correspondente na tabela Unicode (ou ASCII), ou ainda, pela sequência '\x' onde x especifica o caractere a ser referido. Esta especificação de sequência de escape obedece às mesmas convenções do C/C++. Por exemplo: 'a', 'f', '\n', etc, são constantes do tipo char.

Tipos de ponto flutuante

Em Java, existem duas categorias de de variáveis de ponto flutuante: float armazena valores numéricos em ponto flutuante de precisão simples e double de precisão dupla. Ambas seguem norma: IEEE Standard for Binary Floating Point Arithmetic, ANSI/IEEE Std. 754-1985 (IEEE, New York). O fato de obedecer a essa norma é que torna os tipos de dados aceitos pela linguagem Java tão portáveis. Esses dados serão aceitos por qualquer plataforma, independendo do tipo desistema operacional e do fabricante do computador. A representação dos valores em ponto flutuante pode ser feita usando a notação decimal (exemplo: -24.321) ou a notação científica (exemplo: 2.52E-31).

Além dos possíveis valores numéricos que uma variável de ponto flutuante pode assumir há também os seguintes:

• menos infinito
• mais infinito
• zero
• NAN - not a number

Estes são requeridos pela norma. O mais infinito é usado, por exemplo, ao somarmos 1 ao maior valor possivelmente representável por esse sistema.
Muitas das operações realizáveis com inteiros (porém não todas) têm análogas para números de ponto flutuante. Eis um resumo:

Operação	Descrição
=, +=, -=, *=, /=	Operadores de atribuição
==, !=	Operadores de igualdade e diferença
<, <=, >, >=	Operadores de desigualdade
+, -	Sinais unários
+, -, *, /	Adição, subtração, multiplicação e divisão
+=, -=, *=, /=	Operadores de atribuição com adição, subtração, multiplicação e divisão
++, --	Operadores unários de incremento e decremento