pip install jpype1==1.4.1

import jpype
print("JPype版本：", jpype.__version__)
if not jpype.isJVMStarted():
    jpype.startJVM(jpype.getDefaultJVMPath())
    print("JVM啟動(dòng)成功")
    jpype.shutdownJVM()

jvm_path = jpype.getDefaultJVMPath()
# 配置JVM參數(shù)
jvm_args = [
    "-Xms512m", 
    "-Xmx2048m",
    "-Djava.class.path=./myjava.jar"
]
jpype.startJVM(jvm_path, *jvm_args)

# math_utils.py
def add(a, b):
    return a + b

def multiply(a, b):
    return a * b

class Calculator:
    def __init__(self):
        self.name = "Python計(jì)算器"
    
    def power(self, x, n):
        return x **n

import org.jpype.Python;
import org.jpype.Proxy;
import org.jpype.JPypeContext;

public class PythonCaller {
    public static void main(String[] args) {
        // 啟動(dòng)JVM并指定Python路徑
        String jvmPath = JPypeContext.getDefaultJVMPath();
        JPypeContext.startJVM(jvmPath, "-Dpython.path=./");
        
        try {
            // 導(dǎo)入Python模塊
            Proxy mathUtils = Python.importModule("math_utils");
            
            // 調(diào)用Python函數(shù)
            int sum = (int) mathUtils.call("add", 3, 5);
            System.out.println("3 + 5 = " + sum);
            
            // 創(chuàng)建Python類實(shí)例
            Proxy calculator = mathUtils.call("Calculator");
            
            // 調(diào)用實(shí)例方法
            double result = (double) calculator.call("power", 2, 10);
            System.out.println("2^10 = " + result);
        } finally {
            // 關(guān)閉JVM
            JPypeContext.shutdownJVM();
        }
    }
}

try {
    Proxy utils = Python.importModule("non_existent_module");
} catch (Exception e) {
    System.err.println("模塊導(dǎo)入失?。? + e.getMessage());
}

try {
    Proxy mathUtils = Python.importModule("math_utils");
    mathUtils.call("add", "string", 5); // 錯(cuò)誤的參數(shù)類型
} catch (Exception e) {
    System.err.println("函數(shù)調(diào)用錯(cuò)誤：" + e.getMessage());
}

import jpype
from jpype import JClass, JString

# 啟動(dòng)JVM（假設(shè)已包含所需的Java類）
jpype.startJVM(jpype.getDefaultJVMPath(), "-Djava.class.path=./myapp.jar")

# 加載Java類
ArrayList = JClass("java.util.ArrayList")
HashMap = JClass("java.util.HashMap")

# 創(chuàng)建Java對(duì)象
array_list = ArrayList()
array_list.add("Python")
array_list.add("Java")
print("列表大?。?, array_list.size())

# 調(diào)用Java方法
hash_map = HashMap()
hash_map.put("name", JString("JPype"))
hash_map.put("version", JString("1.4.1"))
print("Map內(nèi)容：", hash_map.get("name"))

# 關(guān)閉JVM
jpype.shutdownJVM()

// 定義回調(diào)接口
public interface CalculatorCallback {
    int calculate(int a, int b);
}

// 使用回調(diào)的Java類
public class Processor {
    public int process(int x, int y, CalculatorCallback callback) {
        return callback.calculate(x, y);
    }
}

import jpype
from jpype import JClass, JImplements, JOverride

# 啟動(dòng)JVM
jpype.startJVM(jpype.getDefaultJVMPath(), "-Djava.class.path=./")

# 實(shí)現(xiàn)Java接口
@JImplements("CalculatorCallback")
class PythonCallback:
    @JOverride
    def calculate(self, a, b):
        # 在Python中實(shí)現(xiàn)計(jì)算邏輯
        return a * b + a + b

# 創(chuàng)建Java處理器實(shí)例
Processor = JClass("Processor")
processor = Processor()

# 傳遞Python回調(diào)對(duì)象
result = processor.process(3, 4, PythonCallback())
print("處理結(jié)果：", result)  # 輸出3*4+3+4=19

jpype.shutdownJVM()

# 操作帶泛型的Java類
List = JClass("java.util.List")
ArrayList = JClass("java.util.ArrayList")

# 創(chuàng)建泛型列表
str_list = ArrayList()
str_list.add("Hello")
str_list.add("World")

# 遍歷列表
for item in str_list:
    print(item)

# 調(diào)用繼承的方法
Object = JClass("java.lang.Object")
print(isinstance(str_list, Object))  # 輸出True（ArrayList繼承自O(shè)bject）

import tensorflow as tf
import numpy as np
from PIL import Image

class ImageClassifier:
    def __init__(self, model_path):
        # 加載預(yù)訓(xùn)練模型
        self.model = tf.keras.models.load_model(model_path)
        # 類別標(biāo)簽
        self.labels = ["cat", "dog", "bird", "flower"]
    
    def preprocess_image(self, image_path):
        # 圖像預(yù)處理
        img = Image.open(image_path).resize((224, 224))
        img_array = np.array(img) / 255.0
        return np.expand_dims(img_array, axis=0)
    
    def classify(self, image_path):
        # 圖像分類
        processed_img = self.preprocess_image(image_path)
        predictions = self.model.predict(processed_img)
        predicted_class = self.labels[np.argmax(predictions)]
        confidence = float(np.max(predictions))
        return {
            "class": predicted_class,
            "confidence": confidence
        }

import org.jpype.Python;
import org.jpype.Proxy;
import org.jpype.JPypeContext;
import java.util.Map;

public class ImageClassificationService {
    private Proxy classifier;
    
    public ImageClassificationService(String modelPath) {
        // 初始化分類器
        classifier = Python.importModule("image_classifier").call("ImageClassifier", modelPath);
    }
    
    public ClassificationResult classifyImage(String imagePath) {
        try {
            // 調(diào)用Python分類方法
            Map<String, Object> result = (Map<String, Object>) classifier.call("classify", imagePath);
            
            // 封裝結(jié)果
            return new ClassificationResult(
                (String) result.get("class"),
                (Double) result.get("confidence")
            );
        } catch (Exception e) {
            throw new RuntimeException("圖像分類失敗：" + e.getMessage());
        }
    }
    
    public static void main(String[] args) {
        // 啟動(dòng)JVM，指定TensorFlow所需環(huán)境
        String jvmArgs = "-Dpython.path=./;../venv/lib/site-packages";
        JPypeContext.startJVM(JPypeContext.getDefaultJVMPath(), jvmArgs);
        
        try {
            ImageClassificationService service = new ImageClassificationService("./model.h5");
            ClassificationResult result = service.classifyImage("./test.jpg");
            System.out.println("分類結(jié)果：" + result.getClassName() + 
                               "，置信度：" + result.getConfidence());
        } finally {
            JPypeContext.shutdownJVM();
        }
    }
}

// 結(jié)果封裝類
class ClassificationResult {
    private String className;
    private double confidence;
    
    // 構(gòu)造方法、getter等省略
}