diff --git a/README.md b/README.md
index 71f0718..1c87f60 100644
--- a/README.md
+++ b/README.md
@@ -1,15 +1,21 @@
-### Java 7+/Android JSON Serializer/Deserializer, MIT (c) 2020-2024 @miktim  
+### Java 7+/Android JSON parser/generator, MIT (c) 2020-2024 @miktim  
   
 #### Release notes:  
   
 Java SE 7+/Android RFC 8259 compliant package
 (see: [https://datatracker.ietf.org/doc/rfc8259/?include_text=1](https://datatracker.ietf.org/doc/rfc8259/?include_text=1) ).  
-No external dependencies.  
+\- no external dependencies;  
+\- arrays of mixed type are allowed;  
+\- “JSON” means text in JSON format. JSON text exchanged between systems MUST be encoded using UTF-8 (default charset);  
+\- “Json” means the Java representation of a JSON object.  
+
+
+The class [JSON](#JSON) contains static methods for parsing/generating text in JSON format. Parser converts JSON to <a name="native"></a> **package-native** objects: **[Json object](#Json)** ( the Java representation of a JSON object )**, String, Number, Boolean, null, Object[ ]** - an array of the listed types. The JSON generator accept any Java object, all Java primitives and their arrays.   
+
+Instances of Java classes can be converted to Json object (usually empty) using [Json.converter](#Converter).  
+
+The [JsonObject](#JsonObject) abstract class and [JsonConvertible](#JsonConvertible) interface use the JavaScript-like replacer/reviver tool to convert object instance fields to or from [Json object](#Json) members.  
 
-<a name="native"></a>**Native** serializable objects are: [Json object](#Json) ( Java representation of a JSON object ), String, Number, Boolean, null, Object[ ] - an array of the listed types. Java numeric and boolean primitives and their arrays also supported.  
-Instances of existing Java classes are typically serialized into an empty JSON object.  
-To serialize existent Java object, use the [Nativizer](#Nativizer) interface and [register instance](#ClasRegistry) for class. Newly created classes can extends [Nativefier](#Nativefier) class. The abstract Nativefier class applies a JavaScript-like approach, using a replacer/reviver to convert the fields of an object instance to the native type.  
-The class [JSON](#JSON) is responsible for serializing objects to JSON text and vice versa.
   
 #### package org.miktim.json  
   
@@ -17,15 +23,14 @@ The class [JSON](#JSON) is responsible for serializing objects to JSON text and
 <a name="JSON"></a> 
 #### class JSON
 
-This class contains static serialization and conversion methods.  
-JSON text exchanged between systems that are not part of a closed ecosystem MUST be encoded using UTF-8 (default charset).  
+This class contains static parsing/generating methods.  
 
 <p style="background-color: #B0C4DE;">
 &emsp;<b>Methods:</b>
 </p>  
 
 **static Object fromJSON ( String jsonText ) throws IOException, ParseException**  
-Parse JSON text to a native object  
+Parse JSON text to a native objects  
 
 **static Object fromJSON ( InputStream in, String charsetName ) throws IOException, ParseException**  
 Parse JSON text from an input stream with the specified encoding
@@ -34,7 +39,7 @@ Parse JSON text from an input stream with the specified encoding
 Serializes a Java object as a single-line text in JSON format  
 
 **static String toJSON ( Object obj, int space ) throws IOException**  
-Serializes a Java object as JSON text with the specified number of spaces in the indentation  
+Generate a Java object as JSON text with the specified number of spaces in the indentation  
 
 **static &lt;T\>T toJSON ( T obj, OutputStream out, int space, String charsetName ) throws IOException**  
 Serializes a Java object as JSON text into a stream with the specified indentation and encoding. Returns obj.  
@@ -44,7 +49,7 @@ Methods for converting or copying Java objects.  Notes:
 \- sample must be initialized;  
 \- arrays must have the same dimension;  
 \- casting numbers may involve rounding or truncation;  
-\- casting a null object returns empty array or initial value;  
+\- casting a null object to primitive returns empty array or initial value;  
 \- casting to null returns null.  
   
 
@@ -65,7 +70,7 @@ Casting a Java object to a Class
 
 // cast by class. Numbers truncated to integers
 int ints = JSON.cast(int[].class,
-  JSON.fromJSON("[1.2, 3.4, 5.6]"));
+  JSON.fromJSON("[1.2, 3.4, 5]"));
 // generate JSON with two spaces in the indentation
 System.out.println(JSON.toJSON(ints, 2));
 /* console output:
@@ -83,20 +88,18 @@ System.out.println(Arrays.deepToString(dbls));
 [[1.0, 2.0, 3.0], [7.0, 8.0, 9.0]]
 */
 ```
-#### JSON.serializer
   
 <a name="Json"></a>
-#### public class Json extends HashMap &lt;String, Object\>
+#### class Json extends HashMap &lt;String, Object\>
 This class is a Java representation of a JSON object.
-Json member native types:  
-Json object, String, Number, Boolean, null, Object[ ] array of listed types.
+Json member types: **Json object, String, Number, Boolean, null, Object[ ]** array of listed types.
    
-Put, set, get notes:  
+Put, set notes:  
 \- Json object setters accept any Java object, all Java primitives and primitive arrays;  
 \- RFC 8259 does not recommend using Java BigDecimal and BigInteger as Json member values;  
 \- AVOID RECURSION!;  
-\- put, set methods cast Java primitives to the corresponding objects:  
-**float** as **Number**, **boolean** as **Boolean**  
+\- put, set methods cast Java primitives to the corresponding objects: 
+**Number**, **Boolean** or **String** for chars  
 \- Java arrays are stored as:  
 **int[ ][ ]** as **Object[ ] { Object[ ] { Number, ... }, Object[ ] { Number, ... } }**, **String[ ]** as **Object[ ] { String, ... }**  
 
@@ -115,6 +118,7 @@ Create Json object from String
 
 **Json ( InputStream inStream ) throws IOException, ParseException**  
 Create Json object from UTF-8 encoded stream.  
+
 <p style="background-color: #B0C4DE;">
 &emsp;<b>Example:</b>
 </p>  
@@ -143,13 +147,13 @@ Returns a list of the names of the members of this Json object
 Returns true if there is a member or an element of the member array  
 
 **Object put ( String memberName, Object value );**  
-inherited  
+Put Json member.  
 
 **Json set ( String memberName, Object value );**  
 Create or replace member. Returns this.   
 
-**Object get ( String memberName )**  
-inherited  
+**Object get( String memberName );**  
+Get Json member.
 
 **Object remove ( String memberName );**  
 inherited  
@@ -160,16 +164,16 @@ Returns null, the value of an member, or an array element
 **Json getJson ( String memberName, int... indices ) throws ClassCastException, IndexOutOfBoundsException**  
 Returns a nested Json object 
   
-**String getString ( String memberName, int... indices )     throws ClassCastException, IndexOutOfBoundsException**
+**String getString ( String memberName, int... indices ) throws ClassCastException, IndexOutOfBoundsException**
 Casts member or array element to String  
 
-**Number getNumber ( String memberName, int... indices )         throws ClassCastException, IndexOutOfBoundsException**  
+**Number getNumber ( String memberName, int... indices ) throws ClassCastException, IndexOutOfBoundsException**  
 Casts member or array element to Number
   
-**Boolean getBoolean ( String memberName, int... indices )        throws ClassCastException, IndexOutOfBoundsException**  
+**Boolean getBoolean ( String memberName, int... indices ) throws ClassCastException, IndexOutOfBoundsException**  
 Casts member or array element to Boolean  
 
-**Object[ ] getArray ( String memberName, int... indices )        throws ClassCastException, IndexOutOfBoundsException**  
+**Object[ ] getArray ( String memberName, int... indices ) throws ClassCastException, IndexOutOfBoundsException**  
 Casts member to array of Objects  
 
 **&lt;T\> T castMember ( T sample, String memberName, int... indices ) throws ClassCastException, IndexOutOfBoundsException**  
@@ -204,6 +208,7 @@ Output UTF-8 encoded single line JSON text to outStream. Returns this.
 Json j = (new Json())
   .set("personId", 1234)
   .set("firstName","John")
+  ,set("lastName","Doe")
 // "phones" is nested Json object
   .set("phones", 
     new Json("home", "123-4567","work","890-1234"));
@@ -211,7 +216,8 @@ System.out.println(JSON.toJSON(j, 2));
 /* console output
 {
   "personId": 1234, 
-  "firstName": "John", 
+  "firstName": "John",
+  "lastName": "Doe", 
   "phones": {
     "home": "123-4567", 
     "work": "890-1234"
@@ -229,113 +235,200 @@ System.out.printf("%d %s %s\n\r", personId, firstName, homePhone);
 1234 John 123-4567
 */
 ```
-<a name="Native"></a>
-#### interface Nativizer  
-  
+<a name="Converter"></a> 
+#### Json.converter  
+Used to convert existing instances of Java objects to/from a Json object.  
+Only the visible (context depended!) fields are converted. The converter ignores the final and transient fields.
+
 <p style="background-color: #B0C4DE;">
 &emsp;<b>Methods:</b>
 </p>  
 
-**&lt;T\> T fromNative(Object nativeObj)**  
-Returns target object.  
+**Json toJson ( Object targetObj )**  
+Returns a Json object from the target object  
+
+**&lt;T\> T fromJson ( T targetObj, Json jsonObj ) throws IOException, ParseException**  
+Loads Json to target object. Returns target object.  
 
-**&lt;T\> T toNative()**  
-Returns [native](#native) object.   
-  
-#### JSON Class Registry methods  
+<p style="background-color: #B0C4DE;">
+&emsp;<b>Example:</b>
+</p>  
   
-**Nativizer JSON.registerClass(Class cls, Nativizer serializer)**  
-**Nativizer JSON.getRegistered(Class cls)**  
-**Class[] JSON.listRegistered()**
-**Nativizer JSON.unregisterClass(Class cls)**  
+```java
+/*
+ * Fields visibility
+ */
+  public static class Foo {
+    public String pub = "public"; // visible
+    String def = "default"; // invisible in the converter
+    protected String pro = "protected"; // visible in the same package
+    private String pri = "private"; // invisible in the converter
+    public transient String pubt = "public transient"; // ignored
+    public final String pubf = "public final"; // ignored
+
+    public Foo() {}; // default constructor
+  }
   
+  public static void main(String[] args) throws Exception {
+    Foo foo = new Foo();  
+    System.out.println(Json.converter.toJson(foo));
+/* console output:
+{"pub": "public", "pro": "protected"}
+*/
+  }
+```  
+
+<a name="JsonConvertible"></a>
+#### interface JsonConvertible  
+The JsonConvertible interface provdes JavaScript-like methods for conversion fields of a Java object to/from a package [native](#native) objects. Notes:  
+\- visibility of object fields as from the object constructor (including the privates);  
+\- Java transient and final fields are ignored;  
+\- it is strongly recommended to initialize the accessible fields and create a public default constructor;  
+\- non-native, non Json convertible fields MUST be managed using replacer/reviver.  
+
 <p style="background-color: #B0C4DE;">
-&emsp;<b>Example:</b>
+&emsp;<b>Constants:</b>
 </p>  
 
+**static final Object IGNORED**  
+Returned from the replacer/reviver methods to skip the field.  
+
+<p style="background-color: #B0C4DE;">
+&emsp;<b>Methods:</b>
+</p>  
+
+**Object replacer ( String name, Object value );**  
+Applies on unloading to Json object:  
+\- name is object field class and name delimited with colon ( : ), value is object field value;  
+\- first call with the target object class name and the target object as the value;  
+\- returns Json-supported object or IGNORED.  
+
+**Object reviver ( String name, Object value );**  
+Applies on loading from Json object:  
+\- name is object field class and name delimited with colon ( : ), value is Json-supported object;  
+\- first call with the target object class name and the Json object as value;  
+\- returns a value that is compatible with the target object field or IGNORED  
+
+<p style="background-color: #B0C4DE;">
+&emsp;<b>Example:</b>
+</p>  
+  
 ```java
 /*
- * Create and register serializer for Java File class
- * An instance of a File will be represented by its path
+ * Creating a JsonConvertible object from a HashMap
  */
-static class FileClass implements Nativizer {
-  FileClass();
+public class NamesOfNumbers extends HashMap<Double, String>
+    implements JsonConvertible {
+
+  public int space = 2; // spaces in indentation
+ 
+  public NamesOfNumbers() {
+    super();
+  }
+
+// unload fields to Json object
   @Override
-  <T> T toNative(Object target) {
-    return (T) (new Json()).set("filePath", ((File)target).getPath());
+  public Object replacer(String name, Object value) {
+    if (name.indexOf(':') < 0) { // first call without field name
+// convert HashMap to Json object
+      Json j = new Json();
+      for (Double key : this.keySet().toArray(new Double[0])) {
+        j.put(key.toString(), this.get(key));
+      }
+      return new Json("HashMap", j); // return newly created Json object
+    }
+    return value; // unloading other fields "by default"
   }
+
+// load fields from Json object
   @Override
-  <T> T fromNative(Object native) {
-  	return (T) new File(((Json)native).getString("filePath"));
+  public Object reviver(String name, Object value) {
+    if (name.indexOf(':') < 0) { // first call without field name
+// fill HashMap from the Json object 
+      Json j = ((Json) value).getJson("HashMap");
+      this.clear(); // erase HashMap
+      for (String key : j.listNames()) {
+        this.put(new Double(key), j.getString(key));
+      }
+      return IGNORED; // nothing to do
+    }
+    return value; // loading other fields "by default"
   }
-}
 
-public static void main(String args) {
-  File file = new File("./example.json");
-  System.out.println(JSON.toJSON(file)); // before registering a Java class
-  JSON.registerClass(File.class, new FileClass());
-  System.out.println(JSON.toJSON(file)); // after
+// serialize this to String with spaces in the indentation 
+  public String toJSON() throws IOException {
+    return JSON.toJSON(Json.converter.toJson(this), this.space);
+  }
+// deserialize this from String
+  public void fromJSON(String s) throws IOException, ParseException {
+    Json.converter.fromJson(this, new Json(s));
+  }
+    
+  public static void main(String[] args)
+      throws IOException, ParseException {
+    NamesOfNumbers names = new NamesOfNumbers();
+    names.put(0.0, "zero");
+    names.put(1.0, "one");
+    names.put(1.5, "one and five tenths");
+    String s = names.toJSON();
+    System.out.println(s);
+    names.clear();
+    names.fromJSON(s);
+    System.out.println(names.get(1.5));
+  }
 /* console output:
-{ }
-{ "filePath": ".\/example.json" }
-*/	
+{
+  "HashMap": {
+    "0.0": "zero", 
+    "1.0": "one", 
+    "1.5": "one and five tenths"
+  }, 
+  "space": 2
 }
+one and five tenths
+*/
+}
+
 ```  
+
   
-<a name="Nativefier"></a>
-#### abstract class Nativefier implements Nativizer
-Java object extender. Unload/load fields of a Java object to/from a [native](#native) objects. Notes:  
-\- visibility of object fields as from the object constructor;  
+<a name="JsonObject"></a>
+#### abstract class JsonObject implements JsonConvertible
+Java object extender. Unload/load fields of a Java object instance to/from a [native](#native) objects. Notes:  
+\- visibility of object fields as from the object constructor (including the privates);  
 \- Java transient and final fields are ignored;  
-\- it is highly recommended to initialize accessible fields and create a default constructor;  
-\- non-native fields MUST be managed using replacer/reviver.  
+\- it is highly recommended to initialize accessible fields and create a public default constructor;  
+\- non-native, non Json convertible fields MUST be managed using replacer/reviver.  
   
 <p style="background-color: #B0C4DE;">
 &emsp;<b>Constants:</b>
 </p>  
   
-**protected static final transient Object IGNORED**  
+**static final Object IGNORED**  
 Returned from the replacer/reviver methods to skip the field  
 
 <p style="background-color: #B0C4DE;">
 &emsp;<b>Methods:</b>
 </p>  
 
-**Json toNative ( ) throws IllegalArgumentException, IllegalAccessException;**  
+**public Object replacer ( String name, Object value );**  
+**public Object reviver ( String name, Object value );**  
+See [JsonConvertible](#JsonConvertible) interface.
+
+**Json toJson ( );**  
 Returns a Json object from this object  
 
-**&lt;T\> T fromNative ( Object nativeObj ) throws IllegalArgumentException, IllegalAccessException;**  
+**&lt;T\> T fromJson ( Json jsonObj );**  
 Loads Json to this object. Returns this object.  
 
-**Json toNative ( Object targetObj ) throws IllegalArgumentException, IllegalAccessException;**  
-Returns a Json object from the target object  
-
-**&lt;T\> T fromNative ( T targetObj, Object nativeObj ) throws IllegalArgumentException, IllegalAccessException;**  
- Loads Json to target object. Returns target object.  
- 
-**protected Object replacer ( String name, Object value );**  
-Applies on unloading:  
-\- name is object field class and name delimitet with dot (.), value is object field value;  
-\- first call with the target object class name and the target object as the value;  
-\- returns [native](#native) object or IGNORED  
-
-**protected Object reviver ( String name, Object value );**  
-Applies on loading:  
-\- name is object field class and name delimited with dot (.), value is Json-supported object;  
-\- first call with the target object class name and the Json object as value;  
-\- returns a value that is compatible with the object field or IGNORED  
-
-**static boolean isClassName ( String name );**  
-Returns true if name is class name.  
-
-<!--
-**protected &lt;T> T getTarget ( );**  
-Get target object. Accessible from replacer/reviver
--->  
-
 **String toString ( );**  
 Overridden. Generate JSON text as a single line  
   
+<!--  
+**static boolean isClassName ( String name );**  
+Returns true if name is class name.  
+-->
+  
 <!--
 **protected &lt;T\> T castMember( T sample, String memberName, Json jsonObj );**  
 Returns the sample if Json member does not exists or is null  
@@ -347,50 +440,46 @@ Returns the sample if Json member does not exists or is null
   
 ```java
 /*
- * Create Nativefier instance
+ * Declare JsonObject 
  */
-public static class Person extends Nativefier {
-  int personId = 0;
-  String firstName = "";
-  String lastName = "";
-  boolean married = false;
+  public static class Person extends JsonObject {
+    int personId = 0;
+    String firstName = "";
+    String lastName = "";
+    boolean married = false;
 // use Json class (HashMap<String, Object>) for phones
-  Json phones = new Json();
+    Json phones = new Json();
 
 // default constructor
-  public Person() {
+    public Person() {
+    }
   }
-}
 
-public static void main(String[] args)
-  throws IllegalArgumentException, IllegalAccessException,
-         IOException, ParseException {
-
-// create and fill Person object
-  Person person = new Person();
-  person.personId = 12345;
-  person.firstName = "John";
-  person.lastName = "Doe";
-  person.phones.put("home", "123-4567");
-  person.phones.put("work", "789-0123");
-// unload person to string
-  String s = person.toNative().toJSON();
-  System.out.println(s);
+  public static void main(String[] args)
+    throws IOException, ParseException {
+
+// create and fill Person instance
+    Person person = new Person();
+    person.personId = 12345;
+    person.firstName = "John";
+    person.lastName = "Doe";
+    person.phones.put("home", "123-4567");
+    person.phones.put("work", "789-0123");
+// unload person to JSON string
+    String s = person.toJson().toJSON();
+    System.out.println(s);
+// load person from JSON string
+    person = new Person();
+    person.fromJson(new Json(s));
+// get a home phone number
+    System.out.println(person.phones.getString("home"));
 /* console output:
 {"personId": 12345, "firstName": "John", "lastName": "Doe", "married": false, "phones": {"work": "789-0123", "home": "123-4567"}}
-*/
-// load person from string
-  person = new Person();
-  person.fromNative(new Json(s));
-  System.out.println(person.phones.getString("home"));
-));
-/* console output:
 123-4567
 */
-}
+  }
 ```  
   
-**See usage here:**  
-  ./test/json/JsonTest.java  
-  ./test/json/JsonCastTest.java  
-  ./test/json/NativefierTest.java  
+**See also:**  
+[https://www.baeldung.com/java-json](https://www.baeldung.com/java-json)  
+[https://www.json.org/json-en.html](https://www.json.org/json-en.html)  
diff --git a/src/org/miktim/json/AbstractNaturalizer.java b/src/org/miktim/json/AbstractNaturalizer.java
deleted file mode 100644
index 9310bb0..0000000
--- a/src/org/miktim/json/AbstractNaturalizer.java
+++ /dev/null
@@ -1,9 +0,0 @@
-/**
- * AbstractNaturalizer class, MIT (c) 2024 miktim@mail.ru
- * Java object converter
- */
-package org.miktim.json;
-
-public abstract class AbstractNaturalizer {
-    
-}
diff --git a/src/org/miktim/json/JSON.java b/src/org/miktim/json/JSON.java
index cefd03a..947e3f3 100644
--- a/src/org/miktim/json/JSON.java
+++ b/src/org/miktim/json/JSON.java
@@ -23,37 +23,9 @@
 import java.lang.reflect.Array;
 import java.lang.reflect.Constructor;
 import java.text.ParseException;
-import java.util.HashMap;
 
 public class JSON {
 
-    /*
-    static {
-        try {
-
-        } catch (Exception e) {
-
-        }
-    }
-     */
-    private static HashMap<Class, JsonObject> serializers = new HashMap<>();
-
-    public static JsonObject registerClass(Class cls, JsonObject serializer) {
-        return serializers.put(cls, serializer);
-    }
-
-    public static JsonObject getRegistered(Class cls) {
-        return serializers.get(cls);
-    }
-
-    public static Class[] listRegistered() {
-        return serializers.keySet().toArray(new Class[0]);
-    }
-
-    public static JsonObject unregisterClass(Class cls) {
-        return serializers.remove(cls);
-    }
-
     public static <T> T toJSON(T obj, OutputStream out, int space, String charsetName)
             throws IOException {
         JSONGenerator generator = new JSONGenerator(out, space, charsetName);
@@ -110,14 +82,10 @@ public static <T> T cast(Class<T> dstCls, Object obj) {
 
     @SuppressWarnings({"unchecked"})
     static <T> T cast(Class<T> dstCls, Object obj, CastAdapter adapter) {
-//        if (srcCls.isArray()) { //*
-//        if (obj.getClass().isArray()){
         if (dstCls.isArray()) {
             int arrLen = obj == null ? 0 : Array.getLength(obj);
-//            Class cmpCls = srcCls.getComponentType(); //*
             Class cmpDstCls = dstCls.getComponentType();
             T arr = (T) Array.newInstance(cmpDstCls, arrLen);
-//            T arr = (T) Array.newInstance(cmpCls, arrLen); //*
             for (int i = 0; i < arrLen; i++) {
                 T retVal = (T) cast(cmpDstCls, Array.get(obj, i), adapter);
                 Array.set(arr, i, retVal);
@@ -144,7 +112,11 @@ public static boolean isNativeType(Object obj) {
         if (obj == null) {
             return true;
         }
-        Class<?> cls = JSON.getElementClass(obj.getClass());
+        return isNativeClass(obj.getClass());
+    }
+    
+    public static boolean isNativeClass(Class clazz) {
+        Class<?> cls = JSON.getElementClass(clazz);
         return cls.equals(Number.class)
                 || cls.equals(String.class)
                 || cls.equals(Boolean.class)
@@ -157,7 +129,7 @@ interface CastAdapter {
 
         <T> T castValue(Object value) throws ClassCastException;
     }
-// TODO: safeCast from BigDecimal?
+// TODO: ?safeCast from BigDecimal
 
     @SuppressWarnings("unchecked")
     static CastAdapter getAdapter(Class cls) {
@@ -182,12 +154,14 @@ static CastAdapter getAdapter(Class cls) {
             return booleanAdapter;
         } else if (cls == Json.class) {
             return jsonAdapter;
-        } else if (cls.isAssignableFrom(JsonObject.class)) {
-            return new JsonObjectAdapter(cls);
+//        } else if (JsonConvertible.class.isAssignableFrom(cls)) {
+//            return new ObjectAdapter(cls);
         }
-
-        return defaultAdapter;
+// TODO: ?Map, List adapters
+        return new ObjectAdapter(cls);
+//        return defaultAdapter;
     }
+/*
     @SuppressWarnings("unchecked")
     private static final CastAdapter defaultAdapter = new CastAdapter() {
         @Override
@@ -195,25 +169,26 @@ public Object castValue(Object obj) {
             return obj;
         }
     };
-
+*/
     @SuppressWarnings("unchecked")
-    static class JsonObjectAdapter implements CastAdapter {
+    static class ObjectAdapter implements CastAdapter {
 
         Class<?> clazz;
 
-        JsonObjectAdapter(Class<?> clazz) {
+        ObjectAdapter(Class<?> clazz) {
             this.clazz = clazz;
         }
 
         @Override
-        public Object castValue(Object json) {
+        public Object castValue(Object obj) {
             try {
-                if (json == null) {
-                    return null;
+                if (obj == null || obj.getClass() == clazz) {
+                    return obj;
                 }
-                Object obj = createInstance(clazz);
-                return ((JsonObject) obj).fromJson(json);
-            } catch (IllegalArgumentException | IllegalAccessException ex) {
+//                if(obj.getClass() == clazz) return obj;
+                Object newObj = createInstance(clazz);
+                return Json.converter.fromJson(newObj, (Json)obj);
+            } catch (IllegalArgumentException ex) {
                 throw new ClassCastException(ex.getMessage());
             }
         }
@@ -223,8 +198,8 @@ public Object castValue(Object json) {
     static Object createInstance(Class<?> clazz) {
         try {
 //            Class<?> clazz = obj.getClass();
-            Constructor<?> ctor = clazz.getConstructor(String.class);
-            return ctor.newInstance(new Object[0]);
+            Constructor<?> ctor = clazz.getConstructor();
+            return ctor.newInstance();//new Object[0]);
         } catch (Exception ex) {
             throw new ClassCastException(ex.getMessage());
         }
@@ -268,7 +243,7 @@ public Object castValue(Object obj) {
     private static final CastAdapter longAdapter = new CastAdapter() {
         @Override
         public Object castValue(Object obj) {
-            return obj == null ? 0 : ((Number) obj).longValue();
+            return obj == null ? 0L : ((Number) obj).longValue();
         }
     };
     @SuppressWarnings("unchecked")
diff --git a/src/org/miktim/json/JSONGenerator.java b/src/org/miktim/json/JSONGenerator.java
index dbce110..427f5e8 100644
--- a/src/org/miktim/json/JSONGenerator.java
+++ b/src/org/miktim/json/JSONGenerator.java
@@ -56,6 +56,9 @@ void generateObject(Object value, int level) throws IOException {
         } else if (value instanceof String) {
             write("\"" + escapeString((String) value) + "\"");
             return;
+        } else if (value instanceof Character) {
+            generateObject(String.valueOf(value), level - 1);
+            return;
         } else if (value.getClass().isArray()) {
             write("[");
             String separator = "";
@@ -83,10 +86,9 @@ void generateObject(Object value, int level) throws IOException {
             return;
         }
         try {
-            Json.converter.toJson(value);
+            generateObject(Json.converter.toJson(value), level);
         } catch (Exception ex) {
             throw new ClassCastException(ex.getMessage());
-//            generateObject(ex, level);
         }
     }
 
diff --git a/src/org/miktim/json/Json.java b/src/org/miktim/json/Json.java
index 76e67fe..97ea78a 100644
--- a/src/org/miktim/json/Json.java
+++ b/src/org/miktim/json/Json.java
@@ -160,11 +160,35 @@ public Json normalize() throws IOException, ParseException {
         return (Json) JSON.fromJSON(this.toString()); // :)
     }
 */
-    public static class Converter extends JsonObject {
+    public static class Converter extends JsonConverter {
 
         public Converter() {
 
         }
+
+    @SuppressWarnings("unchecked")
+    public Json toJson(Object targetObj) {
+//            throws IllegalArgumentException, IllegalAccessException {
+        return unload(this, targetObj);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T> T fromJson(Object targetObj, Object jsonObj) {
+//            throws IllegalArgumentException, IllegalAccessException {
+        return (T) load(this, targetObj, jsonObj);
     }
+/*
+        @Override
+        public Object replacer(String name, Object value) {
+             return value;
+        }
+
+        @Override
+        public Object reviver(String name, Object value) {
+            return value;
+        }
+*/
+    }    
+
     public static Converter converter = new Converter();
 }
diff --git a/src/org/miktim/json/JsonConverter.java b/src/org/miktim/json/JsonConverter.java
new file mode 100644
index 0000000..2f50813
--- /dev/null
+++ b/src/org/miktim/json/JsonConverter.java
@@ -0,0 +1,192 @@
+/**
+ * JsonConverter abstract class, MIT (c) 2024 miktim@mail.ru
+ *
+ * Converts visible fields of the Java object instance
+ * to package native and vice versa. 
+ * Java final and transient fields are ignored.
+ */
+package org.miktim.json;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.LinkedHashMap;
+
+abstract class JsonConverter implements JsonConvertible {
+    
+    protected static final transient Object IGNORED = new Object();
+
+    @Override
+    public Object replacer(String name, Object value) {
+        return value;
+    }
+
+    @Override
+    public Object reviver(String name, Object value) {
+        return value;
+    }
+    
+    protected Json unload(JsonConvertible thisObj, Object targetObj) {
+
+        try {
+            if (targetObj instanceof JsonConvertible) {
+                thisObj = (JsonConvertible) targetObj;
+            }
+            Object json = thisObj.replacer(targetObj.getClass().getName(), targetObj);
+            if (!(json instanceof Json)) {
+                json = new Json(); // replacer returns target object
+            }
+            Field[] fields = getAccessibleFields(thisObj, targetObj);
+            int ignored = Modifier.FINAL | Modifier.TRANSIENT;
+            for (Field field : fields) {
+                if ((field.getModifiers() & ignored) != 0) {
+                    continue;
+                }
+                field.setAccessible(true);
+                Object newValue = thisObj.replacer(fieldName(field),
+                        field.get(targetObj));
+                if (newValue.equals(IGNORED)) {
+                    continue;
+                }
+// TODO: !? newValue == null
+//                Class fieldCls = fieldType();
+//                if (!(JSON.isNativeClass(fieldCls) || newValue.getClass().isArray())) {
+                if (!(JSON.isNativeType(newValue) || newValue.getClass().isArray())) {
+                    newValue = Json.converter.toJson(newValue);
+                }
+                ((Json) json).set(field.getName(), newValue);
+            }
+            return (Json) json;
+        } catch (IllegalArgumentException | IllegalAccessException ex) {
+            throw new ClassCastException(ex.getMessage());
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    protected <T> T load(JsonConvertible thisObj, T targetObj, Object json) //{
+    {
+        try {
+            if (targetObj instanceof JsonConvertible) {
+                thisObj = (JsonConvertible) targetObj;
+            }
+            json = thisObj.reviver(targetObj.getClass().getName(), json);
+            if (json instanceof Json) {
+                Field[] fields = getAccessibleFields(thisObj, targetObj);
+                int ignored = Modifier.FINAL | Modifier.TRANSIENT;
+                for (Field field : fields) {
+                    if ((field.getModifiers() & ignored) != 0) {
+                        continue;
+                    }
+                    String fieldName = field.getName();
+                    if (((Json) json).exists(fieldName)) {
+                        field.setAccessible(true);
+                        Object value = field.get(targetObj); // sample for casting
+// 
+                        Object newValue = thisObj.reviver(fieldName(field),
+                                ((Json) json).get(fieldName));
+                        if (newValue.equals(IGNORED)) {
+                            continue;
+                        }
+// TODO: !? field value == null
+                        Class fieldCls = field.getType();
+                        if (!(JSON.isNativeClass(fieldCls) || value.getClass().isArray())) {
+//                        if (!(JSON.isNativeType(value) || value.getClass().isArray())) {
+                            newValue = Json.converter.fromJson(value, newValue);
+                        }
+                        field.set(targetObj, JSON.cast(fieldCls, newValue));
+//                        field.set(targetObj, JSON.cast(value, newValue));
+                    }
+                }
+            }
+            return (T) targetObj;
+        } catch (IllegalArgumentException | IllegalAccessException ex) {
+            throw new ClassCastException(ex.getMessage());
+        }
+    }
+
+    private Field[] getAccessibleFields(Object thisObj, Object targetObj) {
+        LinkedHashMap<String, Field> accessibleFields = new LinkedHashMap<>();
+        Class thisCls = thisObj.getClass();
+        Package thisPkg = thisCls.getPackage();
+        int ignore = Modifier.STRICT | Modifier.INTERFACE
+                | Modifier.ABSTRACT | Modifier.NATIVE;
+        Class cls = targetObj.getClass();
+        while (cls != null) {
+            Field[] fields = cls.getDeclaredFields();
+            Package clsPkg = cls.getPackage();
+            for (Field field : fields) {
+//                if (isIgnored(fieldName) continue;
+                int modifiers = field.getModifiers();
+                if (field.isSynthetic() || field.isEnumConstant()
+                        || (modifiers & ignore) != 0) {
+                    continue;
+                }
+// only public and protected fields are available for different packages 
+                if (clsPkg != thisPkg
+                        && (modifiers & (Modifier.PUBLIC | Modifier.PROTECTED)) == 0) {
+                    continue;
+                }
+// private fields should be excluded for different classes               
+                if (cls != thisCls && (modifiers & Modifier.PRIVATE) != 0) {
+                    continue;
+                }
+                String name = field.getName();
+// skip overridden fields                
+                if (!accessibleFields.containsKey(name)) {
+                    accessibleFields.put(name, field);
+                }
+            }
+            cls = cls.getSuperclass();
+        }
+        return accessibleFields.values().toArray(new Field[]{});
+    }
+
+    private String fieldName(Field field) {
+        return field.getDeclaringClass().getName() + ":" + field.getName();
+    }
+
+/*
+    public static boolean isClassName(String fldName) {
+        try {
+            Class.forName(fldName);
+        } catch (ClassNotFoundException ex) {
+            return false;
+        }
+        return true;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T> T castMember(T sample, String memberName, Json jsonObj) {
+        if (jsonObj.get(memberName) != null) {
+            return JSON.cast(sample, jsonObj.get(memberName));
+        }
+        return sample;
+    }
+*/
+    /*
+    private transient Object target;
+    @SuppressWarnings("unchecked")
+    protected <T> T getTarget() {
+        return (T) target;
+    }
+
+    private transient HashSet<String> ignoredFields = new HashSet<>();
+
+    protected final boolean isIgnored(String fldName) {
+        return ignoredFields.contains(fldName);
+    }
+
+    protected final void setIgnored(String[] fldNames) {
+        ignoredFields.clear();
+        addIgnored(fldNames);
+    }
+
+    protected final void addIgnored(String[] fldNames) {
+        Collections.addAll(ignoredFields, fldNames);
+    }
+
+    protected final String[] getIgnored() {
+        return ignoredFields.toArray(new String[0]);
+    }
+     */
+
+}
diff --git a/src/org/miktim/json/JsonConvertible.java b/src/org/miktim/json/JsonConvertible.java
new file mode 100644
index 0000000..5a26731
--- /dev/null
+++ b/src/org/miktim/json/JsonConvertible.java
@@ -0,0 +1,17 @@
+/**
+ * JsonConvertible interface, MIT (c) 2024 miktim@mail.ru
+ * 
+ * Provides conversion of the accessible fields of the Java object instance
+ * to package native and vice versa.
+ */
+package org.miktim.json;
+
+public interface JsonConvertible {
+
+    static final Object IGNORED = JsonConverter.IGNORED;
+
+    Object replacer(String name, Object value);
+
+    Object reviver(String name, Object value);
+
+}
diff --git a/src/org/miktim/json/JsonObject.java b/src/org/miktim/json/JsonObject.java
index 676e71b..d635312 100644
--- a/src/org/miktim/json/JsonObject.java
+++ b/src/org/miktim/json/JsonObject.java
@@ -1,225 +1,34 @@
-/*
+/**
  * JsonObject abstract class. MIT (c) 2022-2024 miktim@mail.ru
- + Java object extender
  *
- * Unloads/loads Java object accessible fields to/from Json object.
- * - Java final, transient fields are ignored;
- * - see the notes on the Json methods set/get/cast.
+ * Converts Java object instance accessible fields to/from Json object.
+ * Java final and transient fields are ignored.
  *
  * Created: april 2022
  */
-package org.miktim.json;
 
-import java.io.IOException;
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.util.LinkedHashMap;
+package org.miktim.json;
 
-public abstract class JsonObject {
+public abstract class JsonObject extends JsonConverter {
 
     @SuppressWarnings("unchecked")
-    public Json toJson()
-            throws IllegalArgumentException, IllegalAccessException {
+    public Json toJson() {
+//            throws IllegalArgumentException, IllegalAccessException {
         return unload(this, this);
     }
 
     @SuppressWarnings("unchecked")
-    public Json toJson(Object targetObj)
-            throws IllegalArgumentException, IllegalAccessException {
-        return unload(this, targetObj);
-    }
-
-    @SuppressWarnings("unchecked")
-    public <T> T fromJson(Object nativeObj)
-            throws IllegalArgumentException, IllegalAccessException {
-        return (T)load(this, this, nativeObj);
-    }
-
-    @SuppressWarnings("unchecked")
-    public <T> T fromJson(Object targetObj, Object jsonObj)
-            throws IllegalArgumentException, IllegalAccessException {
-        return (T) load(this, targetObj, jsonObj);
-    }
-
-    protected static final transient Object IGNORED = new Object();
-
-    protected Object replacer(String name, Object value) {
-        return value;
-    }
-
-    protected Object reviver(String name, Object value) {
-        return value;
+    public <T> T fromJson(Json jsonObj) {
+//            throws IllegalArgumentException, IllegalAccessException {
+        return (T) load(this, this, jsonObj);
     }
-
+    
     @Override
     public String toString() {
         try {
-            return JSON.toJSON(JsonObject.this.toJson());
-        } catch (IllegalArgumentException | ReflectiveOperationException | IOException ex) {
-            ex.printStackTrace();
-            return ex.getMessage();
-        }
-    }
-
-    protected Json unload(JsonObject thisObj, Object targetObj) //{// returns Object
-            throws IllegalArgumentException, IllegalAccessException {
-        if (targetObj instanceof JsonObject) {
-            thisObj = (JsonObject) targetObj;
-        }
-        Object json = thisObj.replacer(targetObj.getClass().getName(), targetObj);
-        if (!(json instanceof Json)) {
-            json = new Json(); // replacer returns target object
-        }
-        Field[] fields = getAccessibleFields(thisObj, targetObj);
-        int ignored = Modifier.FINAL | Modifier.TRANSIENT;
-        for (Field field : fields) {
-            if ((field.getModifiers() & ignored) != 0) {
-                continue;
-            }
-            String fieldName = field.getName();
-
-            field.setAccessible(true);
-            Object value = field.get(targetObj);
-
-            Object newValue = thisObj.replacer(fieldName(targetObj, field),
-                    field.get(targetObj));
-            if (newValue.equals(IGNORED)) {
-                continue;
-            }
-            if (value instanceof JsonObject && !thisObj.equals(value)) {
-                newValue = thisObj
-                        .unload(thisObj, newValue);
-            }
-            if (!JSON.isNativeType(newValue) && !JSON.isNativeType(value)) {
-                newValue = unload(thisObj, newValue);
-            }
-            ((Json) json).set(fieldName, newValue);
-
-        }
-        return (Json) json;//.normalize(); //???
-    }
-
-    protected <T> T load(JsonObject thisObj, T targetObj, Object json) //{
-            throws IllegalArgumentException, IllegalAccessException {
-        if (targetObj instanceof JsonObject) {
-            thisObj = (JsonObject) targetObj;
-        }
-        json = thisObj.reviver(targetObj.getClass().getName(), json);
-        if (json instanceof Json) {
-            Field[] fields = getAccessibleFields(thisObj, targetObj);
-            int ignored = Modifier.FINAL | Modifier.TRANSIENT;
-            for (Field field : fields) {
-                if ((field.getModifiers() & ignored) != 0) {
-                    continue;
-                }
-                String fieldName = field.getName();
-                if (((Json) json).exists(fieldName)) {
-                    field.setAccessible(true);
-                    Object value = field.get(targetObj); // sample for casting
-// TODO  fieldname of JsonObject field
-                    Object newValue = thisObj.reviver(fieldName(targetObj, field),
-                            ((Json) json).get(fieldName));
-                    if (newValue.equals(IGNORED)) {
-                        continue;
-                    }
-                    if (value instanceof JsonObject) {
-                        newValue = load((JsonObject) value, value, newValue);
-                        thisObj = (JsonObject) value;
-                    }
-//                    if (!JSON.isNativeType(newValue) || (newValue instanceof Json)) {
-                    if (!JSON.isNativeType(value)) {
-                        newValue = load(thisObj, value, newValue);
-                    }
-                    field.set(targetObj, JSON.cast(value, newValue));
-                }
-            }
+            return this.toJson().toString();
+        } catch (Exception ex) {
+            throw new RuntimeException(ex.getMessage(), ex);
         }
-        return (T) targetObj;
     }
-
-    private Field[] getAccessibleFields(Object thisObj, Object targetObj) {
-        LinkedHashMap<String, Field> accessibleFields = new LinkedHashMap<>();
-        Class thisCls = thisObj.getClass();
-        Package thisPkg = thisCls.getPackage();
-        int ignore = Modifier.STRICT
-                | Modifier.INTERFACE | Modifier.ABSTRACT | Modifier.NATIVE;
-        Class cls = targetObj.getClass();
-        while (cls != null) {
-            Field[] fields = cls.getDeclaredFields();
-            Package clsPkg = cls.getPackage();
-            for (Field field : fields) {
-//                if (isIgnored(fieldName) continue;
-                int modifiers = field.getModifiers();
-                if (field.isSynthetic() || field.isEnumConstant()
-                        || (modifiers & ignore) != 0) {
-                    continue;
-                }
-// for different packages: public and protected fields 
-                if (clsPkg != thisPkg
-                        && (modifiers & (Modifier.PUBLIC | Modifier.PROTECTED)) == 0) {
-                    continue;
-                }
-// for different classes except private               
-                if (cls != thisCls && (modifiers & Modifier.PRIVATE) != 0) {
-                    continue;
-                }
-                String name = field.getName();
-// skip overridden fields                
-                if (!accessibleFields.containsKey(name)) {
-                    accessibleFields.put(name, field);
-                }
-            }
-            cls = cls.getSuperclass();
-        }
-        return accessibleFields.values().toArray(new Field[]{});
-    }
-
-    public static boolean isClassName(String fldName) {
-        try {
-            Class.forName(fldName);
-        } catch (ClassNotFoundException ex) {
-            return false;
-        }
-        return true;
-    }
-
-    private String fieldName(Object target, Field field) {
-        return target.getClass().getName() + "." + field.getName();
-    }
-// TODO ???
-
-    @SuppressWarnings("unchecked")
-    protected <T> T castMember(T sample, String memberName, Json jsonObj) {
-        if (jsonObj.get(memberName) != null) {
-            return JSON.cast(sample, jsonObj.get(memberName));
-        }
-        return sample;
-    }
-    /*
-    private transient Object target;
-    @SuppressWarnings("unchecked")
-    protected <T> T getTarget() {
-        return (T) target;
-    }
-
-    private transient HashSet<String> ignoredFields = new HashSet<>();
-
-    protected final boolean isIgnored(String fldName) {
-        return ignoredFields.contains(fldName);
-    }
-
-    protected final void setIgnored(String[] fldNames) {
-        ignoredFields.clear();
-        addIgnored(fldNames);
-    }
-
-    protected final void addIgnored(String[] fldNames) {
-        Collections.addAll(ignoredFields, fldNames);
-    }
-
-    protected final String[] getIgnored() {
-        return ignoredFields.toArray(new String[0]);
-    }
-     */
-
 }
diff --git a/test/json/Example4.java b/test/json/Example4.java
index cb8b5b5..a798e34 100644
--- a/test/json/Example4.java
+++ b/test/json/Example4.java
@@ -30,17 +30,17 @@ public Person() {
 // HashSet is not native class
         @Override
         @SuppressWarnings("unchecked")
-        protected Object replacer(String name, Object value) {
-            if (name.endsWith(".friends")) {
+        public Object replacer(String name, Object value) {
+            if (name.endsWith(":friends")) {
 // unload friends Set as array                 
-                return ((HashSet<Integer>)value).toArray();
+                return ((HashSet<Integer>)value).toArray(new Integer[0]);
             }
             return value;
         }
 
         @Override
-        protected Object reviver(String name, Object value) {
-            if (name.endsWith(".friends")) {
+        public Object reviver(String name, Object value) {
+            if (name.endsWith(":friends")) {
 // load friends Set, first create collection from array                
                    List<Integer> list = Arrays.asList(JSON.cast(Integer[].class, value));
                    return new HashSet<>(list);
@@ -49,7 +49,7 @@ protected Object reviver(String name, Object value) {
         }
     }
     public static class Persons extends Json {
-        Persons() {
+        public Persons() {
         }
         public Person remove(Object personId) {
             Person person = remove(String.valueOf(personId));
@@ -70,7 +70,8 @@ public static void main(String[] args) throws
         Json persons = new Json(fis);
         String s = persons.toJSON();
         System.out.println(s);
-        Person person = (Person)persons.get("12345");
+// TODO: !cast not use Json.converter for convertible Objs     
+        Person person = persons.castMember(Person.class, "12345");
         System.out.println(JSON.toJSON(person, 2));
     };
 }
diff --git a/test/json/JsonCastTest.java b/test/json/JsonCastTest.java
index f35b3d3..7c8e45e 100644
--- a/test/json/JsonCastTest.java
+++ b/test/json/JsonCastTest.java
@@ -9,14 +9,24 @@
 import org.miktim.json.Json;
 
 public class JsonCastTest {
+    public static class Foo {
+        public int i = 0;
+        public String s = "zero";
+        public Foo() {};
+        public Foo(int i, String s) {
+            this.i = i;
+            this.s = s;
+        }
+    }
 
-    static void log(Object s) {
-        System.out.println(String.valueOf(s));
+    static void log(Object obj) {
+        System.out.println(String.valueOf(obj));
     }
 
     public static void main(String[] args) throws Exception {
         log("JsonCast test\n\r");
 
+// TODO chars, Json arrays        
         Json json = new Json(
                 "i", 1234567,
                 "bl", true,
@@ -26,11 +36,11 @@ public static void main(String[] args) throws Exception {
                 "abl1", new boolean[]{true, false, true, false},
                 "ad1", new double[]{1.5, 2.1},
                 "e1", new Object[]{},
-                "ao2", new Object[][]{{8, 9.9, 10, 11.6}, {12, 0.0}}
+                "ao2", new Object[][]{{8, 9.9, 10, 11.6}, {12, 0.0}},
+                "aFoo", new Foo[]{new Foo(1,"one"), new Foo(2,"two"), new Foo(3, "three")}
         );
 
-//        json = json.normalize();
-        log(json);
+        log(JSON.toJSON(json,-1));
 
         byte b = 0;
         short s = 0;
@@ -79,8 +89,14 @@ public static void main(String[] args) throws Exception {
         String[][] ast2 = new String[][]{{},{}};
         String[] ast1 = new String[0];
         boolean[] abl1 = new boolean[0];
-
+        Foo[] aFoo = new Foo[0];
+        Json[] aJson = new Json[0];
         log("\n\rCast arrays:");
+//        log(JSON.toJSON(aFoo));
+        aFoo = JSON.cast(Foo[].class, json.getArray("aFoo"));
+        log(JSON.toJSON(aFoo) + " \"aFoo\" to " + aFoo.getClass().getSimpleName());
+        aJson = JSON.cast(Json[].class, json.getArray("aFoo"));
+        log(JSON.toJSON(aFoo) + " \"aFoo\" to " + aJson.getClass().getSimpleName());
         af1 = JSON.cast(af1, json.getArray("ad1"));
         log(JSON.toJSON(af1) + " \"af1\" to " + af1.getClass().getSimpleName());
         aI1 = JSON.cast(aI1, json.getArray("ad1"));
@@ -92,20 +108,18 @@ public static void main(String[] args) throws Exception {
         ast2 = JSON.cast(ast2, json.getArray("ao2"));
         log(JSON.toJSON(ast2) + " \"ai2\" to " + ast2.getClass().getSimpleName());
 // NullPointerException: "ac2" member does not exist
-//        ac2 = JSON.cast( ac2, json.getArray("ac2"));
-//        log(Arrays.deepToString(ac2) + " \"ac2\" to " + ac2.getClass().getSimpleName());
+//        ac1 = JSON.cast( ac1, json.getArray("ast1"));
+//        log(Arrays.deepToString(ac1) + " \"ast1\" to " + ac1.getClass().getSimpleName());
 // TODO ClassCastException
-//        ac1 = JSON.cast(ac1, json.getArray("ast1"));
-//        log(Arrays.toString(ac1) + " \"ac1\" to " + ac1.getClass().getSimpleName());
+        ac1 = JSON.cast(ac1, json.getArray("ast1"));
+        log(Arrays.toString(ac1) + " \"ast1\" to " + ac1.getClass().getSimpleName());
 
         ast1 = JSON.cast(ast1, json.getArray("ast1")); // !!!null cast to "null"
         log(JSON.toJSON(ast1) + " \"ast1\" to " + ast1.getClass().getSimpleName());
         abl1 = JSON.cast(abl1, json.getArray("abl1"));
         log(JSON.toJSON(abl1) + " \"abl1\" to " + abl1.getClass().getSimpleName());
-// casting char[][] to char[][][] throws java.lang.IllegalArgumentException: array element type mismatch       
-//        ac3 = JSON.cast(json.getArray("ac2"), ac3);
-// casting char[][] to char[] throws java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to java.lang.String
-//        ac1 = JSON.cast(json.getArray("ac2"), ac1);
+        abl1 = JSON.cast(abl1, json.getArray("ast1"));
+        log(JSON.toJSON(abl1) + " \"ast1\" to " + abl1.getClass().getSimpleName());
 // casting to null returns null, casting null to an array returns an empty array
 // casting null to primitive returns initial value: boolen = false, char = (char) 0, int = 0 ...
         log("\n\rCasting null or to null:");
@@ -121,6 +135,7 @@ public static void main(String[] args) throws Exception {
         log(st);
         i = JSON.cast(i, null);
         log(i);
+        log((JSON.cast(int[].class, null)).getClass().getSimpleName());
 // restore ai2 = null
         log("\n\rCast to an uninitialized array:");
         int[][] ai = JSON.cast(int[][].class, json.getArray("ao2"));
diff --git a/test/json/JsonObjectTest.java b/test/json/JsonObjectTest.java
index d271c35..7f51f91 100644
--- a/test/json/JsonObjectTest.java
+++ b/test/json/JsonObjectTest.java
@@ -4,87 +4,77 @@
 //package json; 
 
 import java.lang.reflect.Modifier;
+import java.util.ArrayList;
 import java.util.HashMap;
 import org.miktim.json.Json;
 import org.miktim.json.JsonObject;
 
 public class JsonObjectTest {
 
-    public static void log(Object s) {
-        System.out.println(String.valueOf(s));
-    }
-
-    JsonObjectTest() {
+    static void log(Object... obj) {
+        for (Object item : obj) {
+            System.out.print(String.valueOf(item) + " ");
+        }
+        System.out.println();
     }
 
-    public static class Av extends Bv {
-
-        public D objD = new D();
-        public String pubAv = "public Av";
-        protected String proAv = "protected Av";
-        String defAv = "default Av";
-        private String privAv = "private Av";
+//    JsonObjectTest() {
+//    }
+    static class F extends E {
+
+        public D objFD = new D();
+        public String pubFs = "pub Fs";
+        protected String proFs = "pro Fs";
+        String defFs = "def Fs";
+        private String privFs = "priv Fs";
+// debug fields
+        public transient ArrayList<String> namesReplaced = new ArrayList<>();
+        public transient ArrayList<String> namesRevived = new ArrayList<>();
         public transient boolean enableNames = true;
 // TODO: objC
-        public C objC = new C();
+        public C objFC = new C();
 
-        Av() {
+        F() {
         }
 
         @Override
-        protected Object replacer(String name, Object value) {
+        public Object replacer(String name, Object value) {
             if (enableNames) {
                 log(name);
             }
-            try {
-// TODO: pri_dS
-                if (name.endsWith(".objD")) {
-//                    return toJson(value);
-                }
-            } catch (Exception ex) {
-                ex.printStackTrace();
-                return IGNORED;
-            }
+            namesReplaced.add(name);
             return value;
         }
 
         @Override
-        protected Object reviver(String name, Object value) {
+        public Object reviver(String name, Object value) {
             if (enableNames) {
                 log(name);
             }
-            try {
-                if (name.endsWith(".objD")) {
-//                    fromJson(objD, (Json)value);
-//                    return IGNORED;
-                }
-            } catch (Exception ex) {
-                ex.printStackTrace();
-                return IGNORED;
-            }
+            namesRevived.add(name);
             return value;
         }
     }
 
-    public static class Bv extends JsonObject {
+    static class E extends JsonObject {
 
-        public String pubBs = "public Bv";
-        protected String proBs = "protected Bv";
-        String defBs = "default Bv";
-        private String priBs = "private Bv";
-        public transient String transBs = "transient Bv";
+        public String pubEs = "pub Es";
+        protected String proEs = "pro Es";
+        String defEs = "def Es";
+        private String priEs = "pri Es";
+        public transient String transEs = "trans Es";
 
-        Bv() {
+        E() {
         }
     }
 
-    public static class D {
+    static class D {
 
-        protected String proDs = "protected dS";
+        protected String proDs = "pro Ds";
         public int pubDi = 123;
-        String defDs = "";
-        public C pubDC = new C();
-        private String priDs = "private dS";
+        String defDs = "def Ds";
+        public C[] pubDaC = new C[]{new C(), new C(1, "one"), new C(2, "two")};
+        private String priDs = "priv Ds";
 
         D() {
         }
@@ -96,25 +86,23 @@ public static class D {
     }
 
     public static class C extends JsonObject {
-// unload/load run in the context of an instance
-// of an object, so private fields are visible
 
-        int ci = 0;
-        String cS = "some string";
+        int defCi = 0;
+        String defCs = "zero";
 
-        C() {
+        public C() {
         }
 
-        C(int i, String s) {
-            ci = i;
-            cS = s;
+        public C(int i, String s) {
+            defCi = i;
+            defCs = s;
         }
     }
 
     public static class B extends A {
 
-        double bd = 123.123;
-        D bD = new D();
+        double defBd = 123.123;
+        D defBD = new D();
 
         B() {
             super();
@@ -122,38 +110,38 @@ public static class B extends A {
         }
 
         @Override
-        protected Object replacer(String name, Object value) {
+        public Object replacer(String name, Object value) {
 //            log(name);
             try {
-                if (isClassName(name)) { // first call
+                if (name.indexOf(':') < 0) { // first call
 // ignored field was declared in A
 //                log("Ignored: " + Arrays.toString(getIgnored()));
 // private a.pri_ad field is invisible here. Unload by getter
 // on first call we MUST return Json object
-                    return (new Json()).set("set_aD", get_aD());
-                } else if (name.endsWith(".bD")) {
+                    return (new Json()).set("set_aD", get_Ad());
+                } else if (name.endsWith(":BD")) {
 //                    return toJson(value);
                 }
-            } catch (Exception e) {
+            } catch (IndexOutOfBoundsException e) {
                 e.printStackTrace();
             }
-            return super.replacer(name, value);
+            return super.replacer(name, value); // TODO target?
         }
 
         @Override
-        protected Object reviver(String name, Object value) {
+        public Object reviver(String name, Object value) {
             try {
-                if (isClassName(name)) {
+                if (name.indexOf(':') < 0) { // first call
 // load a.priv_ad by setter
-                    set_aD(castMember(get_aD(), "set_aD", (Json) value));
+                    set_Ad(((Json)value).castMember(get_Ad(), "set_aD"));
                     return IGNORED;
-                } else if (name.endsWith(".bD")) {
+                } else if (name.endsWith(":BD")) {
 //                    return fromJson(bD, (Json) value);
                 }
             } catch (Exception e) {
                 e.printStackTrace();
             }
-            return super.reviver(name, value);
+            return super.reviver(name, value); // TODO target?
         }
     }
 
@@ -162,108 +150,111 @@ public static class A extends JsonObject {
 //        public String pub_aS = "public aS";
 //        final String fin_aS = "final aS";
 //        private String pri_aS = "private aS";
-//        protected String pro_aS = "protected aS";
-        public transient String tra_aS = "transient aS";
-        private double pri_ad = 3.14159;
-        int[][] ai = new int[][]{{1, 2}, {3, 4}};
-        final HashMap<Integer, C> maC = new HashMap<>();
+//        public String pro_aS = "public aS";
+        public transient String transAs = "trans As";
+        private double priAd = 3.14159;
+        int[][] defAai = new int[][]{{1, 2}, {3, 4}};
+        HashMap<Integer, C> defAmpC = new HashMap<>();
+        public C[] pubAaC = new C[]{new C(), new C(1, "one"), new C(2, "two")};
 
         A() {
-            maC.put(3, new C(1, "one"));
-            maC.put(2, new C(2, "two"));
-            maC.put(1, new C(3, "three"));
+            defAmpC.put(3, new C(1, "one"));
+            defAmpC.put(2, new C(2, "two"));
+            defAmpC.put(1, new C(3, "three"));
 //            setIgnored(new String[]{"pub_aS"});
         }
 
-        public double get_aD() {
-            return pri_ad;
+        public double get_Ad() {
+            return priAd;
         }
 
-        public void set_aD(double ad) {
-            this.pri_ad = ad;
+        public void set_Ad(double ad) {
+            this.priAd = ad;
         }
 
         @Override
         @SuppressWarnings("unchecked")
-        protected Object replacer(String name, Object value) {
-            if (name.endsWith(".maC") && value != null) {
+        public Object replacer(String name, Object value) {
+            if (name.endsWith(":defAmpC") && value != null) {
 // unload Map
                 Json j = new Json();
-                try {
-                    for (HashMap.Entry<Integer, C> entry : ((HashMap<Integer, C>) value).entrySet()) {
-                        j.set(entry.getKey(), toJson(entry.getValue()));
-                    }
-                } catch (IllegalArgumentException | ReflectiveOperationException | IndexOutOfBoundsException ex) {
-                    ex.printStackTrace();
-//                    return IGNORED;
+                for (HashMap.Entry<Integer, C> entry : ((HashMap<Integer, C>) value).entrySet()) {
+                    j.set(entry.getKey(), Json.converter.toJson(entry.getValue()));
                 }
-//                log(j);
-                return j;
+                return new Json("HashMap", j);
             }
             return value;
         }
 
         @Override
-        protected Object reviver(String name, Object value) {
-            try {
-                if (name.endsWith(".maC") && value != null) {
+        public Object reviver(String name, Object value) {
+            if (name.endsWith(":defAmpC") && value != null) {
 // load Map
-                    maC.clear();
-                    Json j = (Json) value;
-                    for (String key : j.listNames()) {
-                        C c = fromJson(new C(), j.getJson(key));
-                        maC.put(new Integer(key), c);
-                    }
-                    return IGNORED; // aC already loaded
+                defAmpC.clear();
+                Json j = ((Json) value).getJson("HashMap");
+                for (String key : j.listNames()) {
+                    C c = Json.converter.fromJson(new C(), j.getJson(key));
+                    defAmpC.put(new Integer(key), c);
                 }
-            } catch (Exception ex) {
-                ex.printStackTrace();
-                return IGNORED;
+                return IGNORED; // aC already loaded
             }
+//
             return value;
         }
 
     }
-    A a = new A();
-    B b = new B();
-    D d = new D(456, "default dS");
-    Av av = new Av();
-
 
-public static void main(String[] args) throws Exception {
+    public static void main(String[] args) throws Exception {
         log("\n\rJsonObject test");
-        JsonObjectTest t = new JsonObjectTest();
         Json j;
-        
-        log("\n\r Av instance toJson:");
-        j = t.av.toJson();
+
+        log("\n\r A instance to/from Json:");
+        A a = new A();
+        j = a.toJson();
+        j.set("pubAaC", new C[]{new C(3, "three"), new C(4, "four")});
+        j.set("defAai", new int[][]{{5},{6}});
+        j.getJson("defAmpC").set("HashMap", new Json());
+        a.fromJson(j);
+        log(a);
+        if (!j.toString().equals(a.toString())) {
+            log("Failed! ");
+            return;
+        }
+        F f = new F();
+        log("\n\r F instance toJson:");
+        j = Json.converter.toJson(f);
         log(j);
-        j.getJson("objD").set("proDs", "updatedDs");
 //        t.av.enableNames = false;
-        log("\n\r Av instance fromJson:");
-        t.av.fromJson(j);
-        t.av.enableNames = false;
-        log(t.av.toJson());
-        log(" Av instance with Json.converter");
-        log(Json.converter.toJson(t.av));
+        log("\n\r F instance fromJson:"); // TODO inherited B fields???
+        Json.converter.fromJson(f, j);
+        if (f.namesReplaced.size() != f.namesRevived.size()) {
+            log("Failed! ");
+            return;
+        }
+        f.enableNames = false;
+        log(Json.converter.toJson(f));
+        log(" F instance with Json.converter");
+        log(Json.converter.toJson(f));
+        B b = new B();
+        D d = new D(456, "default dS");
 
         log("\n\r B instance toJson/fromJson :");
 // TODO JsonObject returns Object
-        String s = ((Json)t.b.toJson()).toJSON();
+        String s = ((Json) Json.converter.toJson(b)).toJSON();
         log(s);
-        t.b.fromJson(new Json(s));
+        Json.converter.fromJson(b, new Json(s));
 
         log(" B instance with Json.converter:");
-        j = Json.converter.toJson(t.b);
+        j = Json.converter.toJson(b);
         log(j);
-        
+
         log("\n\r D instance with Json.converter:");
-        j = Json.converter.toJson(t.d);
+        j = Json.converter.toJson(d);
         log(j);
         log(" load updated Json into new D instance");
-        j.set("proDs", "updated dS").set("pubDi", 0);
-        t.d = Json.converter.fromJson(new D(), j);
-        log(Json.converter.toJson(t.d));
+        j.set("proDs", "updated Ds").set("pubDi", 0);
+        d = Json.converter.fromJson(new D(), j);
+        log(Json.converter.toJson(d));
 
         log("\n\r java.lang.reflect.Modifier instance with Json.converter:");
         j = Json.converter.toJson(new Modifier());
diff --git a/test/json/JsonTest.java b/test/json/JsonTest.java
index 2af10be..4faa1ff 100644
--- a/test/json/JsonTest.java
+++ b/test/json/JsonTest.java
@@ -14,9 +14,10 @@
 
 public class JsonTest {
 
-    static void log(Object... s) {
-        for(int i=0; i<s.length; i++)
-            System.out.print(String.valueOf(s[i]) + " ");
+    static void log(Object... obj) {
+        for (Object item : obj) {
+            System.out.print(String.valueOf(item) + " ");
+        }
         System.out.println();
     }
     public static void main(String[] args) throws Exception {