Mathématiques.Méthode maximale en java
Comparaison INT / INT
La syntaxe est:
statique int max (int a, int b)Exemple de programme:
Importer Java.égouter.*classe theclass
public static void main (String [] args)
int x = 2;
int y = 7;
int z = mathématiques.Max (x, y);
Système.dehors.println (z);
La sortie est 7. Les mathématiques de classe sont dans le java.égouter.* emballer. Dans la méthode maximale, X ou Y peut être tapé en premier. Le programme suivant produit 7, entre -7 et +7:
Importer Java.égouter.*classe theclass
public static void main (String [] args)
int x = -7;
int y = +7;
int z = mathématiques.Max (y, x);
Système.dehors.println (z);
La sortie est 7. Le programme suivant produit -3, entre -7 et -3:
Importer Java.égouter.*classe theclass
public static void main (String [] args)
int x = -7;
int y = -3;
int z = mathématiques.Max (x, y);
Système.dehors.println (z);
La sortie est -3.
Si les deux nombres sont les mêmes, le résultat est la même valeur, comme illustré dans le programme suivant:
Importer Java.égouter.*classe theclass
public static void main (String [] args)
int x = 5;
int y = 5;
int z = mathématiques.Max (x, y);
Système.dehors.println (z);
La sortie est 5.
Comparaison longue / longue
Un long type de données est un type entier. Il doit être utilisé lorsque les gammes des entiers recherchés sont plus que celles de l'int.
La syntaxe est:
statique long max (long a, long b)Exemple de programme:
Importer Java.égouter.*classe theclass
public static void main (String [] args)
long x = 200000000;
long y = 700000000;
long z = mathématiques.Max (x, y);
Système.dehors.println (z);
La sortie est 700000000. Les mathématiques de classe sont dans le java.égouter.* emballer. Dans la méthode max (), X ou Y peut être tapé en premier. Le programme suivant produit 700000000, entre -700000000 et +700000000:
Importer Java.égouter.*classe theclass
public static void main (String [] args)
long x = -700000000;
long y = +700000000;
long z = mathématiques.Max (y, x);
Système.dehors.println (z);
La sortie est 700000000. Le programme suivant produit -300000000, entre -700000000 et -300000000:
Importer Java.égouter.*classe theclass
public static void main (String [] args)
long x = -700000000;
long y = -300000000;
long z = mathématiques.Max (x, y);
Système.dehors.println (z);
La sortie est -300000000.
Si les deux nombres sont les mêmes, le résultat est la même valeur, comme illustré dans le programme suivant:
Importer Java.égouter.*classe theclass
public static void main (String [] args)
long x = 500000000;
long y = 500000000;
long z = mathématiques.Max (x, y);
Système.dehors.println (z);
La sortie est 500000000.
Comparaison du flotteur / flotteur
Un numéro de flotteur est un nombre avec une partie décimale (fractionnaire).
La syntaxe est:
float statique Max (flottant A, flotteur b)Exemple de programme:
Importer Java.égouter.*classe theclass
public static void main (String [] args)
float x = 2.5f;
float y = 7.5f;
float z = mathématiques.Max (x, y);
Système.dehors.println (z);
La sortie est 7.5. Les mathématiques de classe sont dans le java.égouter.* emballer. Dans la méthode maximale, X ou Y peut être tapé en premier. Le programme suivant produit 7.5, entre -7.5 et +7.5:
Importer Java.égouter.*classe theclass
public static void main (String [] args)
float x = -7.5f;
float y = +7.5f;
float z = mathématiques.Max (x, y);
Système.dehors.println (z);
La sortie est 7.5. Le programme suivant produit -3.5, entre -7.5 et -3.5:
Importer Java.égouter.*classe theclass
public static void main (String [] args)
float x = -7.5f;
float y = -3.5f;
float z = mathématiques.Max (x, y);
Système.dehors.println (z);
La sortie est -3.5 .
Si les deux nombres sont les mêmes, le résultat est la même valeur, comme illustré dans le programme suivant:
Importer Java.égouter.*classe theclass
public static void main (String [] args)
float x = -2.5f;
float y = -2.5f;
float z = mathématiques.Max (x, y);
Système.dehors.println (z);
La sortie est -2.5.
Comparaison du double / double
Un numéro double est similaire à un numéro de flotteur, mais il est plus précis et n'a pas besoin du suffixe F.
La syntaxe est:
Double max statique (double a, double b)Exemple de programme:
Importer Java.égouter.*classe theclass
public static void main (String [] args)
double x = 2.5;
double y = 7.5;
double z = mathématiques.Max (x, y);
Système.dehors.println (z);
La sortie est 7.5. Les mathématiques de classe sont dans le java.égouter.* emballer. Dans la méthode max (), X ou Y peut être tapé en premier. Le programme suivant produit 7.5, entre -7.5 et +7.5:
Importer Java.égouter.*classe theclass
public static void main (String [] args)
double x = -7.5;
double y = +7.5;
double z = mathématiques.Max (x, y);
Système.dehors.println (z);
La sortie est 7.5 pour +7.5. Le programme suivant produit -3.5, entre -7.5 et -3.5:
Importer Java.égouter.*classe theclass
public static void main (String [] args)
double x = -7.5;
Double Y = -3.5;
double z = mathématiques.Max (x, y);
Système.dehors.println (z);
La sortie est -3.5 .
Si les deux nombres sont les mêmes, le résultat est la même valeur, comme illustré dans le programme suivant:
Importer Java.égouter.*classe theclass
public static void main (String [] args)
double x = 2.5;
double y = 2.5;
double z = mathématiques.Max (x, y);
Système.dehors.println (z);
La sortie est 2.5.
Nombre de types différents
Long et int peuvent être comparés. Cependant, le résultat de toute autre combinaison n'est pas fiable, surtout si les nombres sont proches. La comparaison suivante entre int et long a lieu sans aucun problème, et le résultat est valide:
Importer Java.égouter.*classe theclass
public static void main (String [] args)
int x = 15;
long y = 14;
long z = mathématiques.Max (x, y);
Système.dehors.println (z);
La sortie est 15. Dans ce type de comparaison, le résultat (retour) devrait être un type long.
Le programme suivant compare un INT et un double sans même un message d'avertissement:
Importer Java.égouter.*classe theclass
public static void main (String [] args)
int x = 8;
double y = 2.5;
double z = mathématiques.Max (x, y);
Système.dehors.println (z);
La sortie est 8.0. L'int 8 a été converti en flotteur 8.0. Bien qu'aucun message d'avertissement n'ait été donné, il n'est toujours pas conseillé de mélanger les types, sauf pour INT et Long. Les types ne doivent pas être mélangés, à titre de comparaison, car un flotteur ou un double est à peine représenté exactement.
Conclusion
Maths java.La méthode statique max () compare les nombres du même type; et renvoie le plus grand nombre. Si les nombres sont les mêmes, le même numéro est renvoyé. Les types ne doivent pas être mélangés en comparaison, sauf pour INT et long.