W jaki sposób napisać w klasie Klasa konstruktor tak, żeby obiekty tej klasy były dynamiczną tablicą dowolnych obiektów (typ Object)?
Zastosuj listę a nie tablicę, np. ArrayList.
Odgórnie, to musi być tablica.
Acha to zmienia postać rzeczy.
To wtedy deklarujesz w polu klasy zmienną tablicową, a w konstruktorze podajesz np. tablicę którą chcesz przesłać, albo wielkosć tablicy:
Klasa
{
Object tabObjektow[];
public Klasa(int parWielkoscTablicy)
{
tabObjektow= new Object [parWielkoscTablicy];
}
}
lub:
Klasa
{
Object tabObjektow[];
public Klasa(Object tablica[])
{
tabObjektow = new Object[tablica.length];
System.arraycopy(tablica, 0, tabObjektow, 0, tablica.length);
}
}
Zależy co chcesz osiągnąć. Jeśli chcesz żeby po utworzeniu obiektu klasy Klasa można było zmieniać rozmiar tablicy wtedy musisz zaimplementować odpowiednie metody (z wykorzystaniem tymczasowej tablicy ;) ).
I czemy dałeś tytuł z klasą Vector?
Potrzebuję konstruktora bezargumentowego, który potem można by tak wykorzystać:
Klasa k = new Klasa() ;
k.add(jakiśObiekt);
k.size() ...
No to co to za problem? Wystarczy chwilę pogłówkować....
w add() zrób tak, że robisz tablicę temp o rozmiarze o 1 większy niż dotychcaczosowa tablica, dodajesz obiekt na koniec tablicy,a potem to co jest w temp przesyłasz do tablicy z twojej klasy (wcześniej zmieniając jej rozmiar przez new Object[nowy_rozmiar]).
size() to już prościzna taka, że szkoda gadać - public int size() { return tabObjektow.length; }
chodziło mi o to, że
add(object o )
int size() i inne
to metody z klasy Vector.
To o co ci w końcu chodzi - co chcesz DOKŁADNIE zrobić?
Chce zaimplementowac podobna funkcjonalnosc co Vector i List.
Mam klasę KlasaA, które importuje java.util.Vector i dwie klasy po niej dziedziczące KlasaB extends KlasaA , KlasaC extends KlasaA.
Chcę napisać takie konstruktory dla tych klas, żeby obiekty klas pochodnych były dynamicznymi tablicami dowolnych obiektów czyli żebum mogła potem w programie testującym tworzyć obiekty klas pochodnych i stosować do nich metody z klasy Vector.
Vector to nie tablica tylko kolekcja. Tablica to np Object[], kolekcja to np Vector<Object>.
Masz do wyboru co najmniej dwa rozwiązania. Jedno to rozszerzenie klasy Vector:
import java.util.Vector;
public class Rozszerzająca<A> extends Vector<A> {
}
Drugie to delegowanie operacji do już zaimplementowanej kolekcji:
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Vector;
public class Delegująca<A> {
private Vector<A> wektor = new Vector<A>();
public synchronized void trimToSize() {
wektor.trimToSize();
}
public synchronized <T> T[] toArray(T[] a) {
return wektor.toArray(a);
}
public synchronized Object[] toArray() {
return wektor.toArray();
}
public synchronized List<A> subList(int fromIndex, int toIndex) {
return wektor.subList(fromIndex, toIndex);
}
public synchronized int size() {
return wektor.size();
}
public synchronized void setSize(int newSize) {
wektor.setSize(newSize);
}
public synchronized void setElementAt(A obj, int index) {
wektor.setElementAt(obj, index);
}
public synchronized A set(int index, A element) {
return wektor.set(index, element);
}
public synchronized boolean retainAll(Collection<?> c) {
return wektor.retainAll(c);
}
public synchronized void removeElementAt(int index) {
wektor.removeElementAt(index);
}
public synchronized boolean removeElement(Object obj) {
return wektor.removeElement(obj);
}
public synchronized void removeAllElements() {
wektor.removeAllElements();
}
public synchronized boolean removeAll(Collection<?> c) {
return wektor.removeAll(c);
}
public synchronized A remove(int index) {
return wektor.remove(index);
}
public boolean remove(A o) {
return wektor.remove(o);
}
public synchronized ListIterator<A> listIterator() {
return wektor.listIterator();
}
public synchronized ListIterator<A> listIterator(int index) {
return wektor.listIterator(index);
}
public synchronized int lastIndexOf(Object o, int index) {
return wektor.lastIndexOf(o, index);
}
public synchronized int lastIndexOf(Object o) {
return wektor.lastIndexOf(o);
}
public synchronized A lastElement() {
return wektor.lastElement();
}
public synchronized Iterator<A> iterator() {
return wektor.iterator();
}
public synchronized boolean isEmpty() {
return wektor.isEmpty();
}
public synchronized void insertElementAt(A obj, int index) {
wektor.insertElementAt(obj, index);
}
public synchronized int indexOf(Object o, int index) {
return wektor.indexOf(o, index);
}
public int indexOf(Object o) {
return wektor.indexOf(o);
}
public synchronized A get(int index) {
return wektor.get(index);
}
public synchronized A firstElement() {
return wektor.firstElement();
}
public synchronized void ensureCapacity(int minCapacity) {
wektor.ensureCapacity(minCapacity);
}
public Enumeration<A> elements() {
return wektor.elements();
}
public synchronized A elementAt(int index) {
return wektor.elementAt(index);
}
public synchronized void copyInto(Object[] anArray) {
wektor.copyInto(anArray);
}
public synchronized boolean containsAll(Collection<?> c) {
return wektor.containsAll(c);
}
public boolean contains(A o) {
return wektor.contains(o);
}
public void clear() {
wektor.clear();
}
public synchronized int capacity() {
return wektor.capacity();
}
public synchronized void addElement(A obj) {
wektor.addElement(obj);
}
public synchronized boolean addAll(int index, Collection<? extends A> c) {
return wektor.addAll(index, c);
}
public synchronized boolean addAll(Collection<? extends A> c) {
return wektor.addAll(c);
}
public void add(int index, A element) {
wektor.add(index, element);
}
public synchronized boolean add(A e) {
return wektor.add(e);
}
}
Wyciąłem metody należące do klasy Object. Klasa Vector jest synchronizowana oraz oznaczona jako przestarzała (deprecated) - NetBeans podkreśla mi ją na żółto. Zamiast niej użyj innej implementacji interfejsu List np wspomniany ArrayList.
PS:
Ale bug. NetBeans generuje delegaty w odwrotnej kolejności :P