Java Delphi-like class references -

in delphi there called class references:

type   tsomeclass = class(tancestorclass)   .   . end; // declared weird syntax: (i know java has no type declarations) type     tsomeclassreference = class of tsomeclass;   

stated such declaration, can used argument

// can pass tsomeclassreference or descendant class function function classfactory (pclasstocreate : tsomeclassreference) : tsomeclass;  // invoke   var : tsomeclass;   b : tsomeclassderivedfromtsomeclass;    := classfactory (tsomeclass); b := classfactory (tsomeclassderivedfromtsomeclass); b := classfactory (tanotherclass); // wrong! 

or instance variable

tanotherclass = class(tanyclassnotderivedfromtsomeclass)   .   .   // same: can hold reference tsomeclass or descendant   fdriverclass : tsomeclassreference; end;    var     : tanotherclass;      a.fdriverclass := tsomeclass;     a.fdriverclass := tsomeclassderivedfromtsomeclass;     a.fdriverclass := tanotherclass;   // wrong!   

i heavyly use such class references in delphi creating class factories among other things. there syntax in java doing this? mean

public tsomeclass classfactory (pclasstocreate tsomeclassreference)  {...} 

or

public class tanotherclass extends tanyclass {     tsomeclassreference fdriverclass; } 

in java class equivalent of tclass in delphi. java object class has getclass() method returns class of particular object instance, similar delphi's tobject class classtype method

public final class<?> getclass() // java  function classtype: tclass; // delphi 

for example type of string.class class<string>

to equivalent of delphi metaclass tsomeclassreference declared as

  tsomeclassreference = class of tsomeclass; 

in java use upper bounded wildcard on class<t>

  class<? extends someclass> 

that give same compile time type checking delphi has.

---

following example demonstrates simple object factory in java

public class baseclass {     public int b = 0;      public baseclass()     {         b = 10;     } }  public class classa extends baseclass {     public classa()     {         b = 20;     } }  public class classaa extends classa {     public classaa()     {         b = 22;     } }  public class classb extends baseclass {     public classb()     {         b = 30;     } }  public class basefactory  {     public static baseclass create(class<? extends baseclass> clazz)     {         try         {             return clazz.getconstructor().newinstance();         }         catch (nosuchmethodexception e)         {             e.printstacktrace();         }         catch (invocationtargetexception e)         {             e.printstacktrace();         }         catch (instantiationexception e)         {             e.printstacktrace();         }         catch (illegalaccessexception e)         {             e.printstacktrace();         }         return null;     } } 

and can use factory create objects like

class<? extends baseclass> c = classa.class; baseclass o = basefactory.create(c); 

or

baseclass o = basefactory.create(baseclass.class); baseclass o = basefactory.create(classa.class); baseclass o = basefactory.create(classaa.class); baseclass o = basefactory.create(classb.class);  class<? extends baseclass> c = string.class; // not compile baseclass o = basefactory.create(string.class); // not compile 

---

equivalent object factory in delphi - type names have been changed match delphi coding style.

baseclass - tbaseobject

classa - tobjecta

class<? extends baseclass> - tbaseclass

program project1;  {$apptype console}  {$r *.res}  uses   system.sysutils,   system.classes;  type   tbaseobject = class(tobject)   public     b: integer;     constructor create; virtual;   end;    tbaseclass = class of tbaseobject;    tobjecta = class(tbaseobject)   public     constructor create; override;   end;  constructor tbaseobject.create; begin   inherited;   b := 10; end;  constructor tobjecta.create; begin   inherited;   b := 20; end;  function basefactory(clazz: tbaseclass): tbaseobject; begin   result := clazz.create; end;  var   o: tbaseobject;   c: tbaseclass; begin   o := basefactory(tbaseobject);   writeln(o.b); // 10   o.free;    o := basefactory(tobjecta);   writeln(o.b); // 20   o.free;    c := tobjecta;   o := basefactory(c);   writeln(o.b); // 20   o.free;    readln; end.