Matematica.Metodo massimo in Java

Il metodo Java Max () restituisce il massimo di due numeri. I numeri confrontati dovrebbero essere dello stesso tipo. Possono essere di int/int, lunghi/lunghi, galleggianti/galleggianti o doppi/doppi. Per questo, il Java.Lang.La lezione di matematica deve essere importata (ma non obbligatoria).

Confrontando Int/Int

La sintassi è:

static int max (int a, int b)

Programma di esempio:

Importa Java.Lang.*;
class theclass
public static void main (string [] args)
int x = 2;
int y = 7;
int z = matematica.max (x, y);
Sistema.fuori.println (z);

L'output è 7. La matematica di classe è nel Java.Lang.* pacchetto. Nel metodo Max, X o Y possono essere digitati prima. Il seguente programma produce 7, tra -7 e +7:

Importa Java.Lang.*;
class theclass
public static void main (string [] args)
int x = -7;
int y = +7;
int z = matematica.max (y, x);
Sistema.fuori.println (z);

L'output è 7. Il seguente programma produce -3, tra -7 e -3:

Importa Java.Lang.*;
class theclass
public static void main (string [] args)
int x = -7;
int y = -3;
int z = matematica.max (x, y);
Sistema.fuori.println (z);

L'output è -3.

Se i due numeri sono uguali, il risultato ha lo stesso valore, come illustrato nel seguente programma:

Importa Java.Lang.*;
class theclass
public static void main (string [] args)
int x = 5;
int y = 5;
int z = matematica.max (x, y);
Sistema.fuori.println (z);

L'output è 5.

Confronto a lungo/lungo

Un tipo di dati lungo è un tipo intero. Dovrebbe essere usato quando le gamme di numeri interi desiderati sono più di quello per l'int.

La sintassi è:

statico lungo max (lungo a, lungo b)

Programma di esempio:

Importa Java.Lang.*;
class theclass
public static void main (string [] args)
lungo x = 2000000;
lungo y = 700000000;
Long Z = matematica.max (x, y);
Sistema.fuori.println (z);

L'output è 700000000. La matematica di classe è nel Java.Lang.* pacchetto. Nel metodo max (), X o Y possono essere digitati prima. Il seguente programma produce 700000000, tra -7000000 e +700000000:

Importa Java.Lang.*;
class theclass
public static void main (string [] args)
lungo x = -700000000;
lungo y = +700000000;
Long Z = matematica.max (y, x);
Sistema.fuori.println (z);

L'output è 700000000. I seguenti programmi emette -300000000, tra -7000000 e -300000000:

Importa Java.Lang.*;
class theclass
public static void main (string [] args)
lungo x = -700000000;
lungo y = -300000000;
Long Z = matematica.max (x, y);
Sistema.fuori.println (z);

L'output è -300000000.

Se i due numeri sono uguali, il risultato ha lo stesso valore, come illustrato nel seguente programma:

Importa Java.Lang.*;
class theclass
public static void main (string [] args)
lungo x = 500000000;
lungo y = 500000000;
Long Z = matematica.max (x, y);
Sistema.fuori.println (z);

L'output è 500000000.

Confrontare il galleggiante/galleggiante

Un numero di galleggiante è un numero con una parte decimale (frazionaria).

La sintassi è:

Float statico Max (galleggiante A, galleggiante B)

Programma di esempio:

Importa Java.Lang.*;
class theclass
public static void main (string [] args)
float x = 2.5f;
fluttuare y = 7.5f;
float z = matematica.max (x, y);
Sistema.fuori.println (z);

L'output è 7.5. La matematica di classe è nel Java.Lang.* pacchetto. Nel metodo Max o x o y può essere digitato per primo. Il seguente programma produce 7.5, tra -7.5 e +7.5:

Importa Java.Lang.*;
class theclass
public static void main (string [] args)
float x = -7.5f;
float y = +7.5f;
float z = matematica.max (x, y);
Sistema.fuori.println (z);

L'output è 7.5. Il seguente programma produce -3.5, tra -7.5 e -3.5:

Importa Java.Lang.*;
class theclass
public static void main (string [] args)
float x = -7.5f;
float y = -3.5f;
float z = matematica.max (x, y);
Sistema.fuori.println (z);

L'output è -3.5 .

Se i due numeri sono uguali, il risultato ha lo stesso valore, come illustrato nel seguente programma:

Importa Java.Lang.*;
class theclass
public static void main (string [] args)
float x = -2.5f;
float y = -2.5f;
float z = matematica.max (x, y);
Sistema.fuori.println (z);

L'output è -2.5.

Confrontare il doppio/doppio

Un doppio numero è simile a un numero di galleggiante, ma è più preciso e non ha bisogno del suffisso f.

La sintassi è:

Static Double Max (Double A, Double B)

Programma di esempio:

Importa Java.Lang.*;
class theclass
public static void main (string [] args)
doppio x = 2.5;
doppio y = 7.5;
doppia z = matematica.max (x, y);
Sistema.fuori.println (z);

L'output è 7.5. La matematica di classe è nel Java.Lang.* pacchetto. Nel metodo max (), X o Y possono essere digitati prima. Il seguente programma produce 7.5, tra -7.5 e +7.5:

Importa Java.Lang.*;
class theclass
public static void main (string [] args)
doppio x = -7.5;
Double y = +7.5;
doppia z = matematica.max (x, y);
Sistema.fuori.println (z);

L'output è 7.5 per +7.5. Il seguente programma produce -3.5, tra -7.5 e -3.5:

Importa Java.Lang.*;
class theclass
public static void main (string [] args)
doppio x = -7.5;
Double y = -3.5;
doppia z = matematica.max (x, y);
Sistema.fuori.println (z);

L'output è -3.5 .

Se i due numeri sono uguali, il risultato ha lo stesso valore, come illustrato nel seguente programma:

Importa Java.Lang.*;
class theclass
public static void main (string [] args)
doppio x = 2.5;
doppio y = 2.5;
doppia z = matematica.max (x, y);
Sistema.fuori.println (z);

L'output è 2.5.

Numeri di tipi diversi

Long and int può essere confrontato. Tuttavia, il risultato di qualsiasi altra combinazione non è affidabile, soprattutto se i numeri sono vicini. Il seguente confronto tra INT e Long avviene senza alcun problema e il risultato è valido:

Importa Java.Lang.*;
class theclass
public static void main (string [] args)
int x = 15;
lungo y = 14;
Long Z = matematica.max (x, y);
Sistema.fuori.println (z);

L'output è 15. In questo tipo di confronto, il risultato (reso) dovrebbe essere un tipo lungo.

Il seguente programma confronta un INT e un doppio senza nemmeno un messaggio di avvertimento:

Importa Java.Lang.*;
class theclass
public static void main (string [] args)
int x = 8;
doppio y = 2.5;
doppia z = matematica.max (x, y);
Sistema.fuori.println (z);

L'output è 8.0. L'int 8 è stato convertito in un galleggiante 8.0. Sebbene non sia stato dato alcun messaggio di avviso, non è ancora consigliabile mescolare i tipi, tranne che per int e lungo. I tipi non devono essere miscelati, per il confronto, perché un galleggiante o un doppio non è appena rappresentato esattamente.

Conclusione

Java Math.Il metodo statico max () confronta i numeri dello stesso tipo; e restituisce il numero più grande. Se i numeri sono gli stessi, viene restituito lo stesso numero. I tipi non devono essere miscelati in confronto, ad eccezione di int e lunghi.