Saudações leitores e paraquedistas. Estou aqui mais uma vez postando as aulas da faculdade. Esta acho que vai ser a mais complicada que eu escrevo. Não porque o assunto seja complexo. Para muitos caras como o Popolon ou o TaQ, que mexem direto com Java, isso é tranquilo. Para mim que não sou programador (estou aprendendo Ruby que é uma linguagem que gosto e é incrível na minha opinião, além de ser bem simples e divertida) e não gosto de Java como já disse antes, vai ser complicado. Vamos ver o que vai virar. Comentários, sugestões, correções e críticas são muito bem-vindos.

O que é Java?

Linguagem de programação orientada a objetos desenvolvida pela Sun. Diferentemente das linguagens convencionais, que são compiladas para um código nativo, a linguagem Java é compilada para um “bytecode” que é executado por uma máquina virtual.

Desde seu lançamento, em maio de 1995, a plataforma Java foi adotada mais rapidamente do que qualquer outra linguagem na história da computação. Em 2003 atingiu a marca de 4 milhões de desenvolvedores em todo o mundo. O Java se tornou popular pelo seu uso na internet e hoje possui seu ambiente de execução presente em navegadores, sistemas operacionais, mainframes, celulares, palmtops, cartões inteligentes etc.

Foi projetada tendo em vista os seguintes objetivos:

• Orientação a objeto (baseado no modelo de Smalltalk e Simula67)
• Portabilidade – Independência de plataforma
• Recursos de rede
• Segurança

Outras características são:

• Sintaxe similar a Linguagem C/C++
• Facilidade de internacionalização (suporte nativo a caracteres Unicode)
• Simplicidade na especificação
• Distribuida com um vasto conjunto de bibliotecas (ou APIs)
• Possui facilidades para criação de programas distribuídos e multitarefa
• Desalocação da memória automática por processo de coletor de lixo (garbage collector)
• Carga Dinâmica de Código (Programas em Java são formados por uma coleção de classes armazenadas independentemente e que podem ser carregadas no momento de utilização)

Referência: Wikipedia

Máquina Virtual Java

A máquina virtual do Java (Java Virtual Machine – JVM) é um programa que carrega e executa os aplicativos Java, convertendo os bytecodes em código executável da máquina. A JVM é responsável pelo gerenciamento dos aplicativos, à medida que são executados.

Graças à máquina virtual Java, os programas escritos em Java podem funcionar em qualquer plataforma de hardware e software que possua uma versão da JVM, tornando assim essas aplicações independentes da plataforma onde funcionam.

Referência: Wikipédia

Programas que serão usados

Na primeira aula de Java foi usado um software chamado JCreator. Apesar disso aconselho todos a usarem o editor Vim que foi o que usei nas aulas e funcionou muito bem, além de ser um editor altamente customizável e excelente.

Basta escrever o código no Vim, salvar e depois usar o javac para compilar:

javac programa.java

Depois basta rodar o programa:

java programa

Primeiro Contato O.o

Em linguagem C, quando faziamos um programinha, tinhamos que colocar as bibliotecas:

#include <stdio.h>;

void main()
{
	printf("Olá mundo!");
}

Também temos os includes no java. O comando se chama import.

Exemplo: import java.lang.*

Criação das Classes

Quando criar a classe, se a classe for pública, o arquivo precisa ter o mesmo nome da classe.

Uma classe pública (ou variável global) é algo que tudo dentro do programa tem acesso. Não é obrigado colocar público, mas se for, é necessário dar o mesmo nome do arquivo para a classe. Esta é uma regrinha básica.

Portanto, todo o programa fica dentro da classe, como pode ser visto no código abaixo (que deverá estar dentro de um arquivo chamado exemplo1.java):

public class exemplo1
{
        public static void main (String args[])
        {
                System.out.println("Olá mundo!");
        }
}

Em C, por exemplo, tudo fica dentro do void main(). É depois daquilo que o programa passa a ser executado. Ele é a função principal.

No Java é igual, apenas um pouco mais complexa sua construção:

Tem o void main (sempre minúsculo) da mesma forma que no C tem void main(). Void é uma função que não retorna valor, mas pode receber uma string de argumentos. O args lá dentro pode receber qualquer nome. Na chamada do programa, pode ser que eu chame parâmetros, então ele já está pronto para receber esses parâmetros. O Public é para mostrar que é uma função pública. Static mostra que a função pode ser compartilhada em todas as outras funções do programa.

Todo o programa começa a ser executado por esse trecho de código que é a função principal do programinha. Ele executa o que tem dentro das chaves (que no exemplo é apenas uma mensagenzinha que será mostrada na tela).

System.out.print é o que imprime algo na tela. O ln junto (System.out.println) faz com que seja pulada uma linha. Também pode ser usado o comando System.out.printf, da mesma forma que o printf é usado na linguagem C.

Incremento

Se usarmos o incremento (++) antes da variável, ele incrementa antes de, por exemplo, imprimir uma linha. Se colocarmos o incremento depois, ele imprime depois. Por exemplo, se você pedir para imprimir a variável media:

System.out.println(“Média = ” + ++media);

O valor incrementado já sairá na linha que for impressa. Se a variável média originalmente tiver, por exemplo, o valor 5, será impresso o número 6.

Se usarmos o incremento depois da variável dessa forma:

System.out.println(“Média = ” + media++);

A variável media será incrementada, mas o valor impresso será o valor antigo, que no exemplo, seria 5. Para aparecer o valor incrementado teriamos que pedir para escrever a variável de novo na tela:

System.out.println(“Média = ” + media);

Dessa forma sairia o número 6

Exemplo de uso de variáveis

public class exemplo2
{
        public static void main(String args[])
        {
                double nota1 = 10, nota2 = 5, media = 0;
                media = (nota1 + nota2) / 2;
                System.out.println("A média entre " + nota1 + " e " + nota2 + " é = " + media);
        }
}

No exemplo acima definimos as variáveis nota1, nota2 e media como double (e já demos um valor para elas). Depois tiramos a média dos valores que estavam nas variáveis nota1 e nota2 e jogamos o resultado para a variável media.

No final apenas imprimimos o valor da variável média na tela com o comando System.out.println.

Exemplo de uso de operadores lógicos

O exemplo abaixo mostra o uso de operadores lógicos. Como os códigos a partir daqui são um pouquinho maiores e com mais comandos do que os anteriores, vou deixá-los comentados para facilitar o entendimento:

public class exemplo3
{
        public static void main(String args[])
        {
                double nota1 = 10, nota2 = 5, media = 0; // Aqui definimos as variáveis e damos os valores

                media = (nota1 + nota2) / 2; // Fizemos o cálculo da média. Somamos os valores de nota1 e nota2 e dividimos por 2. O resultado é jogado dentro da variável media.
                if (media >= 5) // Aqui é feito o teste. Se média for maior ou igual a 5 o código dentro deste bloco será executada.
               {
                        System.out.println("Aluno aprovado!");
                }
                else if (media =< 0) // Caso o valor de média seja menor que 5, ele fará um teste para verificar seo valor de média é maior ou igual a 0. Se for ele executará o código dentro do bloco.
                {
                        System.out.println("Aluno reprovado!");
                }
        }
}

Como pode ser visto, definimos as variáveis nota1, nota2 e media como double e já demos valores a elas. Depois tiramos a média de nota1 e nota2 e jogamos o resultado dentro da variável media.

Após isso fizemos um teste: Se o valor da variável media for maior ou igual a 5, ele deverá mostrar na tela a frase “Aluno aprovado!”. Se não passar no teste (neste caso, se o valor for menor que 5), ele fará outro teste verificando se o valor dentro da variável média é maior ou igual a zero. Se for, ele imprimirá na tela a frase “Aluno reprovado!”.

Exemplo de uso de incremento

public class exemplo4
{
        public static void main (String args[])
        {
                double x = 5; // Aqui definimos a variável x como double e demos o valor 5 a ela

                while (x <= 10) // Aqui repetiremos o bloco abaixo enquanto o x não for maior ou igual a 10
                {
                        x++; // Incrementamos o x, portanto o primeiro valor a ser impresso será 6
                        System.out.println("x = " + x); // Aqui ela vai mostrando na tela o valor do x
                }
                for (double i=0; i < 10; i=i+0.5) // Aqui já definimos o i como double demos o valor inicial de 0. Ele ficará em loop enquanto o valor de i for menor que 10. Cada vez que o bloco rodar ele irá adicionará 0.5 ao valor de i.
                {
                        System.out.println("i = " + i);
                }
        }
}

Ok, acho que ficou meio mal feito esta aula minha. Como falei antes, não sou programador e não conheço quase nada de Java. Mas acho que dá para a galera que já programa e vem de outras linguagens entender Sei que pode ter ficado meio confuso o post, mas acho que a culpa é da metodologia da professora que apenas escreve os código na lousa, dá uma mexida e explica meio que fazendo um rolo haheueheuheheeheheheh!

Prometo que vou tentar fazer melhor nos próximos posts referentes a esta matéria! Por enquanto aguardo comentários, sugestões, críticas e sugestões. Sei que os melhores programadores de Java estão aqui na Internet e que possivelmente o grande Popolon dará uma passada aqui (Aeeee Popolon, vê se não xinga muito o Terrinha. Apesar de termos opiniões diferentes em relação a Java, nós dois somos os “xiitas” que fazem do BR-Linux um lugar melhor e mais divertido de se viver hauehaeueahueahueahuaeheu. Pelo menos aqui não vou ser moderado negativamente ;D) para reclamar de alguma coisa hehehehe.

Abraços galera! E prometo que o nível das aulas vai melhorar com o tempo. É só esperar que estou me adaptando a esta nova rotina (de estudar as matérias da faculdade ¬¬).

Technorati Tags: Java, aula, primeira, orientação a objetos, objetos, orientada, linguagem, máquina virtual, virtual, máquina, jvm, sun, javac, vim, jcreator, eclipse, netbeans, ide, jbuilder, código, programa, programação, software, desenvolvimento, faculdade, matéria, operadores, incremento, variável, bytecode, compilar

Powered by ScribeFire.