quarta-feira, 29 de outubro de 2008

Importação e Exportação no Oracle

Olá, pessoal.

Estou passando por aqui porque tenho visto algumas pessoas com problemas para importar e exportar dados de um banco Oracle e, como venho fazendo isso com certa freqüência, resolvi fazer um post para mostrar os simples passos para a execução desta tarefa.

Primeiramente, você deve abrir o prompt do DOS (Iniciar > Executar > Digite "cmd" (sem aspas) > OK) e se posicionar dentro da pasta onde o executável do exp e do imp estão. No meu caso, tenho instalado na máquina um Oracle XE.
A pasta dos executáveis é a pasta BIN, que fica dentro da pasta onde o Oracle foi instalado. Supondo que o mesmo foi instalado em C:\Arquivo de Programas, o caminho seria algo assim: C:\Arquivos de Programas\oraclexe\app\oracle\product\10.2.0\server\BIN.


Então, no prompt, dê um "cd\" e vá para a pasta, fazendo "cd Arquivos de Programas\oraclexe\app\oracle\product\10.2.0\server\BIN".

Feito isso, para exportar, devemos executar o seguinte comando:

exp username/password@database file=arquivo.dmp log=arquivo.log full=yes

Onde:
username: Usuário do banco
password: Senha do Usuário
database: Instância do banco
arquivo.dmp: Caminho do arquivo de exportação
arquivo.log: Caminho do arquivo de log

Artigo completo (View Full Post)

quarta-feira, 22 de outubro de 2008

Bit Box - Beat Box

O que é o Bit Box (Beat-Box)?

1- Um novo estilo de música? Acho que não.
2- É uma nova forma de música? Dependendo do ponto de vista, pode ser.

Multiplexação Vocal
Arrisco definir da seguinte forma:
Uma técnica de expressão musical, relativamente nova, que vem se aprimorando cada vez mais. Usa exclusivamente como instrumento a voz, imitando Drums Kit (Setups de percursão), sons eletrônicos (Sintetizadores, lead, pad, bass, fx). Cujo ênfase está na multiplexação da fala visando simular a emissão de sons simultâneos mixando esses efeitos (podendo haver o auxílio precursivo de qualquer parte do corpo).
O primeiro exemplo de algo semelhante ao Bit-Box que vi foi no início da década de 80 em uma performance de Bobby McFerrin.



Agravação de "Can't take my eyes off of you" por Lauryn Hill (no album The Miseducation) foi um tremendo holofote sobre o estili do Bit-Box.






Atualizando o post, graças ao comentário do Malta. Sobre o T 6. Por incrível que pareça eles estavam na minha mente enquanto eu escrevia este post. Então, por isso vou adicionar mais um exemplo. Segue uma faixa onde eles estão juntos: Take 6, Bob Mcferrin, em companhia de um timaço de gênios na música atual (Só tem fera).

B.DoinIt (Quincy Jones – Back On The Bloc)


Acabei encontrando um tutorial. Tem uma série de vídeos no YouTube sobre ...



O site do do Tyte



Marvin Gay by Take 6

Take 6 - What's Goin On (Live)


Artigo completo (View Full Post)

Front End x Back End – UDFS no Servidor SGBD


UDF: “User Defined Function”, nos SGDBs, são funções criadas pelo desenvolvedor. Os principais fornecedores de tecnologia de banco de dados disponibilizam essa feature nos seus produtos.

O modelo Cliente/Servidor caracteriza-se por centralizar a programação referente a regra de negócio no servidor SGBD. Neste artigo, veremos como executar uma função no banco Oracle (PL/SQL) a partir da aplicação em Delphi.

No Back-And

Primeiro vamos criar a função no Oracle, a qual posteriormente evocaremos de uma interface (um aplicativo, front-end), um programa desenvolvido em Delphi.


create or replace function DeterminaMaior(ZNValor1 in NUMBER, ZNValor2 in NUMBER, ZNValor3 in NUMBER) return number is
Result number;
begin
IF (ZNValor1 > ZNValor2) AND (ZNValor1 > ZNValor3) THEN
RESULT := ZNValor1;
ELSE
IF (ZNValor2 > ZNValor1) AND (ZNValor2 > ZNValor3) THEN
RESULT := ZNValor2;
ELSE
RESULT := ZNValor3;
END IF;
END IF;
return(Result);
end DeterminaMaior;



Compile a função “DeterminaMaior” e pronto! Finalizamos aqui a parte de programação no servidor.

No Front-End

Inicie uma aplicação (no menu - File, New, Application), adicione no form1 os Seguintes componentes:

1- TADOConnection (Palheta ADO): configure a conexão com o banco na propriedade “ConnectionString”. Em seguida, Altere a propriedade “LoginPrompt” para “False”.

2- TADOStoredProc(Palheta ADO): Associe ele ao ADOConnection através da propriedade “Connection”. Em seguida, na propriedade “ProcedureName” digite o nome da função que acabamos de criar. Exemplo: “DeterminaMaior”. Pode ser conveniente digitar o nome do schema ponto o nome da função, tipo: “[eschemaName]. DeterminaMaior”.

Feto isso, click na propriedade parameters e veja alista re parâmetros que ele recupera automaticamente. Veja a ilustração abaixo:




Adicione também um TBitBtn (Palheta Additional). Na propriedade “Caption” defina: “Determinar Maior”.

Preciso adicionar três edits (TEdit – Palheta Standard) e um Memo (TMemo – Palheta Standard).




Codificando o evento OnClick do BitBtn1: Digite conforme exemplificado abaixo:


procedure TForm1.BitBtn1Click(Sender: TObject);
const
ZnConstMsg = 'www.estacaozn.blogspot.com - O Valor maior é %s';
Var
ZnMsg: String;
begin

with ADOStoredProc1 do
begin
Parameters[0].Value := 0;
Parameters[1].Value := GetValorEdit(Edit1);
Parameters[2].Value := GetValorEdit(Edit2);
Parameters[3].Value := GetValorEdit(Edit3);
ExecProc;
end;
ZnMsg := Format(ZnConstMsg,
[VarTOStr(ADOStoredProc1.Parameters[0].Value)]);
Memo1.Lines.Add(ZnMsg);
MessageDlg(ZnMsg, mtInformation, [mbOK], 0);
end;

Nas linhas 2 e 3, defini como constante o valor da mensagem a ser exibida como resultado do processamento da UDF que criamos.

Nas linhas 4 e 5, declarei uma variável para auxiliar no out put do processamento que estamos realizando. Quando recuperar o valor retornado pela UDF vamos usá-la para compor a mensagem para o usuário.

Na liha 6, a palavra reservada “begin” inidca o início do bloco de comando executados pelo procedimento “BitBtn1Click”.

Na linha 7, espaço em branco. Devemos deixar espaços em branco em alguns casos onde desejamos que, na leitura do nosso código, o entendimento fique mais fácil.

Da linha 9 a 12, passamos os valores para os parâmetros do “ADOStoredProc1”. Note que criei uma função “GetValorEdit” para poder recuperar o valor dos edits de forma segura. veremos o código dela mais adiante.

Na linha 13, chamamos o método ExecProc, de TADOStoredProc, o qual executa a UDF, “DeterminaMaior”, no banco.

Na linha 15, formatamos o valor da mensagem que deverá ser exibida composta do valor retornado do processamento no banco.

Na linha 17, adiciono ao Memo1 a mensagem.

Na linha 18, chamamos a função “MessageDlg”, API do Windows, para exibir o resultado do processamento para o usuário.


Codificando o Método “GetValorEdit”:

Na seção “private” vamos codificar a declaração método “GetValorEdit”. Segue trecho de código ilustrando o corpo do método:



function TForm1.GetValorEdit(Edt: TEdit): Double;
var
AuxNum: Double;
begin
try
AuxNum := StrToFloat(Edt.Text);
except
on EConvertError do
AuxNum := 0;
end;

Result := AuxNum;
end;


Agora execute a aplicação (pressione F9) e teste ...



A seguir, código completo da unit ...
unit Unit1;

interface

uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, Buttons, DB, ADODB;

type
TForm1 = class(TForm)
BitBtn1: TBitBtn;
ADOStoredProc1: TADOStoredProc;
ADOConnection1: TADOConnection;
Memo1: TMemo;
Edit1: TEdit;
Edit2: TEdit;
Edit3: TEdit;
procedure BitBtn1Click(Sender: TObject);
private
function GetValorEdit(Edt: TEdit): Double;
public
{ Public declarations }
end;

var
Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.BitBtn1Click(Sender: TObject);
const
ZnConstMsg = 'www.estacaozn.blogspot.com - O Valor maior é %s';
Var
ZnMsg: String;
begin

with ADOStoredProc1 do
begin
Parameters[0].Value := 0;
Parameters[1].Value := GetValorEdit(Edit1);
Parameters[2].Value := GetValorEdit(Edit2);
Parameters[3].Value := GetValorEdit(Edit3);
ExecProc;
end;
ZnMsg := Format(ZnConstMsg,
[VarTOStr(ADOStoredProc1.Parameters[0].Value)]);
Memo1.Lines.Add(ZnMsg);
MessageDlg(ZnMsg, mtInformation, [mbOK], 0);
end;

function TForm1.GetValorEdit(Edt: TEdit): Double;
var
AuxNum: Double;
begin
try
AuxNum := StrToFloat(Edt.Text);
except
on EConvertError do
AuxNum := 0;
end;

Result := AuxNum;
end;

end.


Artigo completo (View Full Post)

Pl/SQL Sequence

A “Sequence” é um objeto de banco de dados cujo aprincipal e única função é permitir que vários usuários possam gerar valores inteiros isentos de duplicidade (não repetidos). Essa funcionalidade é usada quando precisamos gerar valores para uma coluna Unique Key (UK). Ou seja,uma coluna cujos valores são únicos. Uma coluna “Uk” pode ser definida como chave primária (PK).
Outros SGBDSR, além do Oracle, também trabalham com ess conceito.
Observe que, embora o nome seja “sequence” não há nela nehum comprometimento em gerar sequencias de valores. A sequence tem a responsabilidade apenas de gerar valores únicos.
Abaixo veja a sintaxe para criação de uma “Sequence”:

CREATE SEQUENCE [schema.]sequence
[INCREMENT BY integer]
[START WITH integer]
[MAXVALUE integer]
[MINVALUE integer]
[CYCLE | NOCYCLE]
[CACHE integer | NOCACHE]
[ORDER | NOORDER]


Sobre os Parâmetros

schema :
Nome do usuário dono da sequence.
Sequence: Nome da sequence.
INCREMENT BY: Define o intervalo entre os números gerados.
MINVALUE: Define o valor mínimo que a sequence pode assumir.
MAXVALUE: Valor máximo que a sequence pode assumir.
START WITH: O primeiro valor gerado pela sequence.
CYCLE: Define a sequence como cíclica. Ou seja, recomeçará, do valor mínuimo, a contagem quando atingir os extremos.
NOCYCLE: Define a sequence como não cíclica. Incrementando até atingir o limite estipulado.
CACHE: Otimiza o processo de geração de UK. Define quantos valores da sequence o ORACLE ira manter na memória para um acesso mais rápido.
NOCACHE: Não terá valores pré-alocados.
ORDER: Garante que o numero gerado pela sequence obedece a ordem de requisição.
NOORDER: Não garante que os números seqüenciais gerados obedecem à ordem de requisição.




Exemplo I
O comando seguinte cria uma sequence com incremento de 10 começando do 1:

CREATE SEQUENCE ZnVSqc
INCREMENT BY 10


Exemplo II
O comando a seguir cria uma sequence com incremento de 1 começando do 11:

CREATE SEQUENCE ZnVSqc_MusicUk
INCREMENT BY 1
START WITH 11;

Para usar a sequence e gerar um valor “uk” novo, ou verificar qual o valor do último gerado, podemos através de comandos SQL retornar valor desejado. Veja conforme ilustração abaixo:

-- retorna o valor coorente da sequence
SELECT ZnVSqc_MusicUk.currval FROM dual;
-- Gera um novo uk e retorna o valor gerado (Nextval).
SELECT ZnVSqc_MusicUk.nextval FROM dual;








Artigo completo (View Full Post)

Conexão ADO & Oracle – Configurando uma conexão TADOConnection

Este post pretende exemplificar como configurar, no Delphi, uma conexão com Oracle usando a middleware de acesso a dados OLE DB.

Para configurar a conexão com o banco temos que acessar a propriedade “ConnectionString” de TADOConnection. Em tempo de projeto, pelo Object Inspector, podemos usar o wizard de configuração da string de conexão. Para isso, dê um duplo click na propriedade, ou com o botão direito do mouse sobre o componente ADOConnectio (que estiver no seu form ou datamodule), selecione “Edit ConnectionString”.




No botão “Build” acessamos o diálogo para definir o driver de acesso que vamos usar (nativamente a MS OLE DB provê drivers para algumas tecnologias de banco de dados).




Selecione OLE DB Provider for Oracle ... em seguida click no botão “Avançar >>”


Em Nome do Servidor, digite o nome da conexão que esta definida no arquivo “tnsnames.ora” (Normamente fica em \oracle\product\[versão]\server\NETWORK \ADMIN).



XEZn =
(DESCRIPTION =
(ADDRESS = (PROTOCOL = TCP)(HOST = 123.1.22.22)(PORT = 1521))
(CONNECT_DATA =
(SERVER = DEDICATED)
(SERVICE_NAME = XEZn)
)
)




O login de acesso você digita em “Nome do Usuário” e “Senha”. Marque “Permitir salvamento de senha”. Após digitar esses valores click em “Testar Conexão”.
Ao receber a mensagem de que a conexão foi feita com sucesso, click em “OK”.


Para finalizar, configure a propriedade “LoginPrompt” para “False”. Fazemos isso quando não desejamos que, ao ativarmos a conexão, seja exibido o diálogo para digitação do login (usuário/senha).






Sua string de conexão deverá ter sido montada semelhante ao exemplificado abaixo:
Provider=MSDAORA.1;Password=blavlablaval;User ID=EstacaoZN;Data Source=XEZn;Persist Security Info=True 


OBS:
No dia a dia profissional, corriqueiramente usamos a sigla referente aos objetos de acesso a dados (ADO ActiveX Data Objects) como se isso fosse o nome da middleware da Microsoft. Esse hábito pode causar algumas confusões para quem esta tendo um primeiro contado com essa tecnologia.
Existem dois drivers na OLE DB para conexões Oracle. Um deles é o nativo da OLE DB: “Microsoft OLE DB Privider for Oracle”. O Segundo é um driver da própria Oracle: “Oracle Provider for OLE DB”. O OraOLEDB provider é um componente COM. A versão 10.0.1.2.0 suporta Oracle Grids, além de suportar os seguintes datatypes nativos do Oracle Database 10g:

BINARY_DOUBLE
BINARY_FLOAT
O Microsoft OLE DB Privider for Oracle possui incompatibilidade com os tipos "LOB" nativos do Oracle, CLOB (Character Large Object) e BLOB (Binary Large Object).


A versão 9.2.0.4.0 trouxe suporte aos seguintes datatypes introduzidos no Oracle9i:
- TIMESTAMP
- TIMESTAMP WITH TIME ZONE
- TIMESTAMP WITH LOCAL TIME ZONE
- INTERVAL YEAR TO MONTH
- INTERVAL DAY TO SECOND

Artigo completo (View Full Post)

segunda-feira, 20 de outubro de 2008

Declarar Variável - Pl/SQL - Oracle

Podemos usar programação em PL/SQL sem necessariamente criar uma procedure ou function para isso.


DECLARE
ZnNum1 NUMBER(3);

Para declara variáveis, atribuir valores e verificar o valor de saída, veja o trecho de código ilustrado abaixo:


DECLARE
ZnNum1 NUMBER(3);
ZnNum2 NUMBER(3);
ZnData DATE;

BEGIN
ZnNum1 := 3;
ZnNum2 := ZnNum1 + 10;
ZnData := SYSDATE;

DBMS_OUTPUT.PUT_LINE('ZnNum1 = ' || ZnNum1);
DBMS_OUTPUT.PUT_LINE('Calculando ZnNum2 ....');
DBMS_OUTPUT.PUT_LINE('ZnNum2 = ' || ZnNum2);

DBMS_OUTPUT.PUT_LINE('Fim do Cálculo');

DBMS_OUTPUT.PUT_LINE('Data = ' || ZnData);
END;

Artigo completo (View Full Post)

domingo, 5 de outubro de 2008

Java - Declarações e Modificadores de Classes - Declaração para Arquivos-Fontes

Os modificadores se dividem em duas categorias: “Modificadores de acesso” e “Modificadores que não se referem a acesso”.

1) Modificadores de acesso

Servem para você poder restringir ou permitir acesso a uma classe que você está criando (ou partes dessa classe). Ou seja, definem o escopo de visivilidade de uma classe. Os escopos devisibilidade definido pelos modificadores de acesso são: Público, Protegido e Privado.
Eles são definidos em código através do emprego das palavras reservadas: “public” (Escopo de visibilidade público), protected (Escopo de visibilidade protegido), private (Escopo de visibilidade privado).
É importante notar que, embora existam quatro controles de acesso (que funcionam como níveis de acesso), os modificadores de acesso são apenas três (public, protected, private). O quarto nível de controle de acesso (chamado de acesso “default” ou "de pacote") é o que você obtém quando não usa nenhum dos três modificadores de acesso na declaração realizada durante a codificação de uma classe. Ou seja, toda classe, método, ou/e variável de instância que você declarar possui um controle de acesso, independentemente disso ser declarado explicitamente ou não.
Todos os quatro controles de acesso são adequados para as declarações de métodos e variáveis. Contudo, para classses, somente dois deles são válidos: público ou default . Uma classe só pode ser declarada como pública ou default, os outros dois níveis de controle de acesso não se aplicam para classes.
Os modificadores de acesso são os responsáveis por outra característica fundamental para a O.O. o “encapsulamento

1.1) Acesso a Classes

O termo aceeso a classes refere-se ao fenômeno que através de um método próprio, uma classe (classe “ZnX”) acessar outra (classe “ZnY”). Isso significa que a classe “ZnX” pode fazer uma das seguintes coisas:
1) Criar uma instancia da classe “ZnY”.
2) Estender a classe “ZnY” (ou seja, tornar-se uma subclasse da classe “ZnY”).
3) Acessar certos métodos e variáveis dentro da classe “ZnY”, dependendo do controle de acesso desses métodos e variáveis.


Definindo Controle de Acesso em Classes

Na prática, acesso significa visibilidade. Suponha que temos duas classes: classe “ZnX” e classe “ZnY”. Se a classe “ZnX” não puder ver a classe “ZnY”, o nível de acesso dos métodos e variáveis dentro da classe “ZnY” não fará diferença. A classe“ZnX” não terá como acessar os métodos e propriedades de “ZnY”.

Acesso Default: Uma classe cujo modificador de acesso é o chamado “default”, é a quela que não tem nenhum modificador precedendo na sua declaração. Esse é o controle de acesso que você obtém quando não digita um modificador na declaração da classe. Pense no acesso defaultcomo um acesso de nível de pacote, porque a classe com acesso default só pode ser vista por classes de dentro do mesmo pacote. Por exemplo: Se a classe “ZnX” e a classe “ZnY” estiverem em pacotes diferentes, e a classe “ZnX” tiver acesso default, a classe “ZnY” não será capaz de criar uma instância da classe “ZnX”. Nem mesmo, se quer, declarar uma variável ou tipo de retorno da classe “ZnX”. Fataliticamente, para a classe “ZnY” a classe “ZnX” nem sequer existe. Do contrário, o compilador irá reclamar caso isso não seja repeitado. Observe o seguinte arquivo-fonte:



package fermentadosZN;

class VinhoZn { }


Agora observe o segundo arquivo-fonte:

package destiladosZN;

import fermentadosZN.VinhoZn;

class ConhacZn extends VinhoZn { }


Observe, nos trechos de código ilustrados acima que, a superclasse “VinhoZn” está em um pacote diferente da subclasse “ConhacZn”. Veja na linha 3 a declaração “import” possibilitando a package “destiladosZN” importar a classe “VinhoZn” para a ser usado n apackage “destiladosZN”. Supondo que tentássemos compilar, o arquivo “fermentadosZN” compilará sem problemas, contudo, quando tentamos compilar o arquivo “destiladosZN”, receberemos uma mensagem de exceção semelhante do tipo:



Can't access class destiladosZN. Class or interface must be public, in same package,or an
accessible member class.
import destiladosZN;


“destiladosZN” não compila porque a sua superclasse, “VinhoZn”, tem acesso default e está em um pacote diferente. Existem duas coisas que podemos pode fazer para nosso problema hipotético:

1) Poderiamos colocar ambas as classes no mesmo pacote,
2) Ou. poderiamos declarar “VinhoZn” como public. Exemplo:


Esse tipo de situação/problema costuma ser usado em prova de certificação. Portanto, quando você vir uma questão com lógica complexa, certifique-se de olhar os modificadores de acesso antes de qualquer coisa. Assim, caso identifique uma violação de acesso (por exemplo, uma classe do pacote “X” tentando acessar uma classe default do pacote “Y”), você saberá que o código não vai compilar, portanto não precisa nem se dar ao trabalho de tentar entender a suposta lógica complexa da questão. A qual está lá justamente para desviar sua atenção indizindo você ao erro. Além de economizar tempo e stress.

Acesso Público: Uma declaração de classe com a palavra reservada public torna ela visivél a todas as classes, de todos os pacotes. Todas as classes do Universo Java (JU) têm acesso a uma classe pública. Contudo, não se esqueça que mesmo sendo pública, uma classe para ser usada, se estiver em um pacote diferente, será obrigatório importar-lá.


2) Outros Modificadores de Classes (Não-referentes a Acesso)

Além dos modificadores vistos anteriormente ainda existem mais três, os quais são definidos pelas palavras reservadas “final”, “abstract” e “strictfp”. Esses modificadores existem em adição a qualquer controle de acesso existente na classe. Logo poderiamos, por exemplo, declarar uma classe como “public” e “final” ao mesmo tempo.
Todavia, isso não é adequado para todas as situações. Não é sempre que podemos misturar modificadores não-referentes a acesso. Por exemplo: É possível usar “strictfp” em combinação com “final”, contudo nunca (jamais, em tempo algum) marcar uma classe como “final” e “abstract” ao mesmo tempo.
Imagino que isso possa parecer óbvio demais para quem já conhece bem orientação a objetos. Entretando, muitos aprendem java sem necessáriamente aprofundar sobre OO. Quase sempre por isso, sentirá dificuldade em aprender e aplicar certos pontos sobre Java que estiver nesta situação.

Vejamos então sobre estes últimos modificadores ....

strictfp”: Palavra reservada que pode ser usada para modificar uma classeou um método, mas nunca uma variável. Marcar uma classe como “strictfp” significa que qualquer código de método na classe será compatível com às regras do padrão IEEE 754 para pontos flutuantes. Sem esse modificador, os pontos flutuantes usados nos métodos poderão se comportar de forma variante conforme a plataforma. Se não declarar a classe como strictfp, ainda assim você poderá obter um comportamento strictfp para métodos específicos, declarando o método como strictfp.

final”: Define as “Classes Finais” - a palavra-chave “final” significa que a classe em questão não pode ser subclassificada. Ou seja não pode ser estendida, herdada por nenhuma outra. Nenhuma outra classe jamais poderá estender uma classe final. Caso alguém tente fazê-Io receberá um erro de compilação.
Tenha cuiadado ao usar esse tipo de modificados, você só deve marcar uma classe como final se possuir certeza absoluta de que numca vai precisar especializá-la. Nunca nenhum dos métodos dessa classe jamais vai ser sobrescrito.
Por que, então, precisamos marcar uma classe como “final”. Visto que, isso restringe aplicação do conceito de herança presente nas linguagens orientadas a objetos? Suponhamos que o comportamento de sua classe seja profundamente dependente da implementação de certos métodos. Por isso você considere que se esses, certos, métodos forem alterados seja impossível garantir um comportamento adequado a classe. Logo, marcá-la como “final” lhe dará a segurança de que ninguém poderá modificar a implementação dos mesmos sem você saber.
Note que muitas classes das bibliotecas fundamentais Java são declaradas como “final”. Por exemplo, a classe String não pode ser estendida. Não é difícil considerar os riscos caso você não pudesse garantir a forma como um objeto String funcionaria em qualquer sistema que executasse a sua aplicação. Você concorda comigo que, se os programadores tivessem a liberdade de estender a classe String (e assim colocar as suas novas instâncias da subclasse String onde esperam-se instâncias de java.lang.String), dar manutenção em muitos sistemas Java seria a principal causa dos picicóticos maniácos depressivos internados nos centros psquiátricos da vida?
Portanto, use final para segurança, mas apenas quando tiver certeza de que a sua classe final de fato já disse tudo o que precisa ser dito nos seus métodos. Marcar uma classe como final significa, na prática,que a sua classe nunca será especializada para uso mais específico.

Asseguir vamos modificar nosso exemplo anterior colocando a palavra reservada “final” na declaração:

package fermentadosZN;

public final class VinhoZn {

public void fermentar(){}
}


Ok, supondo que tentassemos compilar a subclasse ConhacZn:


package destiladosZN;

import fermentadosZN.VinhoZn;

class ConhacZn extends VinhoZn { }


Então, receberemos um erro tipo:

Can't subclass final classes: class
fermentadosZN.VinhoZn class ConhacZn extends VinhoZn{
1 error}


OBS:
É de extrema importância entender que marcar uma classe como “final” elimina um benefício fundamental da orientação a objeto, a estensibilidade (herança). No dia-a-dia, tipo vida real, você raramente precisará criar uma classe final. Portanto, exceto que você tenha uma séria e justificada razão, presuma sempre que algum dia, em algum momento, outro desenvolvedor poderá precisar estender a sua classe.

abstract: Palavra reservado para marcar classes como “Abstratas”. Uma classe marcada com “abstract” não pode ser instanciada nunca. Isso é a primeira coisa mais importante que você precisa saber sobre classes abstratas. A segunda coisa mais importante sobre elas é que, o seu único propósito, sua principal missão no universo, é ser estendida (Herdada, especialisada, em algumas literaturas encontraremos o termo “subclassificada”). Imagino que alguém possa estar se perguntando: Se posso fazer herança a partir de qualquer classe (exceto as marcadas como “final”), por que preciso de uma classe abstrata? A resposta consiste na mesma idéia envolvida quando, por exemplo, ao nos referirmos sobre um determinado veículo o fazemos usando o termo "Automóvel".
Uma classe abstrata pode ser executada, mas não podemos criar uma instância dela. Caso essa explicação tenha deixado dúvidas procure ler outros artigos onde eu e Felipe explicamos sobre herança.

Outras questões sobre classes abstratas

Repare que você pode compilar e executar uma classe abstrata, desde que não tente criar uma instância dela. Por que criar uma classe se você não pode criar (instanciar) objetos dela? Antes de respondermos, gostaria de chamar a atenção que este entendimento é um elemento chave para quem pretende usar OO em seus projetos. Não acho fácil responder essa pergunta, mesmo assim tentarei apresentar uma linha de raciocínio que possa trazer mais luz sobre essa questão.
Pois bem, prossigamos: Considere um fenômeno comum o qual aplicamos recorrente mente no cotidiano em diversas situações. Esse fenômeno a que me refiro, consiste na capacidade que temos de abstrair ou especializar significados quando estamos nos relacionando com o mundo exterior: Ao tentarmos comunicar alguma mensagem, ou quando estamos do outro lado, interpretando um conteúdo comunicado, ou quando estamos construindo uma idéia sobre alguma coisa e precisamos fazer avaliações e comparações. Entendo que o grande benefício da utilização de classes abstratas, é permitir que possamos “importar” essa flexibilização para perceber significados, usada nos processos cognitivos (construção e interpretação de informações) para a computação (especificamente na construção de programas).
Analisemos uma situação hipotética, um exemplo: Num dado momento ao falar sobre música, uma pessoa, usa o termo “composições” para abstrair detalhes sobre autor, estilo, ou versão:

“Gostaria de conhecer mais sobre as composições musicais no século passado”.

Esse tipo de construção permitiu um grau de abstração grande sobre o significado “Música”. Isso lhe foi bastante útil porque ela poder expressar de forma eficaz seu desejo em conhecer qualquer estilo de música que tenha sido composta no século passado. Entretanto, se ela falar especificamente numa música o termo genérico não encontra significância. Ou seja, não é possível apresentar nenhum exemplo de música onde os detalhes sobre o estilo, gênero, autor, versão sejam ausentes. Por exemplo, em resposta a pergunta sobre uma música que atenda o critério de “composição do século passado” alguém cante “Born to Be Wild”, a resposta traz intrínseca as informações sobre os detalhes que a identificam univocamente como tal.

Outro exemplo, supondo que alguém cite genericamente o significado “veículo”. Logo, podemos presumir podermos contar com alguma outras coisas (atributos e ações), genéricas, comuns a todos os veículos. Como no mundo real não conseguimos encontrar um exemplo qualquer de veículo, pois, seguindo o raciocínio anterior, ao citar o exemplo pedido imediatamente os detalhes sobre ele se revelam exaurindo a generalização embutida na palavra “veículo”, trazendo a existência uma instância detalhada do significado pedido. Portanto, da mesma forma quando programando, definimos uma classe “Veiculo” ela não deve permitir ser instanciada. Pois, definitivamente não desejamos que alguém de fato crie um objeto “Veiculo” genérico. Caso isso não fosse respeitado o primeiro e principal problema encontrado é justamente que o mecanismo de generalização descrito na parágrafo anterior seria perdido. Conseqüentemente teríamos alguns problemas: Como inicializar o seu estado deste objeto “Veiculo”? De que cor ele seria? Quantos assentos? Potência do motor? Direção hidráulica ou não? Ainda, de que forma ele se comportaria? Como os métodos seriam implementados?
Isso demandaria um esforço considerável, o que tornaria o desenvolvimento do seu módulo bastante suscetível implementações confusas. Quando na verdade que você precisa é as instancias de sua classe “Veiculo”sejam tipos reais de carros, como BMW Boxster, ou Nisan 350Z. Observe a seguinte classe abstrata:


abstract class vehicle {
private double price;
private String model;
private String year;
private String manufacturer;
public abstract void goFast ();
public abstract void goUpHill ();
public abstract void impressNeighbors ();
// codificar o resto do código importante aqui

}


3)Regras de Declaração para Arquivos-Fontes

Já que estamos tratando de declarações e controles de acesso de classes, julgo então que este é um momento propício para fazermos uma breve revisão das regras pertinentes a declaração de classes, declarações import e declarações de package em um arquivo fonte:


1° - Só pode haver uma classe com escopo de visibilisdade “public” em cada arquivo de código-fonte.

2° - Os comentários podem aparecer no início ou no fim de qualquer linha no arquivo do código-fonte. Eles são independentes de qualquer das regras de posicionamento.

3° - Se houver uma classe pública em um arquivo, o nome do arquivo deve ser o mesmo desta classe . Por exemplo, uma classe declarada como “public class ZnVinho { }” precisa estar em um arquivo de código-fonte chamado “ZnVinho. java.”

4° - Se a classe fizer parte de um pacote, a declaração package deve estar na primeira linha do arquivo do código-fonte, antes de quaisquer declarações import que estejam presentes.

5° - Se houver declarações “import”, elas devem ficar entre a declaração package (se houver) e a declaração da classe. Se não houver uma declaração package, então a(s) declaração(ões) “import” deve(m) estar na(s) primeira(s) linha(s) do arquivo fonte. Se não houver declarações package nem import, então a declaração da classe deve estar na primeira linha do arquivo do fonte.

6° - As declarações import e package aplicam-se a todas as classes dentro de um arquivo fonte. Ou seja, não é possível declarar múltiplas classes em um arquivo e tê-la sem diferentes pacotes, ou usar diferentes importações.

7° - Um arquivo pode ter mais de uma classe não-pública.

8° - Arquivos que não tenham classes públicas podem ter um nome que não seja o mesmo de nenhuma das classesdo arquivo.


Posteriormente, aprofundaremos mais sobre as regras envolvidas com a declaração e o uso de importações, pacotes. Além disso, pretendo falar embreve sobre importações estáticas.

Referência:
SCJP: Certificação Sun para Programador Java 5 - Guia de Estudo

Artigo completo (View Full Post)

Para matar um sessão no Orcle

Dica enviada pelo meu brother Diogo Pizaneschi:


No SqlPlus ou qualquer outra ferramenta, faça um select em
"v$session" para procurar na a sessão que deseja matar. Em seguida, após identificar a sessão, pegar os valores das colunas "SID" e "SERIAL#", referentes a sua sessão. Finalmente, executar o comando:


alter system kill session 'SID,SERIAL#' immediate


Ou seja, substitua os valores da sessão identificada, referentes as colunas citadas acima pela sua respectiva posição (exemplificada no comando anterior). Portanto, supondo que os valores para as colunas "SID" e "SERIAL#" que desejamos matar sejam, respctivamente, "135" e "6487", logo o comando para matar esta sessão deverá ser assim:


alter system kill session '135,6487' immediate


Obrigado Diogão!

Artigo completo (View Full Post)

 
BlogBlogs.Com.Br