Overriding

שפת Java – הפעם נלמד overriding.

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

נגדיר מחלקה ראשית עם פונקציה move

מטודה move מדפיסה מילה "First"

class First {

public void move() {
System.out.println("First");
}

}

נגדיר מחלקה יורשת בשם Second

class Second extends First {

public void move() {
System.out.println("Second");
}

public void hifun() {
System.out.println("Hi..");
}

}

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

עכשיו נגדיר שני אובייקטים:
* אובייקט X מבוסס על המחלקה First
* אובייקט Y מבוסס על המחלקה Second

public class TestClass {

public static void main(String args[]) {
First x = new First(); // First reference & object
Second y = new Second(); // Second reference & object

x.move(); // runs the method in First class
y.move(); // runs the method in Second class
y.hifun();
}

}

באדום, x.move מריץ מטודה אשר מוגדרת במחלקה First

לכן יודפס First

class First 
{ 
 public void move() 
 { 
  System.out.println("First"); 
 } 
}

בכחול, x.move מריץ מטודה אשר מוגדרת במחלקה Second

לכן יודפס Second

class Second extends First {

public void move() {
System.out.println("Second");
}


}

צילום מסך של הרצת הקוד אשר למעלה.

כל כבוד לכם!!!

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

Encapsulation

שפת Java – הפעם נלמד encapsulation.

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

public class TestClass {
private String x;
private String y;
private int z;


public int getX() {
return x;
}

public String getY() {
return y;
}

public String getZ() {
return z;
}

public void setZ( int z) {
this.z = z;
}

public void setX(String x) {
this.x = x;
}

public void setY( String y) {
this.y = y;
}
}

הסבר:

בעזרת מילה שמורה private אנחנו מגבילים גישה למחלקות יורשות לפרמטרים:
x,y,z

public class TestClass {
private String x;
private String y;
private int z;
}

עם זאת נותנים גישה לפרמטרים האלו תוך שימוש בפונקציות.

כי לפונקציות שלנו יש גישה מסוג public – פתוחות למחלקות יורשות (לאומת private אשר לא פתוחות למחלקות יורשות).

לדוגמה:
* מטודה setX מקבלת פרמטר X מסוג STRING ומאתחלת X של המחלקה בעזרת this.x

* מטודה getX מחזריה את X של המחלקה

public class TestClass {
private String x;
private String y;
private int z;


public void setX(String x) {
this.x = x;
}

public int getX() { 
return x; }
}

דוגמה:

public class MainTestClass{

   public static void main(String args[]) {
      TestClass obj = new TestClass();
      obj.setX("Xtest");
      obj.setZ(12);
      obj.setY("Ytest");

      System.out.print("X: " + obj.getX() + " Z: " + obj.getZ());
   }
}

בצבע כחול מוגדר אובייקט בשם obj מבוסס על המחלקה TestClass

בצבע ירוק בעזרת פונקציה setX מאתחלים X בערך "Xtest"

כזכור:

public class TestClass {
private String x;

public void setX(String x) {
this.x = x;
}
}

כנ"ל בעזרת פונקציה setZ מאתחלים Z בערך 12

public class TestClass {
private int z;

public void setZ( int z) {
this.z = z;
}

}

ובעזרת פונקציה setY מאתחלים Y בערך "Ytest" מסוג STRING

public class TestClass {
private String y;

public void setY( String y) {
this.y = y;
}
}

בסוף מדפיסים

System.out.print("X: " + obj.getX() + " Z: " + obj.getZ());

כאשר פונקציה obj.getX מחזריה ערך X שזה "Xtest"
ופונקציה obj.getZ מחזריה ערך Z שזה 12

דרך אגב אם היינו מנסים לגשת ישירות לפרמטרים האלו (X, Z) כגון

System.out.print("X: " + obj.x + " Z: " + obj.z);

אז היינו מקבלים שגיאת גישה כי לפרמטרים האלו יש סוג פרטי PRIVATE

לכן:

X: Xtest Z: 12

כי:

public class TestClass {
private String x;
private int z;


public int getX() {
return x;//Xtest 
}


public String getZ() {
return z;//12
}


}

ירושה

שפת Java – הפעם נלמד inheritance.

הגדרה של מחלקה בשם Mainclass שממנה תהיה ירושה

class Mainclass {
int x;

Mainclass (int x) {
this.x= x; 
}

public void getX() {
System.out.println("X in super class: " +this.x);
}

}

הסבר:

במחלקה Mainclass הגרנו פרמטר X מסוג Integer
וגם בנאי אשר מקבל פרמטר ומאתחל X בערך מסוג Integer

class Mainclass 
{ 
  int x; 

  Mainclass (int x) 
  { 
    this.x= x; 
  } 
}

כזכור בעזרת this אנחנו מפנים אל פרמטר X אשר הוגדר במחלקה
ומבדילים מפרמטר X שאותו מקבלים בבנאי!

בסוף יש מטודה בשם getX, אשר מדפיסה את הערך X

 public void getX() 
 { 
   System.out.println("X in super class: " +this.x);
 }

דוגמה:

קריאה למטודה ממחלקה ראשית שממנה יש ירושה

public class SubMainclass extends Mainclass {


SubMainclass(int x) {
super(x);//17

public static void main(String args[]) {
SubMainclass obj = new SubMainclass(17);//X in super class: 17
obj.getX();
}

}

הסבר:

מחלקה בשם SubMainclass מקבלת יורשה ממחלקה  Mainclass

public class SubMainclass extends Mainclass {

SubMainclass(int x) {
super(x);//17
}

}

מה זה יורשה?
יורשה זה קבלת כל פרמטרים ומטודות שהוגדרו ממחלקה שממנה יורשים.

* אנחנו עוד נלמד איך אפשר להסתיר פרמטרים ומטודות שלא יהיו נגישים למחלקות יורשות.
** תמיד מחלקה יורשת חייבת להכיל בנאי של המחלקה ראשית!

לכן במחלקה SubMainclass יש כל פרמטרים ומטודות של המחלקה ראשית Mainclass

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

במקרה שלנו למחלקה ראשית Mainclass  יש בנאי

Mainclass (int x) 
{ 
  this.x= x; 
}

לכן במחלקה יורשת SubMainclass יהיה בנאי:

* בעזרת super (מילה שמורה) אנחנו מאתחלים את הבנאי ממחלקה ראשית Mainclass

super(x)

לסיכום זה הבנאי במחלקה היורשת SubMainclass

SubMainclass(int x) 
{
 super(x);//17 
}

עכשיו בו נתמקד במשהו שכתוב בכחול

public class SubMainclass extends Mainclass {


SubMainclass(int x) {
super(x);//17

public static void main(String args[]) {
SubMainclass obj = new SubMainclass(17);//X in super class: 17
obj.getX();
}

}

כאן יש הגדרה של הקוד להרצת תוכנה ב-Java,

public static void main(String args[]) {
SubMainclass obj = new SubMainclass(17);//X in super class: 17
obj.getX();
}

אשר מכיל הגדרה של אובייקט ממחלקה ראשית

SubMainclass obj = new SubMainclass(17);//X in super class: 17

ובעזרה מטודה getX מדפיסים את הביטוי

public void getX() 
{ 
  System.out.println("X in super class: " +this.x);
}

שזה:

"X in super class: 17

Methods

שפת Java – הפעם נלמד methods.

דוגמה איך ניתן לקרוא לפונקציה של מחלקה נוכחית בעזרת this

בצבע כחול יש אתחול בנאי ריק

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

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

public class Some_Class
{
   int x=1;

   Some_Class()
   {
     //empty constructor 
   }

   Some_Class(int num)
   {
     this.x=num;
   }

   public void greet() 
   {
   System.out.println("I am greet method" + x);
   }

   public void print() 
   {
   this.greet();// THIS calls the method -greet- in our class    
   }
}

הסבר:

WOW סוף סוף נלמד קצת על OOP – Object-oriented programming 

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

אז יש לנו מחלקה בשם Some_Class

public class Some_Class {
}

במחלקה הגדרנו פרמטר X מסוג Integer (מספר שלם)

int x=1;

ובנאי ריק

Some_Class()  
{ 
 //empty constructor   
}

מה זה בנאי?

בנאי=בונה=>לבנות : )

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

בנאי יכול להיות ריק ויכול לקבל פרמטרים.

במקרה שלנו – בנאי לא מקבל פרמטרים ולכן הוא בנאי ריק.

Some_Class()  
{ 
 //empty constructor   
}

בנוסף במחלקה שלנו קיים עוד בנאי אשר מקבל פרמטר num מסוג Integer

Some_Class(int num)  
{  
  this.x=num;  
}

מה זה "this"?

בעזרת this יש הפניה לפרמטר אשר שייך למחלקה שלנו.
זוכרים את הפרמטר x אשר הוגדרנו בהתחלה של מחלקה?

int x=1;

אז במקום 1 פרמטר X יקבל ערך שווה ל-num

הגדרת מטודה במחלקה

public void greet() 
{ 
   System.out.println("I am greet method" + x); 
}

מה זה מטודה?

מטרה של מטודה זה להגדיר פעילות מסוימת (אופי) למחלקה.
במקרה שלנו יש לנו מטודה מסוג VOID בשם greet אשר מדפיסה:

System.out.println("I am greet method" + x);

מה זה סוג VOID?

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

מטודה מסוג VOID לא מחזירה ערך או אובייקט…

בנוסף יש לנו עוד מטודה בשם print

public void print()   
{ 
  this.greet();// THIS calls the method -greet- in our class 
}

בעזרת this יש הפניה למטודה greet אשר נמצאת במחלקה שלנו.

דוגמה של יצירת אובייקט על בסיס המחלקה שלנו 

public static void main(String[] args) 
{
  Some_Class obj1 = new Some_Class();
  obj1.print();
  Some_Class obj2 = new Some_Class(30);

  obj1.print();//x=1 
  obj1.print();//x=30 
}

הסבר:

כמו בכל תוכנה בשפת Java כותבים את הקוד אשר רוצים להעריץ
בתוך סוגריים של void main:

public static void main(String[] args) {

}

בתוך סוגריים של public static void main מוגדר אובייקט בשם obj1 

Some_Class obj1 = new Some_Class();

זוכרים שמטרה של המחלקה זה ליצור בסיס מסוים, כך שנוכל ליצור אובייקטים שונים בעלי אותו בסיס?!

אז במקרה שלנו – יש לנו אובייקט בשם obj1 אשר מבוסס על המחלקה Some_Class

obj1.print();

האובייקט obj1 קורה למטודה ()print וכזכור לפי מחלקה Some_Class

public void print()   
{ 
  this.greet();// THIS calls the method -greet- in our class 
}

זאת אומרת שיש קריאה ממטודה ()print למטודה ()greet

public void greet() 
{ 
   System.out.println("I am greet method" + x); 
}

לכן יודפס 1 I am greet method

בנוסף יש לנו עוד אובייקט בשם obj2

Some_Class obj2 = new Some_Class(30);

לאומת האובייקט הראשון obj1
הפעם בהגדרת אובייקט obj2 אנחנו מעבירים פרמטר לבנאי – 30.

זוכרים מה הבדל בין בנאי ריק ולא?!

כזכור במחלקה Some_Class הגדרנו שני בנאים:

בנאי ריק

Some_Class()  
{ 
 //empty constructor   
}

ובנאי אשר מקבל פרמטר

Some_Class(int num)  
{  
  this.x=num;  
}

לכן הפעם האובייקט obj2 קורה למטודה ()print וכזכור לפי מחלקה Some_Class

public void print()   
{ 
  this.greet();// THIS calls the method -greet- in our class 
}

זאת אומרת שיש קריאה ממטודה ()print למטודה ()greet

public void greet() 
{ 
   System.out.println("I am greet method" + x);//x=30 
}

כאשר הפעם x=30  לכן יודפס 30 I am greet method

Arrays

שפת Java – הפעם נלמד arrays.

הדפסת מערך

הדפסת מערך, כאשר כל פעם יש
הורדת שורה [n/]

double[] myList = {0.9,4.6,2.1};
for (int i = 0; i < myList.length; i++) 
{ 
 System.out.println(myList[i] + " ");//0.9 /n 4.6 /n 2.1
}

הסבר:

הגדרנו מערך myList מסוג double (מספרים לא שלמים)

לאחר מכן יש הרצה על מערך כולו תוך שימוש ב-for
למעשה בהתחלה  i=0
לכן:

myList[0]=0.9

בלולאה הבא i=1

לכן:

myList[1]=4.6

וכך עד myList.length כי

for (int i = 0; i < myList.length; i++) 
{ 
 System.out.println(myList[i] + " ");//0.9 /n 4.6 /n 2.1
}

כלומר עד שה-i פחות משלוש:

for (int i = 0; i < 3; i++) 
{  
  System.out.println(myList[i] + " ");//0.9 /n 4.6 /n 2.1 
}

שזה אורך המערך 3 כך שערך אחרון של i זה 2.

לכן כאשר i=2, יודפס:

myList[2]=2.1

מערך דו ממדי:

int[][] foo = new int[][] 
{
 new int[] { 1, 2, 3 },
 new int[] { 1, 2, 3, 4},
};

System.out.println(foo.length); //2
System.out.println(foo[0].length); //3
System.out.println(foo[1].length); //4
System.out.println(foo[1][2]);// 3

הסבר:

הגדרנו מערך דו ממדי בשם foo
1,2,3
1,2,3,4
למעשה במערך דו-מימדי יש שתי שורות:
שורה ראשונה 1,2,3
ושורה שניה 1,2,3,4

בעזרת foo.length מקבלים כמה שורות יש במערך -2

בעזרת foo[0].length מקבלים כמה איברים יש בשורה ראשונה – 3

בעזרת foo[1].length מקבלים כמה איברים יש בשורה השנייה- 4

  • בעזרת [2][1]foo ניתן למצוא את האיבר במערך אשר נמצא
    
    בשורה 1 ועמודה 2 שזה 3
    
    * ספירה מאפס
  • בעזרת [2][0]foo ניתן למצוא את האיבר במערך אשר נמצא
    
    בשורה 0 ועמודה 2 שזה 3
    
    * ספירה מאפס
  • בעזרת [1][0]foo ניתן למצוא את האיבר במערך אשר נמצא
    
    בשורה 0 ועמודה 1 שזה 2
    
    * ספירה מאפס

קבלת מערך כאובייקט לפונקציה

קבלת מערך כאובייקט לפונקציה והחזרת מערך עם ערכים מהסוף להתחלה

public class Main {

public static void main(String[] args) {

double[] myList = {0.9,4.6,2.1};

myList=reverse(myList);

for (int i = 0; i < myList.length; i++)
{
System.out.println(myList[i]);//2.1, 4.6, 0.9
}
}

public static double[] reverse(double[] myList) {

double[] result = new double[myList.length];//3

for (int i = 0, j = result.length - 1; i < myList.length; i++, j--)
{
result[j] = myList[i];//2.1, 4.6, 0.9
}

return result;//return Array: 2.1, 4.6, 0.9
}

}

הסבר:

הגדרנו מערך myList מסוג double

double[] myList = {0.9,4.6,2.1};

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

myList=reverse(myList);

כלומר פונקציה מחזירה מערך {2.1,4.6,2,0.9}:

myList= {2.1, 4.6,2, 0.9}

אבל הפונקציה reverse עושה את זה?

תשובה:

נגדיר פונקציה reverse אשר מקבלת מערך חד מימדי – myList מסוג double

public static int[] reverse(double[] myList) 
{  

}

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

int[] result = new int[myList.length];

באורך 3 כי

myList.length=3
לכן
int[] result = new int[3];

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

for (int i = 0, j = result.length - 1; i < myList.length; i++, j--)
{
result[j] = myList[i];//2.1, 4.6, 0.9
}

שזה כמו:

* result.length=3
* myList.length=3

for (int i = 0, j = 3 - 1; i < 3; i++, j--)
{
result[j] = myList[i];//2.1, 4.6, 0.9
}

או

for (int i = 0, j = 2; i < 3; i++, j--)
{
result[j] = myList[i];//2.1, 4.6, 0.9
}

ולכן

result[j] = myList[i];
שזה
result[2] = myList[0]=0.9

עם זאת מכיוון שעכשיו:

* i=0
* j=2

 i++, j--
אז
i=1 גדל ב-1
j=1 קטן ב-1

אז בהרצה הבאה של for

result[j] = myList[i];
שזה
result[1] = myList[1]=4.6

לאחר מכן

 i++, j--
אז
i=2 גדל ב-1
j=0 קטן ב-1

ולכן

result[j] = myList[i];
שזה
result[0] = myList[2]=2.1

זאת אומרת במערך result יש מערך הפוך מזה שהתקבל בפונקציה reverse

ובסוף אנו מחזרים את המערך הפוך הזה

 return result;//return Array: 2.1, 4.6, 0.9

ואז מדפיסים את המערך myList

myList=reverse(myList);

for (int i = 0; i < myList.length; i++)
{
System.out.println(myList[i]);//2.1, 4.6, 0.9
}

Strings

שפת Java – הפעם נלמד Strings

חישוב אורך המחרוזת:

String palindrome = "Let's do it";
int len = palindrome.length();
System.out.println( "String Length is : " + len );//String Length is :11

הסבר:

הגדרנו מחרוזת palindrome אשר מכילה טקסט: Let's do it

לאחר מכן תוך שימוש בפונקציה ()length מקבלים את האורך של מחרוזת Let's do it

int len = palindrome.length();

בשורה אחרונה מדפיסים את האורך הזה: String Length is :11

System.out.println( "String Length is : " + len );//String Length is :11

מחרוזות מילים:

String word = "Shalom";
System.out.println("Hi, my name is: " + word + ", nice to meet you!");

הסבר:

הגדרנו מחרוזת word אשר מכילה טקסט: Shalom

לאחר מכן, מדפיסים את המילים:

Hi, my name is +word+nice to meet you!

מה זה פרמטר word?

String word = "Shalom";

לכן יודפס:

Hi, my name is Shalom nice to meet you!

 


הפיכת אותיות קטנות לגדולות

String word= "Shalom";
System.out.println(word.toUpperCase() );//SHALOM

הסבר:

הגדרנו מחרוזת word אשר מכילה טקסט: Shalom

לאחר מכן תוך שימוש בפונקציה toUpperCase
הופכים Shalom לאותיות גדולות SHALOM


יש הרבה אופציות לשחק ב-STRINGS, יותר פירוט ניתן למצוא בקישור הזה:
https://docs.oracle.com/javase/7/docs/api/java/lang/String.html

שם בקישור אתם צריכים לרדת עד ה-Method Summary כמו בצילום המסך:

if – switch

קורס אונליין בשפת Java – הפעם נלמד if ו-switch.

if

int x = 7;

if( x == 3 ) 
{ 
 System.out.print("X is 3"); 
}
 else if( x == 20 ) 
{ 
 System.out.print("X is 20"); 
}
 else 
{ 
 System.out.print("X is else, ahah");//X is else, ahah
}

הסבר:

לפי הגדרה X=7, לכן
תנאי X==3 לא מתקיים;

if( x == 3 )

גם תנאי X==20 לא מתקיים;

else if( x == 20 )

לכן נשארת כל אופציה אחרת שזה הדפסת X is else, ahah

else 
{  
System.out.print("X is else, ahah");
}

switch

הדפסת Excellent! מכיוון ש-GRADE=A

char grade = 'A';

switch(grade) 
{ 
 case 'A' : System.out.println("Excellent!"); break;//Excellent! 
 case 'B' : System.out.println("Well done"); break;
 default : System.out.println("Invalid "); 
}

הסבר:

לפי הגדרה grade =A לכן זה מאתים למשהו בכחול: הדפסת Excellent!

* דרך אגב, אם לא היה break אז לאחר הדפסה היינו ממשיכים אל הדפסה "Well done"
** אם לפי הגדרה היה grade =C אז מכיוון שזה לא A ולא B היינו מדפיסים Invalid (משהו ב-default)

loops – while – if

שפת Java – הפעם נלמד לולאות.

FOR

הדפסת X מערך 2 עד הערך 5

for(int x = 2; x < 5; x++) 
{         
  System.out.println("x="+ x);//2,3,4     
}

הסבר:

  • int x=2 – הגדרת משתנה בשם X מסוג Integer(מספר שלם)
  • בדיקה האם X<5, מכיוון ש 2 פחות מ-5 לכן תנאי מתקיים.
  • הדפסת X=2
System.out.println("x="+ 2);
  • X גדל באחד שזה אומר X=3
x++

עכשיו X=3 ואנחנו שוב בודקים האם X<5, מכיוון ש 3 פחות מ-5 לכן תנאי מתקיים.

  • הדפסת X=3
  • X גדל באחד שזה אומר X=4

בדיקה האם X<5, מכיוון ש 4 פחות מ-5 לכן תנאי מתקיים.

  • הדפסת X=4
  • X גדל באחד שזה אומר X=5

בודקים האם X<5, מכיוון ש 5 לא פחות מ-5 לכן התנאי לא מתקיים.

  • הפעם לא נכנסים לסוגריים של ה-for.

הגדרת מערך:

נגדיר מערך מסוג INTEGER – מספרים

int [] numbers = {1, 3, 7, 40};

הדפסת מספר אחרי מספר ממערך:

for(int x : numbers ) 
{ 
 System.out.print(x+',' );//1,3,7,40 
}

הסבר:

במערך numbers יש 4 מספרים, לדוגמה מספר 1 נמצא במיקום 0 לכן ניתן לגשת עליו כך:

numbers[0]=1

מספר 3 במערך שלנו, נמצא במיקום 1, לכן ניתן לגשת עליו:

numbers[1]=3

אבל יש דרך יותר קצרה להדפיס את כל ערכים שבמערך:

פרמטר X יקבל בכל לולאה ערך ממערך numbers
כלומר: 1,3,7,40

for(int x : numbers ) 
{ 
  System.out.print(x+',' );//1,3,7,40 
}

הדפסת שמות ממערך:

נגדיר מערך מסוג STRING – מחרוזות

String [] names = {"Shalom", "Avraham", "Daniel"};
for( String name : names ) 
{
 System.out.print(name +',' );//Shalom, Avraham, Daniel
}

הבסר

בהתחלה יודפס Shalom

לאחר מכן איבר הבא במערך names: Avraham

ובסוף יודפס Daniel

WHILE

הדפסת X כל עוד X גדול מ-3

int x = 10;

while( x > 3 ) 
{
 System.out.println("x" + x );//10,9,8,7,6,5,4 
  x--;
}

הסבר:

בהתחלה X=10 לכן תנאי של X>3 מתקיים;
לאחר מכן X=9 כי X קטן באחד.

x--

וגם אז תנאי של X>3 מתקיים;

לאחר מכן X=8 וגם אז תנאי של X>3 מתקיים;
… כאשר X=3 אז תנאי של X>3 לא מתקיים – לכן תהיה יציאה מה-WHILE.

לכן יודפס:

10
9
8
.
.
4


WHILE DO

הדפסת X כל עוד X גדול מ-3, כאשר תנאי כניסה ל-while ייבדק כל פעם בסוף

int x = 10;

do 
{ 
System.out.println("x" + x ); //10,9,8,7,6,5,4
x--; 
}
while( x > 3 );

הסבר:

קודם נכנסים ל-WHILE ולאחר מכן בודקים את התנאי של WHILE.

  • בהתחלה X=10 מדפיסים 10 ו-X קטן באחד שזה 9. בסוף בודקים תנאי של X>3 והתנאי מתקיים;
  • עכשיו X=9 מדפיסים 9 ו-X קטן באחד שזה 8. בסוף בודקים תנאי של X>3 והתנאי מתקיים;
  • עכשיו X=8 מדפיסים 8 ו-X קטן באחד שזה 7. בסוף בודקים תנאי של X>3 והתנאי מתקיים;
  • עכשיו X=4 מדפיסים 4 ו-X קטן באחד שזה 3. בסוף בודקים תנאי של X>3 והתנאי לא מתקיים;

לכן יודפס:

10
9
8
.
.
4

התחלה – לפני תכנות

מה נלמד ?
התקנה של IntelliJ IDEA כולל יצירת מחלקה ראשונה בשפת Java.


מה התוכנה הטובה ביותר כדי להתחיל לתכנת ?

  1. יש להוריד IntelliJ IDEA, Netbeans − A Java IDE
    * יש לבחור Community

בהתקנה יש לבחור הגדרות כמו בצילום מסך:

 

לאחר שהורדנו הכל, והרצנו IntelliJ IDEA יהיה חלון הבא:

אנחנו צריכים ללחוץ על Create New Project

במידה ועדיין אין לכם SDK אז יש להוריד את SDK

לאחר הורדת SDK יש ללחוץ NEXT כמו בצילום מסך:

יש לשים סימן V כמו בצילום במסך הבא :

יש לבחור מיקום לפרויקט שלנו והשם שלו.

מזל טוב, הכל מוכן לקוד שלנו : )

package com.company;

public class Main {
public static void main(String[] args) {
// My first program - comments here
 System.out.println("Hello World");
}
}

הסבר:

תיקיה:

package com.company;

זאת התיקייה איפה קובץ של התוכנה נמצא

בקרה של כל תוכנה ב-Java

public class Main {  }

או

public class Main {

}

או

public class Main
{

}

זה יהיה תמיד בכל תוכנה שלנו ב-Java, בינתיים יש לזכור שכל משהן בין סוגריים {} ירוץ בתוכנה!

הוראות למתכנת

// My first program - comments here

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

הדפסה על מסך

System.out.println("Hello World");

 למעשה תמיד אם אנחנו רוצים להדפיס משהו אז יש להשתמש ב-System.out.println
במקרה הזה יודפס Hello World

הרצת תוכנה

אז בואו נריץ תוכנה ראשונה שלנו: Hello World,
כדי להריץ אותה יש צורך בלחיצת סימן ירוק של PLAY (ראה חץ אדום).

ב-IntelliJ IDEA ניתן לעצב קוד למארה טוב יותר

לדוגמה יש לנו קוד

package com.company;

public class Main {
public static void main(String[] args) {
// My first program - comments here
 System.out.println("Hello World");
}
}

אבל לאחר העתק-הדבק של הקוד הזה בIntelliJ IDEA נקבל:

וזה לא כל כך נראה טוב…וגם קוד לא ירוץ כך!

לצורך תצוגה הרבה יותר ברורה וגם שלא יהיו שגיאות יש לסמן את הכל הקוד
ולבחור Adjust code style settings

ואז יש לסמן checkbox ..העיקר שהכפתור SAVE יהפוך להיות פעיל.

לאחר לחיצת SAVE נקבל:

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

 

package com.company;

public class Main {
public static void main(String[] args) {
// My first program - comments here
 System.out.println("Hello World");
}
}

לאחר סידור: