ความแตกต่างระหว่างวิธีการเรียนและอินสแตนซ์คืออะไร?

ความแตกต่างระหว่างวิธีการเรียนและวิธีการอินสแตนซ์คืออะไร?

อินสแตนซ์เป็น accessors (getters และ setters) ในขณะที่เมธอด class นั้นค่อนข้างทุกอย่างหรือไม่?

เช่นเดียวกับคำตอบอื่น ๆ ส่วนใหญ่ที่กล่าวไว้วิธีการใช้อินสแตนซ์ของคลาสในขณะที่วิธีการเรียนสามารถใช้กับชื่อคลาส ใน Objective-C พวกมันถูกนิยามไว้ดังนี้:

@interface MyClass : NSObject

+ (void)aClassMethod;
- (void)anInstanceMethod;

@end

พวกเขาสามารถใช้เช่นนั้นได้:

[MyClass aClassMethod];

MyClass *object = [[MyClass alloc] init];
[object anInstanceMethod];

ตัวอย่างบางส่วนของโลกที่แท้จริงของวิธีการเรียนวิธีการอำนวยความสะดวกในการเรียนมูลนิธิมากมายเช่นNSString's +stringWithFormat:หรือNSArray' +arrayWithArray:s วิธีการเช่นจะNSArray's -countวิธี

รายละเอียดทางเทคนิคทั้งหมดได้รับการกล่าวถึงเป็นอย่างดีในคำตอบอื่น ๆ ฉันแค่ต้องการแบ่งปันการเปรียบเทียบแบบเรียบง่ายที่ฉันคิดว่าแสดงให้เห็นถึงความแตกต่างระหว่างคลาสและตัวอย่าง:

ระดับเป็นเหมือนพิมพ์เขียวของบ้าน: คุณมีเพียงหนึ่งพิมพ์เขียวและ (ปกติ) คุณไม่สามารถทำเช่นนั้นได้มากกับพิมพ์เขียวเพียงอย่างเดียว

อินสแตนซ์ (หรือวัตถุ ) เป็นจริงบ้านที่คุณสร้างขึ้นอยู่กับพิมพ์เขียว: คุณสามารถสร้างจำนวนมากจากบ้านพิมพ์เขียวเดียวกัน จากนั้นคุณสามารถทาสีผนังที่มีสีแตกต่างกันในแต่ละบ้านเช่นเดียวกับที่คุณสามารถเปลี่ยนคุณสมบัติของแต่ละอินสแตนซ์ของคลาสได้อย่างอิสระโดยไม่กระทบกับอินสแตนซ์อื่น

เช่นเดียวกับคำตอบอื่น ๆ ที่กล่าวไว้วิธีการทำงานของอินสแตนซ์ทำงานบนวัตถุและเข้าถึงตัวแปรอินสแตนซ์ของมันในขณะที่วิธีการเรียนดำเนินการกับคลาสโดยรวมและไม่สามารถเข้าถึงตัวแปรของอินสแตนซ์ที่เฉพาะเจาะจงได้ พารามิเตอร์).

ตัวอย่างที่ดีของวิธีการเรียนเป็นวิธีการชนิดเคาน์เตอร์ซึ่งส่งกลับจำนวนรวมของอินสแตนซ์ของชั้นเรียน วิธีการเรียนเริ่มต้นด้วยในขณะที่คนเช่นเริ่มต้นด้วย+ -ตัวอย่างเช่น:

static int numberOfPeople = 0;

@interface MNPerson : NSObject {
     int age;  //instance variable
}

+ (int)population; //class method. Returns how many people have been made.
- (id)init; //instance. Constructs object, increments numberOfPeople by one.
- (int)age; //instance. returns the person age
@end

@implementation MNPerson
- (id)init{
    if (self = [super init]){
          numberOfPeople++;
          age = 0;
    }    
    return self;
}

+ (int)population{ 
     return numberOfPeople;
}

- (int)age{
     return age;
}

@end

main.m:

MNPerson *micmoo = [[MNPerson alloc] init];
MNPerson *jon = [[MNPerson alloc] init];
NSLog(@"Age: %d",[micmoo age]);
NSLog(@"%Number Of people: %d",[MNPerson population]);

เอาท์พุท: อายุ: 0 จำนวนคน: 2

อีกตัวอย่างคือถ้าคุณมีวิธีที่คุณต้องการให้ผู้ใช้สามารถโทรได้บางครั้งมันก็ดีที่จะทำให้เป็นวิธีการเรียน ตัวอย่างเช่นถ้าคุณมีคลาสที่เรียกว่า MathFunctions คุณสามารถทำสิ่งนี้ได้:

+ (int)square:(int)num{ 
      return num * num;
}

ดังนั้นผู้ใช้จะโทร:

[MathFunctions square:34];

โดยไม่ต้องยกตัวอย่างชั้นเรียน!

นอกจากนี้คุณยังสามารถใช้ฟังก์ชั่นชั้นเรียนเพื่อส่งคืนวัตถุที่ถูกลบอัตโนมัติเช่น NSArray

+ (NSArray *)arrayWithObject:(id)object

ที่นำวัตถุมาวางไว้ในอาร์เรย์และส่งกลับอาร์เรย์รุ่น autoreleded ที่ไม่จำเป็นต้องมีการจัดการหน่วยความจำที่ดีสำหรับอาร์เรย์อารมณ์และสิ่งที่ไม่

ฉันหวังว่าคุณจะเข้าใจในเวลาและ / หรือทำไมคุณควรใช้วิธีการเรียน !!

วิธีการอินสแตนซ์นำไปใช้กับอินสแตนซ์ของคลาส (เช่นวัตถุ) ในขณะที่วิธีการเรียนใช้กับคลาสเอง

ใน C # วิธีการเรียนที่มีการทำเครื่องหมายแบบคงที่ วิธีการและคุณสมบัติที่ไม่ได้ทำเครื่องหมายคงที่เป็นวิธีการอินสแตนซ์

class Foo {
  public static void ClassMethod() { ... }
  public void InstanceMethod() { ... }
}

คำตอบสำหรับคำถามของคุณไม่เฉพาะเจาะจงกับวัตถุประสงค์ -c อย่างไรก็ตามในภาษาต่าง ๆ วิธีการเรียนอาจเรียกว่าวิธีการคงที่

ความแตกต่างระหว่างวิธีการเรียนและวิธีการเช่น

วิธีการเรียน

• ทำงานกับตัวแปรคลาส (ไม่สามารถเข้าถึงตัวแปรอินสแตนซ์)
• ไม่ต้องการวัตถุที่จะสร้างอินสแตนซ์ที่จะนำไปใช้
• บางครั้งอาจเป็นกลิ่นรหัส (บางคนที่ยังใหม่กับ OOP ใช้เป็น crutch เพื่อทำการเขียนโปรแกรมแบบโครงสร้างในสภาพแวดล้อม OO)

วิธีการอินสแตนซ์

• ทำงานกับตัวแปรอินสแตนซ์และตัวแปรคลาส
• ต้องมีวัตถุที่ได้รับการอนุญาตให้ทำงาน

ผมคิดว่าวิธีที่ดีที่สุดที่จะเข้าใจในเรื่องนี้คือการมองและalloc initนี่เป็นคำอธิบายที่ทำให้ฉันเข้าใจความแตกต่าง

วิธีการเรียน

วิธีการเรียนถูกนำไปใช้กับชั้นเรียนโดยรวม หากคุณตรวจสอบallocวิธีการนั่นเป็นวิธีการเรียนที่แสดงโดย+ก่อนการประกาศวิธีการ มันเป็นวิธีการเรียนเพราะมันถูกนำไปใช้กับชั้นเรียนเพื่อสร้างตัวอย่างที่เฉพาะเจาะจงของชั้นเรียนที่

วิธีการอินสแตนซ์

คุณใช้วิธีการอินสแตนซ์เพื่อปรับเปลี่ยนอินสแตนซ์เฉพาะของคลาสที่ไม่ซ้ำกับอินสแตนซ์นั้นแทนที่จะเป็นคลาสทั้งหมด initตัวอย่างเช่น (แสดงด้วย-ก่อนที่จะประกาศวิธีการ) allocเป็นวิธีการเช่นเพราะคุณเป็นปกติการปรับเปลี่ยนคุณสมบัติของชั้นว่าหลังจากได้รับการสร้างขึ้นด้วย

ตัวอย่าง

NSString *myString = [NSString alloc];

คุณกำลังเรียกเมธอดคลาสallocเพื่อสร้างอินสแตนซ์ของคลาสนั้น สังเกตว่าผู้รับข้อความเป็นคลาสได้อย่างไร

[myString initWithFormat:@"Hope this answer helps someone"];

คุณกำลังแก้ไขอินสแตนซ์ของการNSStringเรียกmyStringโดยการตั้งค่าคุณสมบัติบางอย่างในอินสแตนซ์นั้น ขอให้สังเกตว่าผู้รับข้อความเป็นตัวอย่าง (วัตถุของคลาสNSString)

วิธีการเรียนมักจะใช้ในการสร้างอินสแตนซ์ของชั้นเรียนนั้น

ตัวอย่างเช่น[NSString stringWithFormat:@"SomeParameter"];ส่งคืนNSStringอินสแตนซ์พร้อมพารามิเตอร์ที่ส่งไปให้ ดังนั้นเนื่องจากมันเป็นวิธีการเรียนที่ส่งกลับวัตถุประเภทของมันก็จะเรียกว่าวิธีการอำนวยความสะดวก

ดังนั้นถ้าฉันเข้าใจถูกต้อง

classวิธีไม่จำเป็นต้องคุณสามารถจัดสรรตัวอย่างของวัตถุที่ใช้ / การประมวลผล classวิธีการเป็นตัวเองที่มีอยู่และสามารถทำงานได้โดยไม่ต้องพึ่งพาอาศัยกันของสถานะของวัตถุของคลาสที่ใด ๆ classวิธีการที่คาดว่าจะจัดสรรหน่วยความจำสำหรับการทำงานของตัวเองและ deallocate เมื่อทำตั้งแต่ตัวอย่างของการเรียนว่าไม่มีจะสามารถเพิ่มหน่วยความจำใด ๆ ที่ได้รับการจัดสรรในการเรียกก่อนหน้านี้กับวิธีการเรียน

instanceวิธีเป็นเพียงตรงข้าม คุณไม่สามารถเรียกมันได้เว้นแต่คุณจะจัดสรรอินสแตนซ์ของคลาสนั้น มันเหมือนคลาสปกติที่มีคอนสตรัคเตอร์และสามารถมี destructor (ที่ล้างข้อมูลหน่วยความจำที่จัดสรรทั้งหมด)

น่าจะเป็นส่วนใหญ่ (ยกเว้นกรณีที่คุณกำลังเขียนห้องสมุดนำมาใช้ใหม่ที่คุณไม่ควรต้องมีclassตัวแปร

วิธีการอินสแตนซ์ทำงานบนอินสแตนซ์ของคลาส (เช่น "วัตถุ") วิธีการเรียนที่เกี่ยวข้องกับการเรียน (ภาษาส่วนใหญ่ใช้คำหลักstaticสำหรับพวกเหล่านี้)

ยกตัวอย่างเช่นเกมที่มีรถยนต์จำนวนมากวางไข่ .. แต่ละคนอยู่ในคลาส CCar เมื่อรถยนต์มีการยกตัวอย่างมันจะทำการโทรออก

[CCar registerCar:self]

ดังนั้นคลาส CCar สามารถสร้างรายการของ CCar ทุกอินสแตนซ์ได้ สมมติว่าผู้ใช้เสร็จสิ้นระดับและต้องการลบรถยนต์ทั้งหมด ... คุณสามารถทำได้: 1 - ไปที่รายการของ CCar ทุกอันที่คุณสร้างขึ้นด้วยตนเองและทำwhicheverCar.remove(); หรือ 2- เพิ่มวิธี removeAllCars ไปที่ CCar ซึ่งจะทำเช่นนั้น สำหรับคุณเมื่อคุณโทร [CCar removeAllCars] กล่าวคือ allCars[n].remove();

หรือตัวอย่างเช่นคุณอนุญาตให้ผู้ใช้ระบุขนาดตัวอักษรเริ่มต้นสำหรับแอปทั้งหมดซึ่งถูกโหลดและบันทึกเมื่อเริ่มต้น หากไม่มีวิธีเรียนคุณอาจต้องทำอะไรบางอย่างเช่น

fontSize = thisMenu.getParent().fontHandler.getDefaultFontSize();

[FontHandler getDefaultFontSize]ด้วยวิธีการเรียนที่คุณจะได้รับไปด้วย

สำหรับฟังก์ชั่น removeVowels ของคุณคุณจะพบว่าภาษาเช่น C # มีทั้งสองวิธีด้วยวิธีการบางอย่างเช่น toLower หรือ toUpper

เช่นmyString.removeVowels() และ String.removeVowels(myString) (ใน ObjC นั้นน่าจะเป็น[String removeVowels:myString])

ในกรณีนี้อินสแตนซ์อาจเรียกเมธอดคลาสดังนั้นทั้งคู่จึงพร้อมใช้งาน กล่าวคือ

public function toLower():String{
  return String.toLower();
}

public static function toLower( String inString):String{
 //do stuff to string..
 return newString;
}

โดยทั่วไปการmyString.toLower() โทร [String toLower:ownValue]

ไม่มีคำตอบที่ชัดเจน แต่ถ้าคุณรู้สึกว่าการผลักวิธีการเรียนในการปรับปรุงรหัสของคุณให้มันยิงและจำไว้ว่าวิธีการเรียนจะช่วยให้คุณใช้วิธีการ / ตัวแปรชั้นเรียนอื่น ๆ

วิธีการเรียน

เป็นวิธีการที่ประกาศเป็นแบบคงที่ วิธีการที่สามารถเรียกได้โดยไม่ต้องสร้างตัวอย่างของชั้นเรียน วิธีการเรียนสามารถทำงานได้เฉพาะกับสมาชิกในชั้นเรียนและไม่ได้อยู่ในสมาชิกอินสแตนซ์เป็นวิธีการเรียนรู้ของสมาชิกอินสแตนซ์ วิธีการอินสแตนซ์ของคลาสนั้นไม่สามารถถูกเรียกจากภายในเมธอดคลาสได้นอกจากว่าพวกมันถูกเรียกบนอินสแตนซ์ของคลาสนั้น

วิธีการอินสแตนซ์

ในทางกลับกันจำเป็นต้องมีอินสแตนซ์ของคลาสที่มีอยู่ก่อนจึงจะสามารถเรียกใช้ได้ดังนั้นจำเป็นต้องสร้างอินสแตนซ์ของคลาสโดยใช้คีย์เวิร์ดใหม่ วิธีการอินสแตนซ์ทำงานบนอินสแตนซ์ของคลาสที่เฉพาะเจาะจง วิธีการที่อินสแตนซ์จะไม่ประกาศว่าเป็นแบบคงที่

ใน Objective-C วิธีการทั้งหมดเริ่มต้นด้วยอักขระ "-" หรือ "+" ตัวอย่าง:

@interface MyClass : NSObject
// instance method
- (void) instanceMethod;

+ (void) classMethod;
@end

อักขระ "+" และ "-" ระบุว่าวิธีใดวิธีหนึ่งclass methodหรือinstance methodตามลำดับ

ความแตกต่างจะชัดเจนถ้าเราเรียกวิธีการเหล่านี้ MyClassนี่คือวิธีการที่มีการประกาศใน

instance method ต้องการตัวอย่างของคลาส:

MyClass* myClass = [[MyClass alloc] init];
[myClass instanceMethod];

ภายในMyClassวิธีอื่น ๆ สามารถเรียกวิธีการMyClassใช้อินสแตนซ์ของself:

-(void) someMethod
{
    [self instanceMethod];
}

แต่class methodsต้องถูกเรียกบนชั้นเรียนด้วยตัวเอง:

[MyClass classMethod];

หรือ:

MyClass* myClass = [[MyClass alloc] init];
[myClass class] classMethod];

สิ่งนี้จะไม่ทำงาน:

// Error
[myClass classMethod];
// Error
[self classMethod];

วิธีการเรียน

โดยทั่วไปเมธอดคลาสจะสร้างอินสแตนซ์ใหม่ของคลาสหรือดึงคุณสมบัติโกลบอลของคลาส วิธีการเรียนไม่ทำงานบนอินสแตนซ์หรือมีการเข้าถึงตัวแปรอินสแตนซ์

วิธีการทันที

วิธีการอินสแตนซ์ทำงานบนอินสแตนซ์เฉพาะของคลาส ตัวอย่างเช่นเมธอด accessors ที่คุณใช้เป็นเมธอดอินสแตนซ์ทั้งหมด คุณใช้พวกเขาเพื่อตั้งค่าหรือรับตัวแปรอินสแตนซ์ของวัตถุเฉพาะ

ขอร้อง

ในการเรียกใช้เมธอดอินสแตนซ์คุณส่งข้อความไปยังอินสแตนซ์ของคลาส

ในการเรียกใช้เมธอดคลาสคุณส่งข้อความไปยังคลาสโดยตรง

ที่มา: IOS - วัตถุประสงค์ -C - วิธีการเรียนและวิธีการอินสแตนซ์

วิธีการเรียนไม่สามารถเปลี่ยนหรือรู้ค่าของตัวแปรอินสแตนซ์ใด ๆ นั่นควรเป็นเกณฑ์สำหรับการรู้ว่าวิธีการอินสแตนซ์สามารถเป็นวิธีการเรียนได้ไหม

ยังจำความคิดเดียวกันที่ใช้กับตัวแปร คุณจะเจอคำต่างๆเช่นสแตติก, สมาชิก, ตัวอย่าง, คลาสและอื่น ๆ เมื่อพูดถึงตัวแปรเช่นเดียวกับที่คุณใช้สำหรับวิธีการ / ฟังก์ชั่น

ดูเหมือนว่าคำทั่วไปในชุมชน Obj-C นั้นเป็น ivar สำหรับตัวแปรอินสแตนซ์ แต่ฉันไม่ใช่คนที่ Obj-C เลย

การอัปเดตคำตอบข้างต้นฉันยอมรับวิธีการใช้อินสแตนซ์ของคลาสในขณะที่วิธีการเรียนสามารถใช้กับชื่อคลาสได้

ไม่มีความแตกต่างใด ๆ ระหว่างวิธีการอินสแตนซ์และวิธีการเรียนหลังจากการนับการอ้างอิงอัตโนมัติเกิดขึ้นใน Objective-C

สำหรับตัวอย่าง[NS StringWithformat:..]วิธีการเรียนและวิธี[[NSString alloc] initwihtformat:..]การอินสแตนซ์ทั้งสองจะเหมือนกันหลังจาก ARC

หมายเหตุ:นี่เป็นรูปแบบรหัสหลอกเท่านั้น

วิธีการเรียน

เกือบจะทั้งหมดจะต้องทำคือช่วงเวลารวบรวม ไม่จำเป็นต้องป้อนข้อมูลผู้ใช้ใด ๆ หรือการคำนวณของมันจะขึ้นอยู่กับอินสแตนซ์ ทุกอย่างเกี่ยวกับมันขึ้นอยู่กับคลาส / พิมพ์เขียว - ซึ่งเป็นเอกลักษณ์นั่นคือคุณไม่มีพิมพ์เขียวหลายรายการสำหรับหนึ่งชั้น คุณสามารถมีรูปแบบที่แตกต่างกันในช่วงเวลารวบรวม? ไม่ดังนั้นคลาสนั้นมีความเป็นเอกลักษณ์และไม่ว่าคุณจะเรียกวิธีการเรียนกี่ครั้งก็ตามตัวชี้ที่ชี้ไปนั้นจะเหมือนกัน

PlanetOfLiving: return @"Earth" // No matter how many times you run this method...nothing changes.

วิธีการอินสแตนซ์

ในทางตรงกันข้ามวิธีการอินสแตนซ์ที่เกิดขึ้นระหว่างรันไทม์เนื่องจากเป็นเพียงที่คุณได้สร้างอินสแตนซ์ของบางสิ่งบางอย่างที่อาจแตกต่างกันไปตามทุกอินสแตนซ์

initWithName: @"John" lastName: @"Doe"Age:12 @"cool"
initWithName: @"Donald" lastName: @"Drumpf"Age:5 attitude:@"He started"
initWithName: @"President" lastName: @"Obama"Age:54 attitude: @"Awesome"
//As you can see the value can change for each instance.

หากคุณมาจากภาษาอื่นวิธีการคงที่เช่นเดียวกับวิธีการเรียน
หากคุณมาจาก Swift วิธีการพิมพ์จะเหมือนกับวิธีเรียน

การเพิ่มคำตอบข้างต้น

วิธีการเรียนจะทำงานในชั้นเรียนเราจะใช้สิ่งนี้เพื่อวัตถุประสงค์ทั่วไปที่ชอบ + stringWithFormat ขนาดของชั้นเรียนและที่สำคัญที่สุดสำหรับ init ฯลฯ

NSString *str = [NSString stringWithFormat:@"%.02f%%",someFloat]; 

อินสแตนซ์เมธอดจะทำงานกับอินสแตนซ์ของคลาสที่ไม่ได้อยู่ในคลาสอย่างที่เรามีสองคนและเราต้องการทราบความสมดุลของแต่ละส่วนแยกกันที่นี่เราจำเป็นต้องใช้วิธีอินสแตนซ์ เพราะมันจะไม่ตอบสนองทั่วไป เช่นกำหนดจำนวน NSSArray เป็นต้น

[johnson getAccountBalance];
[ankit getAccountBalance];