forum de línguagem de programação

Prévia do material em texto

Olá pessoal, bom dia!
Tenho percebido que existe uma dúvida recorrente dentre aqueles que iniciam o estudo de lógica de programação com a linguagem Java: o que significa cada instrução do escopo básico para um programa "Hello World"?
Antes de iniciarmos o tratamento do objetivo, gostaria de pincelar por cima do conceito desse tal programa "Hello World". O "Olá Mundo" ou "Alô Mundo" é um famoso programa de computador que imprime "Olá, Mundo!" (ou "Hello, World!"), utilizado como um teste ou como um exemplo de código minimalista de uma linguagem de programação. Programadores do mundo todo fazem dessa frase sua primeira experiência com uma linguagem de programação.
Em Java, o "Olá Mundo" seria assim:
public class OlaMundo
{
    public static void main(String[] args)
    {
        System.out.println("Ola mundo");  
    }
}
Toda palavra que não esteja em língua inglesa, no código acima, é uma instrução da linguagem Java.
Java é uma linguagem que trabalha com Orientação a Objetos, isso já foi dito na apostila da disciplina e implica dizer que a ações do programa podem girar em torno de uma estrutura manipulável chamada "objeto". Os objetos são construídos a partir de "moldes" chamados classes (Tanto os objetos quanto as classes são observados como comandos dentro do código fonte do programa).
A palavra "class" é a instrução responsável por declarar uma nova classe. No código acima a classe terá o nome de "OlaMundo" (sou eu quem escolho o melhor nome para a classe) e será pública (comando "public"), isso significa dizer que essa classe poderá ser utilizada por outras classes presentes em pacotes diferentes (em arquivos diferentes do mesmo projeto).
A palavra "main" é o comando dado ao método principal da classe (função principal do código). Dentro do projeto poderemos ter muitas classes, porém apenas uma delas terá um método principal. A diretiva "void" indica que essa função não retorna nenhum valor após a conclusão de sua rotina (o que é óbvio, visto que ela é a função principal). A palavra "static" informa que o método principal é estático, em Orientação a Objetos isso significa que esse método não precisa de um objeto para ser executado (caso não fosse estático seria necessário ter um objeto para chamar a função principal, coisa sem lógica visto que e papel da função principal dar uma "plataforma" para a criação de objetos). Finalmente o "Public", como já sabemos, define que o método principal pode ser utilizado por outras classes presentes em pacotes diferentes (em arquivos diferentes do mesmo projeto).
System.out.println() é um método para escrever na tela, no nosso exemplo será escrita a frase "Ola mundo".
As chaves indicam o início (quando abrem) e o fim (quando fecham) de qualquer bloco de diretivas (classes, métodos, funções, estruturas, etc.).
E é isso aí, pessoal! Espero que ajuda aqueles que ainda estão dando os primeiros passos e me ponho a disposição para ajudar os colegas a entender qualquer coisa que eu tenha deixado confuso no texto.
 
Responder
Pessoal, seguindo no raciocínio de que muito estão pela primeira vez utilizando uma Linguagem Orientada a Objetos (no caso Java), venho nessa segunda participação trazer alguns conceitos sobre o que é orientação a objetos.
Ao contrário da Programação Estruturada, que estudamos na disciplina de algoritmos (que prima pela manipulação de várias tarefas isoladas para um objetivo comum), a POO busca meios de criar operações diretas com as entidades que compõem o problema, portanto, nela não basta apenas identificar os passos, pois é também necessário determinar quem (ou o que) será responsável por realizar cada um deles e/ou quem (ou que) será “estimulado” por eles (quem ou o que == objetos do programa, daí vem o nome do paradigma que estamos tentando explicar aqui). Desta forma, pode-se dizer que a POO está baseada na composição e interação entre diversas unidades de software chamadas de objetos.
Apesar de não possuírem o mesmo desempenho de códigos estruturados similares, oferece uma modularidade muito maior, com as seguintes vantagens:
Melhor organização e mais semântica
Maior reaproveitamento (bibliotecas multifuncionais)
Códigos mais flexíveis e adaptáveis (ideal para sistemas com evolução em versões)
Cada objeto que utilizamos em nossos programas são elementos que possuem atributos (que na prática funcionam como variáveis para esses objetos) e métodos (que na prática funcionam como funções para esses métodos), e esses membros (atributos e métodos) são definidos por meios de modelos descritivos chamados de CLASSES. As classes descrevem por meio da linguagem de programação quais são as características (atributos) que um grupo de objetos de possuir e quais ações (métodos) eles poderão realizar. Assim, cada objeto pertence a uma determinada classe.
Em Java, as classes são declaradas por meio da palavra reservada "class" (que é, simplesmente, classe em língua inglesa). Vimos essa palavras quando estamos nas primeiras linhas de código de nossos programas, mas também podemos criar outras classes para auxiliar aquela que contém a função (método) principal (chamada de "main").
As classes são apenas definições de como serão os objetos, portanto, não manipulamos classes, mas sim seus objetos. Em Java, para declarar um objeto seguimos a seguinte sintaxe:
nome_da_classe nome_do_objeto = new nome_do_contrutor();
Percebemos a ocorrência de outra palavras reservada, chamada "new". Esse comando tem por objetivo criar uma nova instância de um objeto, ou seja, torná-lo um elemento realmente manipulável dentro do código (diferentemente da classe). Logo após o new, é chamado um membro da classe denominado "construtor". Por regra, o nome do construtor em Java sempre é igual ao nome da classe, ele tem um funcionamento quase semelhante a um método, tanto que possui até parênteses que podem receber parâmetros, mas com as seguintes diferenças:
não retorna valores;
não pode ser chamado quando bem quisermos;
sempre é executado quando um objeto é instanciado. (isso é muito aproveitado para inicializar atributos)
Quando queremos fazer uma leitura do teclado, por exemplo, utilizamos a seguinte linha:
Scanner num = new Scanner(System.in); 
Nessa linha de código temos:
O nome de uma classe, Scanner, que contém as definições necessárias para entrada de dados via console de comandos;
num, que é um objeto para litura de dados, cujo o nome foi definido por nós;
A diretiva new, que fará o instanciamento do objeto que estamos declarando;
a chamada do construtor, que possui o mesmo nome da classe do nosso objeto;
Um parâmetro que será utilizado para a inicialização de nosso objeto.
Nesse parâmetro percebemos o uso de outra classe, chamada System, e por ela chamamos o atributo estático "in" com ajuda do operador ponto. Esse atributo configura a instância da classe Scanner de forma que ele fará leitura de dados da entrada padrão, que na maioria das vezes é o prompt de comando, mas em alguns casos pode ser um arquivo.
Agora temos uma divergência: eu falei que só poderíamos manipular membros (atributos ou métodos) de classes por meio de uma objeto, contudo, no exemplo dado, o atributo "in" foi utilizado em um objeto (e portanto, diretamente pela classe System). Isso aconteceu porque esse atributo é declarado como membro estático (modificador de acesso conseguido com o comando "static" em Java) dentro da classe. Essa é a única exceção: membros estáticos não precisam de objetos para serem utilizados. Como eu já havia dito no meu post anterior, o método principal "main" é declarado como estático e nos serve como exemplo também.
A partir de agora, conseguiremos enxergar objetos por toda parte em nosso código! hehehe
Sobre o 3° capítulo:
As classes podem possuir relacionamentos entre elas, com o propósito de compartilham informações, assim colaborando umas com as outras. Portanto podemos entender que um sistema desenvolvido com linguagem de POO é composto classes que podem se relacionar entre si para solucionar o problema proposto.Principais tipos de relacionamentos entre classes são:
Dependência
Associação
Tipo simples (ou plana)
Tipo agregação
De composição
Simples (ou compartilhada)
Herança
A dependência é o relacionamento mais simples entre classes/objetos, porém menos comum, pois é normal que ele tenda a ser evitado durante a modelagem de um sistema, pois com a dependência se a especificação mudar, é necessário atualizar o objeto dependente. Contudo, muitas vezes é impossível eliminar todas as dependências entre os objetos.
A associação é um relacionamento um pouco mais “elaborado” que a dependência e costuma ser o mais comum entre objetos. Nela, um determinado objeto contém uma referência a outro objeto, funcionando como um apontamento para outro objeto. Isso permite que se passem dados de um objeto para outro (use membros de um por meio do outro).
Observação: na associação a multiplicidade determina quantos objetos de cada tipo estão envolvidos na associação. Ela pode ser um ou muitos, zero ou muitos, zero ou um, apenas um e apenas muitos.
A agregação é um tipo especial de associação, na qual um objeto agrega outro objeto, ou seja, torna um objeto externo parte de si mesmo. Assim, um objeto pode trazer pra si (agregar) um ou muitas instancias de um outro objeto (arrays de objetos).
Observação: A análise desse relacionamento entre objetos segue uma lógica todo/parte, onde existe objeto-todo e objeto-parte. A parte só é criada quando o todo é criado, demonstrando que as informações de um objeto precisam ser complementadas por um objeto de outra classe
 A composição é mais rigorosa que a agregação, nela os objetos dessa relação não são independentes uns dos outros (relacionamento forte), pois um objeto é parte essencial do outro. Em geral, na prática, é mais comum usar agregação mesmo quando o relacionamento é mais forte.
Observação: A relação depende do todo, pois se o objeto todo for destruído, todos os seus objetos parte também serão. Conceitualmente: o todo não existe (ou não faz sentido) sem as partes, ou as partes não existem sem o todo.
Mais sobre agregação x composição:
A diferença entre composição e agregação tem relação com a existência dos objetos
Essa diferença não é tratada pelas linguagens de programação que seguem o paradigma orientado a objetos (pelo menos não as convencionais: java, c#, c++), portanto, não há diferença na implementação e sim no comportamento
Agregação: Se eu tiver um sistema de cadastro de times, preciso cadastras várias pessoas para agregar os times, assim, cada pessoa pode agregar um time, nenhum time, ou vários times. A pessoa é independente do time, mas agrega valor a ele. Exemplo: Time é agregado por Pessoa
Composição: É necessário que exista pelo menos um item em uma nota fiscal para que a nota fiscal exista. Exemplo: NotaFiscal é composta de ItemNotaFiscal.
Porém, os comportamentos semânticos das associações devem estar presentes quanto a existência. Para composição, por exemplo, poderíamos forçar que toda vez que uma nota seja criada, uma nova lista de ItemNotaFiscal deve ser criado. E toda vez que a nota fiscal for apagada, os itens devem ser destruídos.
A herança permite que você baseie a definição de uma nova classe a partir de uma classe previamente existente. Nela, as classes derivadas (classe filha ou sub-classe) herdam automaticamente todos os atributos, comportamentos e implementações presentes na classe geral, contudo, ainda assim, podem possuir membros a mais, tornam-se cada vez mais especializadas. Portanto, a classe mais ao topo da hierarquia é a generalização, enquanto a última classe é a mais especializada.
Sobre o 4° capítulo:
A linguagem Java possui diversos recursos para prover a interface humano-computador, todos eles podem ser localizados nas seguintes bibliotecas:
java.awt (Abstract Window Toolkit): antigo conjunto de ferramentas para interfaces gráficas do Java que pode nos servir erve para oferecer infraestrutura mínima de interface gráfica (nivela por baixo). Seus componentes têm aparência dependente de plataforma e, portanto, é limitado em recursos devido a depender de suporte de cada plataforma para os componentes oferecidos, fato que pode trazer bugs e incompatibilidades entre plataformas.
javax.swing (Swing Componets – Graphical User Interface): oferece uma interface muito mais rica, além de garantir que as telas planejadas terão a mesmo forma, aparência e comportamento independente de sistema operacional. o Swing também possui melhor tratamento dos eventos dos componentes, recursos estendidos do AWT e melhor aparência.
Independe da biblioteca utilizada, a produção das telas de interface consiste em manipular componentes visuais, que por sua vez podem ser de dois tipos:
Container: utilizados para manter, ou suportar, em posição, outros componentes visuais;
Componentes funcionais: elementos com propósitos diretos à interação com usuários, sejam para entrada ou para saída de dados.
 
Existem três maneiras básicas de organizar componentes em uma GUI (acrônimo para Graphical User Interface - interface gráfica do usuário):
Posicionamento absoluto: fornece o maior nível de controle sobre a aparência de uma GUI, pois configura o layout de um Container como null podendo especificar a posição absoluta de cada componente GUI em relação ao canto superior esquerdo do Container usando os métodos Component setSize e setLocation ou setBounds;
Gerenciadores de layout: é mais simples e mais rápido para criar uma posição GUI com posicionamento absoluto, mas acaba perdendo controle sobre tamanho e o posicionamento dos componentes GUI;
Programação visual em uma IDE: facilita o desenvolvimento em GUI, pois toda IDE tem uma ferramenta de design que permite arrastar e soltar (drag and drop) os componentes para uma área de desenho.
Cada contêiner individual pode ter apenas um gerenciador de layout, mas vários contêineres no mesmo aplicativo podem utilizar cada um gerenciador de layout. Os gerenciadores de layout são diversos, mas os principais são:
FlowLayout: aloca os componentes GUI em um contêiner da esquerda para a direita na ordem em que são adicionados no contêiner, via código. Quando a borda do contêiner é alcançada, os componentes continuarão a ser exibidos na próxima linha. A classe FlowLayout permite aos componentes GUI ser alinhados à esquerda, centralizados (padrão) e alinhados à direita.
GridLayout: divide o contêiner em uma grade de modo que os componentes podem ser colocados nas linhas e colunas. A classe GridLayout estende a classe Object e implementa a interface LayoutManager. Cada componente no GridLayout tem os mesmos tamanhos, onde podem ser inserida uma célula na parte superior esquerda da grade que prossegue da esquerda para a direita até preencher por completa.
BorderLayout: organiza os componentes, sendo a parte superior do contêiner dividida em cinco regiões: NORTH, SOUTH, EAST, WEST e CENTER. A classe BorderLayout estende a Object e implementa a interface LayoutManager2 sendo uma subinterface de LayoutManager que adiciona vários métodos para obter um processamento de layout aprimorado.
GridBagLayout: Semelhante a GridLayout, mas diferente pelo fato que podemos variar o tamanho dos componentes, trazendo um efeito de "mesclar células", além de podermos adicionar em qualquer ordem. Cada objeto do GridBagLayout mantém uma grade de células retangulares. 
Cada componente Java tem um tamanho preferencial, que normalmente é o menor tamanho necessário para apresentar o componente de maneira visualmente significativa. O Gerenciador de Layout equilibra duas considerações: a política de layout e o tamanho preferencial de cada componente; onde a prioridade é para a política de layout.
Conclusão:
Os Gerenciadores de Layout são fornecidos para organizar componentes GUI em um container para propósitos de apresentação, processando a maioria dos detalhes e fornecendo uma maneira automática de posicionar os componentes gráficos nos containers. 
Existem diversas formas de controlar o posicionamento e a aparência dos elementosque compõem a interface gráfica e a associação das possibilidade pode garantir, em diversas situações, uma melhor ergonomia e interação com o usuário.
Todos os gerenciadores de Layout implementam a interface LayoutManager ou a subinterface LayoutManager2.