Java|Variable Arguments

החל מג'אווה 1.5 קיימת אופציה חדשה שבה ניתן לקרוא לפונקציה אם מספר פרמטרים לא מוגדר מראש.

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

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

איך עושים את זה?

סינטקס:

Type … variable name

  1. Example:

Public int Sum(int… numbers)

{

                Int total=0;

For(int i=0; i< numbers.length; i++)

{

                Total+=number[i];

}

Return total;

}

נשים לב שהפונקציה מקבלת int… numbers – ז"א הטיפוס שנרצה לקבל [כמובן ניתן לקבל גם משתנה גנרי – אני יראה את זה בדוגמא הבאה], לאחר מכן שלוש נקודות … אשר יגדירו לנו מערך של מספר מסויים של אינסטנסים ושם הרשימה שתחזיק לנו אותם, במקרה שלנו numbers.

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

בדוגמא הבא אני יראה שימוש בשיטה גנרית.

  1. Example

Public int Sum (E… numbers)

{

                // NOTE: u can use type safe for E

                …

}

הפונקציה תקבל רשימה גנרית מסוימת ותבצע עליה מניפולציות.

  • בשיטה זאת משתמשים בקריאת לפונקציות של רפלקשיין, כמו : getMethod, invoke etc…

יום טוב וחג שמח

מודעות פרסומת
מאת chenreuven פורסם ב-Java

תפקיד JUnit + דוגמאות ולינקים

מה זה Junit?

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

ההיתרונות של הכלי הם בכך שניתן להריץ סט של בדיקות שלא נמצאות בתלות עם הפרוייקט, קרי ניתן להריץ אותם בתוך ספרייה בתוך הפרוייקט ואף מחוץ לפרוייקט, רק חשוב לקשור בן בדיקה לבין פונקציה שנבדקת. יתר על כן ניתן להעביר את הבדיקות בין פרוייקטים שונים שכן כמו שאמרתי מקודם אין תלות וזה Stand Alone Unit.

הורדה: https://github.com/KentBeck/junit/downloads

מדריך להתקנה: http://www.vogella.de/articles/JUnit/article.html

מדריך קצר באנגלית: http://code.google.com/p/t2framework/wiki/JUnitQuickTutorial

 

מאת chenreuven פורסם ב-Java

JAVA| transient keyword

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

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

public class MainClass {

 

  public static void main(String[] argsthrows Exception {

 

    User a = new User("A""B");

 

    System.out.println("logon a = " + a);

 

    ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("User.out"));

 

    o.writeObject(a);

 

    o.close();

 

    Thread.sleep(1000)// Delay for 1 second

 

    ObjectInputStream in = new ObjectInputStream(new FileInputStream("User.out"));

 

    System.out.println("Recovering object at " new Date());

 

    a = (Userin.readObject();

 

    System.out.println("logon a = " + a);

 

  }

 

}

 

class User implements Serializable {

 

  private Date date = new Date();

 

  private String username;

 

  private transient String password;

 

  public User(String name, String pwd) {

 

    username = name;

 

    password = pwd;

 

  }

 

  public String toString() {

 

    String pwd = (password == null"(n/a)" : password;

 

    return "logon info: \n   username: " + username + "\n   date: " + date + "\n   password: "

 

        + pwd;

 

  }

 

}

 

 

תהנו 🙂
מאת chenreuven פורסם ב-Java, Types

חלק שני| Reflection

מה נלמד היום?

1. השגת ה- class לאובייקט
2. השגת שם רגיל +מקוצר
3. זיהוי המזהים, Modifiers.
4. זיהוי ספרייה
5. superclass
6. interfaces
7. constructors
8. Methods
9. Fields
10. Annotation

זה אמור להספיק 🙂

Reflection כמו שאמרתי בכתבה הקודמת (לינק) הינה דרך ליצירת אובייקט בזמן ריצה, והדגש הוא כמובן בזמן ריצה!
השיטה הזאת נפוצה מאוד בחברות קטונות/גדולות, שכן היצירה של האובייקט מתרחשת בזמן ריצה דבר שמקנה לנו הרבה אפשרויות לשינויים והרחבה.

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

1. Get Class from Class
קיימות 2 אפשרויות:
– Class myObjectClass = MyObject.class
– (Class class = Class.forName(className
*When using the Class.forName() method you must supply the fully qualified class name
2. שם המחלקה
Class aClass = … //מה שראינו מקודם
String className = aClass.getName();
or

String simpleClassName = aClass.getSimpleName();

3. Modifiers["public", "private", "static" etc.]
int modifiers = aClass.getModifiers();
4. Package information
Package package = aClass.getPackage();
5. superClass
Class superclass = aClass.getSuperclass();
6. interfaces
בגלל העובדה שלמחלקה יכולים להיות מספר ממשק שהיא תממש אז נחזיר מערך של ממשקים
Class[] interfaces = aClass.getInterfaces();
7. Constructors
Constructor[] constructors = aClass.getConstructors();
8.Methods
Method[] method = aClass.getMethods();
9. Fields
Field[] method = aClass.getFields();
10. Annotations
Annotation[] annotations = aClass.getAnnotations();

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

תודה על ההקשבה

Reflection| Introduction

Hi All,

in the next few weeks i will explain on sessions about reflection API, i  will explain the basics of Java Reflection including how to work with arrays, annotations, generics and dynamic proxies, and do dynamic class loading and reloading.

reflection API is stong API that it very important for a developer to know to wrok with him.

Introduction:

Java's Reflection API's makes it possible to inspect classes, interfaces, fields and methods at runtime, without knowing the names of the classes, methods etc. at compile time. It is also possible to instantiate new objects, invoke methods and get/set field values using reflection.

Reflection by Sun site:

http://java.sun.com/developer/technicalArticles/ALT/Reflection/

Java | Garbage Collection

Hi,

  • 1. The process of disposing of dead objects is called garbage collection.

2. Encouraging the Java Virtual Machine (JVM) to do some garbage collecting and recover the memory.

Example:

class MyClass{
  double var; // Radius of a sphere

  MyClass() {

  }

  // Class constructor
  MyClass(double x) {
    var= x; // Set the radius
  }
}
public class MainClass {
  public static void main(String[] arg){
    MyClasss myClass= new MyClass();
    System.gc(); // Direct order to garbage collection
  }

}

Life cycle: http://chaoticjava.com/posts/how-does-garbage-collection-work/

מאת chenreuven פורסם ב-Java

Sorting On Array , The Easy Way

Hi,

I see developer that use some alghorithms for sorting on array and it fine. but there is another way that it more useful.

import java.util.Arrays;

Arrays.sort (int [])
Arrays.sort (String [])
Arrays.sort (float [])
Arrays.sort (double [])
Arrays.sort (long [])
Arrays.sort (Object [])
Sort in Ascending, example:
//Sort array in ascending order
String [] stringArray = {"ab", "aB", "c", "0", "2", "1Ad", "a10"}
Arrays.sort(stringArray);
System.out.println("****** Sorted String Array *******");
for (String str : stringArray) {
System.out.println(str);
}
Output:
****** unsorted string *******
ab
aB
c
0
2
1Ad
a10
Sort in Decending, example:
Arrays.sort (Object [], Comparator)
example:
//Sort array in reverse order
Arrays.sort(stringArray, Collections.reverseOrder());
System.out.println("****** Reverse Sorted String Array *******");
for (String str : stringArray) {
System.out.println(str);
}
Output:
****** Reverse Sorted String Array *******
c
ab
aB
a10
2
1Ad
0
Selective Sorting
Arrays.sort (Object [], int startIndex, int endIndex)
Example:
//Sorting array starting from index 3 till 6
Arrays.sort(stringArray, 3, 6);
System.out.println("****** Selective Sort String Array *******");
for (String str : stringArray) {
System.out.println(str);
}
Output:
****** Selective Sort String Array *******
ab
aB
c
0
1Ad
2
a10
One more thing important.
if u Sort Object, u MUST overide the function compareTo…
Enjoy From Sorting


מאת chenreuven פורסם ב-Java

Java Naming Conventions

  • What Is a Naming Convention?

    A naming convention is a rule to follow as you decide what to name your identifiers (e.g. class, package, variable, method, etc..).

    Why Use Naming Conventions?

    Different Java programmers can have different styles and approaches to the way they program. By using standard Java naming conventions they make their code easier to read for themselves and for other programmers. Readability of Java code is important because it means less time is spent trying to figure out what the code does, leaving more time to fix or modify it.

    Standard Java Naming Conventions

    The below list outlines the standard Java naming conventions for each identifier type:

    Packages: Names should be in lowercase. With small projects that only have a few packages it's okay to just give them simple (but meaningful!) names:

     package pokeranalyzer package mycalculator

    In software companies and large projects where the packages might be imported into other classes, the names will normally be subdivided. Typically this will start with the company domain before being split into layers or features:

     package com.mycompany.utilities package org.bobscompany.application.userinterface

    Classes: Names should be in CamelCase. Try to use nouns because a class is normally representing something in the real world:

     class Customer class Account

    Interfaces: Names should be in CamelCase. They tend to have a name that describes an operation that a class can do:

     interface Comparable interface Enumerable

    Note that some programmers like to distinguish interfaces by beginning the name with an "I":

     interface IComparable interface IEnumerable

    Methods: Names should be in mixed case. Use verbs to describe what the method does:

     void calculateTax() string getSurname()

    Variables: Names should be in mixed case. The names should represent what the value of the variable represents:

     string firstName int orderNumber

    Only use very short names when the variables are short lived, such as in for loops:

     for (int i=0; i<20;i++) {    //i only lives in here }

    Constants: Names should be in uppercase.

     static final int DEFAULT_WIDTH static final int MAX_HEIGHT

     

    * credit to Paul Leah

מאת chenreuven פורסם ב-Java