Fluxograma para criação do projeto de uma WEB SERVICE.

Para desenvolver páginas da WEB com uma excelente IDE. O Dreamwever.

O programa DREAMWEVER era da MACROMÉDIA e se tornou referência para desenvolvimento WEB. Depois foi comprado pela ADOBE que continua a desenvolvê-lo.

Para quem gosta de desenvolver páginas em HTML ou XHTML, é uma excelente ferramenta, porque além de fornecer os códigos a medida que se vai escrevendo a página, permite visualizar a mesma ao lado da página escrita de tal forma que ao se selecionar um elemento visualmente ele é destacado na página de código escrita.

Isso facilita muito o trabalho porque evita que se fique procurando determinado elemento em uma infinidade de linhas de marcação. Basta posicionar a página ao lado e visualmente clicar em cima do elemento que se deseja trabalhar. Pode ser uma figura, um link ou um texto. No mesmo momento a marcação correspondente ao elemento que se deseja trabalhar é selecionado e destacado.

Um dos bons recursos também é o dimensionamento de elementos que pode ser  feito apenas arrastando os lados de uma figura por exemplo, de forma a se obter a dimensão ideal sem necessidade  de se ficar experimentando até chegar-se ao tamanho adequado.

O Dreamwever dá suporte a práticamente toda as tecnologias WEB de hoje constituindo-se dessa forma em uma excelente ferramenta e um excelente Ambiente de Desenvolvimento.

Se você deseja obter o pacote Adobe completo com o Dreamweaver, Photoshop, Adobe Premiere para edição de vídeo e Adobe ilustrator, e muitas outras ferramentas, clique aqui

Você irá baixar o arquivo ZIPADO. A senha para abri-lo é filotec7

O arquivo baixado corresponde a dois DVDs que são fornecidos em duas imagens padrão "ISO". É necessário descompactá-lo e aparecerão duas imagens de dois DVDs. Tendo as imagens, basta clicar sobre cada uma delas tendo dois DVDs virgens um de cada vez e um programa para converter a imagem ISO em DVD. Esse programa pode ser o ASHAMPOO quetem uma versão gratuita, ou o NERO ou outro qualquer.

Os dois DVDs contém todas as  explicações para a instalação, além de um vídeo explicativo que fornece detalhes e um método excelente para você ter  em seu computador o pacote ADOBE CS6 totalmente liberado para uso.

Boa sorte.

VARIAVEIS QUE RECEBEM COMO TIPO O NOME DA CLASSE

OBJETOS EXECUTANDO MÉTODOS

OBJETOS DA CLASSE EXECUTANDO MÉTODOS.

<

CRIAÇÃO DE OBJETOS DENTRO DA CLASSE

CRIAÇÃO DE OBJETOS EM JAVA UTILIZANDO-SE O OPERADOR NEW

REFERÊNCIA RÁPIDA.

Uma das coisas que mais sinto falta quando tento aprender Java é uma referência rápida.

Referência rápida é uma lista de informações sintéticas que nos permitam ter rápido acesso a elas em caso de necessidade. Como não encontrei nenhuma até então estou aqui tentando fazer uma. 

É óbvio que seria pretensão de minha parte querer acaba-la agora, por isso irei aos poucos construindo-a e atualizando-a. 

Agradeceria se alguém quiser me ajudar. É só postar um comentário com a informação desejada que eu imediatamente incorporarei a informação a essa REFERÊNCIA RÁPIDA.

Outro dia mesmo eu estava em dúvida como fazer uma mudança de linha. Você coloca um texto e não quer que a continuidade do texto fique na mesma linha. Depois encontrei a tabela abaixo que não só tem a mudança de linha como outros recursos da linguagem.

Variaveis em JAVA

boolean - Tipo lógico que pode assumir o valor true ou o valor false.

char - Caractere em notação Unicode de 16 bits. Serve para a armazenagem de dados alfanuméricos.

byte - Inteiro de 8 bits em notação de complemento de dois. Variáveis deste tipo podem assumir valores entre -27=-128 e 27-1=127.

short - Inteiro de 16 bits em notação de complemento de dois. Os valores possíveis cobrem a faixa de -215=-32.768 a 215-1=32.767.

int - Inteiro de 32 bits em notação de complemento de dois. Pode assumir valores entre -231=-2.147.483.648 e 231-1=2.147.483.647.

long - Inteiro de 64 bits em notação de complemento de dois. Pode assumir valores entre -263 e 263-1.

float

Representa números em notação de ponto flutuante normalizada em precisão simples de 32 bits em conformidade com a norma IEEE 754-1985. O menor valor positivo que pode ser representado por esse tipo é 1.40239846e-46 e o maior é 3.40282347e+38.

double

Representa números em notação de ponto flutuante normalizada em precisão dupla de 64 bits em conformidade com a norma IEEE 754-1985. O menor valor positivo que pode ser representado é 4.94065645841246544e-324 e o maior valor positivo é 1.7976931348623157e+308.

Iremos aos poucos enriquecendo essa "REFERÊNCIA RÁPIDA" e se alguém quiser ajudar, faça um comentário acrescentando qualquer coisa que iremos acrescentar a essa referência rápida.


Saudações

A palavra reservada "static"

Não sou especialista em JAVA. estou aprendendo, e como aprendiz não tenho condições de postar nada como se soubesse. Portanto vou colocar aqui as minhas dúvidas e procurar discuti-las com os que se interessarem. Esse blog procura mostrar as dificuldades de um iniciante, e auxiliar os mais espertos a entender essas dificuldades.

Os posts aqui colocados poderão ser tirados da Internet e nesse caso eu citarei as fontes.

Veja que eu gosto de entender o que está sendo programado. Cada virgula, cada palavra. e quando encontro algo que não entendo, eu paro. Não vou adiante, até entender o raio daquela palavra ou virgula ou seja lá o que for.
Foi quando me deparei com a seguinte linha:

 public static void main(String[] args) {


para quem está acostumado a programar, essa expressão está para lá de manjada, e eu entendo quase tudo, senão vejamos.

public - Refere-se a um método public, ou seja aquele método que dá acesso a tudo, completamente desnudo vamos dizer assim.
void - significa que é um método sem retorno. Se tivesse retorno iria executar um processamento e retornar alguma coisa. Um valor ou uma string. Se não retorna nada é VOID..
 main - É a função principal. A função raiz de onde todas as outras derivam.

Coisa que não entendi.

static e (String[] args) {

Ato contínuo ==> GOOGLE e colocamos na busca static + java.

De primeira encontrei essa excelente explicação.

ENTENDI TUDO

ENTENDENDO STATIC

em 14/02/2003 , por Rafael Steil 

Quando e porquê usar static? static é uma das palavras-chave do Java, e é também motivo de muita confusão e dúvidas entre o pessoal que esta começando. Aliás, mesmo os mais experienciados confundem-se às vezes em usar ela. O método static mais famoso de todos é o main. É através dele que vimos nosso primeiro programa em Java nascer, e é sempre via main que nossos programas criam vida. Por definição da linguagem Java, o métodomain precisa necessariamente ter acesso public, ser static, não retornar coisa alguma ( void ) e receber como argumento um array de String ( String args[] ): 

view plainprint?

1. public static void main(String args[])  

Entendendo static

Como regra geral, tenha isso em mente: dentro de métodos static somente é possível pode acessar outros métodos e variáveis que também sejam static. Dentro do método pode-se definir qualquer tipo de variável, static ou não. Caso seja necessário acessar algum método ou membro não-static, é necessário criar uma instância da classe e então chamar o que quiser. Já o contrario é um pouco diferente: dentro de membros não-static, é possível acessar tanto propriedades static quanto as não-static. O fato de ser preciso primeiramente criar uma instância da classe para só então chamar algum método não-static ou acessar uma variável comum dentro de um métodostatic deve-se ao fato que dentro dele não existe uma referência para o ponteiro this. O ponteiro this é utilizado para referenciar propriedades da classe em que estamos trabalhando. Por exemplo: 

view plainprint?

1. ...  
2. // Variável simples, para guardar o nome  
3. private String nome;  
4.   
5. // Algum método comum  
6. public void meuMetodo()  
7. {  
8.     this.nome = "Fulano";  
9. }  

No exemplo acima, this.nome = "Fulano" diz que estamos atribuindo ao membro da classe chamado nome o valor "Fulano". O uso de this é automático, portando o exemplo acima poderia ser escrito simplesmente da forma 

view plainprint?

1. ...  
2. // Variável simples, para guardar o nome  
3. private String nome;  
4.   
5. // Algum método comum  
6. public void meuMetodo()  
7. {  
8.     nome = "Fulano";  
9. }  

Note que agora não mais usamos this, e funciona da mesma maneira. Se o método meuMetodo fosse static, o código acima não funcionaria, pois como foi dito antes, métodos static não possuem this. Ao contrário do que o nome soa, static não significa que a variável ou método sera estática do ponto de vista que seu valor não pode mudar ( final é usado para estes casos ). static nos garante que somente haverá uma, e não mais que uma, referência para determinada variável ou método disponível em mémoria. Em outras palavras, declarando alguma coisa como static, todas as instâncias da classe irão compartilhar a mesma cópia da variável ou método. Declarar algo como static também permite você acessar as coisas diretamente, ou seja, sem precisar criar uma instância da classe. Existe inclusive um Design Patter baseado no uso de static: Singleton.

Exemplificando

Para entender melhor tudo o que foi dito, nada melhor que alguns exemplos práticos para ver com os próprios olhos o funcionamento. O primeiro exemplo consiste em uma classe com 2 variáveis, uma static e outra não-static. A cada novo objeto criado, incrementados ambas variáveis e imprimimos o resultado na tela. Digite o seguinte código em um arquivo chamado "TesteStatic.java": 

view plainprint?

1. // TesteStatic.java  
2. class Classe1  
3. {  
4.     // Variavel static  
5.     public static int contador = 0;  
6.   
7.     // Variavel nao-static  
8.     public int outroContador = 0;  
9.   
10.     public Classe1() {}  
11.   
12.     // Precisa ser static porque "contador" é static  
13.     public static void incrementaContador()  
14.     {  
15.         contador++;  
16.   
17.         System.out.println("contador agora é "+ contador);  
18.     }  
19.   
20.     public void incrementaOutroContador()  
21.     {  
22.         outroContador++;  
23.   
24.         System.out.println("outroContador agora é "+ outroContador);  
25.     }  
26. }  
27.   
28. public class TesteStatic  
29. {  
30.     public static void main(String args[])  
31.     {  
32.         Classe1 c1 = new Classe1();                       
33.         c1.incrementaContador();  
34.         c1.incrementaOutroContador();  
35.   
36.         Classe1 c2 = new Classe1();  
37.         c2.incrementaContador();  
38.         c2.incrementaOutroContador();  
39.           
40.         Classe1 c3 = new Classe1();  
41.         c3.incrementaContador();  
42.         c3.incrementaOutroContador();  
43.   
44.         Classe1 c4 = new Classe1();  
45.         c4.incrementaContador();  
46.         c4.incrementaOutroContador();  
47.     }  
48. }  

A saida gerada por este programa será 

view plainprint?

1. contador agora é 1  
2. outroContador agora é 1  
3. contador agora é 2  
4. outroContador agora é 1  
5. contador agora é 3  
6. outroContador agora é 1  
7. contador agora é 4  
8. outroContador agora é 1  

Note que a variavel "contador", que é static, não teve seu valor zerado a cada novo objeto criado da classe Classe1, mas sim incrementado, enquando "outroContador", que é uma variável comum, ficou sempre em 1, pois a zeramos o valor no construtor da classe.

Acesso direto

Ao contrário de tipos de dados não-static, qualquer variável ou método static podem ser acessado diretamente, sem necessitar de uma instância da classe criada: 

view plainprint?

1. // TesteStatic2.java  
2. class Classe2  
3. {  
4.     // Escreve alguma frase na tela  
5.     public static void escreve(String msg)  
6.     {  
7.         System.out.println(msg);  
8.     }  
9.       
10.     // Retorna a multiplicação de dois números int  
11.     public static int multiplica(int n1, int n2)  
12.     {  
13.         return (n1 * n2);  
14.     }  
15.       
16.     // Construtor, apenas para mostrar que  
17.     // ele nem chega ser chamado  
18.     public Classe2()  
19.     {  
20.         System.out.println("Construtor de Classe2");  
21.     }  
22. }  
23.   
24. public class TesteStatic2  
25. {  
26.     public static void main(String args[])  
27.     {  
28.         Classe2.escreve("Multiplicando 3 vezes 3:");  
29.         int resultado = Classe2.multiplica(3, 3);  
30.         Classe2.escreve("Resultado: "+ resultado);  
31.     }  
32. }  

Rode este programa e repare no resultado. Veja que o construtor da classe não foi chamado, pois não aparece na tela a string "Construtor de Classe2". Repare também que não criamos instância alguma de Classe2 para chamar seus métodos. Caso os métodos escreve e multiplica não fossem static, seria necessário fazer 

view plainprint?

1. public class TesteStatic2  
2. {  
3.     public static void main(String args[])  
4.     {  
5.         Classe2 c2 = new Classe2();  
6.         c2.escreve("Multiplicando 3 vezes 3:");  
7.         int resultado = c2.multiplica(3, 3);  
8.         c2.escreve("Resultado: "+ resultado);  
9.     }  
10. }  

Note que o código acima funciona perfeitamente mesmo com os métodos static. Isso funciona porque apesar de podermos chamar diretamente as coisas quando elas são static, não é obrigatório, podendo perfeitamente ser criada uma instância da classe e então chamar os métodos. O uso de static depende muito do caso, e conforme você vai pegando mais experiência, irá naturalmente identificar os lugares que precisam - ou que são mais convenientes - ao uso de tal palavra-chave.