1. Integer
తరగతి
Integer
క్లాస్గా ఉండటం కూడా మంచిది, అంటే దానికి ఫీల్డ్లు మరియు పద్ధతులు ఉండవచ్చు. మరియు, వాస్తవానికి, అది వాటిని కలిగి ఉంది. వాటిలో చాలా - డజన్ల కొద్దీ. ఇక్కడ మేము చాలా ప్రాథమిక వాటిని పరిశీలిస్తాము.
తరగతికి Integer
రెండు ఫీల్డ్లు ఉన్నాయి, అవి రకం యొక్క గరిష్ట మరియు కనిష్ట సాధ్యమైన విలువలను కలిగి ఉంటాయి int
:
ఫీల్డ్ | వివరణ |
---|---|
|
int రకం యొక్క గరిష్ట సాధ్యమైన విలువ |
|
int రకం యొక్క కనీస సాధ్యం విలువ |
int
కొన్నిసార్లు మీరు వేరియబుల్కు సాధ్యమయ్యే చిన్న లేదా అతిపెద్ద విలువను కేటాయించాలనుకుంటున్నారు . అపారమయిన స్థిరాంకాలతో మీ కోడ్ను చిందరవందర చేయడాన్ని నివారించడానికి, మీరు దీన్ని చాలా స్పష్టంగా ఈ క్రింది విధంగా వ్రాయవచ్చు:
కోడ్ | వివరణ |
---|---|
|
|
తరగతిలో Integer
కొన్ని ఆసక్తికరమైన పద్ధతులు కూడా ఉన్నాయి. వారు ఇక్కడ ఉన్నారు:
పద్ధతులు | వివరణ |
---|---|
|
సంఖ్య యొక్క హెక్సాడెసిమల్ ప్రాతినిధ్యం ఉన్న స్ట్రింగ్ను అందిస్తుంది |
|
సంఖ్య యొక్క బైనరీ ప్రాతినిధ్యం అయిన స్ట్రింగ్ను అందిస్తుంది |
|
సంఖ్య యొక్క అష్టాంశ ప్రాతినిధ్యం అయిన స్ట్రింగ్ను అందిస్తుంది |
|
పాస్ను int ఒక Integer వస్తువులో చుట్టేస్తుంది |
|
పాస్ చేసిన స్ట్రింగ్ నుండి పొందిన సంఖ్యను అందిస్తుంది |
మీరు మునుపు స్టాటిక్ Integer.parseInt()
పద్ధతిని ఎదుర్కొన్నారు. ఇది ఎలా పనిచేస్తుందో గుర్తుచేసుకుందాం:
int name = Integer.parseInt(string);
ఒక సంఖ్యను (అంకెలు మాత్రమే) కలిగి ఉన్న స్ట్రింగ్ పద్ధతికి పంపబడితే parseInt()
, అది స్ట్రింగ్ను అన్వయించి, అందులో ఉన్న సంఖ్యను తిరిగి ఇస్తుంది.
మిగిలిన పద్ధతులు కూడా ఉపయోగపడతాయి. ఉదాహరణకు, వాటిలో కొన్ని పాస్ చేసిన సంఖ్యను సంఖ్య యొక్క బైనరీ, ఆక్టల్ లేదా హెక్సాడెసిమల్ ప్రాతినిధ్యం ఉన్న స్ట్రింగ్గా మార్చగలవు.
2. Double
తరగతి
సాధారణంగా, Double
తరగతి తరగతిని పోలి ఉంటుంది Integer
, ఇది double
ఒక కంటే a కాకుండా చుట్టబడుతుంది int
. ఇందులో మనకు ఆసక్తి కలిగించే ఫీల్డ్లు మరియు పద్ధతులు కూడా ఉన్నాయి. వాటిలో కొన్నింటిని పరిగణించండి:
తరగతి Double
ఆరు ఆసక్తికరమైన ఫీల్డ్లను కలిగి ఉంది:
ఫీల్డ్ | వివరణ |
---|---|
|
ప్రతికూల అనంతం |
|
సానుకూల అనంతం |
|
కనిష్ట సాధ్యమైన ఘాతాంకం (2 x ) |
|
సాధ్యమయ్యే గరిష్ట ఘాతాంకం (2 x ) |
|
double రకం యొక్క కనీస సాధ్యం విలువ |
|
double రకం యొక్క గరిష్ట సాధ్యమైన విలువ |
అనంతం
-1.0
మీరు ద్వారా విభజించినట్లయితే 0.0
, మీరు ప్రతికూల అనంతాన్ని పొందుతారు. 1.0
మీరు ద్వారా విభజించినట్లయితే 0.0
, మీరు సానుకూల అనంతాన్ని పొందుతారు. మీరు a ని సున్నా ద్వారా విభజించడమే కాకుండా double
, మీరు ఈ ఆపరేషన్ల ఫలితాన్ని నిల్వ చేయడానికి కూడా ఉపయోగించవచ్చు.
a యొక్క ఘాతాంకంdouble
ఘాతాంకాన్ని అర్థం చేసుకోవడం సులభం. అంతర్గతంగా, డబుల్లో మాంటిస్సా మరియు ఘాతాంకం ఉంటాయి. కానీ ఇక్కడ ఘాతాంకం విలువ కాదు . ఈ విధంగా, ఘాతాంకం పెరిగితే , సంఖ్య యొక్క మొత్తం విలువ రెట్టింపు అవుతుంది.10x
2x
1
MIN_EXPONENT == -1024
, అంటే , ఇది సుమారుగా సమానం2-1024
10-308
మరియు వాస్తవానికి, Double
తరగతికి ఆసక్తికరమైన పద్ధతులు ఉన్నాయి:
పద్ధతులు | వివరణ |
---|---|
|
సంఖ్య యొక్క హెక్సాడెసిమల్ ప్రాతినిధ్యం ఉన్న స్ట్రింగ్ను అందిస్తుంది |
|
పాస్ చేసిన సంఖ్య అనంతం కాదా అని తనిఖీ చేస్తుంది. |
|
పాస్ చేసిన నంబర్ ఉందో లేదో తనిఖీ చేస్తుందిNaN |
|
పాస్ను double ఒక Double వస్తువులో చుట్టేస్తుంది |
|
పాస్ చేసిన స్ట్రింగ్ నుండి పొందిన సంఖ్యను అందిస్తుంది |
ఆసక్తికరంగా, పాస్ చేసిన సంఖ్య పాజిటివ్ లేదా నెగటివ్ ఇన్ఫినిటీ అయితే isInfinite()
తిరిగి ఇచ్చే పద్ధతి ఉంది .true
పద్ధతి isNaN()
సారూప్యంగా ఉంటుంది - ఇది ఆమోదించబడిన సంఖ్య కాదా అని తనిఖీ చేస్తుంది NaN
( ఒక సంఖ్య కాదు , నిర్వచించబడని విలువను సూచించే ప్రత్యేక స్థిరాంకం).
3. Character
తరగతి
Character
క్యారెక్టర్లు వివిధ వర్గాలకు చెందినవా అని తనిఖీ చేయడానికి మిమ్మల్ని అనుమతించే దాని పెద్ద సంఖ్యలో స్టాటిక్ యుటిలిటీ పద్ధతుల కోసం క్లాస్ ఆసక్తికరంగా ఉంటుంది .
ఉదాహరణలు
పద్ధతులు | వివరణ |
---|---|
|
అక్షరం అక్షర అక్షరమా కాదా అని తనిఖీ చేస్తుంది |
|
అక్షరం అక్షరమా కాదా అని తనిఖీ చేస్తుంది |
|
అక్షరం అంకెనా అని తనిఖీ చేస్తుంది |
|
అక్షరం ఖాళీ, లైన్ బ్రేక్ లేదా పేజీ విరామమా అని తనిఖీ చేస్తుంది (కోడ్లు: 12, 13, 14) |
|
అక్షరం వైట్స్పేస్ కాదా అని తనిఖీ చేస్తుంది: ఖాళీ, ట్యాబ్ మొదలైనవి. |
|
అక్షరం చిన్న అక్షరంలో ఉందో లేదో తనిఖీ చేస్తుంది |
|
అక్షరం పెద్ద అక్షరంలో ఉందో లేదో తనిఖీ చేస్తుంది |
|
అక్షరాన్ని చిన్న అక్షరానికి మారుస్తుంది |
|
అక్షరాన్ని పెద్ద అక్షరానికి మారుస్తుంది |
ఈ పద్ధతుల యొక్క లక్షణం ఏమిటంటే అవి అన్ని తెలిసిన వర్ణమాలలతో పని చేస్తాయి: అరబిక్ సంఖ్యలు అంకెలుగా వర్గీకరించబడ్డాయి, మొదలైనవి.
4. Boolean
తరగతి
రకం Boolean
వాస్తవంగా రకానికి సమానంగా ఉంటుంది boolean
. తేడాలు తక్కువ.
క్రింద మేము తరగతి యొక్క సరళీకృత సంస్కరణను చూపుతాము Boolean
:
కోడ్ | వివరణ |
---|---|
|
స్థిరాంకాలు: TRUE и FALSE వేరియబుల్ Boolean క్లాస్ కన్స్ట్రక్టర్ పద్ధతి అంతర్గత వేరియబుల్ విలువను అందిస్తుంది ఈ స్టాటిక్ పద్ధతి true టు TRUE మరియు false కు మారుస్తుంది FALSE . |
రకానికి Boolean
రెండు స్థిరాంకాలు ఉన్నాయి (రెండు ఫీల్డ్లు):
తరగతి స్థిరాంకాలు | బూలియన్ రకానికి ప్రతిరూపం | వివరణ |
---|---|---|
|
|
నిజం |
|
|
తప్పుడు |
మీరు ఈ రకంతో పని చేసే విధంగానే మీరు వారితో పని చేయవచ్చు boolean
:
కోడ్ | గమనిక |
---|---|
|
క్లాస్ Boolean అనేది షరతు లోపల వ్రాయగలిగే ఏకైక తరగతి |
|
మూడు వేరియబుల్స్ సమానంగా ఉంటాయి true /TRUE |
|
స్థిరాలను రెండింటినీ ఉపయోగించి పోల్చవచ్చు equals మరియు == ఇది కూడా పని చేస్తుంది. |
ఆటోబాక్సింగ్ ఇక్కడ అద్భుతంగా పనిచేస్తుంది. అంటే మీరు ఈ రకాన్ని రకాన్ని అదే విధంగా ఉపయోగించవచ్చు boolean
— గమనించవలసిన ఆపదలు లేవు.
ఇది ఎలా వ్రాయబడింది | అది ఎలా పని చేస్తుంది |
---|---|
|
|
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
:
కోడ్ | గమనిక |
---|---|
|
ఇది కంపైల్ చేసి పని చేస్తుంది |
ఇది కంపైల్ అవుతుంది, కానీ ఇది పని చేయదు!
కోడ్ | గమనిక |
---|---|
|
లోపం . ఈ లైన్ మినహాయింపును విసురుతుంది |
5. ఆటోబాక్సింగ్ సమయంలో కాషింగ్ విలువలు
పూర్ణాంక రేపర్ రకాలకు సంబంధించి కొన్ని ఆపదలు ఉన్నాయి.
int
మీకు ఇప్పటికే తెలిసినట్లుగా, మేము ఒక మరియు aని పోల్చినట్లయితే Integer
, ఇది Integer
ఒకదిగా మార్చబడుతుంది int
:
ఇది ఎలా వ్రాయబడింది | అది ఎలా పని చేస్తుంది |
---|---|
|
|
మీరు రెండు వస్తువులను ఒకదానితో ఒకటి పోల్చినట్లయితే , అవి s Integer
కి మార్చబడవు :int
కోడ్ | కన్సోల్ అవుట్పుట్ |
---|---|
|
|
a == c
మరియు , కానీ , ఎందుకంటే మనం పోల్చినప్పుడు మరియు మేము సూచనలను పోల్చినప్పుడు. ఇది తప్పనిసరిగా మనం ఆశించేది.b == c
a != b
a
b
ఆశ్చర్యం
500
కానీ మేము తో భర్తీ చేస్తే 100
, మేము పూర్తిగా భిన్నమైన ఫలితాన్ని పొందుతాము:
కోడ్ | కన్సోల్ అవుట్పుట్ |
---|---|
|
|
ఇక్కడ సమస్య ఏమిటంటే ఆటోబాక్సింగ్ సమయంలో కొత్త 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
విలువలు రెండూ స్థిరాంకాలు, కాబట్టి అవి కూడా తప్పనిసరిగా కాష్ చేయబడతాయి.