הפסקת קפה מס' 174. דרכים שונות ליצור אובייקט ב-Java.String ל-Int ב-Java - כיצד להמיר מחרוזת למספר שלם

דרכים שונות ליצור אובייקט ב-Java

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

יצירת אובייקט ב-Java

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

1. באמצעות מילת המפתח החדשה
2. שיטה newInstance()
3. שיטת clone().
4. ביטול סדרה של חפץ

עכשיו בואו נסתכל על כל אחת מהשיטות שהוזכרו בפירוט.

מילת מפתח חדשה

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

Date today = new Date();

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

public class Person {
    private String name;
    private int uid;

    public Person() {
        this.name = "Michael Cole";
        this.uid = 101;
    }

    public Person(String name, int uid) {
        super();
        this.name = name;
        this.uid = uid;
    }

    // getters and setters...

    public static void main(String[] args) {

        Person p1 = new Person();
        Person p2 = new Person("John Bodgan", 102);
        System.out.println("Name: " + p1.getName() + " UID: " + p1.getUid());
        System.out.println("Name: " + p2.getName() + " UID: " + p2.getUid());
    }
}

מקוד זה אנו יוצרים אובייקט Person באמצעות מילת המפתח החדשה :

• האובייקט p1 קורא לבנאי ללא פרמטרים עם ערך שם המשתנה מוגדר ל-"Michael Cole" וה-UID מוגדר ל-101.
• האובייקט p2 קורא לבנאי בעל הפרמטרים, שם הוא מעביר לבנאי את הערך "John Bodgan" ו-102. לאחר מכן מוקצים לערכים אלו שם משתנה ו-UID.

שימוש בשיטת newInstance()

שיטת newInstance() ב-Java משמשת ליצירת מופע דינמי של אובייקט של מחלקה נתונה. ישנם שני שימושים סטנדרטיים בשיטת newInstance() :

• שיטת newInstance() מ- Java.lang.Class API
• שיטת newInstance() מ- Java.lang.reflect.Constructor API

שימוש ב-newInstance() מ-Class API

כדי ליצור אובייקט של מחלקה בזמן ריצה, עלינו לקרוא למתודה newInstance() מ-Class API, אשר מחזירה אובייקט של אותה מחלקה. שיטת newInstance() של המחלקה java.lang.Class אינה לוקחת פרמטרים או ארגומנטים וניתן לקרוא לה בנאי ללא ארגומנט עבור המחלקה הזו. בואו נסתכל על קוד לדוגמה ליצירת אובייקט של המחלקה Person באמצעות שיטת newInstance() של המחלקה java.lang.Class :

public class Person {
    private String name;
    private int uid;

    public Person() {
        this.name = "Carl Max";
        this.uid = 101;
    }

   // getters and setters...
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Class c = Class.forName("com.medium.option2.Person");
        @SuppressWarnings("deprecation")
        Person p = (Person) c.newInstance();
        System.out.println("Name: " + p.getName());
        System.out.println("UID: " + p.getUid());
    }
}

Class.forName (השם המלא של המחלקה) טוען מחלקה בשם Person , ואז newInstance() יוצר אובייקט חדש מסוג Person ומחזיר אליו הפניה. כעת, באמצעות ההפניה ל-Person ל- p , אנו יכולים לקרוא לו getters() ו- setter() כדי לבצע פעולות מסוימות. שימו לב:

• גם Class.forName() וגם newIstance() זורקים חריגים שיש לטפל בהם באמצעות try and catch blocks או מילת המפתח throws .
• שיטת newInstance() מ-Class API הוצאה משימוש מאז Java 9.

שימוש ב-newInstance() מ-Constructor API

שיטת newInstance() של המחלקה Constructor ( java.lang.reflect.Constructor ) דומה לשיטת newInstance() של המחלקה Class , אלא שהיא מקבלת פרמטרים עבור בנאים עם פרמטרים. בואו נדגים גישה זו על ידי יצירת אובייקט של המחלקה Person באמצעות שיטת newInstance() של המחלקה java.lang.reflect.Constructor :

public class PersonTwo {
    private String name;
    private int uid;

    public PersonTwo() {
        this.name = "Maya Kumari";
        this.uid = 101;
    }

    public PersonTwo(String name) {
        this.name = name;
        this.uid = 102;
    }

    public PersonTwo(String name, Integer uid) {
        this.name = name;
        this.uid = uid;
    }

    // getters and setters...
    public static void main(String[] args) {
        try {
            Class.forName("com.medium.option2.PersonTwo");

            Constructor c1 = PersonTwo.class.getConstructor();
            PersonTwo p1 = (PersonTwo) c1.newInstance();
            System.out.println("Name: " + p1.getName());
            System.out.println("UID: " + p1.getUid());

            Constructor c2 = PersonTwo.class.getConstructor(String.class);
            PersonTwo p2 = (PersonTwo) c2.newInstance("James Gunn");
            System.out.println("Name: " + p2.getName());
            System.out.println("UID: " + p2.getUid());

            Constructor c3 = PersonTwo.class.getConstructor(String.class, Integer.class);
            PersonTwo p3 = (PersonTwo) c3.newInstance("Mark Brown", 103);
            System.out.println("Name: " + p3.getName());
            System.out.println("UID: " + p3.getUid());

        } catch (ClassNotFoundException | NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

בקוד שלמעלה, ראשית עלינו לטעון את המחלקה באמצעות השיטה Class.forName() . לאחר מכן, נקרא לשיטת getConstructor() כדי להתאים את סוגי הנתונים של הפרמטרים שהועברו. לבסוף, בשיטת newInstance() נעביר את הפרמטר הנדרש ( null אם אין ארגומנט). השיטה newInstance() תחזיר אובייקט חדש של המחלקה PersonTwo על ידי קריאה לבנאי המתאים.

שימוש בשיטת clone()

שיטת clone() היא חלק מהמחלקה Object ומשמשת ליצירת עותק של אובייקט קיים. זה יוצר אובייקט של המחלקה מבלי לקרוא לשום בנאי מחלקה. כדי לשכפל שיטה, המחלקה המתאימה חייבת ליישם את הממשק Cloneable , שהוא ממשק סמן. כעת ניצור אובייקט של המחלקה Person ולאחר מכן נשכפל אותו לאובייקט אחר של המחלקה Person :

public class Person implements Cloneable {
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    private String name;
    private int uid;

    public Person(String name, int uid) {
        super();
        this.name = name;
        this.uid = uid;
    }

    // getters and setters...

    public static void main(String[] args) {
        Person p1 = new Person("Ryan", 101);
        try {
            Person p2 = (Person) p1.clone();
            System.out.println("Name: " + p2.getName());
            System.out.println("UID: " + p2.getUid());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

    }
}

הערה. האובייקט המשובט יפנה לאותו אובייקט מקורי באמצעות הפניה p2 . עם זאת, לאובייקט המשובט תהיה הקצאת זיכרון נפרדת. משמעות הדבר היא שכל שינוי שנעשה באובייקט ה-Person שאליו מתייחס p2 לא ישנה את אובייקט ה-Personal המקורי שאליו הפנה p1 . הסיבה לכך היא ששיטת clone() יוצרת עותק רדוד של אובייקטים.

שימוש בסידריאליזציה של אובייקטים

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

public class PersonDriver {

    public static void main(String[] args) {
        Person p1 = new Person("Max Payne", 101);
        FileOutputStream fileOutputStream;
        try {
            fileOutputStream = new FileOutputStream("link to text file");
            ObjectOutputStream outputStream = new ObjectOutputStream(fileOutputStream);
            outputStream.writeObject(p1);
            outputStream.flush();
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        FileInputStream fileInputStream;
        try {
            fileInputStream = new FileInputStream("link to text file");
            ObjectInputStream inputStream = new ObjectInputStream(fileInputStream);
            Person p2 = (Person) inputStream.readObject();
            System.out.println("Name: " + p2.getName());
            System.out.println("UID: " + p2.getUid());
            inputStream.close();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

כאן אנו מסדרים לראשונה את האובייקט Person על ידי הפניה p1 לקובץ טקסט. השיטה writeObject() תכתוב את זרם הביטים של האובייקט לקובץ טקסט. לאחר מכן, באמצעות דה-סריאליזציה של אובייקט, אנו מחלצים את אובייקט ה- Person בחזרה לתוך p2 . באופן דומה, השיטה readObject() תקרא אובייקט מזרם הקלט של האובייקט. לבסוף, נדפיס את הנתונים מאובייקט ה- Person אל המסוף.

סיכום

במאמר זה למדנו על הדרכים השונות ליצור אובייקט ב-Java. ראשית, בדקנו יצירת אובייקטים באמצעות מילת המפתח החדשה , שהיא הדרך הנפוצה ביותר. לאחר מכן למדנו את שיטת newInstance() מהמחלקות Class ו- Constructor , שהיא דרך פופולרית נוספת ליצור אובייקטים. לאחר מכן השתמשנו בשיטת clone() , שיוצרת עותק רדוד של האובייקט הקיים במקום ליצור אובייקט חדש. לבסוף, השתמשנו במושג של סריאליזציה של אובייקטים ו-deserialization כדי ליצור אובייקטים ב-Java.

מחרוזת ל-Int ב-Java - כיצד להמיר מחרוזת למספר שלם

מקור: FreeCodeCamp היום תלמדו כיצד להמיר מחרוזת למספר שלם ב-Java באמצעות שתי שיטות של המחלקה Integer - parseInt() ו- valueOf() . זה יעזור לך בעת ביצוע פעולות מתמטיות באמצעות הערך של משתנה מחרוזת.

כיצד להמיר מחרוזת למספר שלם ב-Java באמצעות Integer.parseInt

אפשרות זו מניחה שהמתודה parseInt() לוקחת מחרוזת כדי להמיר למספר שלם כפרמטר:

Integer.parseInt(string_varaible)

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

class StrToInt {
    public static void main(String[] args) {
        String age = "10";

        System.out.println(age + 20);
        // 1020
    }
}

בקוד זה, יצרנו גיל משתנה עם ערך המחרוזת "10". כאשר הוספנו את המספר 20 לערך מספר שלם, קיבלנו בטעות 1020 במקום התשובה הנכונה של 30. ניתן לתקן זאת באמצעות שיטת parseInt() :

class StrToInt {
    public static void main(String[] args) {
        String age = "10";

        int age_to_int = Integer.parseInt(age);

        System.out.println(age_to_int + 20);
        // 30
    }
}

כאן, כדי להמיר את משתנה הגיל למספר שלם, העברנו אותו כפרמטר לשיטת parseInt() - Integer.parseInt(age) - ואחסנו אותו במשתנה בשם age_to_int . כעת כאשר מוסיפים למספר שלם אחר נקבל את התוספת הנכונה: age_to_int + 20 .

כיצד להמיר מחרוזת למספר שלם ב-Java באמצעות Integer.valueOf

השיטה valueOf() פועלת כמו השיטה parseInt() . זה לוקח כפרמטר מחרוזת שצריך להמיר למספר שלם. הנה דוגמה:

class StrToInt {
    public static void main(String[] args) {
        String age = "10";

        int age_to_int = Integer.valueOf(age);

        System.out.println(age_to_int + 20);
        // 30
    }
}

בקוד לעיל אתה יכול לראות את אותו הדבר כמו בסעיף הקודם:

• העברנו מחרוזת כפרמטר ל- valueOf() : Integer.valueOf(age) . הוא אוחסן במשתנה בשם age_to_int .
• לאחר מכן הוספנו 10 למשתנה שנוצר: age_to_int + 20 . התוצאה הייתה 30 במקום 1020.

סיכום

במאמר זה, דנו בהמרת מחרוזות למספרים שלמים ב-Java. כדי להמיר מחרוזת למספר שלם, נעשה שימוש בשתי שיטות של המחלקה Integer - parseInt() ו- valueOf() . קידוד שמח!