వివరంగా రేపర్ తరగతులు

1. Integerతరగతి

Integerక్లాస్‌గా ఉండటం కూడా మంచిది, అంటే దానికి ఫీల్డ్‌లు మరియు పద్ధతులు ఉండవచ్చు. మరియు, వాస్తవానికి, అది వాటిని కలిగి ఉంది. వాటిలో చాలా - డజన్ల కొద్దీ. ఇక్కడ మేము చాలా ప్రాథమిక వాటిని పరిశీలిస్తాము.

తరగతికి Integerరెండు ఫీల్డ్‌లు ఉన్నాయి, అవి రకం యొక్క గరిష్ట మరియు కనిష్ట సాధ్యమైన విలువలను కలిగి ఉంటాయి int:

Integer.MAX_VALUE

Integer.MIN_VALUE

intకొన్నిసార్లు మీరు వేరియబుల్‌కు సాధ్యమయ్యే చిన్న లేదా అతిపెద్ద విలువను కేటాయించాలనుకుంటున్నారు . అపారమయిన స్థిరాంకాలతో మీ కోడ్‌ను చిందరవందర చేయడాన్ని నివారించడానికి, మీరు దీన్ని చాలా స్పష్టంగా ఈ క్రింది విధంగా వ్రాయవచ్చు:

int min = Integer.MIN_VALUE;

min == 0x80000000

తరగతిలో Integerకొన్ని ఆసక్తికరమైన పద్ధతులు కూడా ఉన్నాయి. వారు ఇక్కడ ఉన్నారు:

String Integer.toHexString(int)

String Integer.toBinaryString(int)

String Integer.toOctalString(int)

Integer Integer.valueOf(int i)

Integer Integer.parseInt(String)

మీరు మునుపు స్టాటిక్ Integer.parseInt()పద్ధతిని ఎదుర్కొన్నారు. ఇది ఎలా పనిచేస్తుందో గుర్తుచేసుకుందాం:

int name = Integer.parseInt(string);

ఒక సంఖ్యను (అంకెలు మాత్రమే) కలిగి ఉన్న స్ట్రింగ్ పద్ధతికి పంపబడితే parseInt(), అది స్ట్రింగ్‌ను అన్వయించి, అందులో ఉన్న సంఖ్యను తిరిగి ఇస్తుంది.

మిగిలిన పద్ధతులు కూడా ఉపయోగపడతాయి. ఉదాహరణకు, వాటిలో కొన్ని పాస్ చేసిన సంఖ్యను సంఖ్య యొక్క బైనరీ, ఆక్టల్ లేదా హెక్సాడెసిమల్ ప్రాతినిధ్యం ఉన్న స్ట్రింగ్‌గా మార్చగలవు.

2. Doubleతరగతి

సాధారణంగా, Doubleతరగతి తరగతిని పోలి ఉంటుంది Integer, ఇది doubleఒక కంటే a కాకుండా చుట్టబడుతుంది int. ఇందులో మనకు ఆసక్తి కలిగించే ఫీల్డ్‌లు మరియు పద్ధతులు కూడా ఉన్నాయి. వాటిలో కొన్నింటిని పరిగణించండి:

తరగతి Doubleఆరు ఆసక్తికరమైన ఫీల్డ్‌లను కలిగి ఉంది:

double Double.NEGATIVE_INFINITY

double Double.POSITIVE_INFINITY

int Double.MIN_EXPONENT

int Double.MAX_EXPONENT

double Double.MIN_VALUE

double Double.MAX_VALUE

అనంతం

-1.0మీరు ద్వారా విభజించినట్లయితే 0.0, మీరు ప్రతికూల అనంతాన్ని పొందుతారు. 1.0మీరు ద్వారా విభజించినట్లయితే 0.0, మీరు సానుకూల అనంతాన్ని పొందుతారు. మీరు a ని సున్నా ద్వారా విభజించడమే కాకుండా double, మీరు ఈ ఆపరేషన్ల ఫలితాన్ని నిల్వ చేయడానికి కూడా ఉపయోగించవచ్చు.

a యొక్క ఘాతాంకంdouble

ఘాతాంకాన్ని అర్థం చేసుకోవడం సులభం. అంతర్గతంగా, డబుల్‌లో మాంటిస్సా మరియు ఘాతాంకం ఉంటాయి. కానీ ఇక్కడ ఘాతాంకం విలువ కాదు . ఈ విధంగా, ఘాతాంకం పెరిగితే , సంఖ్య యొక్క మొత్తం విలువ రెట్టింపు అవుతుంది.10x2x1

MIN_EXPONENT == -1024, అంటే , ఇది సుమారుగా సమానం2-102410-308

మరియు వాస్తవానికి, Doubleతరగతికి ఆసక్తికరమైన పద్ధతులు ఉన్నాయి:

String Double.toHexString(double)

boolean Double.isInfinite(double)

boolean Double.isNaN(double)

Double Double.valueOf(double)

Double Double.parseDouble(String)

ఆసక్తికరంగా, పాస్ చేసిన సంఖ్య పాజిటివ్ లేదా నెగటివ్ ఇన్ఫినిటీ అయితే isInfinite()తిరిగి ఇచ్చే పద్ధతి ఉంది .true

పద్ధతి isNaN()సారూప్యంగా ఉంటుంది - ఇది ఆమోదించబడిన సంఖ్య కాదా అని తనిఖీ చేస్తుంది NaN( ఒక సంఖ్య కాదు , నిర్వచించబడని విలువను సూచించే ప్రత్యేక స్థిరాంకం).

3. Characterతరగతి

Characterక్యారెక్టర్‌లు వివిధ వర్గాలకు చెందినవా అని తనిఖీ చేయడానికి మిమ్మల్ని అనుమతించే దాని పెద్ద సంఖ్యలో స్టాటిక్ యుటిలిటీ పద్ధతుల కోసం క్లాస్ ఆసక్తికరంగా ఉంటుంది .

ఉదాహరణలు

Character.isAlphabetic(int)

Character.isLetter(char)

Character.isDigit(char)

Character.isSpaceChar(char)

Character.isWhitespace(char)

Character.isLowerCase(char)

Character.isUpperCase(char)

Character.toLowerCase(char)

Character.toUpperCase(char)

ఈ పద్ధతుల యొక్క లక్షణం ఏమిటంటే అవి అన్ని తెలిసిన వర్ణమాలలతో పని చేస్తాయి: అరబిక్ సంఖ్యలు అంకెలుగా వర్గీకరించబడ్డాయి, మొదలైనవి.

4. Booleanతరగతి

రకం Booleanవాస్తవంగా రకానికి సమానంగా ఉంటుంది boolean. తేడాలు తక్కువ.

క్రింద మేము తరగతి యొక్క సరళీకృత సంస్కరణను చూపుతాము Boolean:

class Boolean
{
   public static final Boolean TRUE = new Boolean(true);
   public static final Boolean FALSE = new Boolean(false);

   private final boolean value;

   public Boolean(boolean value)
   {
      this.value = value;
   }

   public boolean booleanValue()
   {
      return value;
   }

   public static Boolean valueOf(boolean value)
   {
      return (value ? TRUE : FALSE);
   }
}

రకానికి Booleanరెండు స్థిరాంకాలు ఉన్నాయి (రెండు ఫీల్డ్‌లు):

Boolean.TRUE

true

Boolean.FALSE

false

మీరు ఈ రకంతో పని చేసే విధంగానే మీరు వారితో పని చేయవచ్చు boolean:

if (Boolean.TRUE)
{
}

Boolean a = Boolean.TRUE;
boolean b = Boolean.TRUE;
boolean c = true;

Boolean a = Boolean.TRUE;
Boolean b = Boolean.TRUE;
if (a == b)

ఆటోబాక్సింగ్ ఇక్కడ అద్భుతంగా పనిచేస్తుంది. అంటే మీరు ఈ రకాన్ని రకాన్ని అదే విధంగా ఉపయోగించవచ్చు boolean— గమనించవలసిన ఆపదలు లేవు.

Boolean a = true;
Boolean b = true;
Boolean c = false;
boolean d = a;

Boolean a = Boolean.valueOf(true);
Boolean b = Boolean.valueOf(true);
Boolean c = Boolean.valueOf(false);
boolean d = a.booleanValue();

booleanమరియు ఇక్కడ రకాలు మరియు వాటి పోలిక Boolean:

boolean a = true;
Boolean b = true; // b will be equal to Boolean.TRUE
Boolean c = true; // c will be equal to Boolean.TRUE

a == b; // true (compared by value)
a == c; // true (compared by value)
b == c; // true (compared by reference, but they point to the same object)

మీకు నిజంగా స్వతంత్ర వస్తువు అవసరమైతే Boolean, మీరు దానిని స్పష్టంగా సృష్టించాలి:

boolean a = true;
Boolean b = new Boolean(true); // New Boolean object
Boolean c = true; // c will be equal to Boolean.TRUE

a == b; // true (compared by value)
a == c; // true (compared by value)
b == c; // false (compared by reference, and they point to different objects)

మరొక ఉదాహరణ, ఇక్కడ మనం ఒక Booleanలోపలి భాగాన్ని ఉపయోగిస్తాము if:

Boolean less = (2 < 3);
if (less)
{
   ...
}

ఇది కంపైల్ అవుతుంది, కానీ ఇది పని చేయదు!

Boolean less = null;
if (less)
{
   ...
}

5. ఆటోబాక్సింగ్ సమయంలో కాషింగ్ విలువలు

పూర్ణాంక రేపర్ రకాలకు సంబంధించి కొన్ని ఆపదలు ఉన్నాయి.

intమీకు ఇప్పటికే తెలిసినట్లుగా, మేము ఒక మరియు aని పోల్చినట్లయితే Integer, ఇది Integerఒకదిగా మార్చబడుతుంది int:

int a = 5;
Integer b = 5;
if (a == b)
{
   ...
}

int a = 5;
Integer b = Integer.valueOf(5);
if (a == b.intValue())
{
   ...
}

మీరు రెండు వస్తువులను ఒకదానితో ఒకటి పోల్చినట్లయితే , అవి s Integerకి మార్చబడవు :int

Integer a = 500;
Integer b = 500;
int c = 500;

System.out.println(a == b); // Compared by reference
System.out.println(a == c);
System.out.println(b == c);

false
true
true

a == cమరియు , కానీ , ఎందుకంటే మనం పోల్చినప్పుడు మరియు మేము సూచనలను పోల్చినప్పుడు. ఇది తప్పనిసరిగా మనం ఆశించేది.b == ca != bab

ఆశ్చర్యం

500కానీ మేము తో భర్తీ చేస్తే 100, మేము పూర్తిగా భిన్నమైన ఫలితాన్ని పొందుతాము:

Integer a = 100;
Integer b = 100;
int c = 100;

System.out.println(a == b); // Compared by reference
System.out.println(a == c);
System.out.println(b == c);

true
true
true

ఇక్కడ సమస్య ఏమిటంటే ఆటోబాక్సింగ్ సమయంలో కొత్త Integerవస్తువు ఎల్లప్పుడూ సృష్టించబడదు . -128వస్తువులు కలుపుకోవడం ద్వారా విలువల కోసం కాష్ చేయబడతాయి 127.

తరగతి Integerవస్తువులను నిల్వ చేసే దాచిన శ్రేణిని కలిగి ఉంది: Integer(-128), Integer(-127), ... Integer(126),Integer(127)

మీరు వ్రాస్తే Integer x = 128, ఆటోబాక్సింగ్ ప్రక్రియ కొత్త వస్తువును సృష్టిస్తుంది, కానీ మీరు వ్రాస్తే Integer x = 127, ఆటోబాక్సింగ్ ప్రక్రియ కాష్ (అరే నుండి) నుండి ఇప్పటికే ఉన్న వస్తువును తిరిగి పొందుతుంది.

మీరు Integerఆబ్జెక్ట్ కాష్ నుండి రాకూడదనుకుంటే, మీరు దానిని వ్రాయడం ద్వారా స్పష్టంగా సృష్టించాలి:Integer x = new Integer(127);

అన్ని రేపర్ రకాలు అటువంటి కాష్‌ని కలిగి ఉంటాయి: Integer, Long, Byte, Short, Boolean. రకం కోసం Boolean, దాని TRUEమరియు FALSEవిలువలు రెండూ స్థిరాంకాలు, కాబట్టి అవి కూడా తప్పనిసరిగా కాష్ చేయబడతాయి.