ב-Java, ה מעמד הוא שרטוט שממנו נוכל ליצור אובייקט בודד. Java מספקת א מילת מפתח בשם מחלקה שבאמצעותה נוכל להכריז על מחלקה. בתוך הכיתה, אנחנו מגדירים מעמד חברים ופונקציות. לא ניתן ליצור תוכניות Java בלי שיעור. אנחנו יכולים גם להתייחס לכיתה כאל א משתמש הוגדר סוגי חוגים

ישנם שבעה סוגים של שיעורים ב-Java:

מחלקה סטטית שיעור אחרון שיעור מופשט כיתת בטון כיתת סינגלטון שיעור POJO כיתה פנימית

מחלקה סטטית

ב Java , סטטי היא מילת מפתח המנהלת אובייקטים בזיכרון. האובייקט הסטטי שייך למחלקה במקום למופע של המחלקה.

אנחנו יכולים לעשות שיעור סטָטִי אם ורק אם זו מחלקה מקוננת. אנו יכולים גם לומר שמחלקות סטטיות ידועות בתור מחלקות מקוננות. זה אומר שמחלקה שהוכרזה כסטטית בתוך מחלקה אחרת ידועה כמחלקה סטטית. מחלקה סטטית מקוננת אינה דורשת התייחסות למחלקה החיצונית. המטרה של מחלקה סטטית היא לספק את קווי המתאר של המחלקה העוברת בירושה.

המאפיינים של המחלקה הסטטית הם:

• לכיתה יש רק חברים סטטיים.
• זה לא יכול לגשת לחבר (לא סטטי) של המחלקה החיצונית.
• איננו יכולים ליצור אובייקט מהמחלקה הסטטית.

בואו נבין את הרעיון של מחלקה סטטית דרך תוכנית.

StaticClassExample.java

 public class StaticClassExample { private static String str = 'Javatpoint'; //nested class which is a Static class public static class StaticDemo { //non-static method of Static class public void show() { System.out.println(str); } } public static void main(String args[]) { StaticClassExample.StaticDemo obj = new StaticClassExample.StaticDemo(); obj.show(); } } 

תְפוּקָה:

 Javatpoint 

במחלקה החיצונית של התוכנית לעיל, הכרזנו על משתנה str כסטטי מכיוון שאנו ניגשים למשתנה הזה מהקשר סטטי. אם נכריז על המשתנה הזה כלא סטטי, המהדר מציג שגיאה בגלל מחלקה סטטית מקוננת אינה יכולה לגשת לחברים שאינם סטטיים של המחלקה החיצונית.

הדבר השני שיש לשים לב אליו בתוכנית שלמעלה הוא שכדי ליצור את האובייקט של המחלקה המקוננת אנחנו לא צריכים ליצור מופע של המחלקה החיצונית. אם המחלקה המקוננת אינה מחלקה סטטית, עלינו ליצור מופע של המחלקה החיצונית.

שיעור אחרון

המילה סופית פירושה שלא ניתן לשנות. ה סופי מחלקה ב-Java ניתן להכריז באמצעות ה מילת מפתח סופית . ברגע שאנחנו מכריזים על מחלקה כסופית, הערכים נשארים זהים לאורך כל התוכנית. מטרת השיעור האחרון היא להפוך את השיעור בלתי ניתן לשינוי כמו כיתה String. זו רק דרך להפוך את הכיתה לבלתי ניתנת לשינוי. זכור כי ה לא ניתן להאריך את השיעור האחרון . זה גם מונע מהכיתה להיות תת-סיווג .

בואו נבין את הרעיון של השיעור האחרון באמצעות תוכנית.

FinalClassExample.java

 //base class declared as final final class A { void printmsg() { System.out.print('Base class method is executed.'); } } //derived class //extending a final class which is not possible //it shows the error cannot inherit final class at compile time class B extends A { void printmsg() { System.out.print('Derived class method is executed.'); } } //main class public class FinalClassExample { public static void main(String[] arg) { B obj = new B(); obj.printmsg(); } } 

תְפוּקָה:

 /FinalClassExample.java:11: error: cannot inherit from final A class B extends A 

שיעור מופשט

א שיעור מופשט הוא מוצהר עם מילת המפתח תַקצִיר . המחלקה עשויה להכיל שיטות מופשטות או לא. אנחנו לא יכולים ליצור מופע של מחלקה מופשטת אבל זה יכול להיות תת מחלקה. שיעורים אלה אינם שלמים, ולכן כדי להשלים את המחלקה המופשטת עלינו להרחיב את המחלקות המופשטות למחלקה קונקרטית. כאשר אנו מכריזים על תת מחלקה כמופשטת אז יש צורך לספק יישום של שיטות מופשטות. לכן, יש להכריז גם על תת-המחלקה כמופשטת. אנו יכולים להשיג הסתרת נתונים באמצעות המחלקה המופשטת. דוגמה למחלקה מופשטת היא AbstarctMap כיתה שהיא חלק ממסגרת האוספים.

בואו נבין את הרעיון של שיעור מופשט באמצעות תוכנית.

AbstractClassExample.java

 //abstract class abstract class MathematicalOperations { int a=30, b=40; //abstract method public abstract void add(); } public class Operation extends MathematicalOperations { //definition of abstract method public void add() { System.out.println('Sum of a and b is: 'a+b); } public static void main(String args[]) { MathematicalOperations obj = new Operation(); obj.add(); } } 

תְפוּקָה:

 Sum of a and b is: 70 

כיתת בטון

אלו הם שיעורי Java הרגילים. מחלקה נגזרת המספקת את ההטמעות הבסיסיות עבור כל השיטות שאינן מיושמות כבר במחלקת הבסיס, ידועה בשם בֵּטוֹן מעמד. במילים אחרות, אלו מחלקות ג'אווה רגילות שבהן מיושמות כל השיטות של מחלקה מופשטת. אנו יכולים ליצור אובייקט של מחלקת הבטון ישירות. זכרו שמעמד קונקרטי ומעמד מופשט אינם זהים. כיתת בטון עשויה להרחיב את כיתת האם שלה. הוא משמש לדרישות ספציפיות.

בואו נבין את הרעיון של שיעור הבטון באמצעות תוכנית.

ConcreteClassExample.java

 //Concrete Class public class ConcreteClassExample { //method of the concreted class static int product(int a, int b) { return a * b; } public static void main(String args[]) { //method calling int p = product(6, 8); System.out.println('Product of a and b is: ' + p); } } 

תְפוּקָה:

 Product of a and b is: 48 

כיתת סינגלטון

מחלקה שיש בה רק אובייקט בכל פעם מכונה a כיתת יחיד . ובכל זאת, אם אנחנו מנסים ליצור מופע בפעם השנייה, המופע החדש שנוצר מצביע על המופע הראשון. אם ביצענו שינוי כלשהו בתוך המחלקה דרך מופע כלשהו, ​​השינוי משפיע גם על המשתנה של המופע היחיד. הוא משמש בדרך כלל לשליטה בגישה תוך כדי התמודדות עם חיבור מסד הנתונים ותכנות השקע. אם ברצוננו ליצור מחלקה יחידה, בצע את הפעולות הבאות:

• צור פרטי בַּנַאִי .
• צור שיטה סטטית (על ידי שימוש באתחול העצל) שמחזירה את האובייקט של מחלקת הסינגלטון.

SingletonClassExample.java

 public class Singleton { private String objectState; private static Singleton instance = null; private Singleton() throws Exception { this.objectState = 'Javatpoint'; } public static Singleton getInstance() { if(instance==null) { try { instance=new Singleton(); } catch(Exception e) { e.printStackTrace(); } } return instance; } public String getObjectState() { return objectState; } public void setObjectState(String objectState) { this.objectState = objectState; } } 

תְפוּקָה:

 Javatpoint 

שיעור POJO

ב-Java, POJO מייצג אובייקט Java ישן רגיל. מחלקת Java שמכילה רק משתנים פרטיים, setter ו-getter ידועה בשם POJO מעמד. הוא משמש להגדרת אובייקטי Java המגבירים את יכולת השימוש החוזרת והקריאה של תוכנית Java. הכיתה מספקת אנקפסולציה. זה נמצא בשימוש נרחב בג'אווה מכיוון שקל להבין את המחלקות הללו. למחלקת POJO יש את המאפיינים הבאים:

• זה לא מרחיב את המחלקות המוגדרות מראש כמו Arrays, HttpServlet וכו'.
• זה לא יכול להכיל הערות שצוינו מראש.
• זה לא יכול ליישם מוגדר מראש ממשקים .
• אין צורך להוסיף שום בנאי.
• כל משתני המופע חייבים להיות פרטיים.
• הגטר/מגדיר שיטות חייב להיות ציבורי.

בואו נבין את הרעיון של שיעור POJO דרך תוכנית Java.

PojoClassExample.java

 class PojoDemo { //private variable private double price=89764.34; //getter method public double getPrice() { return price; } //setter method public void setPrice(int price) { this.price = price; } } //main class public class PojoClassExample { public static void main(String args[]) { PojoDemo obj = new PojoDemo(); System.out.println('The price of an article is '+ obj.getPrice()+' Rs.'); } } 

תְפוּקָה:

 The price of an article is 89764.34 Rs. 

מעמד פנימי

Java מאפשרת לנו להגדיר מחלקה בתוך מחלקה ומחלקות כאלה ידועות בשם כיתות מקוננות . הוא משמש כדי לקבץ את השיעורים באופן הגיוני ולהשיג כימוס . ניתן לגשת לחברי הכיתה החיצוניים (כולל פרטיים) על ידי ה מעמד פנימי . התחביר הכללי להכרזה על המחלקה המקוננת הוא כדלקמן:

 class OuterClass { //code class NestedClass { //code } } 

המחלקות המקוננות הן משני סוגים:

1. מחלקה מקוננת סטטית: כיתה כלומר סטָטִי ו מקונן נקרא מחלקה מקוננת סטטית. הוא מקיים אינטראקציה עם חבר המופע במחלקה החיצונית שלו. אנו יכולים ליצור אובייקט של המחלקה המקוננת הסטטית על ידי שימוש בתחביר הבא:

 OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass(); 

2. מחלקה מקוננת לא סטטית: מחלקות מקוננות לא סטטיות נקראות כיתות פנימיות .

התחביר הכללי להכרזה על המחלקה המקוננת הסטטית והמחלקה הפנימית הוא כדלקמן:

 class OuterClass { ... static class StaticNestedClass { ... } class InnerClass { ... } } 

בואו נבין את הרעיון של מחלקה פנימית דרך תוכנית Java.

InnerClassExample.java

 public class InnerClassExample { public static void main(String[] args) { System.out.println('This is outer class.'); } class InnerClass { public void printinner() { System.out.println('This is inner class.'); } } } 

סוגי כיתות פנימיות

Java מספקת את שני סוגי המחלקות הפנימיות כדלקמן:

• כיתות מקומיות או שיטה כיתות פנימיות מקומיות
• שיעורים אנונימיים או כיתה פנימית אנונימית

כיתה פנימית מקומית

זהו סוג של מחלקה פנימית המוגדרת בתוך בלוק. כאן בלוק מציין גוף שיטה (קבוצה של הצהרות כלואה בין זוג סוגרים). בשל הגדרה בתוך בלוק הוא ידוע גם בתור מחלקה פנימית מקומית של מתודה. אלו הן המחלקות הלא סטטיות מכיוון שהן יכולות לגשת לחברי המופע של הבלוק. אנו יכולים להגדיר את המחלקות הפנימיות המקומיות בגוף השיטה. מחלקות אלו חייבות להיות מוכנות בבלוק שבו הן מוגדרות.

כאשר אנו קומפילים תוכנית Java (תוכנית המכילה מחלקה פנימית), המהדר מייצר את שני קבצי המחלקה, כלומר מעמד חיצוני ו OuterInner.class. אחד למחלקה החיצונית והשני למחלקה הפנימית המכילה התייחסות למחלקה החיצונית.

בואו נבין את הרעיון של מחלקה פנימית מקומית באמצעות תוכנית Java.

OuterClass.java

 public class OuterClass { private void getValue() { //if you are using Java 7 make the variable final //if you are using Java 8 the code runs successfully int sum = 20; //declaring method local inner class class InnerClass { public int divisor; public int remainder; public InnerClass() { divisor = 4; remainder = sum%divisor; } private int getDivisor() { return divisor; } private int getRemainder() { return sum%divisor; } private int getQuotient() { System.out.println('We are inside the inner class'); return sum / divisor; } } //creating an instance of inner class InnerClass ic = new InnerClass(); System.out.println('Divisor = '+ ic.getDivisor()); System.out.println('Remainder = ' + ic.getRemainder()); System.out.println('Quotient = ' + ic.getQuotient()); } public static void main(String[] args) { //creating an instance of outer class OuterClass oc = new OuterClass(); oc.getValue(); } } 

תְפוּקָה:

 Divisor = 4 Remainder = 0 We are inside the inner class Quotient = 5 

כיתה פנימית אנונימית

זהו סוג של מחלקה פנימית זהה למחלקות מקומיות אך ההבדל היחיד הוא שלמחלקה אין שם מחלקה ונוצר אובייקט בודד מהמחלקה. זה הופך את הקוד לתמציתי יותר. הוא משמש אם אנו רוצים להשתמש במחלקה המקומית פעם אחת. אנו יכולים ליצור שיעורים אנונימיים בשתי הדרכים הבאות:

מערכת קבצים בלינוקס

• על ידי שימוש בממשק
• בהכרזה על המעמד קונקרטי ומופשט

תחביר:

 // the class may an interface, abstract or concrete class DemoClass obj = new DemoClass() { //methods //data members public void demomethod() { //statements } }; 

בהסתכלות על התחביר לעיל, אנו רואים שהוא זהה להפעלת הבנאי, אלא שלמחלקה יש הגדרה הכלולה בבלוק.

AnonymousClassExample.java

 interface Score { int run = 321; void getScore(); } public class AnonymousClassExample { public static void main(String[] args) { // Myclass is hidden inner class of Score interface // whose name is not written but an object to it // is created. Score s = new Score() { @Override public void getScore() { //prints score System.out.print('Score is '+run); } }; s.getScore(); } } 

תְפוּקָה:

 Score is 321 

Java מספקת גם סוג אחר של מחלקת Java המכונה מחלקת עטיפה. בואו נדון בזה בפירוט.

שיעור עטיפה

בג'אווה, המונח שיעור עטיפה מייצג אוסף של מחלקות ג'אווה המייצגות את הסוג הפרימיטיבי של ג'אווה. זה אומר שלכל סוג פרימיטיבי יש מחלקת עטיפה מתאימה. מחלקות העטיפה משמשות לביצוע המרה מסוג פרימיטיבי לאובייקט ולהיפך. האיור הבא מדגים את היררכיית מחלקות העטיפה.

הטבלה הבאה מייצגת את הסוג הפרימיטיבי ואת מחלקת העטיפה המתאימה.

בואו נבין את מחלקת העטיפה דרך תוכנית Java.

WrapperClassExample.java

 public class WrapperClassExample { public static void main(String args[]) { byte x = 0; //wrapping byte primitive type into Byte object Byte byteobj = new Byte(x); int y = 23; //wrapping int primitive type into Integer object Integer intobj = new Integer(y); char c='m'; //wrapping char primitive type into Character object Character charobj=c; //printing values from objects System.out.println('Byte object byteobj: ' + byteobj); System.out.println('Integer object intobj: ' + intobj); System.out.println('Character object charobj: ' + charobj); } } 

תְפוּקָה:

 Byte object byteobj: 0 Integer object intobj: 23 Character object charobj: m