Une méthode est capable de retourner une valeur fabriquée localement, d'un type quelconque exploitable à l'endroit où l'appel s'est produit, en général une méthode d'un niveau supérieur.

[modif] type_retour nomMethode([liste_params]){
  // instructions...
  return valeur;
}

A cet effet, une méthode dispose de :

• l'instruction return, destinée à retourner un résultat,
• un type de retour situé dans la signature de la méthode, indiquant le type du résultat renvoyé.

class UneClasse {
  public static void main(String[] args){
    double r = 10;
    double resultat = surface(r);
    System.out.println("Surface d'un cercle de "+ r + "cm : " + resultat);
  }
  public static double surface(double rayon){
    return (Math.pow(rayon, 2) * Math.PI) / 2;
  }
}

L'évaluation de l'instruction return par la Machine Virtuelle Java, entraîne l'arrêt immédiat de l'exécution de la méthode courante, ainsi que le transfert le résultat de l'expression à l'appelant.

Il est possible de placer plusieurs instructions return dans une méthode, mais à l'unique condition que chaque commande de ce type soit placée dans une structure conditionnelle.

class UneClasse {
  public static void main(String[] args){
    double v = 10;
    char t = 'd';
    System.out.println("Surface d'un cercle d'un " 
                       + (t == 'r' ? "rayon" : "diametre") 
                       + " de " + v + "cm : " + surface(v, t) + "cm2");
  }
  public static double surface(double val, char type){
    if(type == 'r')
        return (Math.pow(val, 2) * Math.PI) / 2;
    else if(type == 'd')
        return (Math.pow(val, 2) * 2 * Math.PI) / 4;
    else
        System.out.println ("Le type de la valeur n'a pas été spécifiée !");
        return 0.0;
  }
}

Une méthode peut retourner aussi bien une valeur primitive (char, int, double, etc.) qu'un objet (String, Vector, File, etc.).
Dans le premier cas, une copie de valeur est réalisée entre le résultat produit par la méthode appelée et l'éventuelle variable, méthode ou expression destinée à recevoir ce résultat.
Dans le second cas, c'est une copie de la référence de l'objet résultant qui est accomplie. De cette manière, lorsque la méthode appelée cesse son activité, la référence d'origine est détruite, mais l'objet reste disponible dans le programme par l'intermédiaire de la copie de référence.

import java.net.*;
import java.io.*;
public class UneClasse {
  public static void main(String[] args) throws IOException {
    URL resCon = saisieAdresse();
    System.out.println ("Protocole : " + resCon.getProtocol() 
              + "\nHote : " + resCon.getHost() 
              + "\nChemin : " + resCon.getPath() 
              + "\nFichier : " + resCon.getFile() 
              + "\nRequete : " + resCon.getQuery());
  }
  public static URL saisieAdresse() throws IOException {
    String url = "http://www.unsite.com/rep/fichier.html?requete=valeur";
    URL adresse = new URL(url);
    return adresse;
  }
}

Il est tout à fait possible de ne pas utiliser la valeur de retour d'une méthode. Cela est souvent le cas dans les méthodes qui ne retourneraient qu'une valeur booléenne indiquant la réussite (true) ou l'échec (false) du traitement.

import java.net.*;
import java.io.*;
public class UnClass {
  public static void main(String[] args) throws IOException {
    URL resCon = saisieAdresse();
    affichage(resCon);
  }
  public static URL saisieAdresse() throws IOException {
    String url = "http://www.unsite.com/rep/fichier.html?requete=valeur";
    URL adresse = new URL(url);
    return adresse;
  }
  public static boolean affichage(URL adr) throws IOException {
    if(!adr.equals("")){
      System.out.println ("Protocole : " + adr.getProtocol() 
                + "\nHote : " + adr.getHost() 
                + "\nChemin : " + adr.getPath() 
                + "\nFichier : " + adr.getFile() 
                + "\nRequete : " + adr.getQuery());
      return true;
    }
    else {
      System.out.println ("L'adresse URL est vide !");
      return false;
    }
  }
}

Si une méthode retourne une valeur, il faut impérativement spécifier un type de retour dans la signature de la méthode, sinon une erreur de compilation se produira indubitablement.

A l'inverse, si une méthode ne renvoie aucune valeur, alors le mot-clé spécial void doit être spécifié afin d'indiquer explicitement cette caractéristique.