Classes Internas (Java)/Gatos Iteráveis - Revision history

Root: Redirected page to ist:Classes Internas (Java)/Gatos Iteráveis

2018-11-07T14:14:03Z

Redirected page to ist:Classes Internas (Java)/Gatos Iteráveis

Root: /* Classes de partes de gato: CatPart e especializações */

2013-10-21T23:03:26Z

Classes de partes de gato: CatPart e especializações

@@ Line 433: / Line 433: @@
+}
 </java5>
 == Leitura adicional ==

Root: /* Classe do conceito gato: Cat */

2013-10-21T22:56:05Z

Classe do conceito gato: Cat

← Older revision		Revision as of 22:56, 21 October 2013
Line 381:		Line 381:

	Note-se que é mantida a proporção (e.g., a probabilidade de produzir uma pate é 4 vezes superior à de produzir uma cauda).		Note-se que é mantida a proporção (e.g., a probabilidade de produzir uma pate é 4 vezes superior à de produzir uma cauda).

			=== Classes de partes de gato: CatPart e especializações ===

			A classe '''CatPart''' é uma classe mantém a simplicidade anterior. É ainda mais simples que no casos anteriores, de facto, já que não mantém informação sobre o número da parte. O único método definido é '''toString''', para ser utilizado pelas subclasses.

			<java5>
			public class CatPart {
			public String toString() { return "PART "; }
			}
			</java5>

			A classe '''Belly''' representa uma barriga de gato:
			<java5>
			public class Belly extends CatPart {
			public String toString() { return super.toString() + ": Belly"; }
			}
			</java5>

			A classe '''Ear''' representa uma orelha de gato:
			<java5>
			public class Ear extends CatPart {
			public String toString() { return super.toString() + ": Ear"; }
			}
			</java5>

			A classe '''Head''' representa uma cabeça de gato:
			<java5>
			public class Head extends CatPart {
			public String toString() { return super.toString() + ": Head"; }
			}
			</java5>

			A classe '''Nose''' representa um nariz de gato:
			<java5>
			public class Nose extends CatPart {
			public String toString() { return super.toString() + ": Nose"; }
			}
			</java5>

			A classe '''Paw''' representa uma pata de gato:
			<java5>
			public class Paw extends CatPart {
			public String toString() { return super.toString() + ": Paw"; }
			}
			</java5>

			A classe '''Tail''' representa uma cauda de gato:
			<java5>
			public class Tail extends CatPart {
			public String toString() { return super.toString() + ": Tail"; }
			}
			</java5>

	== Leitura adicional ==		== Leitura adicional ==

Root: /* Caso 6: usando classes anónimas e polimorfismo */

2013-10-21T22:47:59Z

Caso 6: usando classes anónimas e polimorfismo

← Older revision		Revision as of 22:47, 21 October 2013
Line 325:		Line 325:

	== Caso 6: usando classes anónimas e polimorfismo ==		== Caso 6: usando classes anónimas e polimorfismo ==

			Neste caso, muito semelhante ao caso 5 (em termos de definição de classes internas), especializou-se a classe '''CatPart''', por forma a tirar partido do polimorfismo e criar um gato com partes distintas e identificáveis.

			=== Classe do conceito gato: Cat ===

			Esta classe é como definida no caso 5, mas tem um construtor que inicializa aleatoriamente as partes do gato.

			<java5>
			import java.util.List;
			import java.util.ArrayList;
			import java.util.Iterator;
			public class Cat implements Iterable<CatPart> {
			private List<CatPart> _parts = new ArrayList<CatPart>();

			public Cat(int nparts) {
			int lim = nparts + 1;
			for (int i = 0; i < lim; i++) {
			switch ((int)(lim*Math.random())) {
			case 0: _parts.add(new Head()); break;
			case 1: _parts.add(new Paw()); break;
			case 2: _parts.add(new Ear()); break;
			case 3: _parts.add(new Belly()); break;
			case 4: _parts.add(new Tail()); break;
			case 5: _parts.add(new Paw()); break;
			case 6: _parts.add(new Paw()); break;
			case 7: _parts.add(new Paw()); break;
			case 8: _parts.add(new Ear()); break;
			case 9: _parts.add(new Nose()); break;
			default: _parts.add(new CatPart());
			}
			}
			}

			public Iterator<CatPart> iterator() {
			return new Iterator<CatPart>() {
			int _index = 0;
			public boolean hasNext() { return _index < _parts.size(); }
			public CatPart next() { return _parts.get(_index++); }
			public void remove() { throw new UnsupportedOperationException(); }
			};
			}

			public Iterator<CatPart> iterator(final int start) {
			return new Iterator<CatPart>() {
			int _index = start;
			/* ANONYMOUS() */ { System.out.println("Iterating from: " + _index); }
			public boolean hasNext() { return _index < _parts.size(); }
			public CatPart next() { return _parts.get(_index++); }
			public void remove() { throw new UnsupportedOperationException(); }
			};
			}

			}
			</java5>

			Note-se que é mantida a proporção (e.g., a probabilidade de produzir uma pate é 4 vezes superior à de produzir uma cauda).

	== Leitura adicional ==		== Leitura adicional ==

Root: /* Caso 5: usando classe anónima */

2013-10-21T22:08:06Z

Caso 5: usando classe anónima

← Older revision		Revision as of 22:08, 21 October 2013
Line 233:		Line 233:
	A execução é exactamente como nos casos anteriores.		A execução é exactamente como nos casos anteriores.

	== Caso 5: usando ~~classe anónima~~ ==		== Caso 5: usando classes anónimas ==

	Nos casos 3 e 4 utilizou-se uma classe interna para implementar a interface '''java.util.Iterator<T>'''. Dessa forma, consegui-se esconder a implementação desta interface para a classe gato. No entanto, tanto num caso, como no outro, a classe interna foi apenas utilizada uma vez, pelo que é ainda possível melhorar o aspecto da sua definição.		Nos casos 3 e 4 utilizou-se uma classe interna para implementar a interface '''java.util.Iterator<T>'''. Dessa forma, consegui-se esconder a implementação desta interface para a classe gato. No entanto, tanto num caso, como no outro, a classe interna foi apenas utilizada uma vez, pelo que é ainda possível melhorar o aspecto da sua definição.

Root: /* Caso 5: usando classe anónima */

2013-10-21T22:07:47Z

Caso 5: usando classe anónima

← Older revision		Revision as of 22:07, 21 October 2013
Line 234:		Line 234:

	== Caso 5: usando classe anónima ==		== Caso 5: usando classe anónima ==

			Nos casos 3 e 4 utilizou-se uma classe interna para implementar a interface '''java.util.Iterator<T>'''. Dessa forma, consegui-se esconder a implementação desta interface para a classe gato. No entanto, tanto num caso, como no outro, a classe interna foi apenas utilizada uma vez, pelo que é ainda possível melhorar o aspecto da sua definição.

			Assim, usam-se classes internas, cada um associada a uma utilização específica: o primeiro caso é como anteriormente; o segundo caso permite iterar a partir de uma dada posição.

			Além da classe gato e da aplicação exemplo, todas as classes são como anteriormente.

			=== Classe do conceito gato: Cat ===

			Neste caso, poupa-se a definição de um nome especial para a classe do iterador e, considerando que a classe interna não é reutilizada, define-se uma implementação anónima, utilizada apenas para a criação da única instância associada a esta classe. A sintaxe para este código é a indicada abaixo: o corpo da classe aparece logo a seguir à indicação de criação (este processo pode ser aplicado a qualquer classe ou interface que se queixa especializar ou implementar através de uma classe anónima).

			<java5>
			import java.util.List;
			import java.util.ArrayList;
			import java.util.Iterator;
			public class Cat implements Iterable<CatPart> {
			private List<CatPart> _parts = new ArrayList<CatPart>();

			public Cat(int nparts) {
			for (int i = 0; i < nparts; i++)
			_parts.add(new CatPart(i));
			}

			public Iterator<CatPart> iterator() {
			return new Iterator<CatPart>() {
			int _index = 0;
			public boolean hasNext() { return _index < _parts.size(); }
			public CatPart next() { return _parts.get(_index++); }
			public void remove() { throw new UnsupportedOperationException(); }
			};
			}

			public Iterator<CatPart> iterator(final int start) {
			return new Iterator<CatPart>() {
			int _index = start;
			/* ANONYMOUS() */ { System.out.println("Iterating from: " + _index); }
			public boolean hasNext() { return _index < _parts.size(); }
			public CatPart next() { return _parts.get(_index++); }
			public void remove() { throw new UnsupportedOperationException(); }
			};
			}

			}
			</java5>

			Note-se que, no segundo método '''iterator''', a variável '''start''' deve ser '''final''', para poder ser utilizada na inicialização da classe interna. Esta variável poderia também ser inicializada no bloco anónimo (o comentário antes deste bloco serve apenas para indicar que, em alguns aspectos, o bloco pode ser visto como um construtor -- estes blocos, que pode ser colocados em qualquer classe, anónima ou não, são executados quando se criam objectos da classe).

			=== Aplicação exemplo ===

			Esta aplicação ilustra a utilização dos conceitos acima. Note-se que o modo de iteração utilizado (''for-each'') é válido para entidades que implementem o conceito '''java.util.Iterable<T>''' e para arrays primitivos. No segundo caso de iteração nesta aplicação, usa-se processo de iteração sem recurso a ''for-each'', já que esse processo itera sempre todos os elementos de uma estrutura.

			<java5>
			import java.util.Iterator;
			public class App {
			public static void main(String[] args) {
			Cat cat = new Cat(5);

			for (CatPart part: cat)
			System.out.println(part);

			Iterator<CatPart> it = cat.iterator(2);
			while (it.hasNext())
			System.out.println(it.next());

			}
			}
			</java5>

			=== Como Executar ===

			O processo de execução é o mesmo dos casos 3 e 4.

			Note-se que, neste caso, os ficheiros .class das classes internas já não têm um componente com nome, pois as duas classes internas são anónimas. Os ficheiros .class que as contêm são '''Cat$1.class''' e '''Cat$2.class'''.

			A execução é exactamente como nos casos anteriores.

			O resultado de execução é agora:

			<text>
			PART #0
			PART #1
			PART #2
			PART #3
			PART #4
			Iterating from: 2
			PART #2
			PART #3
			PART #4
			</text>

	== Caso 6: usando classes anónimas e polimorfismo ==		== Caso 6: usando classes anónimas e polimorfismo ==

Root: /* Caso 4: usando classe interna a um método */

2013-10-21T21:48:39Z

Caso 4: usando classe interna a um método

← Older revision		Revision as of 21:48, 21 October 2013
Line 193:		Line 193:
	O código no caso 4 difere do do caso 3 apenas num aspecto: a classe do iterador é privada da classe do gato e é utilizada apenas num local do código: o método que permite obter o iterador ('''iterator''').		O código no caso 4 difere do do caso 3 apenas num aspecto: a classe do iterador é privada da classe do gato e é utilizada apenas num local do código: o método que permite obter o iterador ('''iterator''').

	Não há outras alterações relativamente ao caso 3.		Não há outras alterações de código relativamente ao caso 3.

	=== Classe do conceito gato: Cat ===		=== Classe do conceito gato: Cat ===

Root: /* Caso 4: usando classe interna a um método */

2013-10-21T21:48:09Z

Caso 4: usando classe interna a um método

← Older revision		Revision as of 21:48, 21 October 2013
Line 190:		Line 190:

	== Caso 4: usando classe interna a um método ==		== Caso 4: usando classe interna a um método ==

			O código no caso 4 difere do do caso 3 apenas num aspecto: a classe do iterador é privada da classe do gato e é utilizada apenas num local do código: o método que permite obter o iterador ('''iterator''').

			Não há outras alterações relativamente ao caso 3.

			=== Classe do conceito gato: Cat ===

			Consegue-se uma melhor gestão do código se a classe do iterador se for deslocada para junto da sua única utilização. Deste modo, neste caso a classe do iterador deixa de ser acessível ao nível da class gato e passa apenas a ser acessível no método '''iterator'''.

			<java5>
			import java.util.List;
			import java.util.ArrayList;
			import java.util.Iterator;
			public class Cat implements Iterable<CatPart> {
			private List<CatPart> _parts = new ArrayList<CatPart>();

			public Cat(int nparts) {
			for (int i = 0; i < nparts; i++)
			_parts.add(new CatPart(i));
			}

			public Iterator<CatPart> iterator() {
			class CatIterator implements Iterator<CatPart> {
			int _index = 0;
			public boolean hasNext() { return _index < _parts.size(); }
			public CatPart next() { return _parts.get(_index++); }
			public void remove() { throw new UnsupportedOperationException(); }
			}

			return new CatIterator();
			}

			}
			</java5>

			=== Como Executar ===

			O processo de execução é o mesmo do caso 3.

			Note-se que, neste caso, o ficheiro .class da classe interna já não se chama '''Cat$CatIterator.class''', pois a classe é agora local a um método. O nome do ficheiro da classe interna é, neste caso, '''Cat$1CatIterator.class'''.

			A execução é exactamente como nos casos anteriores.

	== Caso 5: usando classe anónima ==		== Caso 5: usando classe anónima ==

Root: /* Como Executar */

2013-10-21T21:40:53Z

Como Executar

← Older revision		Revision as of 21:40, 21 October 2013
Line 185:		Line 185:
	javac App.java Cat.java CatPart.java		javac App.java Cat.java CatPart.java

	Note-se que, neste caso, além dos ficheiros .class resultantes da compilação das classes indicadas, é produzido também o ficheiro '''Cat$CatIterator.class''' (correspondente à classe interna).		Note-se que, neste caso, além dos ficheiros .class resultantes da compilação das classes indicadas, é produzido também o ficheiro '''Cat$CatIterator.class''' (correspondente à classe interna, cujo nome ao nível do código é '''Cat.CatIterator''').

	A execução é exactamente como nos casos anteriores.		A execução é exactamente como nos casos anteriores.

Root: /* Como Executar */

2013-10-21T21:40:00Z

Como Executar

← Older revision		Revision as of 21:40, 21 October 2013
Line 185:		Line 185:
	javac App.java Cat.java CatPart.java		javac App.java Cat.java CatPart.java

	Note-se que, além dos ficheiros .class resultantes da compilação das classes indicadas, ~~aparece agora~~ o ficheiro '''Cat$CatIterator.class''' (correspondente à classe interna).		Note-se que, neste caso, além dos ficheiros .class resultantes da compilação das classes indicadas, é produzido também o ficheiro '''Cat$CatIterator.class''' (correspondente à classe interna).

	A execução é exactamente como nos casos anteriores.		A execução é exactamente como nos casos anteriores.