Posts filed under 'Aulas'
Ok! Tomei coragem e deixei a preguiça de lado! Quando comecei a escrever este post eu estava meio gripado e de saco cheio de ficar ouvindo minha mãe falando que estou perdendo meu tempo com a internet, que isso não me leva a nada, que eu deveria pensar no mercado de trabalho e estudar a matéria (chata e retrógrada) da faculdade, que eu preciso crescer e blá blá blá! Mas tudo bem! Não quero nem saber quem pintou a zebra! Eis que apresento-lhes… A primeira aula de Ruby deste blog:
Interactive Ruby Shel (irb)
Vamos começar as aulas usando o irb. Um shell interativo no mesmo estilo do shell do Python. Ele vai ser útil para podermos testar os comandos e códigos para irmos aprendendo de forma mais fácil e divertida 
No livro do Ruby - Conhecendo a Linguagem, do TaQ (que eu estou seguindo para fazer essas aulas), ele recomenda que edite o arquivo .irbrc, que pode ser encontrado no diretório home (no Linux), e insira a seguinte linha:
require 'irb/completion'
Feito isso, vamos executar o irb, digitando (tcham, tcham, tcham, tcham….) irb no terminal (ou em um prompt do DOS -.-):
[saibot@upson saibot]$ irb
E com isso seremos recebidos com uma tela onde estará escrito o seguinte:
irb(main):001:0>
Certinho… Vou botar um pequeno codigozinho aqui como exemplo para explicar um pouco sobre a estrutura do irb:
irb(main):001:0> x = 5
=> 5
irb(main):002:0> if x != 5
irb(main):003:1> puts “Diferente de 5″
irb(main):004:1> else
irb(main):005:1* puts “Igual a 5″
irb(main):006:1> end
Igual a 5=> nil
irb(main):007:0>
Como pode ser visto, o prompt é separado por dois pontos (:). Com isso, temos o seguinte:
- Nome do programa (main)
- Número de linhas que digitamos (e estamos) no irb.
- Nível de profundidade
Sobre a profundidade, podemos dizer que é a que estamos quando abrimos ou fechamos uma expressão. Isso pode ser observado no próprio exemplo. Na linha 002, estamos começando a usar o if e o nível de profundidade é 0. Já na linha 003, uma linha depois do if, já entramos no nível de profundidade 1 ;D Na linha 006, fechamos o if com o end, por isso na linha 007 voltamos ao nível 0 de profundidade. Entendido?
Mais uma coisa, observe a linha 005 e perceberá um asterisco (*). Isso ocorre porque o irb “sabe” que o if precisa ser fechado com um end
“Olá Mundo!” no irb
Vamos agora começar fazendo o mais básico que existe em qualquer linguagem (exceto em, digamos…. …Java! Ahueahuaehuaeuae!!!!!!!). O “Hello World!” ou “Olá Mundo!”
Dentro do irb (óbvio O.o) digite:
irb(main):001:0> puts “Olá Mundo!”
Olá Mundo!
=> nil
irb(main):002:0>
Como pode ver, a frase “Olá Mundo!” foi escrita na tela O puts é o comando (um dos) para imprimir coisas na tela…
Da mesma forma que usamos o puts para isso, podemos também usar o print:
irb(main):002:0> print “Olá Mundo!”
Olá Mundo!=> nil
irb(main):003:0>
Como podemos ver, apesar de parecer fazer exatamente o mesmo que o puts, o print apenas imprime na tela e não pula linha nenhuma, enquanto o puts pula uma linha cada vez que é usado.
Variáveis
Apesar de dizerem que tudo em Ruby é um objeto, as variáveis são excessões, sendo apenas referências para estes.
São bem simples de serem utilizadas em Ruby pelo fato de usarem duck typing (uma forma como é chamada a tipagem dinâmica do Ruby).
Exemplo:
[saibot@upson saibot]$ irb
irb(main):001:0> x = “terramel”
=> “terramel”
irb(main):002:0> x.class
=> String
irb(main):003:0> x = 1
=> 1
irb(main):004:0> x.class
=> Fixnum
irb(main):005:0> x = 1.2
=> 1.2
irb(main):006:0> x.class
=> Float
irb(main):007:0>
Ruby também tem tipagem forte, como pode ser observado a seguir:
[saibot@upson saibot]$ irb
irb(main):001:0> x = 1
=> 1
irb(main):002:0> y = “oi”
=> “oi”
irb(main):003:0> z = x + y
TypeError: String can’t be coerced into Fixnum
from (irb):3:in `+’
from (irb):3
from :0
irb(main):004:0>
Quando tentamos somar um número com uma string recebemos um erro (óbvio), já que não é possível somar essas dois coisas diferentes…
Claro que podemos converter o x para String (usando o método .to_s) para concatenarmos os valores das duas variáveis:
irb(main):004:0> z = x.to_s + y
=> “1oi”
irb(main):005:0>
Mais para frente veremos um pouco mais sobre este e outros métodos. Por enquanto, lembrando o que Matz disse que tudo é objeto em Ruby, dê uma olhada nisso:
[saibot@upson saibot]$ irbirb(main):001:0> x = 1
=> 1
irb(main):002:0> x.methods
=> ["to_a", "%", "<<", "respond_to?", ">>", "divmod", "&", "type", "integer?", "chr", "protected_methods", "eql?", "to_sym", "*", "instance_variable_set", "+", "is_a?", "truncate", "hash", "send", "to_s", "-", "between?", "modulo", "singleton_method_added", "prec", "zero?", "/", "size", "class", "tainted?", "private_methods", "__send__", "next", "|", "untaint", "~", "id", "step", "to_i", "inspect", "instance_eval", "prec_i", "remainder", "clone", "nonzero?", "public_methods", "^", "+@", "floor", "extend", "freeze", "-@", "display", "**", "quo", "__id__", "<=>", "downto", "to_f", "<", "methods", "method", "==", "===", "prec_f", "abs", ">", "to_int", "nil?", "dup", "instance_variables", "coerce", ">=", "instance_of?", "ceil", "<=", "upto", "div", "times", "object_id", "=~", "singleton_methods", "equal?", "succ", "taint", "id2name", "[]“, “frozen?”, “instance_variable_get”, “kind_of?”, “round”]
irb(main):003:0>
Esses são os métodos públicos da instância da classe. Teriamos o mesmo resultado usando x.public_methods.
Podemos ver os métodos privados da instância da classe usando x.private_methods:
irb(main):003:0> x.private_methods
=> ["select", "lambda", "local_variables", "chomp", "raise", "print", "sub!", "Array", "method_missing", "format", "trap", "at_exit", "exit!", "readlines", "autoload", "system", "set_trace_func", "getc", "initialize_copy", "split", "fail", "putc", "gsub!", "iterator?", "catch", "p", "remove_instance_variable", "sub", "sleep", "syscall", "callcc", "Integer", "fork", "srand", "singleton_method_removed", "caller", "puts", "chop!", "irb_binding", "scan", "block_given?", "autoload?", "binding", "throw", "warn", "`", "gsub", "loop", "open", "Float", "singleton_method_undefined", "rand", "exit", "chomp!", "gets", "load", "exec", "trace_var", "global_variables", "proc", "initialize", "chop", "printf", "String", "test", "sprintf", "abort", "readline", "untrace_var", "require", "eval"]
irb(main):004:0>
Por enquanto é só… Sei que demorei para postar essa primeira aula, mas com paciência e sempre em frente vamos andando ;D Na próxima aula explicarei um pouco mais sobre varíaveis, os tipos, variáveis públicas, blocos etc. Aguardem! Vou ver se começo a postar as aulas com mais freqüência ;D
Technorati Tags:
Ruby,
aula,
objeto,
matz,
primeira,
variáveis,
duck typing,
puts,
hello world,
olá mundo,
programação,
interpretada,
irb,
shell,
interativo,
fixnum,
int,
inteiro,
stringLeia Também:
Enviar este artigo por e-mail para alguém
Leia Também:
February 10th, 2008
O que é uma projeção? Se temos uma fonte de luz, um projetor, por exemplo, e colocamos qualquer objeto, como uma caneta, na frente, temos um desenho, ou uma projeção, deste objeto na parede. A mesma coisa acontece com Computação Gráfica. Temos fontes de luz e uma câmera virtual em um local aonde o objeto é projetado. Este local pode ter duas configurações básicas: ortogonal ou perspectiva. Na perspectiva, temos a possibilidade de trabalhar com animações que tem maior fidelidade dependendo da distância. Na ortogonal não temos este tipo de efeito, apesar de termos precisão para construir objetos.Vamos imaginar que temos uma área útil para desenhar, algo em torno de 20 centímetros. Como posso representar 2 metros dentro destes 20 centímetros? Simples, trabalhando com escala. Para trabalharmos com escala, temos que saber qual a menor dimensão que conseguimos representar. Um ponto nesta área é chamado de pixel. Podemos usar esse pixel para representar 1 centímetro.
Como estamos trabalhando com uma área de 20 centímetros, o maior objeto que posso representar neste caso será um com no máximo 20 centímetros. Se nos basearmos no tamanho do pixel, podemos saber quanto precisamos usar para representar os objetos que queremos modelar.
Uma saída é a projeção. Quando colocamos a glOrtho, é como se estivessemos dizendo ao programa o universo, a área e quantos pontos quero para trabalhar simplesmente informando os valores nos parâmetros do comando. Por exemplo, chamando a função glOrtho da seguinte forma:
glOrtho(-50,50,-50,50,-50,50);
É criado um volume com -50 à esquerda, 50 à direita, -50 para baixo, 50 para cima, -50 para o fundo e 50 para a frente.
Nesta aula vamos trabalhar na modelagem de uma mesa de 2 metros (ou 200 centímetros). Se queremos desenhar uma mesa com 200cm, precisamos trabalhar com escala. Podemos assumir que cada ponto representa 1 cm. Isso dependerá do projeto que queremos desenvolver. Qual o menor objeto que precisarei apresentar? Talvez um interruptor (1cm x 2cm)… Na hora da modelagem podemos dizer que um interruptor será representado por 1 ponto da coluna. Se o maior objeto a ser representado for uma sala ou uma cidade, quantos pontos precisaremos para fazê-lo?
Se modelarmos uma mesa de 2 metros em um volume que somando negativo com positivo terá um valor igual a 100 (igual o glOrtho do exemplo acima que foi chamado com os valores -50,50,-50,50,-50,50), a mesa obviamente não aparecerá inteira e sim recortada. A solução será chamar a função glOrtho com outros parâmetros que permitam que a mesa apareça inteiramente:
glOrtho(-500,500,-500,500,-500,500);
Extrusão
Extrusão é a técnica de modelar um objeto deformando outro já existente.
Usaremos esta técnica para modelarmos nossa mesa usando o cubo que criamos na aula anterior. Vamos criar 5 cubos para fazer a mesa: Um para a tampa da mesa e os quatro restantes para as pernas.
Biblioteca para o cubo
Para facilitar nosso trabalho, vamos pegar o código que foi usado para o cubo, dar uma modificada e criar uma biblioteca chamada cubo.h:
void cubo(float r, float g, float b, float x, float y, float z, float tam, float transp)
{
r = r/255; g=g/255; b=b/255; // Como glColor4f só vai de 0 a 1 e não de 0 a 255, fizemos essa conversão para podermos usar os dados de 0 a 255
glBegin(GL_QUADS);
glColor4f(r,g,b,transp);
glTranslatef(x,y,z);
glVertex3f(tam,tam,0);
glVertex3f(-1*tam,tam,0);
glVertex3f(-1*tam,-1*tam,0);
glVertex3f(tam,-1*tam,0);
glVertex3f(tam,tam,-10);
glVertex3f(-1*tam,tam,-10);
glVertex3f(-1*tam,-1*tam,-10);
glVertex3f(tam,-1*tam,-10);
glVertex3f(-1*tam,tam,-10);
glVertex3f(-1*tam,tam,0);
glVertex3f(-1*tam,-1*tam,0);
glVertex3f(-1*tam,-1*tam,-10);
glVertex3f(tam,-1*tam,-10);
glVertex3f(tam,-1*tam,0);
glVertex3f(tam,tam,0);
glVertex3f(tam,tam,-10);
glVertex3f(tam,-1*tam,0);
glVertex3f(-1*tam,-1*tam,0);
glVertex3f(-1*tam,-1*tam,-10);
glVertex3f(5,-1*tam,-10);
glVertex3f(-1*tam,tam,0);
glVertex3f(tam,tam,0);
glVertex3f(tam,tam,-10);
glVertex3f(-1*tam,tam,-10);
glEnd();
}
Agora basta chamarmos a biblioteca cubo.h no início do código do arquivo estrutura.c informando corretamente o caminho da biblioteca. Por exemplo, se o arquivo cubo.h está em /home/saibot/estrutura, basta colocarmos o seguinte no código:
#include </home/saibot/estrutura/cubo.h>
Agora podemos chamar o cubo com os valores que quisermos, por exemplo:
cubo(50,50,50,0,0,0,200,0.25);
Os 3 primeiros valores definem a cor do cubo (RGB), os outros 3 movimentam o cubo (a menos que queira, não é necessário mudá-los, já que podemos movimentar cada parte do cubo usando glTranslatef na hora de criarmos cada parte de nossa mesa), o penúltimo valor define o tamanho do cubo e o último valor define a transparência.
Antes de começarmos a modelar nossa mesa, vamos ainda dar uma olhada em alguns comandos.
glTranslatef e glScalef
glTranslatef é a função que realiza a translação, ou seja, movimenta um objeto. A origem do sistema é transladada para a posição fornecida dentro dos parâmetros da função (mais uma vez lembrando que x indica o lado, y a altura e z a profundidade): glTranslatef(x,y,z)
glScalef altera a escala dos objetos. O resultado obtido é o alongamento ou encolhimento dos objetos no sentido dos eixos. A função é usada da seguinte forma: glScalef(x,y,z). Se o valor de algum dos parâmetros for 0, esta cordenada simplesmente será eliminada.
glPushMatrix e glPopMatrix
Essas funções permitem guardar temporariamente a matriz de transformação atual. Após a instrução glPopMatrix() todas as operações que alteram a matriz atual, como por exemplo, glTranslatef, efetuadas após o último glPushMatrix(), são ignoradas.
Por exemplo, se depois de criar e movimentar um cubo não usarmos o glPopMatrix, os outros objetos serão criados à partir do que foi definido depois do primeiro desenho. Se usarmos o glPushMatrix antes do cubo e o glPopMatrix depois, a origem do sistema mais uma vez será a que estava sendo trabalhada antes de criarmos o objeto.
Criando a mesa
Vamos fazer agora a modelagem de nossa mesa. Como já fizemos uma biblioteca para chamar o cubo, podemos chamá-la para criar a tampa e as pernas da mesa, colocando cada parte dentro de glPushMatrix() e glPopMatrix(). Vamos usar o comando glScalef para mudar os tamanhos dos cubos transformando-os na tampa e nas pernas da mesa e o comando glTranslatef para definirmos a posição de cada parte da mesa.
//
//Tampa da mesa
//
glPushMatrix();
glScalef(1,0.05,50);
cubo(160,180,160,0,0,0,200,0.25);
glPopMatrix();
//
//Pernas da mesa
//
glPushMatrix();
glTranslatef(-180,-200,-0);
glScalef(0.1,1,2);
cubo(250,50,50,0,0,0,200,0.25);
glPopMatrix();
glPushMatrix();
glTranslatef(180,-200,0);
glScalef(0.1,1,2);
cubo(250,50,50,0,0,0,200,0.25);
glPopMatrix();
glPushMatrix();
glTranslatef(-180,-200,-480);
glScalef(0.1,1,2);
cubo(250,50,50,0,0,0,200,0.25);
glPopMatrix();
glPushMatrix();
glTranslatef(180,-200,-480);
glScalef(0.1,1,2);
cubo(250,50,50,0,0,0,200,0.25);
glPopMatrix();
glRotatef
glRotatef é a função usada para podermos aplicar a rotação nos objetos. Os parâmetros usados nesta função são: ângulo, componente x, componente y e componente z. Depois de escolhermos o ângulo, damos os valores para x, y e z, que podem ser 0 ou 1.
Por exemplo, se quero rotacionar um objeto em 45 graus no eixo x, chamo a função da seguinte forma:
glRotatef(45,1,0,0);
Se quero rotacionar em 70 graus nos eixos y e z, chamo da seguinte forma:
glRotatef(70,0,1,1);
Exercícios
Agora que já modelamos nossa mesa, vamos criar umas cadeiras, rotacionar alguma(s) delas para deixar mais apresentável nosso desenho
Uma dica é criar uma biblioteca cadeira.h para ficar mais fácil colocar mais cadeiras no desenho. Lembre-se de usar os comandos glPushMatrix e glPopMatrix para cada uma das cadeiras e colocar dentro desses comandos as funções glTranslatef e glRotatef nas cadeiras que quiser rotacionar. Se quiser também pode usar glScalef para mudar o tamanho de algumas cadeira.
Se preferir pode também criar uma biblioteca mesa.h para facilitar a criação de mais mesas se desejar.
A imagem abaixo mostra o desenho que fiz de uma mesa com um bulê de chá e suas cadeiras. Fiz uma delas caída para dar aquela impressão de que algum cara meio chapado acabou derrubando a cadeira (talvez o chá dentro do bulê fosse de cogumelo… Quem sabe? Talvez os caras que beberam ;D)
Technorati Tags: Computação Gráfica, OpenGL, GL, CG, cubo, mesas, cadeiras, modelagem, objetos, sistema, dimensões, ortho, ortogonal, perspectiva, glScalef, glRotatef, glPushMatrix, glPopMatrix, glTranslatef, chá, cogumelo, chá de cogumelos, pés, pernas, pé, perna, tampa, tampas
Powered by ScribeFire.
Enviar este artigo por e-mail para alguém
Leia Também:
September 19th, 2007
O plano de marketing exige a escolha uma empresa real como objeto de estudo para podermos avaliar internamente esta empresa. Se ela está projetada, então já temos uma boa parte para estudar (faturamento, vendas, histórico etc). Outros pontos que devemos estudar são concorrências, história, participações, parcerias etc.
É importante a ênfase no estudo do histórico do faturamento de uma empresa. Um erro comum que muitos fazem é apenas olhar, por exemplo, o faturamento de um mês, o que pode muitas vezes ser um erro. Veja o gráfico abaixo:
Se olharmos apenas o último faturamento das empresas podemos pensar que a empresa A está melhor do que a empresa B, mas, se analisarmos o histórico das duas empresas podemos perceber facilmente que a empresa A apresenta quedas no faturamento, enquanto o faturamento da empresa B sobe. A tendência é que a empresa A continue caindo e a B subindo.
DICA: Forma de abordar uma empresa
Pode ser que algumas empresas se recusem a entregar seus dados para que possamos fazer nosso plano baseado nela. Uma forma de abordagem é mostrar para esta empresa que podemos fazer um trabalho sério e com isto entregar um material interessante para a mesma. Nem sempre é fácil para uma empresa montar seu plano de marketing, mesmo que seu pessoal tenha condições para isso, é possível que a empresa não tenha tempo ou oportunidade. Ai está uma forma de “vendermos nosso peixe”
Objetivo final do plano
O objetivo final do plano de marketing é ter uma série de ações propostas para que a empresa possa ter ações adequadas. Quanto mais informações tivermos da empresa, mais teremos condições de propor ações adequadas para a empresa agir.
Elementos a serem analisados em nosso plano
- Produto e preço (visto nas aulas passadas)
- Distribuição do produto
Distribuição do produto
Canais de distribuições: Meios pelos quais a empresa fornece o produto para seus clientes
Como pode ver na imagem acima, quanto mais canais de distribuição, maior o nível. No nível 0 não existem canais intermediários, a venda é feita diretamente ao cliente. Como o número de intermediários é 0, o nível é 0, quando temos 1 intermediário, o nível é 1, quando temos 2, o nível é dois e por ai vai
Obviamente, quanto maior o nível, maior o preço, já que tem mais gente para ser paga. Um exemplo: Tenho um distribuidor que compra da minha fábrica e vende para outros distribuidores pequenos. Esses distribuidores menores obviamente deverão cobrar mais, pois já estão comprando de outro distribuidor.
Um distribuidor pode até vender direto para o cliente, mas ele na verdade abastece estoques. O distribuidor enche um caminhão e vende enquanto um atacadista é passivo, pois apenas monta um estoque e espera alguém comprar ;D
Alguns atacos costumam cobrar preços diferentes na vende. As vezes cobram menos de quem compra com CNPJ do que de quem compra como pessoa física. Isso é feito para evitar que o canal seja queimado, evitando dessa forma prejudicar as empresas que compram deles.
Quanto menor o nível de fornecimento, menores os gastos, mas ao mesmo tempo é preciso ter uma estrutura maior, já que dessa forma é necessário decidir rotas, checar clientes, montar cargas etc.
Algumas empresas também podem vender para franquias…
Muitas vezes a diferença nos lucros de uma empresa pode estar na distribuição de seus produtos!
Pontos de Venda
O ponto de venda também é importantíssimo e deve ser muito bem avaliado. Não podemos por exemplo montar uma joalheria na periferia da cidade. ¬¬
Alguns pontos que devem ser avaliados:
- Localização
- Características
- Estrutura
- Apelo para o público
- Estacionamento
Uma boa idéia é a reprodução de ambientes. Por exemplo, uma empresa de móveis para escritório pode vender muito mais se, ao invés de simplesmente deixar seus móveis espalhados pela loja, passar aos clientes a sensação de estar em um escritório ao decorar a empresa e dispor seus móveis como em um verdadeiro escritório. A idéia é montar um ambiente de acordo com aquilo que quer vender, convidar o cliente a se sentar… O negócio não é apenas vender os produtos, mas dar experiências ao cliente para que não seja necessário que ele imagine como ficaria o produto em um lugar próprio.
Um exemplo de lugar agradável é o Franz Café. Em Campinas este lugar é conhecido como “Escritório Móvel”. Tem pontos wireless, é bem decorado… Por esses motivos seus clientes costumam ir lá também para fazer reuniões ou até mesmo algum trabalho. Ar condicionado, cheirinho de café, cascata de água em uma parte do caixa etc.
Comunicação
Paga:
- Propaganda
- Informes publicitários
- Assessoria de imprensa
- Promoção
Não paga:
- Redes sociais (ex: Orkut)
- Boca a boca
Objetivos de comunicação:
- Comunicar que a marca/empresa/produto existe
- Comunicar o que a marca/empresa/produto fazem
- Comunicar a superioridade
- Atrair o comprador ao ponto de venda
- Convencer o comprador a adquirir o produto
SIM: Sistema de Informação de Marketing
Cliente:
- Comportamento
- Renda
- Acesso à informação
- Idade
- Tendências culturais, sociais etc
Concorrentes:
- 4P
- Tecnologia
- Capacidade Financeira
Fornecedores:
- Capacidade de fornecimento
- Qualidade
- Poder de barganha
Comercial:
- Volume de vendas
- Produtos mais vendidos
- Market share
- Ciclo de vida
Technorati Tags:
Administração Mercadológica,
Plano de Marketing,
Administração,
Marketing,
Plano,
mercado,
estratégia,
estratégias,
concorrentes,
fornecedores,
produto,
propaganda,
comercial,
market share,
ciclo de vida,
ciclo,
"http://technorati.com/tag/volume" rel="tag">volume,
vendas,
nível,
níveis,
distribuição,
distribuidor,
atacado,
varejo,
cliente,
fábrica,
empresa,
companhia,
estrutura,
ponto,
características,
estacionamento,
apelo,
público,
lucro,
lucros,
histórico,
análise,
finanças,
parceriasPowered by ScribeFire.
Enviar este artigo por e-mail para alguém
Leia Também:
September 17th, 2007
Para explicar orientação a objetos, podem ser feitas comparações com o mundo real, onde vemos objetos como pessoas, animais, plantas, carros, aviões, casas, prédios, computadores, televisões, rádios etc. Os programas de computador também podem ser compostos de objetos que, as vezes, podem ser dividos em duas categorias: animados e inanimados.Os objetos animados são, em certo sentido, “vivos” (se movem e fazem coisas). Os inanimados, por outro lado, não são capazes de fazer coisas por conta própria. Entretanto, ambos os tipos de objetos tem coisas em comum, como atributos (forma, tamanho, cor…) e comportamentos (por exemplo, um carro que acelera).
Diferentes objetos podem ter atributos semelhantes e exibir comportamentos semelhantes. É possível fazer comparações, por exemplo, entre humanos e chimpanzés, entre homens e mulheres, entre carros e motos etc.
Brincando um pouco
Vamos pegar um pincel como exemplo e dar uma olhada em suas características:
- Cor
- Formato
- Espessura
- Tamanho
- Material
Se temos dois pincéis, um vermelho e um azul, as características são as mesmas. A única diferença entre os dois é a cor do pincel e de sua tinta. Eles pertencem ao mesmo objeto, pois tem as mesmas características. A única coisa que é mudada é a informação de cada atributo.
Se cada um dos atributos tem um determinado valor, devemos indicar qual o tipo de informação que está em cada um deles. A cor é de que tipo? String. Formato também é string, espessura é float etc.
String cor;
String formato;
float espessura;
float tamanho;
String material;
Como podem ver, definimos o tipo do objeto e as informações que serão armazenadas em cada um deles. Para transformarmos isso em algo que Java entenda, basta colocarmos o ; no final de cada um e botar dentro da classe:
public class pincel
{
String cor;
String formato;
float espessura;
float tamanho;
String material;
}
Brincando mais um pouco
Vamos aqui definir uma classe carro:
public class carro
{
float rodas;
String cor;
int portas;
float motor;
String portamala;
}
Extendendo…
Vamos agora criar a classe veiculo:
public class veiculo
{
int freios;
String cor, modelo;
}
Agora usamos o extends para suas respectivas subclasses (carro e moto):
public class carro extends veiculo
{
String estepe, limpador;
}
public class moto extends veiculo
{
String manete;
}
O comando extends herda as características de outro método. Aqui no exemplo, usamos para que as subclasses moto e carro herdem as características da classe veiculo.
Como as subclasses de veiculo herdarão os atributos de veiculo, a classe veiculo obviamente deverá ter atributos que serão comuns a suas subclasses.
Mão na massa
Vamos criar um programinha simples para fazer cadastro de animais. Vamos primeiro criar a classe animais (salve o código em um arquivo chamado animais.java).
public class animais {
String comida, sexo;
}
Agora vamos criar suas subclasses (mamiferos, aves e peixes). Lembrando mais uma vez que cada um deve ser salvo em um arquivo com seu respectivo nome (mamiferos.java, peixes.java e aves.java).
public class mamiferos extends animais {
String tipo_pelo;
String especie;
}
public class peixes extends animais {
String cor_escamas;
float tamanho;
}
public class aves extends animais {
int idade;
String cor_pena;
}
Agora que já criamos a classe animais e suas respectivas subclasses, vamos criar o programa principal para entrada dos dados de cada tipo de animal (salve o código em um arquivo chamado cadastro.java)
import java.util.*;
public class cadastro
{
public static void main(String args[])
{
System.out.println(”nnCADASTRO DE ANIMAIS:nn1. Peixesn2. Avesn3. Mamiferosnn4. Sairn”);
System.out.printf(”Escolha a opção: “);
Scanner resp = new Scanner(System.in);
int respo = resp.nextInt();
animais objAnimais = new animais();
Scanner sc_line = new Scanner(System.in);
Scanner sc_int = new Scanner(System.in);
Scanner sc_float = new Scanner(System.in);
System.out.printf(”fDigite a comida de seu animal: “);
objAnimais.comida = sc_line.nextLine();
System.out.printf(”nDigite o sexo de seu animal: “);
objAnimais.sexo = sc_line.nextLine();
if (respo==1)
{
peixes objPeixes = new peixes();
System.out.printf(”nDigite o tamanho do peixe: “);
objPeixes.tamanho = sc_float.nextFloat();
System.out.printf(”nDigite a cor das escamas do peixe: “);
objPeixes.cor_escamas = sc_line.nextLine();
System.out.println(”nnFoi cadastrada um peixe que mede ” + objPeixes.tamanho + “cm(s)!” + (objPeixes.tamanho >= 10 ? ” É um peixe grande” : ” É um peixe pequeno”) + “!”);
System.out.println(”O peixe tem escamas de cor ” + objPeixes.cor_escamas + “!n”);
}
if (respo==2)
{
aves objAves = new aves();
System.out.printf(”nDigite a idade da ave: “);
objAves.idade = sc_int.nextInt();
System.out.printf(”nDigite a cor das penas da ave: “);
objAves.cor_pena = sc_line.nextLine();
System.out.println(”nnFoi cadastrada uma ave de ” + objAves.idade + ” ano(s)!”);
System.out.println(”A ave tem penas cor ” + objAves.cor_pena + “!n”);
}
if (respo==3)
{
mamiferos objMamiferos = new mamiferos();
System.out.printf(”nDigite o tipo de pelo: “);
objMamiferos.tipo_pelo = sc_line.nextLine();
System.out.printf(”nDigite a espécie: “);
objMamiferos.especie = sc_line.nextLine();
System.out.println(”nnFoi cadastrado um mamifero de pelo ” + objMamiferos.tipo_pelo + “!”);
System.out.println(”O mamífero é ” + objMamiferos.especie + “!n”);
}
System.out.println(”O animal come ” + objAnimais.comida + ” e seu sexo é ” + objAnimais.sexo + “nn”);
}
}
No cadastro.java começamos importando a biblioteca java.util.* que é necessária para o uso do Scanner. Foram feitos 3 Scanners (sc_int, sc_float e sc_line), pois é necessário um Scanner para cada tipo de variável. Como foram usados 3 tipos (int, float e String), criamos um Scanner para cada um de seus respectivos tipos. Alguns comandos foram usados para criar um objeto. Por exemplo, animais objAnimais = new animais(); cria um objeto animais e o atribui a objAnimais. Com isso podemos usar, por exemplo, o atributo objAnimais para chamar objetos da classe animais (comida e sexo, que foram chamados da seguinte forma: objAnimais.comida e objAnimais.sexo)
Um dos System.out.println foi feito da seguinte forma:
System.out.println(”\n\nFoi cadastrada um peixe que mede ” + objPeixes.tamanho + “cm(s)!” + (objPeixes.tamanho >= 10 ? ” É um peixe grande” : ” É um peixe pequeno”) + “!”);
Isso porque foi usado o operador ternário. Com ele fizemos um teste para ver direto dentro do System.out.println o valor que foi inserido na variável tamanho (dentro do objeto peixes, por isso, objPeixes.tamanho). Antes do interrogação (?) foi feita a verificação se o valor era maior ou igual a 10. Se essa condição for verdadeira, o System.out.println mostra a frase ” É um peixe grande”. Se a condição for falsa, ele mostra a frase ” É um peixe pequeno”.
Agora que já foi tudo explicado certinho vamos compilar o programa e rodar:
javac cadastro.java (se quiser, pode também usar javac *)
java cadastro
Prontinho, nosso primeiro programinha “orientado a objetos” ;D
Technorati Tags: java, aula, segunda aula, orientação a objetos, oo, programação, programa, desenvolvimento, software, código, exercícios, classe, class, extends, subclasses, herdar, hierarquia, herança, String, int, float, objeto, valor, variável, objetos
Powered by ScribeFire.
Enviar este artigo por e-mail para alguém
Leia Também:
September 6th, 2007
Esta aula tem apenas como finalidade mostrar a estrutura de um Plano de Marketing. Vamos começar agora a traçar alguns objetivos estratégicos. De modo geral a estrutura de um plano de marketing é bastante simples, podendo ser divida em:
- Análise Interna
- Análise Externa
- Estratégias de Marketing
- Orçamento
- Acompanhamento
Análise Interna da Organização
- Histórico da empresa
- Pontos Fracos
- Pontos Fortes
Podemos ter, por exemplo, o objetivo de reposicionar um produto. Lembram-se do caso das havaianas que foi mostrado na primeira aula? As havaianas foram objetos de reposicionamento. A empresa não fez isso por acaso. Foi feito um planejamento. Pode ser que a empresa tenha percebido uma queda nas vendas do produto após um estudo de seu ciclo de vendas, o que levou-a a fazer reposicionamento. Foram criadas mais formas de uso, mais modelos, diferentes estilos, alguns conforme a moda, diferentes lançamentos etc.
Para reposicionar uma marca é necessário investimento. Devemos, portanto, ter retornos.
Análise Externa da Organização
- Macroambiente (variáveis que afetam os setores de forma geral. Por exemplo: inflação que afeta todas as empresas de todos os ramos, tecnologia, aspectos culturais, variação do Dóllar etc.)
- Microambiente (forças próximas à empresa que afetam a ela própria. Por exemplo: a própria empresa, os fornecedores, os mercados-consumidores, os concorrentes etc.)
Estratégias de Marketing
- Planos de Ação
- Plano de Mídia
- Programação
- Atribuições
- Posicionamento
- Produto
- Preço
- Distribuição
- Comunicação/Promoção
Orçamento
Custo total da implementação do plano. É necessário aqui confirmar que o retorno justifique o investimento.
Acompanhamento
Technorati Tags:
Administração Mercadológica,
Marketing,
Administração,
Administration,
Market,
Mercado,
Estratégia,
empresas,
empresa,
organização,
análise interna,
análise externa,
orçamento,
acompanhamento,
histórico,
plano,
marca,
investimento,
objetivos,
estrutura,
pontos fracos,
pontos fortes,
reposicionar,
reposicionamento,
retornos,
queda,
pico,
objetos,
produto,
macroambiente,
microambientePowered by ScribeFire.
Enviar este artigo por e-mail para alguém
Leia Também:
September 5th, 2007
Alguns podem achar um pouco estranho falar sobre religiosidade em aulas de ética. De qualquer forma preciso colocar isso aqui para seguir as aulas que foram passadas na faculdade ;D
Instituição
Conjunto de regras, normas ou leis fundamentais de uma sociedade podendo representar também a própria sociedade em questão.
A experiência do sagrado é que dá origem às instituições.
O Sagrado
Algo digno de veneração. É visto como uma espécie de potência sobrenatural, as vezes como um tipo de “encantador” do mundo. De certa forma o sagrado tem uma relação com a magia.
O sagrado também é visto como o separador entre o natural e o sobrenatural.
A Religiosidade
A consciência é a condição e a causa primordial para o surgimento da religiosidade. Através dela explicamos uma realidade exterior. Algo que independe da ação humana.
A religião não é nada mais do que a forma de unir novamente, criar um vínculo, entre os seres humanos com aquilo que é sagrado. Seu fundamento é a esperança de uma vida mais forte que a morte e a percepção de forças superiores.
O termo religião significa, entre outras definições: crença em uma força superior que deve ser adorada e obedecida e às manifestações desta crença por meio de doutrina e preceitos éticos.
Referência: Prometheus
Rito
Cerimônia em que gestos, palavras, simbolismos etc podem se comunicar/relacionar com a divindade.
Isso se relaciona com o tema por ser a primeira forma pela qual o ser humano tenta entender o mundo. A atribuição ao sagrado de tudo aquilo que não se consegue resposta pela razão é a conseqüência primoridal na qual se fundamentam.
O Bem e o Mal
Nas religiões politeístas existem vários deuses onde uns são bons e outros maus, ou até mesmo os dois ao mesmo tempo. Nas religiões monoteístas, Deus é o próprio bem eterno e o mal não é uma força da mesma realidade e sim a ausência do bem.
Bem: Designa, em geral, o acordo entre o que uma coisa é com o que ela deve ser. É a atualização das virtualidades inscritas na natureza do ser. Relaciona-se com perfeito e com perfectibilidade. Segundo o Espiritismo, tudo o que está de acordo com a Lei de Deus.
Mal: Para a moral, é o contrário de bem. Aceita-se, também, como mal, tudo o que constitui obstáculo ou contradição à perfeição que o homem é capaz de conceber. Divide-se em mal metafísico (imperfeição), mal físico (sofrimento) e mal moral (pecado). Segundo o Espiritismo, tudo o que não está de acordo com a lei de Deus.
Exemplos: Luzes e trevas, perfeito e imperfeito etc.
Referência: Centro Espírita Ismael
O Pecado
Nas religiões da exterioridade o pecado é uma ação externa visível cometida voluntaria ou involuntariamente contra a divindade ou pela violação de suas leis (budista, hindu, chinês, grego etc). Nessas religiões devem ser feitos rituais para se redimir da falta cometida.
Nas religiões de interioridade, a intenção de cometer a falta já é um pecado. Nessas religiões não bastam os rituais, o pecador deve se arrepender do pecado cometido.
Segundo a Bíblia, a causa dos pecados encontra-se de uma maneira definitiva no pecado de Adão e Eva, com as suas conseqüências, transmitidas à posteridade. A este fato se chama a Queda. Basta dizer-se aqui, que, por mais baixo que estivesse oprimeiro homem na escala da humanidade, se ele era homem devia ter tido, na verdade, algum conhecimento rudimentar do bem e do mal, e depois da sua primeira voluntária desobediência ao que lhe dizia a consciência, devia ter ficado numa situação moral inferior à dos tempos passados. A primeira transgressão feita com conhecimento do mal não pôde deixar de ser uma queda mora, por maior que fosse a sua sabedoria adquirida no caminho da vida. Além disso, há razão para aceditar que as crianças, nascidas após a queda, haviam certamente de participar da natureza dos seus pais, a ponto de ficarem mais fracas com respeito à moralidade do que não tendo os seus pais transgredido.
Referência: Vivos!
Imanência e Transcendência
Nas religiões panteístas os deuses estão em todos os lugares e possuem formas e materiais. Já nas religiões teístas, como por exemplo o Cristianismo, Deus não possui um corpo.
As finalidades da religião
- Proteger os seres humanos contra o medo da natureza
- Dar aos seres humanos conhecimento das verdades sobre o mundo e os que nela habitam
- Oferecer aos humanos uma vida após a morte
- Dar consolo aos aflitos explicando os motivos da dor
- Garantir respeito às normas e valores impostos pela sociedade
Críticas à religião
As maiores críticas à religião são contra seu uso político, hora seja para amortecer a combatividade dos oprimidos e explorados, hora seja para unir os povos em revoluções populares pela luta contra a injustiça social e política.
A História nos mostra o que já foi feito por várias instituições religiosas simplesmente para acúmulo de poderes e riquezas. As Cruzadas e a Santa Inquisição da Igreja Católica na Idade Média, a Jihad dos muçulmanos, os faraós do Egito Antigo, a Igreja Universal e algumas outras igrejas evangélicas roubando o povo nos dias de hoje e muito mais.
Technorati Tags:
ética,
religiosidade,
sagrado,
bem,
mal,
rito,
ritos,
ritual,
rituais,
pecado,
religião,
finalidades,
religiões,
djihad,
jihad,
muçulmanos,
católicos
>, espíritas,
judeus,
faraós,
egito,
antigo,
Igreja,
Católica,
Cristianismo,
Deus,
imanência,
transcendência,
Igreja Universal,
humanos,
seres,
homem,
adão,
eva,
sociedade,
dor,
vida,
morte,
valores,
normas,
sociedadePowered by ScribeFire.
Enviar este artigo por e-mail para alguém
Leia Também:
September 4th, 2007
Nesta aula veremos a função glVertex3f que serve para construir vértices. Vamos usá-la para construir primeiramente um quadrado e mais para frente um cubo ;D Também brincaremos um pouco mais com as funções glColor3ub e a usaremos para fazer um degradê estiloso no quadrado ;D
Explicando a Função
A função glColor3f como já disse antes constrói um vértice. Se eu quero construir um quadrado com 10 pixels por exemplo, devo criar os quatro vértices com valores 5 usando quatro vezes a função glVertex3f. O primeiro vértice é o do lado superior direito, o segundo é o do lado superior esquerdo, o terceiro o lado inferior esquerdo e o quatro (obviamente) o lado inferior direito. Vamos dar uma olhada na imagem abaixo para termos uma idéia:
O comando deve ser chamado da seguinte forma: glVertex3f(x,y,z), onde x é a largura, y a altura e z a profundidade. Para criarmos o quadrado de 10 pixels vamos usar 4 vezes a função glVertex3f seguindo a ordem dos vértices, ou seja, o primeiro glVertex3f cuidará do primeiro vértice, o segundo cuidará do segundo e assim por diante. Portanto, para montarmos nosso quadrado de 10 pixels usaremos o comando quatro vezes da seguinte forma:
glVertex3f(5,5,0);
glVertex3f(-5,5,0);
glVertex3f(-5,-5,0);
glVertex3f(5,-5,0);
Por enquanto podemos deixar o z (profundidade) como 0. Isto fará todo o quadrado com o mesmo valor de profundidade, ou seja, 0. Se quiser podemos trazer ele para mais perto de nós aumentando o valor para algo como 10 por exemplo ou então deixá-lo mais afastado colocando um valor como -10. Podemos também deixar apenas um dos vértices mais pertos fazendo algo como:
glVertex3f(5,5,0);
glVertex3f(-5,5,0);
glVertex3f(-5,-5,0);
glVertex3f(5,-5,10);
Pondo a mão na massa
Agora que temos uma idéia melhor de como usar a função glVertex3f, vamos brincar um pouco usando o código do arquivo estrutura_basica.c que foi passada na primeira aula:
Vamos apagar a parte onde está o bule de chá e o cubo e vamos fazer nosso próprio quadrado. Se quiser fazer o download do arquivo basta clicar aqui. Se quiser, também pode copiar o código do arquivo que foi postado na primeira aula, colar em algum editor e salvar.
Vamos agora editar o arquivo:
Vá até a função DISPLAY do programa e apague tudo o que estiver entre glPushMatrix() e glPopMatrix() (ou seja, as funções glColor3ub e glColor4f, que servem para definir a cor, e as funções glutSolidCube e glutSolidTeapot.
Agora copie o seguinte código dentro de glPushMatrix():
glBegin(GL_QUADS);
glColor3ub(255,255,255);
glVertex3f(5,5,0);
glVertex3f(-5,5,0);
glVertex3f(-5,-5,0);
glVertex3f(5,-5,0);
glEnd();
Salve o arquivo, compile e rode. Se você, assim como eu, for um feliz usuário de Linux basta usar o gcc para compilar:
gcc -o quadrado -Wall -lglut -lGL -lGLU estrutura_basica.c
e para rodar apenas digite:
./quadrado
Se fez tudo certo, então já está vendo uma janelinha com o quadrado que fizemos. Como fizemos o quadrado dentro do código do arquivo estrutura_basica.c, pode parecer que ele não está certinho, mas isso é porque ele está sendo visto de cima já que o programinha onde fizemos o quadrado inicia com os valores 0, 10, 20 na função gluLookAt, ou seja, o x está em 0, o y em 10 e o z em 20, por isso vemos ele no meio e um pouco do alto (já que y está em 10). Como o z (profundidade) está em 20, também estamos vendo ele um pouco de longe.
Agora vamos treinar um pouco mudando os valores do glVertex3f. Lembra mais acima que dei um exemplo mudando o valor do z de um dos vértices? Agora é a hora de fazer isso! Vamos ver como vai ficar ;D
Como pode ver, o vértice onde o z está com outro valor ficou afastado do resto do quadrado 
Uma boa idéia é brincar um pouco com os valores (x, y e z) do glVertex3f antes de prosseguirmos.
Cores e degradê
Agora que já fizemos o quadrado e brincamos um pouco com o glVertex3f, vamos mexer um pouco com as cores e aplicar um degradê phodão.
Lembra que antes de criarmos o quadrado usamos a função glColor3ub? Na primeira aula já vimos um pouco sobre esta função já que foi usada no código para dar cor ao cubo e ao bule de chá.
Relembrando, esta função é usada da seguinte forma: glColor3ub(r,g,b) onde r significa vermelho, g significa verde e b significa azul (Red, Green, Blue). Bem óbvio, né? Cada valor vai de 0 (mais escuro) até 255 (mais claro). Se por exemplo usarmos 0,0,0, estaremos pintando de preto e se usarmos 255,255,255, estaremos pintando (um doce para quem adivinhar) de branco (dãããã).
Quando criamos nosso quadrado usamos o glColor3ub com os valores 255,255,255. Isso fez o quadrado ficar branco. Se trocarmos por 0,0,0 o quadrado ficará preto (e não veremos na tela, já que a janela onde o quadrado foi criado é preta hehehehehe). Vamos testar trocar os valores para 20, 0 e 100 deixando a função da seguinte forma: glColor3ub(20,0,100);
Agora nosso quadrado que antes era chato e sem cor está diferente com uma linda e estilosa cor azul. EMOCIONANTE!!!!
Mas como tenho certeza de que muitos de meus leitores (e paraquedistas) no fundo são verdadeiros artistas (minha linda namorada, dona do blog GNU/Fabi, também é artista e já pintou vários quadros lindos e perfeitos), não ficaremos limitados a apenas uma cor, vamos agora aplicar um degradê phodão!
Nos exemplos anteriores pintamos o quadrado com apenas uma cor colocando o glColor3ub antes dos quatro glVertex3f. Para fazermos um degradê basta usarmos mais vezes o glColor3ub. Da mesma forma que cada comando glVertex3f é usado para fazer um vértice, podemos usar o glColor3ub antes de cada glVertex3f para pintar cada um dos vértices da cor que quisermos.
Vamos fazer agora o quadrado com o código do exemplo abaixo:
glColor3ub(20,0,100);
glVertex3f(5,5,0);
glVertex3f(-5,5,0);
glColor3ub(220,100,100);
glVertex3f(-5,-5,0);
glVertex3f(5,-5,0);
Como podem ver, usamos mais de uma vez o glColor3ub e com valores diferentes. O primeiro glColor3ub pinta com os valores 20, 0 e 100 (aquele lindo azul) o primeiro e o segundo vértice. O segundo glColor3ub pinta o terceiro e o quarto vértice com os valores 220, 100, 100 (Um rosa Hello Kitty para os emos que estiverem perdidos aqui ficarem felizes). Agora vamos compilar e executar o programa. Como podem ver, os vértices de baixo do quadrado (terceiro e quarto vértices) vão indo em degradê do rosa para o azul dos vértices de cima (primeiro e segundo vértices).
É aconselhável brincar um pouco com o glColor3ub para treinar um pouco e entender melhor o uso desta função.
Exercício
Usar o glVertex3f e o glColor3ub para criar um cubo em degradê verde e preto dos vértices da esquerda para os da direita. Uma dica antes de começar: Para criar o quadrado usamos o glVertex3f quatro vezes, portanto, para criar um cubo devemos usar 24 vezes o glVertex3f, já que devemos construir seis quadrados de mesmas proporções, apenas alterando os valores x, y e desta vez o z (profundidade) ;D
A resolução está abaixo! Boa sorte
Resolução do Exercício
glBegin(GL_QUADS);
glColor3ub(0,200,0);
glVertex3f(5,5,0);
glColor3ub(0,0,200);
glVertex3f(-5,5,0);
glColor3ub(0,0,200);
glVertex3f(-5,-5,0);
glColor3ub(0,200,0);
glVertex3f(5,-5,0);
glColor3ub(0,200,0);
glVertex3f(5,5,-10);
glColor3ub(0,0,200);
glVertex3f(-5,5,-10);
glColor3ub(0,0,200);
glVertex3f(-5,-5,-10);
glColor3ub(0,200,0);
glVertex3f(5,-5,-10);
glColor3ub(0,200,0);
glVertex3f(-5,5,-10);
glColor3ub(0,0,200);
glVertex3f(-5,5,0);
glColor3ub(0,0,200);
glVertex3f(-5,-5,0);
glColor3ub(0,200,0);
glVertex3f(-5,-5,-10);
glColor3ub(0,200,0);
glVertex3f(5,-5,-10);
glColor3ub(0,0,200);
glVertex3f(5,-5,0);
glColor3ub(0,0,200);
glVertex3f(5,5,0);
glColor3ub(0,200,0);
glVertex3f(5,5,-10);
glColor3ub(0,200,0);
glVertex3f(5,-5,0);
glColor3ub(0,0,200);
glVertex3f(-5,-5,0);
glColor3ub(0,0,200);
glVertex3f(-5,-5,-10);
glColor3ub(0,200,0);
glVertex3f(5,-5,-10);
glColor3ub(0,200,0);
glVertex3f(-5,5,0);
glColor3ub(0,0,200);
glVertex3f(5,5,0);
glColor3ub(0,0,200);
glVertex3f(5,5,-10);
glColor3ub(0,200,0);
glVertex3f(-5,5,-10);
glEnd();
Se conseguiu fazer o exercício certinho, então seu cubo com degradê de verde para azul deve ter ficado mais ou menos como o da figura
Espero que tenham entendido melhor esta aula. Finalmente estou me sentindo mais seguro com essa matéria e até começando a gostar mais. Este semestre o professor de Computação Gráfica mudou completamente a forma de passar a matéria e agora está muito melhor e mais simples de entender. Ontem mesmo já falei para ele que melhorou muito a forma de passar a aula, que estou entendendo mais e que essa aula que antes era a que eu menos gostava se tornou a aula que mais gosto de assistir na faculdade ;D
Technorati Tags: Computação Gráfica, OpenGL, glVertex3f, quadrado, cubo, glColor3ub, GL_QUADS, glBegin, glEnd, Vértices, vértice, função, comando, funções, comandos, C, gcc, compila, compilar, imagem, 3D, gráfico, pixel, pixels, largura, altura profundidade
Powered by ScribeFire.
Enviar este artigo por e-mail para alguém
Leia Também:
August 30th, 2007
Esta é a segunda aula de banco de dados que posto. Praticamente é mais do mesmo. Depois da primeira aula que postei já tive umas 3 ou 4 aulas na faculdade, tudo com basicamente a mesma coisa. Resumi um pouco de tudo aqui. Se você entendeu a primeira aula, então não terá problemas para essa. O que farei aqui será apenas passar alguns exercícios e dar umas dicas para cada um. Se não viu ou não entendeu a primeira aula, basta dar uma olhada de novo clicando aqui.
Não sei se já disse isso, mas na faculdade, infelizmente, é usado o M$ SQL Server em todas as aulas o que acho uma enorme irresponsabilidade e falta de respeito. Irresponsabilidade porque acho que as faculdades deveriam ensinar com Software Livre, especialmente uma faculdade pública. E dai que pode sair de graça um software da Microsoft para as faculdade se no final quando os alunos se formarem eles terão que pagar por ele caso queiram usá-lo em suas empresas ou algo do tipo. Falta de respeito porque a M$ como tem sempre a mania de não seguir padrões e fazer as coisas bem diferentes de todos os outros (provavelmente para dificultar migrações e manter seu monopólio) e isso acaba criando alunos limitados e sem capacidade de usar outro software. Se querem ensinar usando o SQL Server tudo bem, mas pelo menos deveriam ter a finesse de ensinar como as mesmas coisas são feitas em outros bancos como o MySQL. Como sou um cara que acredita na liberdade e no Software Livre estudo e faço tudo usando ferramentas livres. Por enquanto são poucas as coisas que preciso mudar para fazer meus estudos de banco no MySQL, mas sei que a faculdade vai inventar de passar Trigger e essas outras coisas e que vão complicar na hora de estudar usando outro software que não seja o da M$. Quando isso acontecer vou procurar a forma correta de implementar essas coisas aqui no MySQL e dar um jeito de postar tudo aqui no blog (ou então simplesmente paro de postar as aulas de banco). Por enquanto quero dizer que as aulas de banco aqui do blog serão feitas usando
