Tag: PA

Programação avançada – capitulo 8

Num máquina de estados existem os seguintes conceitos:
estados (por exemplo: “sem moedas”, “com moedas”, “em manutenção”, ..),
acções (por exemplo: “insere moeda”, “retira moeda”, “roda manípulo”, “roda manipulo”,…),
tem reacções (de ignorar, ou de alterar o seu estado e executar acções (que por sua vez podem ou não gerar outras acções)).

Assim uma aplicação tem:
contexto ou entidade (entidade cujo contexto depende do seu estado),
eventos (podem acontecer acções que fazem desencadear eventos),
e estados (é a situação que é assumida aquando de eventos e traduz o resultado do comportamento da entidade).

A máquina de estados orientada a objectos
A entidade maquina de estados, tem funções que correspondem ao processamento dos eventos a que reage. O processamento dos eventos depende do estado em que a entidade se encontra. Quando se pretende que o código das funções da entidade que correspondem ao processamento de eventos não envolva instruções if ou switch dependentes do estado:

  1. define-se uma hierarquia de classes que representa os estados possíveis e contém o conhecimento acerca do processamento de eventos em cada estado (incluindo mudanças de estado)
  2. a entidade, em cada momento, tem uma referência para um objecto que representa o estado concreto em que se encontra
  3. as funções da entidade que correspondem a processamento de eventos que dependem do estado, delegam para o objecto que representa o estado corrente, o processamento dos eventos.

O contexto tem uma referência para um objecto que representa o estado (concreto) em que se encontra. Os possíveis estados concretos fazem parte de uma hierarquia que tem por base um tipo abstracto, IEstado.
O comportamento da entidade (o seu contexto) é delegado nesse objecto (estado concreto):
reacção aos eventos
acções a executar
mudanças de estado

Assim surge a entidade ou contexto, o estado e os estados concretos, e que se podem resumir da seguinte forma:
A entidade ou contexto:
define o interface necessário de acordo com as suas responsabilidades
mantém um membro que representa o estado concreto em que se encontra
tem uma referencia para o IEstado (tipo da base da hierarquia que representa os estados possíveis) que refere o objecto que representa o estado concreto em que se encontra
tem métodos que representam o processamento de eventos. A entidade delega o processamento de eventos (que pode variar conforme o seu estado) no objecto que representa o estado corrente

O estado (IEstado):
define o interface para encapsular o comportamento da entidade que pode variar conforme o seu estado concreto

Os Estados concretos, que são classes derivadas da classe EstadoAdapter (que implementa o interface IEstado):
cada classe derivada, representando um estado concreto, implementa o comportamento que lhe e associado.

Tags : , , ,

Programação avançada – capitulo 7

A classe Object:
esta é a classe das quais todas as outras classes derivam
tem métodos importantes:
public String toString()
que retorna uma string que descreve um objeto

public boolean equals(Objecto obj)
tem com objectivo fazer a comparação entre dois objectos, em termos de conteudos, sabendo que usando o == compara referências
e é necessário que ele esteja definido

package e23;

class Animal{
    private int peso;
    private String nome;

    Animal(int p, String s){
        this.peso = p;
        this.nome = s;
    }
    
    public boolean equals(Object ob){
        if(this == ob){
            return true;
        }
        if((ob == null) || (ob.getClass() != this.getClass())){
            return false;
        }
        
        // type casting of the argument
        Animal anim = (Animal)ob;
    
        return (this.peso == anim.peso && this.nome == anim.nome);
    }

}

public class e23 {

    public static void main(String args[]) {
        Animal a1 = new Animal(80, "pedro");
        Animal a2 = new Animal(55, "maria");
        Animal a3 = new Animal(80, "pedro");
        
        if(a1.equals(a3)){
            System.out.println("O método equals");
        }else{
            System.out.println("Não são iguais");
        }
    }
}

public int hashCode()
quando se define o método equals também se deve definir o método hashCode()
este método retorna um inteiro, que resulta da conversão do endereço interno do objecto

package e23;

import java.util.Objects;

class Animal {

    private int peso;
    private String nome;

    Animal(int p, String s) {
        this.peso = p;
        this.nome = s;
    }

    public boolean equals(Object ob) {
        if (this == ob) {
            return true;
        }
        if ((ob == null) || (ob.getClass() != this.getClass())) {
            return false;
        }

        // type casting of the argument
        Animal anim = (Animal) ob;

        return (this.peso == anim.peso && this.nome == anim.nome);
    }

    @Override
    public int hashCode() {
        int hash = 5;
        hash = 17 * hash + this.peso;
        hash = 17 * hash + Objects.hashCode(this.nome);
        return hash;
    }
}

public class e23 {

    public static void main(String args[]) {
        Animal a1 = new Animal(80, "pedro");
        Animal a2 = new Animal(55, "maria");
        Animal a3 = new Animal(80, "pedro");

        if (a1.equals(a3)) {
            System.out.println("O método equals");
        } else {
            System.out.println("Não são iguais");
        }
    }
}

Este método como outros podem ser inseridos de forma automática no netbeans, se dentro da classe e com o lado direito do reato se optar por inserir código (ALT+INSERT)

+infos(geeksforgeeks.org): LINK gostei da explicação

Tags : , , ,

Programação avançada – capitulo 6

O upcasting:
serve para realizar a conversão de tipo, de uma classe derivada para uma classe base
permite assim converter um tipo mais restrito num tipo mais alargado

O polimorfismo:
“O mecanismo de polimorfismo consiste na qualidade de poder decidir a operação que vai ser executada num dado instante , em função dos objetos específicos envolvidos na operação”

As classes abstractas:
um método é abstracto, se o seu prototípico for escrito precedido da palavra abstract
uma classe que tenha um método abstracto tem que ser declarada como abstracta
não se podem criar objectos em classes abstractas
uma classe pode ser abstracta, mesmo não tendo qualquer método abstracto (caso de uma classe derivada de uma abstracta)
uma classe derivada não é abstracta se tiver definidos todos os métodos da classe abstracta
uma classe derivada é abstracta se não tiver pelo menos um método da classe base

exemplo (especialização: do topo para a base, generalização: da base para o topo (sentido das setas)):

package e16;

abstract class Veiculo {
    abstract int calculaCarro();
    abstract int calculaAutocarro();
}

//errada esta classe Carro.. se é abstracta só deveria ter protótipos das funções
abstract class Carro extends Veiculo {
    private int km;
    private int custo = 5;

    public Carro(int k) {
        this.km = k;
    }
    int calculaCarro() {
        int valor = this.km * custo;
        return valor;
    }
    public String toString() {
        return "despesa do carro: " + calculaCarro();
    }
}

class Autocarro extends Veiculo {
    private int km;
    private int custo = 4;

    public Autocarro() { //importante - parte1
    }
    public Autocarro(int k) {
        this.km = k;
    }
    int calculaAutocarro() {
        int valor = this.km * custo;
        return valor;
    }
    int calculaCarro() {
        int valor = this.km * custo;
        return valor;
    }
    public String toString() {
        return "despesa do autocarro: " + calculaAutocarro();
    }
}

class MiniAutocarro extends Autocarro {
    private int km;
    private int custo = 1;

    public MiniAutocarro() { //importante - parte2
    }
    public MiniAutocarro(int k) {
        this.km = k;
    }
    int calculaMiniAutocarro() {
        int valor = this.km * custo;
        return valor;
    }
    public String toString() {
        return "despesa do mini-autocarro: " + calculaMiniAutocarro() + " , " + super.toString();
    }
}

public class e16 {

    public static void main(String args[]) {
        System.out.println("\n Classe abstracta:"); //sout+tab
        Veiculo v1;
        v1 = new Autocarro(100);
        System.out.println(v1.toString());
        Veiculo v2;
        v2 = new MiniAutocarro(200);
        System.out.println(v2.toString());
    }
}

As interfaces:
é outra forma de trabalhar com classes abstractas
a interface pode conter: constantes, ou métodos
para definir uma classe que tem um ou mais interfaces, faz-se uso da expressão implements
os membros variáveis são implicitamente: public, final ou static (e é redundante usar estas expressões)
os métodos são public (e é redundante indicar)
uma classe só deriva de outra classe, e pode ter vários interfaces
várias classes podem implementar um interface

package e17;

interface Livro {
    void oLivro(int paginas);
}

interface Comic {
    void acerca(int paginas);
}

class Policial implements Livro {
    public void oLivro(int p) {
        System.out.println("\nChamada com " + p + " no Policial");
    }
    void maisInformacao() {
        System.out.println("\nOutras informacações no Policial");
    }
}

class Marvel extends Policial implements Comic{
    public void acerca(int p){
        System.out.println("\nOutras informacações na Marvel: " +p);
    }
}

public class e17 {
    public static void main(String args[]) {
        Marvel v = new Marvel();
        v.acerca(2);
        v.maisInformacao();
        
        Policial p = new Policial();
        p.oLivro(10);
        p.maisInformacao();
    }
}

Podem existir referências para um interface, é usado o mecanismo de polimorfismo, e nele podem ser referidos objetos de uma classe que o implementem, e faz uso apenas dos métodos da classe declarados na interface
se uma classe for interface, e não forem definidos todos os métodos que são abstractos, essa classe passa a ser abstracta

package e18;

interface Jogos {
    void precoJogos(int preco);
    void qualidadeJogos(int qualidade);
}

class jogoTabuleiro implements Jogos {
    public void precoJogos(int p) {
        System.out.print("\njogo de tabueliro" + p);
    }
    public void qualidadeJogos(int q) {
        System.out.print("\njogo de tabueliro" + q);
    }
}

abstract class jogoDigital implements Jogos {
    void oJogoDigital(int j) {
        System.out.print("\njogo de tabueliro" + j);
    }
}

class jogoDigitialOficial extends jogoDigital {

    public void oJogoDigital() {
        System.out.print("\njogo digital");
    }

    public void precoJogos(int preco) {
    }; //obrgatorio
    public void qualidadeJogos(int qualidade) {
    } //obrgatorio
}

public class e18 {
    public static void main(String args[]) {
        jogoDigitialOficial jd = new jogoDigitialOficial();
        jd.oJogoDigital();
    }
}

Nas interfaces podem surgir os métodos default
O default define uma implementação por omissão desse métodos, para todas as classes que implementam o interface e que não definam a sua própria implementação
Um método defualt não pode ser abstract nem static

package e19;

interface jogosDigitais {

    void contaJogadores(int n);

    default void precoAtual(int preco) {
        int conta = preco * 2;
        contaJogadores(conta); //pode fazer uso de outros métodos da interface
    }
}

class RTS implements jogosDigitais {

    private int jogadores;

    public void contaJogadores(int ct) {
        this.jogadores = ct;
    }
    
    //redefinição do métdo default
    public void precoAtual(int p){
        contaJogadores(10);
    }
    

    public String toString() {
        return "resultado " + jogadores;
    }
}

public class e19 {
    public static void main(String args[]) {
        jogosDigitais jd1 = new RTS();
        jd1.precoAtual(4);
        System.out.print(jd1);
        jd1.toString(); //nao entendo porque este método não é reproduzido
    }
}

Nas interfaces podem surgir os métodos static
um método static numa interface tem que definir uma implementação
não existe overide nas classes que implementam uma interface com métodos static
o static pode ser usado na interface, para incluir métodos utilitários

package e20;

interface Quadro {

    void ilustrar(int il);

    static void calculo(int valor) {
        valor = valor * 1;
    }
}

class corRGB implements Quadro {

    private int corRGB = 123;

    corRGB() {
        this.corRGB = corRGB;
    }

    public void ilustrar(int i) {
        this.corRGB = i * i * i;
    }

    public String toString() {
        return "do quadro surge " + corRGB;
    }
}

public class e20 {

    public static void main(String args[]) {
        Quadro q1 = new corRGB();
        q1.ilustrar(20);
        System.out.print(q1);
    }
}

Nas interfaces podem surgir constantes que são utilizadas, como utilitárias nas classes derivadas

package e21;

interface valores {
    int EURO = 2;
    int DOLAR = 1;
}

class banco implements valores {

    private int contas;

    banco() {
        this.contas = EURO + DOLAR;
    }
    public String toString() {
        return "das contas surge " + contas;
    }
}

public class e21 {

    public static void main(String args[]) {
        banco b1 = new banco();
        System.out.print(b1);
        b1.toString(); // não é executada e não compreendo do porquê!
    }
}

E também uma interface pode derivar de outras interfaces:
a interface derivada que tenha constantes com o mesmo nome da interface herdada, a que é herdade não é “escondida”
a interface derivada herda todos os métodos abstract e default
a interface derivada não herda os métodos que forem static

package e22;

interface Mae {

    int valor = 10;
    int total = -10;

    static int fala() {
        return valor * 2;
    }

    default int comida() {
        return valor * 3;
    }

    abstract int correr();
}

interface Pai {

    int valor = 20;
    int total = -20;

    static int fala() {
        return valor * 2;
    }

    default int comida() {
        return valor * 3;
    }

    abstract int correr();
}

interface Filha extends Pai, Mae {

    int comida();
}

class Neto implements Filha {

    public int comida() {
        return Mae.valor + Pai.total;
    }

    public int correr() {
        return Mae.total + Pai.valor;
    }
}

public class e22 {

    public static void main(String args[]) {
        Filha f1 = new Neto();
        System.out.println("estatico " + f1.correr()); //20
        System.out.println("estatico " + f1.comida());//-10

    }
}

Como sempre gostei de gráficos aqui fica:

+infos(fonte dos gráficos): LINK

Tags : , , ,

Programação avançada – capitulo 5

A composição e a herança:
por composição: quando temos uma classe cujos membros são referências para objetos de outras classes
por herança: quando se cria uma classe que seja de um tipo de uma classes que já existe (uma especialização). Quando não existe uma derivação vamos estar a criar uma classe derivada da class Object, sendo que esta classe é a classe base de uma hierarquia a que todas as classes em Java pertencem
Na herança, isto é na classe derivada, para se fazer uso de métodos da classe base temos que usar a expressão super (caso tenham o mesmo nome)

Um exemplo de composição:

package e13;

class Pagina {

    private int numero;
    private int quantidadePalavras;

    public Pagina() {
        this(1, 100);
    }

    public Pagina(int n, int qp) {
        numero = n;
        quantidadePalavras = qp;
    }

    @Override
    public String toString() {
        return "\n Pagina " + " numero " + numero + " quantidade paginas " + quantidadePalavras;

    }
}

class Livro {

    private boolean capa;
    private Pagina pagina;

    public Livro() {
        this(false, 2, 200);
    }

    public Livro(boolean c, int n, int qp) {
        capa = c;
        pagina = new Pagina(n, qp);
    }

    @Override
    public String toString() {
        return "\ncapa " + capa + " pagina livro " + pagina;
    }
}

public class e13 {

    public static void main(String args[]) {
        System.out.println("\n A composição de classes:");
        Livro l1 = new Livro();
        System.out.println("\n surge:" + l1);
        Livro l2 = new Livro(true, 3, 300);
        System.out.println("\n surge:" + l2);
    }
}

Um exemplo de Herança:

package e13;

class Pagina {

    private int numero;
    private int quantidadePalavras;

    public Pagina() {
        this(1, 100);
    }

    public Pagina(int n, int qp) {
        numero = n;
        quantidadePalavras = qp;
    }

    protected void setNumeroPagina(int p) {
        numero = p;
    }

    protected int getNumeroPagina() {
        return numero;
    }

    protected void setQuantidadePalavras(int qp) {
        quantidadePalavras = qp;
    }

    protected int getQuantidadePalavras() {
        return quantidadePalavras;
    }

    @Override
    public String toString() {
        return "\n Pagina " + " numero " + numero + " quantidade paginas " + quantidadePalavras;
    }
}

class PaginaComCores extends Pagina {

    private boolean cor;

    public PaginaComCores() {
        this(false);
    }

    public PaginaComCores(boolean c) {
        cor = c;
    }

    protected void setCor(boolean c) {
        cor = c;
    }

    protected boolean getCor() {
        return cor;
    }

    @Override
    public String toString() {
        return "\n PaginaComCores " + super.toString() + ", cor " + cor;
    }
}

public class e13 {

    public static void main(String args[]) {
        System.out.println("\n A herança de classes:");
        Pagina p1 = new Pagina();
        System.out.println(p1);
        PaginaComCores p2 = new PaginaComCores(true);
        System.out.println(p2);
    }
}

Escolher entre composição e derivação:
se um objecto contem objectos de outra classe – composição ( …”contém” …)
se um objecto é especializado de outra classes – derivação/herança ( … “é” …)

O uso de constantes de classe, pode se aplicado através do modificador final
O final associado a uma variável, torna a variável constante
O final associado a uma referência, torna a referência constante
O final associado a um método, impede que uma derivada possa redefinir esse método
O final associado a uma classe, impede que essa classe seja derivada

package e14;

class Pagina {

    private int numero0 = 0;
    private final int numero1 = 1;
    static final int numero2 = 2;
    public static final int numero3= 3;

    
    void setnumero0(int n0){
        numero0=n0;
    }
    
    int getNumero0(){
       return numero0; 
    }
    
    public Pagina() {
        
    }
 
    @Override
    public String toString() {
        return "\n Pagina " + " numero " + numero1 + " - " + numero2  + " - " + numero3;
    }
}


public class e14 {

    public static void main(String args[]) {
        System.out.println("\n O uso da expressão final:");
        Pagina p1 = new Pagina();
        p1.setnumero0(9);
        System.out.println(p1.getNumero0());
      
    }
}

Exemplo de erro aplicado a uma classe e construção de uma derivada

//v1
package e14;

final class Pagina {

    private int numero0 = 0;
    private final int numero1 = 1;
    static final int numero2 = 2;
    public static final int numero3= 3;

    
    void setnumero0(int n0){
        numero0=n0;
    }
    
    int getNumero0(){
       return numero0; 
    }
    
    public Pagina() {
        
    }
 
    @Override
    public String toString() {
        return "\n Pagina " + " numero " + numero1 + " - " + numero2  + " - " + numero3;
    }
}

class PaginaACores extends Pagina{
    boolean cores;
    
    PaginaACores(){
    
    }
    
}

public class e14 {

    public static void main(String args[]) {
        System.out.println("\n O uso da expressão final em classes:");

      
    }
}
Tags : , , , , , , , , ,

Programação avançada – capitulo 4

Um package é um agrupamento de classes com algum significado em comum.
Num ficheiro de código fonte pode existir uma classe publica que deve ter o mesmo nome do ficheiro, sendo que só pode haver uma única classe publica em cada ficheiro de código fonte
Os package podem ter outros package por referência, isto é, podemos ter uma estrutura de um package declarado do tipo package pkg1.pkg2.kg3; e que está gravado pkg1\pkg2\pkg3
A instrução import permite identificar classes pertencentes a outros packages sem ser necessário indicar o caminho até ao interior do package

As classes só podem ter um de dois níveis de acesso:
publico
ou por defeito (sem especificador)

Podemos aceder aos membros das classes com a seguinte organização (private, sem especificador, protected, public):

A organização em packages permite:
evitar situações de problemas onde existem classes com o mesmo nome, mas com significados diferentes
proporcionar segurança nos diferentes níveis de visibilidade

 

 

Tags : , , , ,

Programação avançada – capitulo 3

Objetos
A palavra new permite criar novos objetos
Os delimitadores dos { } permitem define o scope dos objetos

Em java existe o Garbage collector, que detecta todos os objetos que foram criados por new e que já não são referenciados em memória, libertanto desta forma o espaço em memória correspondente (esta dinâmica não existe noutras linguagens como em C, ou o destrutor em C++)

Um classe é constituída por:
membros variáveis (do tipo primitivos ou referências para objetos) Para se usar os membros de um determinado objeto faz-se uso do . (ponto final)
por métodos (podem existir métodos com o mesmo nome na mesma classe, são os métodos overloaded )
por um ou mais construtores (é a forma de garantir a inicialização de todos os objetos de uma classe, e o construtor não pode ser chamado por um seu método)

package e08;

class Texto{
    String palavras;
    int numero_paginas;
    
    Texto(){
        palavras = "vazio";
        numero_paginas = 0;
    }
    
    Texto(String p, int n_p){
        palavras = p;
        numero_paginas = n_p;
    }
    
    boolean valida(int n_p){
        if(n_p <=0){
            return false;
        }
        return true;
    }
}

public class e08 {

    public static void main(String args[]) {
        System.out.println("\n O uso de classes");
        Texto t1 = new Texto();
        System.out.println("\n construtor por defeito: " + t1.numero_paginas + " - " + t1.palavras);
        Texto t2 = new Texto("pedro", 100);
        System.out.println("\n construtor overloaded: " + t2.numero_paginas + " - " + t2.palavras);
        
    }
}

A palavra chave this:
Permite aceder a uma variável ou a um método do próprio objeto
o this também pode ser usado dentro de um construtor, o this faz uma chamada explicita ao construtor (com ou sem argumentos)
um construtor pode então desta forma ser chamado a partir de outro construtor

package e09;

class Texto{
    String palavras;
    int numero_paginas;
    
    Texto(){
        this("vazio", 100);
    }
    
    Texto(String p, int n_p){
        palavras = p;
        numero_paginas = n_p;
    }
    
    boolean valida(int n_p){
        if(n_p <=0){
            return false;
        }
        return true;
    }
}

public class e09 {

    public static void main(String args[]) {
        System.out.println("\n O uso da referência especial this");
        Texto t1 = new Texto();
        System.out.println("\n construtor por defeito: " + t1.numero_paginas + " - " + t1.palavras + " - " + t1.valida(t1.numero_paginas));
    }
}

São membros static:
Aquelas variáveis ou os membros que não estão ligados a qualquer objeto em particular
Só existe uma versão de um membro variável estático, partilhada por todos os objetos
Antes de se criar um objeto, podemos executar o método static ou aceder a qualquer variável static
Os métodos static, não têm a referência a this
Não se pode aceder directamente a variáveis ou métodos não estáticos (pois eles estão sempre ligados a um objeto em particular, e assim só se pode aceder a membros não estáticos se for invocado a partir de um objeto)

package e10;

class Texto {

    String palavras;
    static int numero_paginas = -1;

    Texto() {
        this("vazio", 100);
    }

    Texto(String p, int n_p) {
        palavras = p;
        numero_paginas = n_p;
    }

    static boolean valida(int n_p) {
        if (n_p <= 0) {
            return false;
        }
        return true;
    }
}

public class e10 {

    public static void main(String args[]) {
        System.out.println("\n membros static");
        System.out.println("\n aceder ao métodos antes do objeto: " + Texto.valida(100));
        Texto t1 = new Texto();
        System.out.println("\n aceder ao métodos depois do objeto: " + t1.valida(Texto.numero_paginas));
    }
}

A inicialização
Os membros variáveis das classes se forem usados sem estarem inicializados vão dar erro
É preferível inicializar essas variáveis ou então fazê-lo no construtor, com valores pode defeito
Se forem membros estáticos, eles são inicializados apenas uma vez, quando a classe for usada pela primeira vez
Nos objetos:
são inicializados os membros variáveis e depois o construtor

package e11;

class Texto {

    String palavras;
    int numero_paginas = -1;

    Texto() {
        palavras = "vazio original";
        System.out.println("\n construtor do texto: " + palavras);
    }

    Texto(String p, int n_p) {
        palavras = p;
        numero_paginas = n_p;
        System.out.println("\n segundo construtor do texto: " + palavras);
    }

    static boolean valida(int n_p) {
        if (n_p <= 0) {
            return false;
        }
        return true;
    }
}

class Livro {
    Texto t1 = new Texto("no livro", 100);

    Livro() {
        System.out.println("\n construtor do Livro: " + t1.palavras);
    }
    
    void mostra(){
        System.out.println("\n mostra do Livro");
    }
    static Texto t2 = new Texto("static no livro", 100); //primeiro a ser executado
}

public class e11 {

    public static void main(String args[]) {
        System.out.println("\n inicialização:");
        Livro l1 = new Livro();
        System.out.println("\n no main:" + l1.t1.palavras);
        l1.mostra();

    }
}

Tags : , , , , , , , , , , , , ,

Programação avançada – capitulo 2

Acerca dos tipos primitivos:
foi removida a noção de unsigned

O Java faz uso do unicode

Existe o Boxing e o Unboxing em Java, sendo que um exemplo de Boxing é o da substituição automaticamente por um objeto da classe wrapper correspondente, isto é:

public class e01 {
    public static void main(String args[]){
            System.out.println("\n Primeiro exemplo de Java");
            Integer a = 100;
            Integer a2 = new Integer(101);
            int b = 200;
            System.out.println(a + " - " + b + " - " + a2);
            
        }
}

Os arrays de tipos primitivos:
podem conter tipos primitivos
ou
referências para objetos

Existem duas formas de os representar:
int [] agora;
ou
int ontem[];

public class e02 {
    public static void main(String args[]){
            System.out.println("\n Os arrays em Java");
            int [] antes = new int[12]; //para criar: reservar espaço em memória
            int depois [] = {1,2,3,4,5,6,7,8,9}; //array reservado em memória dinamicamente, atribuição de arrays
            
            antes[0] = 0;
            
            System.out.println("\n Aceder a um elemento do array: " + antes[0]);
            System.out.println("\n Aceder a um elemento do array: " + depois[1]);
            
            System.out.println("\n Aceder ao total de elementos do array: " + antes.length);
            System.out.println("\n Aceder ao total de elementos do array: " + depois.length);
            
            //copiar arrays
            int [] copy = {0,1,3};
            int [] paste = new int[3]; //tem que ter o tamanho do copy
            System.arraycopy(copy, 0, paste, 0, copy.length);
            
            System.out.println("\n Aceder ao total de elementos do array depois de copiado: " + paste[1]);
        }
}

Os arrays como argumentos de métodos

public class e03 {
    static boolean arraysiguais(int []c, int []p){
        if(c.length != p.length){
            return false;
        }
        for(int i=0; i < c.length; i++){
            if(c[i] != p[i]){
                return false;
            }
        }
    return true;
    }
    
    public static void main(String args[]){
            System.out.println("\n Os arrays em Java: arrays como argumentos de métodos");
            int [] copy ={100,200,300};
            int [] paste = new int [3];
            
            //preencher cada um dos arrays
            for(int i=0; i< copy.length ;i++){
                copy[i]=i*i;
            }
            for(int i=0; i< paste.length ;i++){
                paste[i]=i*i*i;
            }
            
            if(arraysiguais(copy, paste)){
                System.out.println("\n Iguais");
            }else{
                System.out.println("\n Diferentes");
            }
        }
}

Os arrays como retorno de métodos:

public class e04 {

    static int[] arrayRetorno(int []a, int b[]){
        int extra[]= new int[Math.min(a.length, b.length)];
        
        for(int i=0; i< extra.length; i++){
            extra[i]=a[i]*b[i];
        }
     return extra;   
    }
    
    public static void main(String args[]){
            System.out.println("\n Os arrays em Java: arrays retorno de métodos");
            int arg1[] = {1,2,3};
            int arg2[] = {3,2,1};
            int argC[];
            
            argC = arrayRetorno(arg1, arg2);
            
            for(int i = 0; i< argC.length; i++){
                System.out.println("\n infos: " + argC[i]);
                
            }
        }
}

Os arrays multidmensionais:

public class e05 {
    static int[][] preenche(int a[][]){
        int aux[][]=new int[a.length][a[0].length];
        
        if(a.length ==0 || a[0].length==0){
            return null;
        }
        
        for(int i=0; i< a.length; i++){ //numero de linhas
            for(int j=0; j< a[i].length; j++){ //numero de colunas
                aux[i][j]=(i+1)*(j+1);
            }
        }
        return aux;
    }
    static void mostra(int a[][]){
        System.out.println("\n numero de linhas:" + a.length);
        System.out.println("\n numero de colunas:" + a[0].length);
        for(int i=0; i< a.length; i++){ //numero de linhas
            for(int j=0; j< a[i].length; j++){
                System.out.println(a[i][j]);
            }
            System.out.println("\n");
        }
    }
    public static void main(String args[]){
            System.out.println("\n Os arrays em Java: arrays multidimensionais");
            
            int multi[][] = new int[2][3];
            multi=preenche(multi);
            mostra(multi);
        }
}

Os operadores podem ser aplicados a todos os tipos de primitivos (int, float,…) contudo existem operadores que se podem aplicar a objetcos (referências para, cópia da referência) e que são:
=
==
!=
outros operadores que também funcionam com a classe String:
+
+=

Exemplo da passagem de um objecto por referência:

class Texto {
    String txt = "ola Java";
}

public class e06 {
    static void funcao(Texto t) {
        t.txt = "Dentro";
    }
    public static void main(String args[]) {
        System.out.println("\n Passagem de objetos a funções");
        Texto txt1 = new Texto();
        txt1.txt = "Ola Mundo";
        System.out.println("\n primeira versão: " + txt1.txt);
        funcao(txt1);
        System.out.println("\n segunda versão: " + txt1.txt);
    }
}

Exemplo do uso do operador equals:

class Texto {
    String txt = "ola Java";
}

public class e06 {
    static void funcao(Texto t) {
        t.txt = "Dentro";
    }
    public static void main(String args[]) {
        System.out.println("\n Passagem de objetos a funções");
        Texto txt1 = new Texto();
        Texto txt2 = new Texto();
        txt1.txt = "Ola Mundo";
        
        System.out.println("\n primeira versão: " + txt1.txt);
        funcao(txt1);
        System.out.println("\n segunda versão: " + txt1.txt);
        
        //operador equals
        txt2.txt = "Ola Mundo!!!";
        System.out.println("\n comparação: " + txt1.txt.equals(txt2.txt));
    }
}

O método equals não poderia ser usado com o objecto txt1 e txt2, porque ele não estava redefinido dentro da classe Texto.

Existem também o operador cast, e que é utilizado para:
conversões de tipos de maior para tipos de menor capacidade
ou outro casos em que não seriam feitas conversões implícitas

public class e07 {
    public static void main(String args[]) {
        System.out.println("\n Conversões de tipo");
        System.out.println("\n uma conversão implicita");
        int a = 100;
        float b;
        b = a;
        System.out.println("\n a: " + a + "\t b: " + b);
        
        System.out.println("\n uma conversão explicita (cast)");
        float d = 200;
        int e;
        e= (int)d;
        System.out.println("\n d: " + d + "\t e: " + e);
    }
}

Para testar um determinado tipo de objeto podemos fazer uso do instanceof

class Testar{
    char t= 'p';
}

public class e07 {

    public static void main(String args[]) {
        System.out.println("\n Testar o tipo de objeto");
        Testar t = new Testar();
        System.out.println(t instanceof Testar);
    }
}

Existe aqui também uma variante do ciclo for, que é o foreach, e que pode ser utilizado com arrays e coleções

public class e07 {

    public static void main(String args[]) {
        System.out.println("\n O ciclo for(each)");
        int i[]={0,1,2,3,4,5,6,7,8,9};
        for(int aux: i){
            System.out.println(i[aux]);
        }
    }
}

por vezes é importante fazer uso das instruções continue e break, sendo que quando o break é executado dentro de um ciclo, o ciclo termina e a execução continua na instrução a seguir
já o uso do continue, dentro de um ciclo while ou do while, termina a iteração corrente, continuando o ciclo a ser executado na iteração seguinte.
o uso do continue, dentro de um ciclo for, provoca a passagem ao incremento do ciclo e em seguida à avaliação da expressão condicional.
podem ser usados label com o caso do “:” (sem aspas) que serve para identificar ciclos do tipo: for, while ou do while

public class e07 {

    public static void main(String args[]) {
        System.out.println("\n a intrução do break e do continue");
        int i[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        System.out.println("\n primeira estrutura");
        primeiro:
        for (int aux : i) {
            if (aux > 5) {
                break primeiro; //ou break;
            }
            System.out.println(i[aux]);
        }
        System.out.println("\n segunda estrutura");
        segundo:
        for (int aux2 : i) {
            if (aux2 > 5) {
                System.out.println(i[aux2]);
            }
            if (aux2 == 8) {
                System.out.println("\n na segunda estrutura");
                continue segundo;
            }
        }
    }
}
Tags : , , , , , , , ,

Programação avançada – capitulo 1

Referências bibliográficas:

Introduction to Programming Using Java, Eighth Edition (http://math.hws.edu/javanotes/)


Java™ How to Program, 11/e (referência LINK)


Java: An Introduction to Problem Solving and Programming (8th edition) (referência LINK)

Por onde começar?
instalar o programa netbeans: https://netbeans.org/ a versão mais recente

public class e01 {
    public static void main(String args[]){
            System.out.println("\n Primeiro exemplo de Java");
        }
}

observações:
existe uma classe de nome e01
as aplicações Java iniciam a execução com a chamada ao método main()
public para se aceder ao main a partir de um contexto exterior
static, para que o método main seja chamado antes de existir algum objecto da classe
String args[], para aceder a argumentos a partir da linha de comandos
println() é o método invocado por System.out

Tags : , , ,