sexta-feira, 26 de fevereiro de 2010

Linguagem de Programação – Java – Aula 2 e 3

Um pouquinho atrasada para postar o conteúdo da segunda e terceira aula de java, mas vamos lá. Na segunda aula, fomos finalmente ao laboratório aplicar os conceitos que havíamos aprendido, que você pode conferir aqui .
Na aula anterior, ficou um exercício pendente, onde deveríamos fazer uma classe chamada Matematica que realize as 4 operações básicas(+ - * /) sobre 2 números float. E depois, utilizando a classe Matematica, escreva uma classe chamada programa que realize as seguintes operações: 5.3 + 4.7. É possível construir esse programa? Por que?

Bem, vamos a classe Matemática então, vou colocar o código por inteiro, mas também colocarei uma imagem de como ele ficou, para que tenham uma melhor visualização da identação e vejam melhor os comentários:

package calculadora;

public class Matematica {

private float num1; //definir atributos sempre como private
private float num2;
private float resultado;


public void somar(){ //definindo métodos
resultado = num1 + num2; //realizando as operações
}
public void subt(){
resultado = num1 - num2;
}
public void mult(){
resultado = num1 * num2;
}
public void div(){
resultado = num1 / num2;
}
public float mostrar(){ //metodo que retornará o resultado, por isso não deve ser void,
//e precisa ser do mesmo tipo do atributo, no caso retornará
//um float
return(resultado);
}
}

o código acima é o mesmo da imagem abaixo:




Continuando o exercício, utilizando a classe Matemática, escreva uma classe chamada programa que realize as seguintes operações: 5.3 + 4.7. É possível construir esse programa? Por que?
Não, não é possível pois os atributos são privados e não há métodos que permitam a entrada de valores na classe, para resolver isso, ou cria um método entrada(), ou, programando de forma porca, coloque os atributos como públicos. Faremos acrescentando um novo método:

public void entrada (float n1, float n2){ //entre parenteses está a definição de parametros
//este método será usado como forma de enviar dados para dentro da classe
num1 = n1;
num2 = n2; //atributos recebendo parametros
}

Portanto ficará assim:



Pronto, agora é possível resolvermos aquele problema. Continuando, vamos fazer a classe onde realmente realizará as operações, a chamei de classe CalculadoraSimples:

package calculadora;
/*A classe realizará as seguintes operações:
* 5.3 + 4.7 e apresentar o resultado */

public class CalculadoraSimples
{
public static void main(String[] args)
{
Matematica calc = new Matematica();//instanciando a classe Matematica,calc é um objeto
//Somar
calc.entrada(5.3f, 4.7f); //atribuindo valores para os parametros n1 e n2
//sempre que passa um numero com casa decimal, ele acha que é double, mas haviamos
//definido que ele seria float, por isso, colocar o f na frente do numero para
//forçar ele entender que é float

calc.somar();

System.out.println("Resultado = " + calc.mostrar());

//Multiplicação

calc.entrada(3, 1.5f);

calc.mult();

System.out.println("Resultado da multiplicação = " + calc.mostrar());
}

}

imagem:


Beleza, continuando, na aula de ontem aprendemos realizar a entrada de dados com o teclado e a converter valores.

Entrada de dados:
Inicialmente deve-­se realizar a importação do pacote java.io, pois, ele contém as classes necessárias que permitirão a entrada de dados através do teclado. A utilização dessas classes requer que o tratamento de exceções seja habilitado, neste exemplo, isso será realizado através da palavra reservada throws.
O próximo passo consiste em criar um objeto pertencente a classe BufferedReader, o qual permitirá receber os dados da System.in que representa o acesso ao dispositivo de hardware teclado. Concluindo este exemplo, o método readLine() obtém o conteúdo digitado até que o usuário pressione a tecla Enter.
É importante salientar que toda entrada de dados é recebida pela linguagem como um objeto pertencente a classe String sendo que, quando necessário, devemos realizar aconversão para o tipo de dados desejado.

Exemplo:

package entradaDeDados;
import java.io.*; //importando pacote para habilitar entrada de teclado

//pacotes em java são conjuntos de classes, esse pacote cuida de classes responsáveis
//por entrada e saida de dados

public class EntradaDeDados
{
public static void main(String[] args) throws IOException
{
String nome, sobrenome, idade; //declarando a variavel nome e idade do tipo String

BufferedReader teclado = new BufferedReader(
new InputStreamReader(System.in)); //cria objeto teclado

System.out.print("Informe o seu nome:"); //saida na tela

nome = teclado.readLine(); //onde pega os valores do teclado, sempre recebe
//em String, caso precise de outros dados, tem que
//converter
System.out.print("Informe seu sobrenome:");
sobrenome = teclado.readLine();

System.out.print("Informe sua idade:"); //o print serve para escrever na frente
idade = teclado.readLine();

System.out.println("Olá, " + nome + " " + sobrenome + " , você tem " + idade + " anos" + "."); //saida em tela
}
}




Conversão de tipos de dados:
A conversão é realizada em dois passos, primeiro é criado um objeto a partir da classe que receberá, como parâmetro, o objeto da classe String, isso porque um dado sempre é recebido como String. Em seguida o método é usado para retornar um valor do tipo de dados inteiro para a variável saída. Exemplo: Convertendo String para int:

String entrada = “12”;
int saida = new Integer(entrada).intValue();

Outro exemplo, convertendo String para double:

String valor = "125.7";
double saida = new Double(valor).doubleValue();

Segue o exemplo de aplicação na classe Soma:

package entradaDeDados;
import java.io.*;

public class Soma
{
public static void main(String[] args) throws IOException
{
String num1, num2; //variaveis
int resulSoma;

BufferedReader teclado = new BufferedReader(
new InputStreamReader(System.in)); //cria objeto teclado

System.out.print("Informe o primeiro valor:"); //mensagem ao usuario
num1 = teclado.readLine(); //pegando valor do teclado

System.out.print("Informe o segundo valor:");
num2 = teclado.readLine();

int valor1 = new Integer(num1).intValue(); //convertendo valores

int valor2 = new Integer(num2).intValue();

resulSoma = valor1 + valor2; //efetuando a operação

System.out.println("O resultado entre " + num1 + " e " + num2 + " é " + resulSoma);

}

}



Agora um Exercício para testar e se divertir:

Efetuar o cálculo da qtde de litros de combustíveis gasta em uma viagem, utilizando um automóvel que faz 12 Km por litro. Para obter o calculo, o usuário deve fornecer o tempo gasto na viagem e a velocidade média.Desta forma, será possível obter a distância percorrida com a fórmula Distancia = tempo * velocidade . Tendo o valor da distancia, basta calcular a quantidade de litros de combustivel utilizada na viagem com a fórmula: Litros_usados = Distacia / 12. O programa deve apresentar os valores da velocidade média, tempo gasto, a distancia percorrida e a qtde de litros utilizados na viagem. Dica: trabalhe com valores reais

package exercicios;

import java.io.*; //para fazer uso do teclado
import java.text.*; //para formatar casas decimais
public class Exe4a {
public static void main(String[] args) throws IOException
{
String sTempo, sVelocidade;
double dDistancia, dDistPercorrida, dLitros;

NumberFormat mascara = new DecimalFormat("###.00"); //para formatar as casas decimais

BufferedReader teclado = new BufferedReader(
new InputStreamReader(System.in)); //cria objeto teclado

System.out.println("Informe o Tempo de Viagem: ");
sTempo = teclado.readLine();

System.out.println("Informe a Velocidade: ");
sVelocidade = teclado.readLine();
//converter as variaveis
double dTempo = new Double(sTempo).doubleValue();
double dVelocidade = new Double(sVelocidade).doubleValue();

dDistPercorrida = dTempo * dVelocidade; //calculo de distacia percorrida
dLitros = dDistPercorrida / 12;

System.out.println("Velocidade Média = " + sVelocidade +
"\nTempo Gasto = " + sTempo +
"\nDistância Percorrida = " + dDistPercorrida +
"\nQuantidade de Litros = " + mascara.format(dLitros));
}
}


Pronto, por enquanto é só, mas os estudos continuam ao longo da semana, agora é melhor eu me concentrar na aqui na aula ;-)

Ahh uma dica, achei um material muito bom para servir de base de estudos, o curso de Java do Jedi, que por sinal, estou aproveitando também, é só conferir aqui.

Bons estudos para todos nós ;-)







domingo, 14 de fevereiro de 2010

Inproprietário: O Mundo do Software Livre


Segue abaixo a reprodução integral do post a respeito do documentário "InProprietário" do blog Verruga do Cérebro

"Todos que amam o software livre já devem ter visto ou ouvido falar de filmes e documentários como Revolution OS e The Code Linux, que são dois dos mais conhecidos exemplos de documentários que abortam o Linux e o software livre, mas poucas pessoas ainda conhecem o ótimo documentário nacional que foi feito como trabalho de conclusão de curso de Comunicação Social Habilitação em Jornalismo curso do Centro Universitário FIEO | UNIFIEO pelos jornalistas Daniel Bianchi e Jota Rodrigo.

O documentário Inproprietário: O Mundo do Software Livre, com duração de 32 minutos, conta com a participação de Richard Stallman e outros amantes de software livre e aborda desde a história da criação do Unix que teve durante um breve período de vida o seu código aberto e que tornou assim a sua derivação e larga utilização em universidades nos EUA possível em meados da década de 70, mas que foi fechado pela AT&T e que fez nascer assim a ideia do software livre e o surgimento do movimento GNU e mais adiante o kernel do Linux.

De forma muito simples e clara o filme tornou possível de ser explicada inclusive para as pessoas não ligadas a área de tecnologia o conceito de software, como ele é escrito e o que é o código fonte de um programa, diz ainda o que é um sistema operacional.

A obra ainda mostra a utilização do software livre e Linux não como uma alternativa tecnológica mas como uma reação de mercado e uma filosofia por diversos profissionais de tecnologia e por diversos setores do governo e forças armadas mostrando através de relatos de algumas pessoas diretamente ligadas a projetos de implementação de software livre como o software livre é viável tecnicamente e economicamente.

Em sua participação Richard Stallman fala sobre a idéia de software livre e os pilares sobre os quais foram fundadas o conceito de software livre.

Como não poderia ficar de fora também foi incluído e demonstrado o conceito de software proprietário, seu custo, suas limitações e sua pesada concorrência com o software livre.

Fica demonstrado nesse filme com clareza a importância do conceito do software livre e do compartilhamento livre e total ao conhecimento humano.

Pessoalmente falando, eu diria que esse documentário está entre os melhores já produzidos com esse assunto, não devendo em nada à produções como as acima citadas, eu particularmente parabenizo ao Daniel e Jota pelo maravilhoso trabalho de divulgação do software livre.

A obra que está licenciada sob a Creative Commons Atributo 2.5 Brasil"


Download

Diversão Livre - Revista Espírito Livre nº 10



Galera, um post um pouco atrasado, mas já foi lançada a edição nº 10 da revista Espírito Livre, com o tema: Diversão Livre . "Esta edição de janeiro da Revista Espírito Livre tenta apresentar aos leitores, experiências, situações e cases onde temos licenças livres propiciando diversão, softwares livres possibilitando a muitos se divertirem, enfim, estas tentamos mostrar que estas duas palavras, em nosso universo, podem conviver pacificamente, criando uma harmoniosa relação. A entrevista internacional tras Adrian Henke, um desenvolvedor de software que mora na Suiça e que está a frente do AssaultCube, um pequeno notável game de tiro em primeira pessoa, que faz milagre em pouco mais de 40 MB, seja nos gráficos, jogabilidade e outros aspectos. Merece toda nossa atenção."


Revista Espírito Livre


:-)

Personalizando seu ubuntu, tudo muito mais agradável

Para algumas pessoas, o impedimento de se usar uma ou outra distribuição GNU/Linux é porque não acham sua aparência muito agradável, independente do grau de dificuldade em si. Por isso, esse post tem um objetivo simples, dar dicas de como personalizar a aparência do Gnome, em especial usando o Ubuntu 9.10.



Antes de mais nada, é importante entendermos como é constituída a interface nas distribuições. O Linux oferece uma grande variedade de interfaces e ambientes atraentes que você pode adicionar à sua instalação existente.

Esta é uma das maiores surpresas que os usuários novos encontram: uma interface gráfica de usuário não é nada mais que uma aplicação que roda em seu sistema. Ela não faz parte do kernel do Linux ou qualquer parte interna do sistema. É uma ferramenta poderosa que ativa as habilidades gráficas de sua estação de trabalho.

Padrões são importantes, como um padrão para desenhar e mover janelas em uma tela, interagir com o usuário através de mouse, teclado e outros aspectos básicos, porém importantes. Assim, foi criado e batizado o X Window System, normalmente abreviado como X11 ou só X. Ele é usado em Unix, Linux e sistemas operacionais parecidos com Unix no mundo inteiro.
A aplicação que oferece a usuários de Linux a habilidade de rodar interfaces gráficas de usuário e que usa o padrão X11 é o Xorg-X11, uma secessão do projeto do XFree86. O XFree86 escolheu usar uma licença que pode não ser compatível com a licença GPL; o uso do Xorg é, portanto, recomendado.

Na questão de interface, o Linux permite o uso de vários tipos de ambientes gráficos e gerenciadores de arquivos, alguns muito sofisticados e em 3D. Algumas interfaces disponíveis são: GNOME, KDE, XFCE, Windowmaker, Fluxbox, Blanes, Blackbox, Afterstep, Enlightenment, IceWM, FVWM, Kahakai, ZappWM, dwm, SithWM, Whim, Karmen, Sawfish, XIGE, Framer, Mavosxwm, WindowLab, OpenBox...

O usuário tem total liberdade de escolher qual deseja usar, e se quiser, pode instalar várias, e escolher qual quer usar quando o sistema estiver carregando.
As mais comuns atualmente são o GNOME e o KDE, neste tutorial, como já mencionado, vamos personalizar o GNOME numa distribuição Ubuntu.

Assim que se instala o sistema, há várias configurações necessárias a fazer, instalar drivers, programas, enfim, dei uma garimpada na internet e já achei várias dicas a esse respeito, essas configurações iniciais não será nosso foco, estamos é de olho em deixa-lo lindo e fazer outros babarem por nosso sistema.

Dicas de configurações iniciais:

Como instalar tudo em Ubuntu

Guia do hardware

Tutoriais Ubuntu

Pesquisa Google

Próximo passo, mudar o Wallpaper, a galera da Canonical tem caprichado nos wallpapers, mas sempre ficamos com gosto de quero mais, segue alguns sites onde há dezenas e dezenas de opção de papéis de parede, é só escolher o que mais agrada:

Interfacelift

Gnome-look
- o gnome-look é um site onde se encontra diversos temas para o gnome, seja wallpapers, ícones … uma porção de coisas

DesktopMachine - pra quem gosta de carros

Orkut – Há um post na comunidade Ubuntu Linux Brasil com centenas de dicas, principalmente postadas por nosso amigo Guevara, fez um excelente trabalho de pesquisa

Digitalblasphemy

eu escolhi esse aqui, gosto de wallpapers escuros e simples.

Para mudar o wallpaper, clique com o botão diretiro em qualquer lugar da área de trabalho, e vá em Alterar plano de fundo, você pode escolher qualquer opção apresentada ou colocar o seu, é só clicar em Adicionar e navegar até onde está sua imagem, clique em abrir e pronto.



Nessa mesma janela, vc pode fazer outras alterações, vá conhecendo as outras abas e escolhendo os modelos que mais agradam.



Depois de mudar o wallpaper, as barras de ferramentas não devem ter combinado muito, então vamos alterar tbm, é só ir com o botão direito em cima da barra, ir em propriedades → Cor de fundo, clique em Cor Sólida e regule a barra de transparência de acordo com seu gosto.






Outra coisa importante é o uso do nosso bom, belo e invejado Compiz – Fusion , para não ficar repetitivo, há ótimo tutoriais na internet sobre ele, recomendo este aqui , e esse efeito de fogo é o recurso do Skydome, que no tutorial ensina também como colocar.



Mais uma coisa que é possível mudar são os ícones usados, de novo vamos no gnome-look e escolher os mais atraentes, eu escolhi esse aqui . É só clicar em download e salvar onde vc deseja, não é necessário descompactar, para instalar vá em Sistemas → Preferências → Aparência , na aba Tema, clique em instalar e navegue até o arquivo que você baixou, clique em Abrir e em Aplicar novo tema, fácil né !

Uma olhadinha em como ele está por enquanto ;-D




Agora vamos instalar a barrinha do avant windows navigator, esse tutorial é excelente para isso, a única mudança que sugiro é, quando der o comando de instalação que é o sudo apt-get install avant-window-navigator-svn apague esse “-svn” no final e coloque apenas sudo apt-get install avant-window-navigator.

Para que ela inicie junto com o sistema, vá em Sistemas → Preferências → Aplicativos de Sessão, clique em Adicionar, na nova janela coloque em nome : AWN e em comando: avant-window-navigator, depois clique em adicionar e em fechar.

A minha última recomendação é instalar o gDesklets, são vários aplicativos que podemos colocar na área de trabalho, para instalar digite no terminal: sudo apt-get install gDesklets , depois vá em Aplicativos → Acessórios → gDesklets e coloque os aplicativos que achar mais válidos.

Para que ela inicie junto com o sistema, vá em Sistemas → Preferências → Aplicativos de Sessão, clique em Adicionar, na nova janela coloque em nome : gDesklets e em comando: gdesklets shell, depois clique em adicionar e em fechar.

Pronto, com isso você já deve ter deixado o seu sistema mais agradável, para mais recursos, o tio google com certeza será de grande auxílio. Segue agora mais algumas fotos pra deixar com água na boca.

Tem alguns posts em comunidades onde fica aberto para usuários postarem os seus screenshots, tem várias dicas legais também.














sábado, 13 de fevereiro de 2010

Dicas de vídeos de palestras apresentadas durante o Campus Party 2010

O Campus Party foi demais, ainda estou naquela depressão pós CP, muita saudade dos amigos, virtuais e reais, da mudança de rotina, da conexão, do conhecimento apresentado.

Segue abaixo uma seleção das palestras que mais gostei apresentadas durante o CP, vale a pena assistir de novo para quem já conferiu, e para quem não teve essa chance, aproveitem essa oportunidade.

Para começar, o Software Livre para a maioria é uma paixão, e por isso, em muitos casos, como o meu, ainda não se consegue trabalhar ou viver exclusivamente de um trabalho baseado na ideologia do SL. Para muitos a visão de que tudo deve ser gratuíto, ainda é muito grande.


A palestra a seguir tem o tema: Software Livre - Modelos de Negócios: transformando a sua paixão em seu trabalho.






Faz a diferença acompanhar essas dicas.


Um outro assunto que me interessa, e que está se tornando uma oportunidade para os desenvolvedores, e a TV Digital, na palestra : TV Digital e Ginga: Oportunidades para o Brasil explica bem o funcionamento e as oportunidades que essa nova tecnologia nos oferece.




No post abaixo, comecei a compartilhar minhas aulas de java, então nada mais interessante que adquirir mais conhecimento sobre o assunto na palestra Desenvolvendo na plataforma Java: Ruby, Python e linguagens com poder da JVM .



Outro tema interessante : Métricas de código-fonte e avaliação automática de projeto software livre.



Liberdade de expressão e censura prévia no Brasil, um assunto que envolve todos nós.



Enfim, foram muitos os assuntos interessantes, quem desejar conferir todos os vídeos disponíveis, acessem a página #cparty do Campus Party no Youtube.


Espero que gostem, absorver e ouvir a experiência e o compartilhamento do conhecimento desses profissionais é que faz a diferença para cada um de nós.

Linguagem de Programação – Java – Aula 1

Olá galera, esse semestre será um pouco puxado, terei que aprender pelo menos 4 linguagens ao mesmo tempo, Progress e Delphi para o emprego, C++ e Java para faculdade, embora o que queira mesmo estudar seja Python. Mas enfim, aproveitando todas essas horas de estudo que terei que dedicar, vou compartilhando aqui o conteúdo que for absorvendo, repassando minhas aulas, exercícios :-D se mais alguém se interessar em compartilhar seu conhecimento, será bem vindo, muito mais legal do que aprender sozinha.


Essa semana tive minha primeira aula de Java, lembro de já ter visto essa matéria no curso técnico, mas as coisas ficaram um pouco confusas para mim, mas agora eu engreno hein ;-)


Um paradigma referente a programação, define o modo de se realizar alguma atividade. Na questão de desenvolvimento de sistemas, há duas opções, a construção de forma Estruturada e a Orientação a Objetos.



No caso do Java, usamos Orientação a Objetos. Na verdade, o Java não é apenas uma linguagem, e sim um conjunto de aplicações e componentes. Ele pode ser usado para o desenvolvimento em console, gráficos, dispositivos móveis e para web.


Dentre algumas vantagens apresentadas em aula foi:

  • Multiplataforma;

  • Multithread : lançar canais para que várias aplicações trabalhem juntas;

  • Distribuição gratuíta;

O Java funciona da seguinte forma: Temos o arquivo com extensão .java, depois de compilado ele gera bytecodes (com extenção .class), e através da Máquina Virtual – JVM – qualquer lugar em que a tenha instalado (a máquina virtual), é possível executar o bytecode, independente da plataforma. A linguagem .NET da Microsoft também foi pensada e criada com esse conceito, mas como não é interessante que outras plataformas além do windows sejam usadas, não temos essa liberdade que o Java oferece.



Orientação a Objeto


A Orientação a Objeto tem alguns conceitos essenciais para o seu entendimento, pode ter uma melhor explicação aqui, aqui no blog darei uma rápida visão do que a engloba:


  • Classe : é a representação de algo que existe no mundo real. Uma classe é composta por:

  • Atributos : características dos objetos;

  • Métodos : ações realizadas ou sofridas pelos objetos;

  • Objeto : Sempre pertence a uma classe, representa algo que existe no mundo real. O objeto é uma instancia de uma classe.


Ahhh uma coisa importante são os comentários, existem três tipos de comentários em Java:

// Este é um comentário de uma só linha
/* Este é um comentário de uma ou mais linhas */
/** Este é um comentário de documentação */

Por isso, durante o exemplo, colocarei vários comentários explicando o que faz cada coisa ok.

Exemplo: Vamos tentar relacionar a vida cotidiana com o Java.


Temos uma Casa (classe) com 5 cômodos (5 objetos) – 2 quartos, banheiro, cozinha e sala. Todos eles tem Lâmpadas (classe), e a possibilidade de seu estado estar acesa ou apagada. Alguns cômodos estão com a lâmpada acesa (quarto 2 e banheiro) e os outro a lâmpada está apagada (quarto 1, cozinha e sala) . Então a representação ficaria assim:


Transformando isso tudo em código:


Classe Lâmpada:


public class Lampada /*começamos definindo a classe, por convenção a primeira letra do nome da classe é maiúscula*/


{ /* A delimitação de um bloco é sempre usando a chave, então para começar, abre a chave, e para terminar, fecha a chave*/


private String estado; /*definimos o atributo, veja que ele é do tipo String, e esse tipo na verdade não é um tipo primitivo, é uma classe da linguagem, e por isso está com a primeira letra maiúscula, e lembre-se que atributos terminam com “ ; ” . Os atributos podem ser : public = disponível para todas as classes; private = visível apenas dentro da classe e protected = que eu tbm só conhecerei mais pra frente. Segundo a boa programação, os atributos devem ser private em sua maioria*/



public void acender() /*aqui definimos o método acender, ele é void porque não produz retorno da aplicação, apenas definirá a ação do atributo estado*/


{


estado = “ACESO”;


}


public void apagar() /*aqui definimos o método apagar, ele tbm é void porque não produz retorno da aplicação, apenas definirá a ação do atributo estado*/


{


estado = “APAGADO”;


}


public String mostrar() /*aqui definimos o método mostrar, ele não é void, porque retornará a ação do atributo estado, como o atributo foi declarado como String, o método tbm deve retornar uma String*/


{


return estado;


}


} // fecha classe



Agora a Classe Casa, porque a classe Lampada sozinha não fará nada:



public class Casa


{


public static void main ( ) /* aqui é onde inicia o programação*/


{


Lampada lsala = new Lampada(); /*instanciando a classe Lampada com o objeto lampada da sala = lsala*/

lsala.apagar(); (método que vem da classe Lampada)



Lampada lcoz = new Lampada();

lcoz.apagar();



Lampada lban = new Lampada();

lban.acender();



Lampada lquarto1 = new Lampada();

lquarto1.apagar();



Lampada lquarto2 = new Lampada();

lcoz.acender();



System.out.println(“A lampada da sala está” + lsala.mostrar() + “A lampada do quarto2 está” + lquarto2.mostrar()); /*aqui é onde mostramos a informação na tela, posso imprimir o estado de todos os comodos*/

}


} //fecha classe Casa


Uma coisa extremamente útil, é a indentação do código, mas aqui no blogger não foi possível fazer isso.


Agora um exercício que ficou pendente para a próxima aula e quem quiser também fique a vontade para fazer: Escrever uma classe chamada Matematica que realize as 4 operações básicas(+ - * /) sobre 2 números float.


Utilizando a classe Matematica, escreva uma classe chamada programa que realize as seguintes operações: 5.3 + 4.7. É possível construir esse programa? Por que?


Bem, vou deixar vocês curiosos quanto a isso também, e na próxima aula volto com a resposta ok. Bons estudos para nós ;-)