One solution. You could use some sort of message system, queue, or broker of some sort to serialize/deserialize, or pass messages between python and java. Then create some sort workers/producer/consumers to put work on the queues to be processed in python, or java.

Also consider checking out for inspiration: https://www.py4j.org/

py4j is used heavily by/for pyspark and hadoop type stuff.

To answer your question more immediately.

Example using json-simple.:

import org.apache.commons.io.FileUtils;
import org.json.simple.JSONObject;
 //import org.json.simple.JSONObject;
  

public class TestObject 
{
   private double[] values;
   private int length;
   private int anotherVariable;
   private boolean someBool;
   private String someString;

   //getters, setters

   public String toJSON() {
       JSONObject obj=new JSONObject();
       obj.put("values",new Double(this.values));
       obj.put("length",new Integer(this.length));
       obj.put("bool_val",new Boolean(this.SomeBool));
       obj.put("string_key",this.someString);
       StringWriter out = new StringWriter();
       obj.writeJSONString(out);
       return out.toString();
   }

   public void writeObject(){
          Writer writer = new BufferedWriter(
                              new OutputStreamWriter(
                                  new FileOutputStream("anObject.json"), "utf-8")
                              )
                           )

          writer.write(this.toJSON());
   }

   public static void setObject(){
       values = 100.134;
       length = 12;
       anotherVariable = 15;
       someString = "spam";
   }
 }

And in python:

class DoStuffWithObject(object):
    def __init__(self,obj):
        self.obj = obj
        self.changeObj()
        self.writeObj()

    def changeObj(self):
        self.obj['values'] = 100.134;
        self.obj['length'] = 12;
        self.obj['anotherVariable'] = 15;
        self.obj['someString'] = "spam";

    def writeObj(self):
        ''' write back to file '''
        with open('anObject.json', 'w') as f:
            json.dump(self.obj, f)

    def someOtherMethod(self, s):
       ''' do something else '''
       print('hello {}'.format(s))

import json
with open('anObject.json','r') as f:
    obj = json.loads(f.read())
# print out obj['values'] obj['someBool'] ...
for key in obj:
    print(key, obj[key])

aThing = DoStuffWithObject(obj)
aThing.someOtherMethod('there')

And then in java read back the object. There are solutions that exist implementing this idea (JSON-RPC, XML-RPC, and variants). Depending, you may may also want to consider using something like ( http://docs.mongodb.org/ecosystem/drivers/java/ ) the benefit being that mongo does json.

See:

• https://spring.io/guides/gs/messaging-reactor/
• http://spring.io/guides/gs/messaging-rabbitmq/
• http://spring.io/guides/gs/scheduling-tasks/
• Celery like Java projects
• Jedis
• RabbitMQ
• ZeroMQ

A more comprehensive list of queues:

• http://queues.io/

Resources referenced:

• http://www.oracle.com/technetwork/articles/java/json-1973242.html
• How do I create a file and write to it in Java?
• https://code.google.com/p/json-simple/wiki/EncodingExamples

Using self would imply that you are calling the function from inside a class.

Edit: As an alternative you can use Unmarshaller object directly:

import javaobj

with open("objCollections.ser") as fobj : 
    marshaller = javaobj.JavaObjectUnmarshaller(fobj)
    pobj = marshaller.readObject()

As you can see in the docs:

https://pypi.org/project/javaobj-py3/

You could also use Py4J. There is an example on the frontpage and lots of documentation, but essentially, you just call Java methods from your python code as if they were python methods:

from py4j.java_gateway import JavaGateway
gateway = JavaGateway()                        # connect to the JVM
java_object = gateway.jvm.mypackage.MyClass()  # invoke constructor
other_object = java_object.doThat()
other_object.doThis(1,'abc')
gateway.jvm.java.lang.System.out.println('Hello World!') # call a static method

As opposed to Jython, one part of Py4J runs in the Python VM so it is always "up to date" with the latest version of Python and you can use libraries that do not run well on Jython (e.g., lxml). The other part runs in the Java VM you want to call.

The communication is done through sockets instead of JNI and Py4J has its own protocol (to optimize certain cases, to manage memory, etc.)

Disclaimer: I am the author of Py4J