java.util.Vector;

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