oop معنى ما الفرق بين الواجهة والفئة المجردة؟




معنى كلمة عنوان بالانجليزي (24)

والفرق الوحيد هو أنه يمكن للمرء أن يشارك في ميراث متعدد ولا يستطيع الآخرون المشاركة.

لقد تغير تعريف الواجهة بمرور الوقت. هل تعتقد أن الواجهة تحتوي فقط على إعلانات للطرق فقط وهل هي مجرد عقود؟ ماذا عن المتغيرات النهائية الثابتة وماذا عن التعريفات الافتراضية بعد Java 8؟

تم تقديم واجهات لجافا بسبب مشكلة الماس مع الميراث متعددة وهذا ما ينوي فعلا القيام به.

الواجهات هي التركيبات التي تم إنشاؤها للتخلص من مشكلة الميراث المتعددة ويمكن أن تحتوي على طرق مجردة ، وتعريفات افتراضية ومتغيرات نهائية ثابتة.

راجع لماذا تسمح Java بالمتغيرات النهائية الثابتة في الواجهات عندما تكون مخصصة للعقود فقط؟ .

ما هو الفرق بالضبط بين الواجهة والفئة المجردة؟


To give a simple but clear answer, it helps to set the context : you use both when you do not want to provide full implementations.

The main difference then is an interface has no implementation at all (only methods without a body) while abstract classes can have members and methods with a body as well, ie can be partially implemented.


عندما تريد توفير سلوك متعدد الأشكال في التسلسل الهرمي للوراثة ، استخدم فئات الملخصات.

عندما تريد سلوك متعدد الأشكال للفصول التي لا علاقة لها تماما ، استخدم واجهة.


أقصر الطرق لتجميعها هي أن interface هي:

  1. مجردة تماما ، وبصرف النظر عن default وطرق static ؛ while it has definitions (method signatures + implementations) for default and static methods, it only has declarations (method signatures) for other methods.
  2. Subject to laxer rules than classes (a class can implement multiple interface s, and an interface can inherit from multiple interface s). All variables are implicitly constant, whether specified as public static final or not. All members are implicitly public , whether specified as such or not.
  3. Generally used as a guarantee that the implementing class will have the specified features and/or be compatible with any other class which implements the same interface.

Meanwhile, an abstract class is:

  1. Anywhere from fully abstract to fully implemented, with a tendency to have one or more abstract methods. Can contain both declarations and definitions, with declarations marked as abstract .
  2. A full-fledged class, and subject to the rules that govern other classes (can only inherit from one class), on the condition that it cannot be instantiated (because there's no guarantee that it's fully implemented). Can have non-constant member variables. Can implement member access control, restricting members as protected , private , or private package (unspecified).
  3. Generally used either to provide as much of the implementation as can be shared by multiple subclasses, or to provide as much of the implementation as the programmer is able to supply.

Or, if we want to boil it all down to a single sentence: An interface is what the implementing class has , but an abstract class is what the subclass is .


Many junior developers make the mistake of thinking of interfaces, abstract and concrete classes as slight variations of the same thing, and choose one of them purely on technical grounds: Do I need multiple inheritance? Do I need some place to put common methods? Do I need to bother with something other than just a concrete class? This is wrong, and hidden in these questions is the main problem: "I" . When you write code for yourself, by yourself, you rarely think of other present or future developers working on or with your code.

Interfaces and abstract classes, although apparently similar from a technical point of view, have completely different meanings and purposes.

ملخص

  1. An interface defines a contract that some implementation will fulfill for you .

  2. An abstract class provides a default behavior that your implementation can reuse.

Alternative summary

  1. An interface is for defining public APIs
  2. An abstract class is for internal use, and for defining SPIs

On the importance of hiding implementation details

A concrete class does the actual work, in a very specific way. For example, an ArrayList uses a contiguous area of memory to store a list of objects in a compact manner which offers fast random access, iteration, and in-place changes, but is terrible at insertions, deletions, and occasionally even additions; meanwhile, a LinkedList uses double-linked nodes to store a list of objects, which instead offers fast iteration, in-place changes, and insertion/deletion/addition, but is terrible at random access. These two types of lists are optimized for different use cases, and it matters a lot how you're going to use them. When you're trying to squeeze performance out of a list that you're heavily interacting with, and when picking the type of list is up to you, you should carefully pick which one you're instantiating.

On the other hand, high level users of a list don't really care how it is actually implemented, and they should be insulated from these details. Let's imagine that Java didn't expose the List interface, but only had a concrete List class that's actually what LinkedList is right now. All Java developers would have tailored their code to fit the implementation details: avoid random access, add a cache to speed up access, or just reimplement ArrayList on their own, although it would be incompatible with all the other code that actually works with List only. That would be terrible... But now imagine that the Java masters actually realize that a linked list is terrible for most actual use cases, and decided to switch over to an array list for their only List class available. This would affect the performance of every Java program in the world, and people wouldn't be happy about it. And the main culprit is that implementation details were available, and the developers assumed that those details are a permanent contract that they can rely on. This is why it's important to hide implementation details, and only define an abstract contract. This is the purpose of an interface: define what kind of input a method accepts, and what kind of output is expected, without exposing all the guts that would tempt programmers to tweak their code to fit the internal details that might change with any future update.

An abstract class is in the middle between interfaces and concrete classes. It is supposed to help implementations share common or boring code. For example, AbstractCollection provides basic implementations for isEmpty based on size is 0, contains as iterate and compare, addAll as repeated add , and so on. This lets implementations focus on the crucial parts that differentiate between them: how to actually store and retrieve data.

APIs versus SPIs

Interfaces are low-cohesion gateways between different parts of code. They allow libraries to exist and evolve without breaking every library user when something changes internally. It's called Application Programming Interface , not Application Programming Classes. On a smaller scale, they also allow multiple developers to collaborate successfully on large scale projects, by separating different modules through well documented interfaces.

Abstract classes are high-cohesion helpers to be used when implementing an interface, assuming some level of implementation details. Alternatively, abstract classes are used for defining SPIs, Service Provider Interfaces.

The difference between an API and an SPI is subtle, but important: for an API, the focus is on who uses it, and for an SPI the focus is on who implements it.

Adding methods to an API is easy, all existing users of the API will still compile. Adding methods to an SPI is hard, since every service provider (concrete implementation) will have to implement the new methods. If interfaces are used to define an SPI, a provider will have to release a new version whenever the SPI contract changes. If abstract classes are used instead, new methods could either be defined in terms of existing abstract methods, or as empty throw not implemented exception stubs, which will at least allow an older version of a service implementation to still compile and run.

A note on Java 8 and default methods

Although Java 8 introduced default methods for interfaces, which makes the line between interfaces and abstract classes even blurrier, this wasn't so that implementations can reuse code, but to make it easier to change interfaces that serve both as an API and as an SPI (or are wrongly used for defining SPIs instead of abstract classes).

Which one to use?

  1. Is the thing supposed to be publicly used by other parts of the code, or by other external code? Add an interface to it to hide the implementation details from the public abstract contract, which is the general behavior of the thing.
  2. Is the thing something that's supposed to have multiple implementations with a lot of code in common? Make both an interface and an abstract, incomplete implementation.
  3. Is there ever going to be only one implementation, and nobody else will use it? Just make it a concrete class.
    1. "ever" is long time, you could play it safe and still add an interface on top of it.

A corollary: the other way around is often wrongly done: when using a thing , always try to use the most generic class/interface that you actually need. In other words, don't declare your variables as ArrayList theList = new ArrayList() , unless you actually have a very strong dependency on it being an array list, and no other type of list would cut it for you. Use List theList = new ArrayList instead, or even Collection theCollection = new ArrayList if the fact that it's a list, and not any other type of collection doesn't actually matter.


دعونا نعمل على هذا السؤال مرة أخرى:

أول شيء لإعلامك هو أن 1/1 و 1 * 1 ينتج عنه نفس الشيء ، ولكن هذا لا يعني أن الضرب والقسمة هما نفس الشيء. من الواضح أنهم يحتفظون ببعض العلاقات الجيدة ، لكن ضع في اعتبارك كلاهما مختلفين.

سأشير إلى الاختلافات الرئيسية ، والباقي قد تم شرحه بالفعل:

تعتبر الفئات Abstract مفيدة في تصميم التسلسل الهرمي للفئة. للوهلة الأولى لأي مطلب ، نحن واضحين بشكل جزئي حول ما يجب بناؤه بالضبط ، لكننا نعرف ما يجب بناؤه. وبالتالي فصولك المجردة هي فصولك الأساسية.

تعتبر الواجهات مفيدة في السماح للتسلسل الهرمي أو الطبقات الأخرى بمعرفة ما يمكنني فعله. وعندما تقول إنني قادر على شيء ما ، يجب أن تكون لديك هذه القدرة. سوف تميز الواجهات بأنها إلزامية بالنسبة للفئة لتنفيذ الوظائف نفسها.


يتم استخدام الوراثة لغرضين:

  • للسماح لكائن بالاعتبار لأعضاء البيانات من نوع الوالدين وتطبيقات الطريقة الخاصة بهم.

  • للسماح باستخدام مرجع لكائنات من نوع واحد من قبل التعليمات البرمجية التي تتوقع وجود مرجع لعنصر supertype.

في اللغات / الأطر التي تدعم الميراث المتعدد المعمم ، غالباً ما تكون هناك حاجة قليلة لتصنيف النوع إما كونه "واجهة" أو "فئة تجريدية". ومع ذلك ، ستسمح اللغات والأطر الشائعة لنوع ما بأن يعتبر أعضاء البيانات من نوع آخر أو تطبيقات الطريقة الخاصة به على الرغم من أنها تسمح بأن يكون نوع ما بديلاً عن عدد عشوائي من الأنواع الأخرى.

قد تحتوي الطبقات المجردة على أعضاء البيانات وعمليات التنفيذ ، ولكن لا يمكن توريثها إلا بالفصول التي لا ترث من أي فئات أخرى. لا تضع الواجهات تقريبًا أي قيود على الأنواع التي تنفذها ، ولكن لا يمكن أن تتضمن أي بيانات أو تطبيقات طريقة.

هناك أوقات يكون من المفيد فيها استبدال الأنواع بالعديد من الأشياء المختلفة ؛ هناك أوقات أخرى عندما يكون من المفيد أن تعتبر الكائنات أعضاء البيانات من نوع الوالدين وعمليات التنفيذ بمثابة تطبيقات خاصة بهم. ويتيح التمييز بين السطوح البينية والفئات التجريدية استخدام كل من تلك القدرات في الحالات التي تكون فيها أكثر ملاءمة.


An abstract class is a class whose object cannot be created or a class which cannot be instantiated. An abstract method makes a class abstract. An abstract class needs to be inherited in order to override the methods that are declared in the abstract class. No restriction on access specifiers. An abstract class can have constructor and other concrete(non abstarct methods ) methods in them but interface cannot have.

An interface is a blueprint/template of methods.(eg. A house on a paper is given(interface house) and different architects will use their ideas to build it(the classes of architects implementing the house interface) . It is a collection of abstract methods , default methods , static methods , final variables and nested classes. All members will be either final or public , protected and private access specifiers are not allowed.No object creation is allowed. A class has to be made in order to use the implementing interface and also to override the abstract method declared in the interface. An interface is a good example of loose coupling(dynamic polymorphism/dynamic binding) An interface implements polymorphism and abstraction.It tells what to do but how to do is defined by the implementing class. For Eg. There's a car company and it wants that some features to be same for all the car it is manufacturing so for that the company would be making an interface vehicle which will have those features and different classes of car(like Maruti Suzkhi , Maruti 800) will override those features(functions).

Why interface when we already have abstract class? Java supports only multilevel and hierarchal inheritance but with the help of interface we can implement multiple inheritance.


باختصار الاختلافات هي التالية:

الاختلافات النحوية بين واجهة وطبقة الملخص :

  1. يمكن لأساليب وأعضاء فئة مجردة أي رؤية. يجب أن تكون جميع طرق الواجهة عامة . // لا يحمل حقيقة من Java 9 بعد الآن
  2. يجب أن تحدد طبقة الطفل الملموسة من فئة خلاصة جميع الأساليب المجردة. يمكن لطبقة الطفل الملخص أن تكون لها طرق مجردة. لا تحتاج واجهة توسيع واجهة أخرى إلى توفير تنفيذ افتراضي للطرق الموروثة من الواجهة الأصل.
  3. لا يمكن للفئة الفرعية سوى تمديد فصل واحد. واجهة يمكن تمديد واجهات متعددة. يمكن للفئة تنفيذ واجهات متعددة.
  4. يمكن لفئة الطفل أن تحدد طرق تجريدية بنفس الرؤية أو أقل تقييدًا ، في حين يجب على الطبقة التي تقوم بتطبيق واجهة تعريف جميع طرق الواجهة بأنها عامة.
  5. يمكن أن تحتوي الفصول الدراسية على بنى وليس على واجهات .
  6. تحتوي واجهات Java 9 على طرق ثابتة خاصة.

في واجهات الآن:

public static - مدعومة
public abstract - مدعوم
public default - مدعوم
private static - معتمد
private abstract - خطأ تجميعي
private default - ترجمة خطأ
private - مدعوم


I'd like to add one more difference which makes sense. For example, you have a framework with thousands of lines of code. Now if you want to add a new feature throughout the code using a method enhanceUI(), then it's better to add that method in abstract class rather in interface. Because, if you add this method in an interface then you should implement it in all the implemented class but it's not the case if you add the method in abstract class.


If you have some common methods that can be used by multiple classes go for abstract classes. Else if you want the classes to follow some definite blueprint go for interfaces.

Following examples demonstrate this.

Abstract class in Java:

abstract class animals
{
    // They all love to eat. So let's implement them for everybody
    void eat()
    {
        System.out.println("Eating...");
    }
    // The make different sounds. They will provide their own implementation.
    abstract void sound();
}

class dog extends animals
{
    void sound()
    {
        System.out.println("Woof Woof");
    }
}

class cat extends animals
{
    void sound()
    {
        System.out.println("Meoww");
    }
}

Following is an implementation of interface in Java:

interface Shape
{
    void display();
    double area();
}

class Rectangle implements Shape 
{
    int length, width;
    Rectangle(int length, int width)
    {
        this.length = length;
        this.width = width;
    }
    @Override
    public void display() 
    {
        System.out.println("****\n* *\n* *\n****"); 
    }
    @Override
    public double area() 
    {
        return (double)(length*width);
    }
} 

class Circle implements Shape 
{
    double pi = 3.14;
    int radius;
    Circle(int radius)
    {
        this.radius = radius;
    }
    @Override
    public void display() 
    {
        System.out.println("O"); // :P
    }
    @Override
    public double area() 
    { 
        return (double)((pi*radius*radius)/2);
    }
}

Some Important Key points in a nutshell:

  1. The variables declared in Java interface are by default final. Abstract classes can have non-final variables.

  2. The variables declared in Java interface are by default static. Abstract classes can have non-static variables.

  3. Members of a Java interface are public by default. A Java abstract class can have the usual flavors of class members like private, protected, etc..


لا أريد أن أسلط الضوء على الاختلافات ، التي سبق أن ذُكرت في العديد من الإجابات (فيما يتعلق بالمعدلات النهائية الثابتة العامة للمتغيرات في الواجهة والدعم للأساليب المحمية والخاصة في الفصول التجريدية)

بعبارات بسيطة ، أود أن أقول:

واجهة: لتنفيذ العقد من قبل كائنات متعددة غير ذات صلة

الفئة التجريدية: لتنفيذ السلوك نفسه أو مختلف بين كائنات متعددة ذات صلة

من documentation أوراكل

فكر في استخدام دروس الملخص إذا:

  1. تريد مشاركة التعليمات البرمجية بين عدة فئات وثيقة الصلة.
  2. تتوقع أن تحتوي الفئات التي تمدد فئة الملخص على العديد من الطرق أو الحقول الشائعة ، أو تتطلب معدِّلات وصول غير عامة (مثل المحمية والخاصة).
  3. تريد الإعلان عن الحقول غير الثابتة أو غير النهائية.

فكر في استخدام واجهات إذا:

  1. تتوقع أن تقوم الفئات غير المرتبطة بتنفيذ الواجهة الخاصة بك. على سبيل المثال ، يمكن للعديد من الكائنات غير المرتبطة تنفيذ واجهة Serializable .
  2. تريد تحديد سلوك نوع بيانات معين ، ولكن لا يهمك من يقوم بتنفيذ سلوكه.
  3. تريد الاستفادة من الميراث المتعدد من النوع.

الطبقة المجردة تؤسس "هي علاقة" مع الطبقات الملموسة. يوفر واجهة "لديها" القدرة على الطبقات.

إذا كنت تبحث عن Java كلغة برمجة ، فإليك بعض التحديثات الإضافية:

لقد قلل Java 8 من الفجوة بين interface والفئات abstract إلى حد ما عن طريق توفير ميزة طريقة default . لم يكن لدى واجهة تطبيق لم يعد صالحًا الآن.

ارجع إلى page الوثائق هذه لمزيد من التفاصيل.

إلقاء نظرة على هذا السؤال SE لأمثلة رمز لفهم أفضل.

كيف يمكنني شرح الفرق بين فئة Interface و Abstract؟


النقاط الرئيسية:

  • يمكن أن يكون للفصل التجريدي خاصية ، حقول البيانات ، الطرق (كاملة / غير مكتملة).
  • إذا حددت الطريقة أو الخصائص في الكلمة الرئيسية المجردة التي يجب أن تتجاوز في الفئة المشتقة (عملها كوظيفة مقترنة بإحكام)
  • إذا قمت بتعريف الكلمة الرئيسية المجردة للطريقة أو الخصائص في الفئة المجردة ، فلا يمكنك تعريف نص الطريقة و / أو الحصول على قيمة للممتلكات والتي يجب أن تتجاوز في الفئة المشتقة.
  • الطبقة المجردة لا تدعم الميراث المتعدد.
  • الطبقة الملخصية تحتوي على منشئات.
  • يمكن أن تحتوي فئة الملخص على معدِّلات الوصول للغواصات الفرعية ، والوظائف ، والخصائص.
  • فقط عضو كامل من الطبقة المجردة يمكن أن تكون ثابتة.
  • يمكن أن ترث واجهة من واجهة أخرى فقط ولا يمكن أن ترث من فئة مجردة ، حيث يمكن أن ترث فئة مجردة من فئة مجردة أخرى أو واجهة أخرى.

أفضلية:

  • هو نوع من العقود التي تجبر جميع الفئات الفرعية على تحمل نفس التسلسل الهرمي أو المعايير.
  • إذا كانت التطبيقات المختلفة من نفس النوع وتستخدم السلوك أو الوضع الشائع ، فمن الأفضل استخدام الفئة التجريدية.
  • إذا أضفنا طريقة جديدة لفئة مجردة ، فلدينا خيار توفير التنفيذ الافتراضي وبالتالي قد تعمل جميع الرموز الموجودة بشكل صحيح.
  • السماح لها بتنفيذ سريع من واجهة (واجهة تتطلب المزيد من الوقت للعثور على الطريقة الفعلية في الفئات المقابلة.)
  • يمكن استخدامه لربط ضيق وواسع.

العثور على التفاصيل هنا ... http://pradeepatkari.wordpress.com/2014/11/20/interface-and-abstract-class-in-c-oops/


الاختلافات الفنية الرئيسية بين فئة مجردة interface هي:

  • يمكن أن تحتوي الطبقات المستخلصة على ثوابت وأعضاء وعناصر أسلوب (أساليب بدون جسم) وطرق محددة ، بينما يمكن أن تحتوي الواجهات على ثوابت وأساليب فقط .

  • يمكن تعريف الأساليب والأعضاء في فئة تجريدية مع أي رؤية ، في حين يجب تعريف جميع طرق الواجهة بأنها public (يتم تعريفها بشكل عام افتراضيًا).

  • عند ورث طبقة تجريدية ، يجب على طبقة الطفل الملموسة تحديد الأساليب المجردة ، في حين أن الطبقة التجريدية يمكن أن تمد فئة أخرى مجردة وأن الأساليب المجردة من الطبقة الأم لا يجب تعريفها.

  • وبالمثل ، فإن السطح البيني لواجهة أخرى ليس مسؤولاً عن تنفيذ الأساليب من الواجهة الأصلية. هذا لأن الواجهات لا يمكن تعريف أي تطبيق.

  • لا يمكن للفئة الفرعية أن توسع إلا فئة واحدة (مجردة أو ملموسة) ، في حين أن واجهة يمكن أن تمتد أو يمكن لفئة تطبيق واجهات متعددة أخرى .

  • يمكن لفئة الطفل أن تحدد طرق تجريدية بنفس الرؤية أو أقل تقييدًا ، في حين يجب على الطبقة التي تقوم بتطبيق واجهة أن تحدد الطرق بنفس الرؤية (الجمهور).


By definition, interfaces cannot have an implementation for any methods, and member variables cannot be initialized.

However, abstract classes can have methods implementated and member variables initialized.

Use abstract classes when you expect changes in your contract, ie, say in future you might need to add a new method.

In this situation, if you decide to use an interface, when the interface is changed to include interface, your application will break when you dumped the new interface dll.

To read in detail, visit difference between abstract class and a interface


يمكن العثور على تفسير في Interface VS Abstract Class في PHP .

الاستنتاجات

يتم استخدام الفئات Abstract لمشاركة الوظائف. يتم استخدام الواجهات لمشاركة طريقة عمل شيء ما.


المقارنة بين الطبقة المقابلة مقابل الطبقة المجردة خاطئة. يجب أن يكون هناك مقاربتان أخريان بدلاً من ذلك: 1) الواجهة مقابل الطبقة و 2) الطبقة التجريبية مقابل الطبقة النهائية .

واجهة مقابل فئة

الواجهة عبارة عن عقد بين جسمين. على سبيل المثال ، أنا ساعي البريد وكنت حزمة لتقديم. أتوقع منك معرفة عنوان التسليم الخاص بك. عندما يعطيني شخص ما حزمة ، عليه أن يعرف عنوان التسليم الخاص به:

interface Package {
  String address();
}

Class هو مجموعة من الكائنات التي تخضع للعقد. على سبيل المثال ، أنا صندوق من مجموعة "بوكس" وأنا أطيع العقد الذي يطلبه ساعي البريد. في نفس الوقت أطيع العقود الأخرى:

class Box implements Package, Property {
  @Override
  String address() {
    return "5th Street, New York, NY";
  }
  @Override
  Human owner() {
    // this method is part of another contract
  }
}

الملخص مقابل النهائي

الطبقة المجردة هي مجموعة من الأشياء غير المكتملة. لا يمكن استخدامها ، لأنهم يفتقدون بعض الأجزاء. على سبيل المثال ، أنا صندوق مجرّد لمعرّف GPS - أعرف كيفية التحقق من موقفي على الخريطة:

abstract class GpsBox implements Package {
  @Override
  public abstract String address();
  protected Coordinates whereAmI() {
    // connect to GPS and return my current position
  }
}

هذه الفئة ، إذا كانت موروثة / موسعة بواسطة فئة أخرى ، يمكن أن تكون مفيدة للغاية. ولكن في حد ذاته - لا جدوى منه ، لأنه لا يمكن أن يكون لها أشياء. يمكن للفئات المستخلصة بناء عناصر الطبقات النهائية.

الطبقة النهائية هي مجموعة من الكائنات الكاملة ، والتي يمكن استخدامها ، ولكن لا يمكن تعديلها. انهم يعرفون بالضبط كيفية العمل وماذا تفعل. على سبيل المثال ، أنا صندوق يذهب دائمًا إلى العنوان المحدد أثناء الإنشاء:

final class DirectBox implements Package {
  private final String to;
  public DirectBox(String addr) {
    this.to = addr;
  }
  @Override
  public String address() {
    return this.to;
  }
}

في معظم اللغات ، مثل Java أو C ++ ، من الممكن أن يكون لديك فئة فقط ، لا مجردة ولا نهائية. يمكن أن تكون هذه الفئة موروثة ويمكن إنشاء مثيل لها. لا أعتقد أن هذا يتماشى تماما مع النموذج الموجه نحو الهدف ، رغم ذلك.

مرة أخرى ، مقارنة الواجهات مع الطبقات المجردة غير صحيحة.


الاختلافات بين الطبقة المجردة والواجهة نيابة عن التنفيذ الحقيقي.

الواجهة : هي عبارة عن كلمة أساسية ويتم استخدامها لتعريف القالب أو الطباعة الزرقاء لكائن ما وتجبر جميع الفئات الفرعية على اتباع نفس النموذج ، أما بالنسبة للتنفيذ ، فإن جميع الفئات الفرعية مجانية لتنفيذ الوظائف هذا هو الشرط.

بعض حالات الاستخدام الأخرى التي ينبغي لنا استخدام واجهة.

الاتصال بين جسمين خارجيين (تكامل الطرف الثالث في تطبيقنا) يتم من خلال الواجهة هنا تعمل الواجهة كعقد.

فئة الملخص: ملخص ، إنها كلمة أساسية وعندما نستخدم هذه الكلمة الأساسية قبل أي فصل ، تصبح فئة مجردة. تستخدم بشكل أساسي عندما نحتاج إلى تعريف القالب بالإضافة إلى بعض الوظائف الافتراضية لكائن يتبعه كل والفئات الفرعية وبهذه الطريقة يزيل رمز زائدة عن الحاجة وحالة استخدام أخرى حيث يمكننا استخدام فئة مجردة ، مثل أننا لا نريد أي فئة أخرى يمكن مباشرة إنشاء كائن من الفئة ، يمكن فقط الطبقات المشتقة استخدام وظيفة.

مثال على فئة الملخص:

 public abstract class DesireCar
  {

 //It is an abstract method that defines the prototype.
     public abstract void Color();

  // It is a default implementation of a Wheel method as all the desire cars have the same no. of wheels.   
 // and hence no need to define this in all the sub classes in this way it saves the code duplicasy     

  public void Wheel() {          

               Console.WriteLine("Car has four wheel");
                }
           }


    **Here is the sub classes:**

     public class DesireCar1 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red color Desire car");
            }
        }

        public class DesireCar2 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red white Desire car");
            }
        }

مثال على واجهة:

  public interface IShape
        {
          // Defines the prototype(template) 
            void Draw();
        }


  // All the sub classes follow the same template but implementation can be different.

    public class Circle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Circle");
        }
    }

    public class Rectangle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Rectangle");
        }
    }

You can find clear difference between interface and abstract class.

جهة تعامل

  • Interface only contains abstract methods.
  • Force users to implement all methods when implements the interface.
  • Contains only final and static variables.
  • Declare using interface keyword.
  • All methods of an interface must be defined as public.
  • An interface can extend or a class can implement multiple other interfaces.

Abstract class

  • Abstract class contains abstract and non-abstract methods.

  • Does not force users to implement all methods when inherited the abstract class.

  • Contains all kinds of variables including primitive and non-primitive

  • Declare using abstract keyword.

  • Methods and members of an abstract class can be defined with any visibility.

  • A child class can only extend a single class (abstract or concrete).


انها بسيطة جدا في الواقع.

يمكنك أن تفكر في واجهة كطبقة لا يُسمح لها إلا بالطرق المجردة ولا شيء آخر.

لذا يمكن للواجهة أن "تعلن فقط" ولا تحدد السلوك الذي تريد أن يكون لدى الصف.

تسمح لك الطبقة المجردة بالقيام بكل من التصريح (باستخدام الأساليب المجردة) بالإضافة إلى تحديد (استخدام أساليب التنفيذ الكامل) السلوك الذي تريد أن يمتلكه الفصل.

والطبقة العادية تسمح لك فقط بتحديد السلوك / الإجراءات التي تريد أن يحصل عليها الطلاب ، وليس الإعلان عنها.

شيء أخير،

في Java ، يمكنك تنفيذ واجهات متعددة ، ولكن يمكنك فقط توسيع واحد (Class Abstract أو Class) ...

وهذا يعني أن توريث السلوك المحدد يقتصر على السماح بواحد فقط لكل فئة ... أي إذا كنت ترغب في فصل دراسي يحتوي على سلوك مغلف من الفئات A و B و C ، فستحتاج إلى القيام بما يلي: Class A يمتد B ، Class C يمتد A .. لها قليلا من جولة حول طريقة الحصول على ميراث متعددة ...

واجهات من ناحية أخرى ، يمكنك ببساطة القيام به: واجهة C تنفذ A ، B

لذا في الواقع ، تدعم Java الوراثة المتعددة فقط في "السلوك المعلن" مثل واجهات ، وراثة واحدة فقط بسلوك محدد .. إلا إذا قمت بالجولة حول الطريقة التي وصفتها ...

نأمل أن يكون ذلك منطقيًا.


واجهات

الواجهة عبارة عن عقد : يقول الشخص الذي يكتب الواجهة: " مهلاً ، أقبل أشياء تبدو بهذه الطريقة " ، والرجل الذي يستخدم الواجهة يقول " حسنًا ، الطبقة التي أكتبها تبدو بهذه الطريقة ".

الواجهة هي غلاف فارغ . هناك فقط توقيعات الطرق ، مما يعني أن الطرق لا تحتوي على جسد. لا يمكن للواجهة القيام بأي شيء. انها مجرد نمط.

على سبيل المثال (رمز زائف):

// I say all motor vehicles should look like this:
interface MotorVehicle
{
    void run();

    int getFuel();
}

// My team mate complies and writes vehicle looking that way
class Car implements MotorVehicle
{

    int fuel;

    void run()
    {
        print("Wrroooooooom");
    }


    int getFuel()
    {
        return this.fuel;
    }
}

إن تنفيذ الواجهة يستهلك القليل جدًا من وحدة المعالجة المركزية (CPU) ، لأنها ليست فئة ، بل مجرد مجموعة من الأسماء ، وبالتالي لا توجد أية عمليات بحث مكلفة للقيام بها. إنه أمر رائع عندما يكون مهمًا ، كما هو الحال في الأجهزة المضمنة.

فصول مجردة

تعتبر الطبقات المجردة ، على عكس الوصلات البينية ، فئات. وهي أكثر تكلفة في الاستخدام ، لأن هناك عملية متابعة للقيام بها عند ورثها.

تبدو الطبقات المجردة تشبه إلى حد كبير الواجهات ، ولكن لديهم شيء أكثر: يمكنك تحديد سلوك لهم. الأمر يتعلق أكثر بشخص يقول: "يجب أن تبدو هذه الفصول على هذا النحو ، ولديهم ذلك المشترك ، لذا املأ الفراغات!".

فمثلا:

// I say all motor vehicles should look like this:
abstract class MotorVehicle
{

    int fuel;

    // They ALL have fuel, so lets implement this for everybody.
    int getFuel()
    {
         return this.fuel;
    }

    // That can be very different, force them to provide their
    // own implementation.
    abstract void run();
}

// My teammate complies and writes vehicle looking that way
class Car extends MotorVehicle
{
    void run()
    {
        print("Wrroooooooom");
    }
}

التنفيذ

في حين يفترض أن تكون الطبقات المجردة والواجهات مفاهيم مختلفة ، فإن التطبيقات تجعل ذلك البيان غير صحيح في بعض الأحيان. في بعض الأحيان ، هم ليسوا حتى ما تعتقد أنهم.

في Java ، يتم فرض هذه القاعدة بشدة ، بينما في PHP ، تكون الواجهات عبارة عن فئات مجردة مع عدم الإعلان عن أي طريقة.

في بيثون ، تعد الطبقات المجردة أكثر خدعة برمجة يمكنك الحصول عليها من وحدة ABC وتستخدم في الواقع metaclasses ، وبالتالي فصول. واجهات أكثر ترتبط بطبع الكتابة في هذه اللغة وهي مزيج بين الاتفاقيات والأساليب الخاصة التي تستدعي واصفات (__method__ methods).

كالعادة مع البرمجة ، هناك نظرية وممارسة وممارسة في لغة أخرى :-)


أقوم ببناء مبنى مكون من 300 طابق

واجهة مخطط المبنى

  • على سبيل المثال ، Servlet (I)

بناء شيدت حتى 200 طوابق - مجزأة جزئيا --- مجردة

  • التنفيذ الجزئي ، على سبيل المثال ، عام و HTTP servlet

الانتهاء من تشييد المباني ملموسة

  • التنفيذ الكامل ، على سبيل المثال ، servlet الخاصة

جهة تعامل

  • لا نعرف أي شيء عن التنفيذ ، فقط المتطلبات. يمكننا الذهاب للواجهة.
  • كل طريقة عامة ومختصرة بشكل افتراضي
  • إنها فئة مجردة نقية 100٪
  • إذا أعلنا عن عدم تمكننا من الإعلان عن الخصوصية والحماية
  • إذا أعلنا عن ملخص ، لا يمكننا الإعلان نهائياً أو ثابتاً أو متزامناً أو صارماً
  • كل واجهة لديها عامة وثابتة ونهائية
  • التسلسل والعبر غير قابل للتطبيق ، لأننا لا نستطيع إنشاء مثيل لواجهة
  • غير متطايرة لأنها نهائية
  • كل متغير هو ثابت
  • عندما نعلن عن متغير داخل واجهة نحتاج إلى تهيئة المتغيرات أثناء التصريح
  • المثيل والكتلة الثابتة غير مسموح بهما

نبذة مختصرة

  • التنفيذ الجزئي
  • لديها طريقة مجردة. بالإضافة إلى ذلك ، فإنه يستخدم الخرسانة
  • لا قيود على معدّلات طريقة الطبقة المجردة
  • لا قيود على المعدلات متغير الطبقة التجريدية
  • لا يمكننا أن نعلن عن المعدلات الأخرى إلا مجرد مجردة
  • لا قيود لتهيئة المتغيرات

مأخوذة من موقع DurgaJobs


النقطة الأساسية هي:

  • الملخص هو كائن موجه . يقدم البيانات الأساسية التي يجب أن يكون لها "كائن" و / أو وظائف يجب أن يكون بمقدوره القيام بها. إنها تهتم بالخصائص الأساسية للكائن: ما لديها وما يمكن أن تفعله. ومن ثم فإن الأشياء التي ترث من نفس الطبقة المجردة تشترك في الخصائص الأساسية (التعميم).
  • واجهة وظيفية موجهة . يحدد وظائف يجب أن يكون كائن. بغض النظر عن ما هو كائن ، طالما أنه يمكن القيام بهذه الوظائف ، والتي تم تعريفها في الواجهة ، فلا بأس. يتجاهل كل شيء آخر. يمكن أن يحتوي الكائن / الفصل على عدة وظائف (مجموعات) ؛ لذلك من الممكن لفئة لتطبيق واجهات متعددة.

واجهة: اتجه (اتجه إلى اليسار ، استدر لليمين.)

فئة الملخص: عجلة.

الفئة: عجلة القيادة ، مستمدة من عجلة القيادة ، تعرض واجهة التشغيل

واحد هو لتصنيف السلوك الذي يمكن تقديمه عبر مجموعة متنوعة من الأشياء ، والآخر هو لنمذجة الوجود للأشياء.





abstract-class