The Java(x, cgopts) calling sequence translates Maple code to Java code.

- If the parameter x is an algebraic expression, then a Java statement assigning the expression to a variable is generated.

- If x is a list, Maple Array, or rtable of algebraic expressions, then a sequence of Java statements assigning the elements to a Java array is produced.  Only the initialized elements of the rtable or Maple Array are translated.

- If x is a list of equations $\mathrm{nm}=\mathrm{expr}$ where $\mathrm{nm}$ is a name and $\mathrm{expr}$ is an algebraic expression, this is understood as a sequence of assignment statements.  In this case, the equivalent sequence of Java assignment statements is generated.

- If x is a procedure, then a Java class is generated containing a function equivalent to the procedure, along with any necessary import statements.

- If x is a module, then a Java class is generated, as described on the JavaDetails help page.

The parameter cgopts may include one or more CodeGeneration options, as described in CodeGenerationOptions.

For more information about how the CodeGeneration package translates Maple code to other languages, see Translation Details. For more information about translation to Java in particular, see JavaDetails.

$\mathrm{with}\left(\mathrm{CodeGeneration}\right)\:$

$\mathrm{Java}\left(x+yz-2xz\,\mathrm{resultname}=''w''\right)$

w = -2 * x * z + y * z + x;

$\mathrm{Java}\left(\left[\left[x\,2y\right]\,\left[5\,z\right]\right]\,\mathrm{resultname}=''w''\right)$

w[0][0] = x;
w[0][1] = 2 * y;
w[1][0] = 5;
w[1][1] = z;

$\mathrm{cs}≔\left[s=1.0+x\,t=\ln \left(s\right)\exp \left(-x\right)\,r=\exp \left(-x\right)+xt\right]\:$

$\mathrm{Java}\left(\mathrm{cs}\,\mathrm{optimize}\right)$

s = 0.10e1 + x;
t1 = Math.log(s);
t2 = Math.exp(-x);
t = t2 * t1;
r = x * t + t2;

$s≔\mathrm{Java}\left(x+y+1\,\mathrm{declare}=\left[x::\mathrm{float}\,y::\'\mathrm{integer}\'\right]\,\mathrm{output}=\mathrm{string}\right)$

$s≔''cg\; =\; x\; +\; (double)\; y\; +\; 0.1e1;''$

f := proc(x, y, z) return x*y-y*z+x*z; end proc:

$\mathrm{Java}\left(f\,\mathrm{defaulttype}=\mathrm{integer}\right)$

class CodeGenerationClass {
  public static int f (int x, int y, int z)
  {
    return(y * x - y * z + x * z);
  }
}

f := proc(n)
  local x, i;
  x := 0.0;
  for i to n do
    x := x + i;
  end do;
end proc:

$\mathrm{Java}\left(f\right)$

class CodeGenerationClass {
  public static double f (int n)
  {
    double x;
    int i;
    double cgret;
    x = 0.0e0;
    for (i = 1; i <= n; i++)
    {
      x = x + (double) i;
      cgret = x;
    }
    return(cgret);
  }
}

f := proc(x::Array(numeric, 5..7))
  return x[5]+x[6]+x[7];
end proc:

$\mathrm{Java}\left(f\right)$

class CodeGenerationClass {
  public static double f (double[] x)
  {
    return(x[0] + x[1] + x[2]);
  }
}

m := module() export p; local q;
    p := proc(x,y) if y>0 then trunc(x); else ceil(x); end if; end proc:
    q := proc(x) sin(x)^2; end proc:
end module:

$\mathrm{Java}\left(m\&comma;\mathrm{resultname}=\mathrm{t0}\right)$

import java.lang.Math;

class m {
  public static int p (double x, int y)
  {
    if (0 < y)
      return((int)(x));
    else
      return((int)Math.ceil(x));
  }
  private static double q (double x)
  {
    return(Math.pow(Math.sin(x), 0.2e1));
  }
}

$\mathrm{Java}\left(2\cosh \left(x\right)-7\tanh \left(x\right)\right)$

cg0 = 0.2e1 * (Math.exp(x) + Math.exp((-0.1e1) * x)) / 0.2e1 - 0.7e1 * (Math.exp(0.2e1 * x) - 0.1e1) / (Math.exp(0.2e1 * x) + 0.1e1);

f := proc(a::integer, p::integer)
  printf("The integer remainder of %d divided by %d is: %d\n", a, p, irem(a, p));
end proc:

$\mathrm{Java}\left(f\right)$

class CodeGenerationClass {
  public static void f (int a, int p)
  {
    System.out.println("The integer remainder of " + a + " divided by " + p + " is: " + a % p);
  }
}