ලබා ගන්නන් සහ සැකසුම් කරුවන් සිටීම වටපිටාව බිඳ දමන්නේ නැත. බ්‍රේක් එන්කැප්ලේෂන් යනු ස්වයංක්‍රීයව සෑම දත්ත සාමාජිකයෙකුටම (සෑම ක්ෂේත්‍රයකම , ජාවා භාෂාවෙන්) ලබා ගන්නෙකු සහ කට්ටලයක් එක් කිරීමකි . සියලුම දත්ත සාමාජිකයන් ප්‍රසිද්ධ කිරීමට වඩා මෙය හොඳ වුවත් එය කුඩා පියවරක් පමණි.
වටකර ගැනීමේ කාරණය නම්, වස්තුවෙන් පිටත සිට වස්තුවේ තත්වය දැන ගැනීමට හෝ වෙනස් කිරීමට ඔබට නොහැකි විය යුතුය, නමුත් එය සිදු කිරීම සඳහා ඔබට සාධාරණ ප්‍රතිපත්තියක් තිබිය යුතුය .
සමහර දත්ත සාමාජිකයන් සම්පූර්ණයෙන්ම වස්තුවට අභ්‍යන්තර විය හැකි අතර ඒවා ලබා ගන්නන් හෝ සැකසුම්කරුවන් නොතිබිය යුතුය.
සමහර දත්ත සාමාජිකයින් කියවීමට පමණක් විය යුතුය, එබැවින් ඔවුන්ට ලබා ගන්නන් අවශ්‍ය විය හැකි නමුත් සැකසුම්කරුවන් නොවේ.
සමහර දත්ත සාමාජිකයන් එකිනෙකාට අනුකූලව තබා ගැනීමට අවශ්‍ය විය හැකිය. එවැනි අවස්ථාවකදී ඔබ එක් එක් සඳහා කට්ටලයක් සපයන්නේ නැත, නමුත් ඒවා එකවර සැකසීම සඳහා තනි ක්රමයක් වන අතර එමඟින් ඔබට අනුකූලතාව සඳහා අගයන් පරීක්ෂා කළ හැකිය.
සමහර දත්ත සාමාජිකයන් වෙනස් කිරීමට අවශ්‍ය වන්නේ නිශ්චිත ප්‍රමාණයකින් වැඩි කිරීම හෝ අඩු කිරීම වැනි නිශ්චිත ආකාරයකින් පමණි. මෙම අවස්ථාවේ දී, ඔබ සැකසුමකට වඩා increment()සහ / හෝ decrement()ක්රමයක් සපයනු ඇත .
තවත් සමහරුන්ට ඇත්ත වශයෙන්ම කියවීමට-ලිවීමට අවශ්‍ය විය හැකි අතර, එය ලබා ගන්නෙකු සහ සැකසුම්කරුවෙකු සිටිය යුතුය.
A හි උදාහරණයක් සලකා බලන්න class Person. පුද්ගලයෙකුට නමක්, සමාජ ආරක්ෂණ අංකයක් සහ වයසක් ඇතැයි කියමු. මිනිසුන්ට ඔවුන්ගේ නම් හෝ සමාජ ආරක්ෂණ අංක වෙනස් කිරීමට අපි කිසිසේත් ඉඩ නොදෙන බව කියමු. කෙසේ වෙතත්, පුද්ගලයාගේ වයස සෑම වසරකම 1 කින් වැඩි කළ යුතුය. මෙම අවස්ථාවෙහිදී, ඔබ විසින් ලබා දී ඇති අගයන්ට නම සහ එස්එස්එන් ආරම්භ කරන ඉදිකිරීම්කරුවෙකු ලබා දෙන අතර එය වයස 0 දක්වා ආරම්භ කරනු ඇත. ඔබ ක්රමයක් ද සපයනු ඇත incrementAge(), එය වයස 1 කින් වැඩි කරයි. ඔබ ද සපයනු ඇත තුන්දෙනාටම ලබා ගන්නන්. මෙම නඩුවේ සැකසුම් අවශ්‍ය නොවේ.
මෙම සැලසුමේදී ඔබ වස්තුවේ තත්වය පන්තියට පිටතින් පරීක්ෂා කිරීමට ඉඩ දෙන අතර පන්තියට පිටතින් එය වෙනස් කිරීමට ඔබ ඉඩ දෙයි. කෙසේ වෙතත්, ඔබ අත්තනෝමතික ලෙස රාජ්‍යය වෙනස් කිරීමට ඉඩ නොදේ. ප්‍රතිපත්තියක් ඇත, එහි නම සහ එස්එස්එන් කිසිසේත් වෙනස් කළ නොහැකි බවත්, වරකට වයස අවුරුදු 1 කින් වැඩි කළ හැකි බවත් effectively ලදායී ලෙස සඳහන් කරයි.
දැන් අපි කියමු පුද්ගලයෙකුට ද වැටුපක් ඇත. මිනිසුන්ට කැමැත්ත පරිදි රැකියා වෙනස් කළ හැකිය, එයින් අදහස් වන්නේ ඔවුන්ගේ වැටුප ද වෙනස් වනු ඇති බවයි. මෙම තත්වය ආදර්ශනය කිරීම සඳහා අපට setSalary()ක්‍රමවේදයක් සැපයීම හැර වෙනත් මාර්ගයක් නැත ! කැමැත්ත පරිදි වැටුප වෙනස් කිරීමට ඉඩ දීම මෙම නඩුවේ පරිපූර්ණ සාධාරණ ප්‍රතිපත්තියකි.
මාර්ගය වන විට, ඔබේ ආදර්ශය, මම පන්ති ලබා දෙන Fridgeමෙම putCheese()සහ takeCheese()ක්රම වෙනුවට get_cheese()සහ set_cheese(). එවිට ඔබට තවමත් සංසරණය වනු ඇත.
public class Fridge {
private List objects;
private Date warranty;
/** How the warranty is stored internally is a detail. */
public Fridge( Date warranty ) {
// The Fridge can set its internal warranty, but it is not re-exposed.
setWarranty( warranty );
}
/** Doesn't expose how the fridge knows it is empty. */
public boolean isEmpty() {
return getObjects().isEmpty();
}
/** When the fridge has no more room... */
public boolean isFull() {
}
/** Answers whether the given object will fit. */
public boolean canStore( Object o ) {
boolean result = false;
// Clients may not ask how much room remains in the fridge.
if( o instanceof PhysicalObject ) {
PhysicalObject po = (PhysicalObject)o;
// How the fridge determines its remaining usable volume is a detail.
// How a physical object determines whether it fits within a specified
// volume is also a detail.
result = po.isEnclosedBy( getUsableVolume() );
}
return result;
}
/** Doesn't expose how the fridge knows its warranty has expired. */
public boolean isPastWarranty() {
return getWarranty().before( new Date() );
}
/** Doesn't expose how objects are stored in the fridge. */
public synchronized void store( Object o ) {
validateExpiration( o );
// Can the object fit?
if( canStore( o ) ) {
getObjects().add( o );
}
else {
throw FridgeFullException( o );
}
}
/** Doesn't expose how objects are removed from the fridge. */
public synchronized void remove( Object o ) {
if( !getObjects().contains( o ) ) {
throw new ObjectNotFoundException( o );
}
getObjects().remove( o );
validateExpiration( o );
}
/** Lazily initialized list, an implementation detail. */
private synchronized List getObjects() {
if( this.list == null ) { this.list = new List(); }
return this.list;
}
/** How object expiration is determined is also a detail. */
private void validateExpiration( Object o ) {
// Objects can answer whether they have gone past a given
// expiration date. How each object "knows" it has expired
// is a detail. The Fridge might use a scanner and
// items might have embedded RFID chips. It's a detail hidden
// by proper encapsulation.
if( o implements Expires && ((Expires)o).expiresBefore( today ) ) {
throw new ExpiredObjectException( o );
}
}
/** This creates a copy of the warranty for immutability purposes. */
private void setWarranty( Date warranty ) {
assert warranty != null;
this.warranty = new Date( warranty.getTime() )
}
}
Getters and setters are often criticized as being not proper OOකරුණාකර උපුටා දැක්වීම.