ජාවා සංස්කෘතිය ගැන පැවසිය හැකි බොහෝ දේ ඇත, නමුත් මම හිතන්නේ ඔබ මේ මොහොතේ මුහුණ දී සිටින අවස්ථාවෙහිදී, වැදගත් අංශ කිහිපයක් තිබේ:
- පුස්තකාල කේතය එක් වරක් ලියා ඇති නමුත් බොහෝ විට භාවිතා වේ. පුස්තකාලය ලිවීමේ පොදු කාර්ය අවම කිරීම සතුටක් වන අතර, පුස්තකාලය භාවිතා කිරීමේ පොදු පිරිවැය අවම වන අයුරින් ලිවීම දිගු කාලීනව වඩා වටී.
- එයින් අදහස් වන්නේ ස්වයං ලේඛනගත කිරීමේ වර්ගයන් විශිෂ්ට බවයි: ක්‍රමයේ නම් මගින් සිදුවන්නේ කුමක්ද සහ ඔබ වස්තුවකින් ඉවත් වන්නේ කුමක් ද යන්න පැහැදිලි කිරීමට උපකාරී වේ.
- ස්ථිතික ටයිප් කිරීම යනු ඇතැම් පන්ති දෝෂ ඉවත් කිරීම සඳහා ඉතා ප්‍රයෝජනවත් මෙවලමකි. එය නිසැකවම සෑම දෙයක්ම නිවැරදි නොකරයි (මිනිසුන් ඔබේ කේතය පිළිගැනීමට ටයිප් පද්ධතිය ලබා ගත් පසු එය බොහෝ විට නිවැරදි යැයි හැස්කෙල් ගැන විහිළු කිරීමට කැමතියි), නමුත් එය සමහර ආකාරයේ වැරදි දේ කළ නොහැකි බවට පත් කිරීම ඉතා පහසු කරයි.
- පුස්තකාල කේතය ලිවීම යනු කොන්ත්‍රාත්තු නියම කිරීමයි. ඔබේ තර්කය සහ ප්‍රති result ල වර්ග සඳහා අතුරුමුහුණත් නිර්වචනය කිරීමෙන් ඔබේ කොන්ත්‍රාත්තු වල සීමාවන් වඩාත් පැහැදිලිව අර්ථ දක්වා ඇත. යම් දෙයක් ටුපල් එකක් පිළිගන්නේ නම් හෝ නිෂ්පාදනය කරන්නේ නම්, එය ඔබට සැබවින්ම ලැබිය යුතු හෝ නිෂ්පාදනය කළ යුතු ආකාරයේ ටුපල් වර්ගයක්ද යන්න ගැන කිසිදු සඳහනක් නොමැත, එවැනි ජනක වර්ගයකට බාධා ඇතිවීමේ ක්‍රමයට ඇත්තේ ඉතා අල්ප ප්‍රමාණයකි (එයට නිවැරදි මූලද්‍රව්‍ය සංඛ්‍යාවක් පවා තිබේද? ඔබ බලාපොරොත්තු වූ ආකාරයේ ඒවාද?).
ක්ෂේත්ර සහිත "ව්යුහය" පන්ති
වෙනත් පිළිතුරු සඳහන් කර ඇති පරිදි, ඔබට පොදු ක්ෂේත්ර සමඟ පන්තියක් භාවිතා කළ හැකිය. ඔබ මේවා අවසාන නම්, ඔබට වෙනස් කළ නොහැකි පංතියක් ලැබෙනු ඇති අතර, ඔබ ඒවා ඉදිකිරීම්කරු සමඟ ආරම්භ කරනු ඇත:
class ParseResult0 {
public final long millis;
public final boolean isSeconds;
public final boolean isLessThanOneMilli;
public ParseResult0(long millis, boolean isSeconds, boolean isLessThanOneMilli) {
this.millis = millis;
this.isSeconds = isSeconds;
this.isLessThanOneMilli = isLessThanOneMilli;
}
}
ඇත්ත වශයෙන්ම, මෙයින් අදහස් කරන්නේ ඔබ කිසියම් පන්තියකට බැඳී ඇති බවත්, විග්‍රහ කිරීමේ ප්‍රති result ලයක් නිපදවීමට හෝ පරිභෝජනය කිරීමට අවශ්ය ඕනෑම දෙයකට මෙම පන්තිය භාවිතා කළ යුතු බවත්ය. සමහර යෙදුම් සඳහා, එය හොඳයි. අනෙක් අයට එය යම් වේදනාවක් ගෙන දිය හැකිය. බොහෝ ජාවා කේතය යනු ගිවිසුම් නිර්වචනය කිරීමයි, එය සාමාන්‍යයෙන් ඔබව අතුරු මුහුණත් වෙත ගෙන යනු ඇත.
තවත් අවාසියක් නම් පන්ති පදනම් කරගත් ප්‍රවේශයකින් ඔබ ක්ෂේත්ර නිරාවරණය කරන අතර එම ක්ෂේත්ර සියල්ලටම අගයන් තිබිය යුතුය . උදා: isSeconds සහ මිලි වලට සෑම විටම යම් අගයක් තිබිය යුතුය, isLessThanOneMilli සත්‍ය වුවද. LessThanOneMilli සත්‍ය වන විට මිලි ක්ෂේත්‍රයේ වටිනාකම පිළිබඳ අර්ථ නිරූපණය කුමක් විය යුතුද?
"ව්‍යුහයන්" අතුරුමුහුණත් ලෙස
අතුරුමුහුණත් වල ස්ථිතික ක්‍රම වලට ඉඩ දී ඇති හෙයින්, සින්ටැක්ටික් පොදු කාර්යයක් නොමැතිව නිශ්චල නොවන වර්ග නිර්මාණය කිරීම සැබවින්ම පහසුය. උදාහරණයක් ලෙස, ඔබ කතා කරන ආකාරයේ ප්‍රති result ල ව්‍යුහයක් මම ක්‍රියාත්මක කළ හැකිය:
interface ParseResult {
long getMillis();
boolean isSeconds();
boolean isLessThanOneMilli();
static ParseResult from(long millis, boolean isSeconds, boolean isLessThanOneMill) {
return new ParseResult() {
@Override
public boolean isSeconds() {
return isSeconds;
}
@Override
public boolean isLessThanOneMilli() {
return isLessThanOneMill;
}
@Override
public long getMillis() {
return millis;
}
};
}
}
එය තවමත් බොයිලේරු ගොඩක් ඇත, මම නියත වශයෙන්ම එකඟ වෙමි, නමුත් ප්‍රතිලාභ කිහිපයක්ද ඇත, තවද මම සිතන්නේ ඒවා ඔබගේ ප්‍රධාන ප්‍රශ්න කිහිපයකට පිළිතුරු දීමට පටන් ගනී.
මෙම විග්‍රහ ප්‍රති result ලය වැනි ව්‍යුහයක් සමඟ, ඔබේ පාර්සර්ගේ කොන්ත්‍රාත්තුව ඉතා පැහැදිලිව අර්ථ දක්වා ඇත. පයිතන්හිදී, එක් ටුපල් එකක් තවත් ටුපල් එකකට වඩා වෙනස් නොවේ. ජාවා හි, ස්ථිතික ටයිප් කිරීම ලබා ගත හැකිය, එබැවින් අපි දැනටමත් ඇතැම් පන්ති දෝෂ ප්රතික්ෂේප කරමු. නිදසුනක් ලෙස, ඔබ පයිතන්හි ටුපල් එකක් ආපසු ලබා දෙන්නේ නම් සහ ඔබට ටුපල් (මිලි, අයිසෙකන්ඩ්ස්, ලෙස්තාන් ඔන්මිලි) ආපසු ලබා දීමට අවශ්ය නම්, ඔබට අහම්බෙන් කළ හැකිය:
return (true, 500, false)
ඔබ අදහස් කළ විට:
return (500, true, false)
මේ ආකාරයේ ජාවා අතුරුමුහුණත සමඟ, ඔබට සම්පාදනය කළ නොහැක:
return ParseResult.from(true, 500, false);
කොහෙත්ම නැහැ. ඔබ කළ යුත්තේ:
return ParseResult.from(500, true, false);
එය සාමාන්‍යයෙන් සංඛ්‍යාත්මකව ටයිප් කළ භාෂාවල වාසියකි.
මෙම ප්‍රවේශය මඟින් ඔබට ලබා ගත හැකි අගයන් සීමා කිරීමේ හැකියාව ද ලබා දේ. උදාහරණයක් ලෙස, getMillis () අමතන විට, ඔබට LessThanOneMilli () සත්‍ය දැයි පරීක්ෂා කර බැලිය හැකි අතර, එසේ නම්, නීතිවිරෝධී ස්ටේට් එක්සෙප්ෂන් එකක් විසි කරන්න (නිදසුනක් ලෙස), එම අවස්ථාවේ දී මිලි වල අර්ථවත් වටිනාකමක් නොමැති නිසා.
වැරදි දේ කිරීම දුෂ්කර කිරීම
ඉහත අතුරුමුහුණත් උදාහරණයේ දී, ඔබට තවමත් ගැටළුවක් ඇත්තේ අහම්බෙන් isSeconds සහ isLessThanOneMilli තර්ක මාරු කළ හැකි නමුත් ඒවා එකම වර්ගයේ බැවින්.
ප්‍රායෝගිකව, ඔබට ටයිම් යුනිට් සහ කාලසීමාව භාවිතා කිරීමට අවශ්ය විය හැකිය, එවිට ඔබට මෙවැනි ප්‍රති result ලයක් ලැබෙනු ඇත:
interface Duration {
TimeUnit getTimeUnit();
long getDuration();
static Duration from(TimeUnit unit, long duration) {
return new Duration() {
@Override
public TimeUnit getTimeUnit() {
return unit;
}
@Override
public long getDuration() {
return duration;
}
};
}
}
interface ParseResult2 {
boolean isLessThanOneMilli();
Duration getDuration();
static ParseResult2 from(TimeUnit unit, long duration) {
Duration d = Duration.from(unit, duration);
return new ParseResult2() {
@Override
public boolean isLessThanOneMilli() {
return false;
}
@Override
public Duration getDuration() {
return d;
}
};
}
static ParseResult2 lessThanOneMilli() {
return new ParseResult2() {
@Override
public boolean isLessThanOneMilli() {
return true;
}
@Override
public Duration getDuration() {
throw new IllegalStateException();
}
};
}
}
ඒක වෙන්න වෙනවා ගොඩක් වැඩි කේතය, එහෙත් ඔබ එක් වරක් පමණක් එය ලිවීමට අවශ්ය, සහ (ඔබ නිසි දේවල් ලේඛනගත තියෙනවා උපකල්පනය කරමින්), අවසන් වූ ජනතාව භාවිතා ඔබගේ කේතය කුමක් නිසා මාර්ගයෙන් අනුමාන කිරීමට නැති බවත්, අහම්බෙන් result[0]ඔවුන් අදහස් කරන විට වැනි දේවල් කළ නොහැක result[1]. ඔබට තවමත් සංක්ෂිප්තව අවස්ථා නිර්මාණය කළ හැකි අතර, ඒවායින් දත්ත ලබා ගැනීම එතරම් අපහසු නොවේ:
ParseResult2 x = ParseResult2.from(TimeUnit.MILLISECONDS, 32);
ParseResult2 y = ParseResult2.lessThanOneMilli();
පංති පදනම් කරගත් ප්‍රවේශය සමඟ ඔබට ඇත්ත වශයෙන්ම මෙවැනි දෙයක් කළ හැකි බව සලකන්න. විවිධ අවස්ථා සඳහා ඉදිකිරීම්කරුවන් සඳහන් කරන්න. අනෙක් ක්ෂේත්ර ආරම්භ කළ යුත්තේ කුමක් ද යන්න පිළිබඳව ඔබට තවමත් ගැටලුවක් ඇති අතර ඔබට ඒවාට ප්‍රවේශ වීම වැළැක්විය නොහැක.
තවත් පිළිතුරක සඳහන් වූයේ ජාවාහි ව්යවසාය ආකාරයේ ස්වභාවය බොහෝ විට ඔබ දැනටමත් පවතින වෙනත් පුස්තකාල රචනා කරන බවයි, නැතහොත් වෙනත් පුද්ගලයින්ට භාවිතා කිරීමට පුස්තකාල ලිවීමයි. ඔබේ පොදු API මඟින් මඟ හැරිය හැකි නම් ප්‍රති result ල වර්ග තේරුම් ගැනීමට ප්‍රලේඛනය විමසීමට බොහෝ කාලයක් අවශ්ය නොවිය යුතුය.
ඔබ මෙම ව්‍යුහයන් එක් වරක් පමණක් ලියන නමුත් ඔබ ඒවා බොහෝ වාරයක් නිර්මාණය කරයි, එබැවින් ඔබට තවමත් එම සංක්ෂිප්ත නිර්මාණය අවශ්ය වේ (ඔබට ලැබෙන). ස්ථිතික ටයිප් කිරීම මඟින් ඔබ ඒවායින් ඉවත් වන දත්ත ඔබ අපේක්ෂා කරන බව සහතික කරයි.
දැන්, කියූ සියල්ලම, සරල ටුපල් හෝ ලැයිස්තු විශාල අර්ථයක් ලබා ගත හැකි ස්ථාන තවමත් තිබේ. යම්කිසි පෙළක් ආපසු ලබා දීමේදී අඩු පිරිවැයක් තිබිය හැකි අතර, එය එසේ නම් (සහ පැතිකඩ සමඟ ඔබ තීරණය කරන පොදු කාර්යය වැදගත් වේ), එවිට අභ්‍යන්තරව සරල අගයන් භාවිතා කිරීම අර්ථවත් කරයි. ඔබගේ පොදු API තවමත් පැහැදිලිව අර්ථ දක්වා ඇති වර්ග තිබිය යුතුය.