COMP 231 LAB SOLUTIONS 
Prepared by : Sewar Abueid  


LAB NO.2: 

Question One: (calculate BMI): 
////////////////////////////////////////////////////////////////////////
import java.util.Scanner;
public class Selection {
public static void main(String [] args) { 
	Scanner input =new Scanner(System.in); 
	System.out.println("Enter your weight in kilograms please :"); 
	double Weight_In_KiloGrams=input.nextDouble(); 
	System.out.println("Enter your length in cm please :"); 
	double Length_In_Meters=input.nextDouble(); 
	// convert the weight to pounds: 
	double pound=Weight_In_KiloGrams*2.2; 
	// convert the length to meters : 
	double inches= Length_In_Meters*0.39; 
	double BMI=(pound*703)/(inches*inches);  
	System.out.println("BMI is \t"+BMI);
	if(15<=BMI&&BMI<19) { 
		System.out.println("UNDERWEIGHT");
	} 
	else if(19<=BMI && BMI<25) { 
		System.out.println("NORMAL");
	}  
	else if(25<=BMI && BMI<30) { 
		System.out.println("OVERWEIGHT"); 
		
	}   
	else 
		System.out.println("Something wrong!!!!!Check of your data and try again !");
	
	input.close();
}
} 
///////////////////////////////////////////////////////////////////////////////// 
Question Two: (Salary for Employees): 

import java.util.Scanner;
public class ComputingSalary { 
	public static void main(String[] args) {  
		Scanner input=new Scanner(System.in);
		int stop=0; 
		while (stop!=-1) {
			System.out.println("Enter your hourworked or -1 to stop");  
			int hourWorked=input.nextInt();  
			if(hourWorked!=-1) {
			System.out.println("Enter your hour rate :"); 
			double hourRate=input.nextDouble(); 
			if(hourWorked<=40) { 
				System.out.println("your salary is"+(hourWorked*hourRate));
			} 
			else if(hourWorked>40) { 
				double salary=(hourWorked*hourRate)+((hourWorked-40)*hourRate*0.5); 
				System.out.println("your salary is"+salary);
			} 
			else { 
				System.out.println("Somthing wrong ! check your data");
			} 
			} 
			else if(hourWorked==-1) { 
				stop=-1;
			}
		}
		
		 input.close();
}
} 
/////////////////////////////////////////////////////////////////////////////////// 
Question Three : (Prime number) : 

import java.util.Scanner;
public class PrimeNumber { 
	public static void main(String[] args) {   
		int counter=0;
		Scanner input=new Scanner(System.in); 
		boolean prime;
		for(int i=2;i<500;i++) { 
			prime =isPrime(i); 
			if(prime==true) 
				System.out.println(i);
		} 
		// Now we  want to improve the program to test the entered number whether it is prime or not: 
		System.out.println("enter the number to test or less than two to end :"); 
		int number=input.nextInt();  
		while(number>2) {
		for(int i=1;i<=number;i++) { 
			if(number%i==0) 
				counter++;
		} 
		if(counter ==2) {
			System.out.println("the number is prime"); 
		}
		else { 
			System.out.println("The number is not prime");  
		} 
		System.out.println("Enter a number to test or less than 2 to end"); 
		int num=input.nextInt(); 
		if(num<2) 
			number=0;
		}
		 input.close();
} 
	public static boolean isPrime(int number) {  
		int count=0;
		
			for(int j=1;j<=number;j++) { 
				if(number%j==0) 
					count++;
			} 
			if(count==2) 
				return true; 
				else 
					return false;
		}

} 
////////////////////////////////////////////////////////////////////////////////////////////// 
LAB NO.3 


Question One :(Find the  exponential) : 


import java.util.Scanner;
public class Exponential {
 public static void main(String [] args) { 
	 Scanner input=new Scanner(System.in); 
	 System.out.println("Enter the number that you want to find the exponential for :"); 
	 int num=input.nextInt();  
	
	 double answer=exp(num); 
	 System.out.println("The answer is "+answer); 
	 input.close();}

 public static double exp(int x) { 
	 double summation=0; 
	 summation=1+(x)+((x*x)/fact(2))+((x*x*x)/fact(3))+((x*x*x*x)/fact(4))+((x*x*x*x*x)/fact(5)); 
	 return summation;
 } 
 public static double fact (int x) { 
	 double result=1;
	for(int i=1;i<=x;i++) { 
		result=result*i;
	}  
	
	return result;
 }
}
//////////////////////////////////////////////////////////////////////////////////////////////////

Question Two :(Perfect Number) :


import java.util.Scanner;
public class PerfectNumber {
public static void main(String [] args) { 
	Scanner input=new Scanner(System.in);   
	for(int i=1;i<=1000;i++) { 
		if(isPrime(i)) { 
			System.out.println(i);
		}
	} 
	// This part is to check whether the entered number by the user is perfect or no  
	int count=0;
	System.out.println("Please enter the number :");
 	int x=input.nextInt();	
    for(int j=1;j<x;j++) { 
    	if(x%j==0) 
    		count+=j;
    } 
    if(count==x) 
    	System.out.println("The number is perfect");
    else 
    	System.out.println("The number is not prime");
	//--------------->>>>>>>>>>> The complement:
	input.close();
} 
 
 public static boolean isPrime(int x) { 
	 int count=0; 
	 for(int i=1;i<x;i++) { 
		 if(x%i==0) 
			 count+=i;
	 } 
	 if(count==x) 
		 return true; 
	 else 
		 return false;
 }
}
////////////////////////////////////////////////////////////////////////////////////////////////// 

Question Three : (Binary to Decimal): 


import java.util.Scanner;
public class BinaryToDecimal { 
	public static void main(String[] args) { 
		Scanner input=new Scanner(System.in);   
		int dec=0;//This variable is to add the summation inside it and store the result(decimal)
		int i=0;//This variable is like a counter to count for the power of 2 in each iteration
		 System.out.println("Enter the binary number you want to convert :"); 
		 
         int num=input.nextInt();
         while(num!=0) { 
        	 int reminder=num%10;//to take the digit on the right  
        	dec+= (int) (reminder*Math.pow(2,i)); // reminder*2^i 
        	i++; // increment the power
        	num=num/10;// get the digit we use away
         }
		
		 System.out.println("the decimal value is : "+dec);//represent the result on the screen 
		
		
		input.close();
	}

}
///-------------------------------------------------->>> Question Three complement :Additional Task  (Decimal To Binary): 
  
import java.util.Scanner;
public class DecimalToBinary { 
	public static void main(String[] args) { 
		Scanner input=new Scanner(System.in);  
		int i=0; 
		int binary []=new int [100];
		System.out.println("Enter the number in decimal to convert to Binary : ");
		int number =input.nextInt(); 
		while(number!=0) { 
			binary[i]=number%2; 
			i++; 
			number=number/2;
		} 
		for(int j=i-1;j>=0;j--) 
			System.out.print(binary[j]);
		
		
		input.close();
	}

}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 

LAB NO.4 : 


Question One : Building (This solution is before modifying)(هذا حل أول فرع من السؤال ): 


import java.util.Scanner;
public class Building { 
	public static void main(String[] args) { 
		Scanner input=new Scanner(System.in); 
		System.out.println("Enter the number of appartments :"); 
		int numOfapart=input.nextInt(); 
		int [] Building=new int[numOfapart]; 
		 for(int i=0;i<Building.length;i++) { 
			 System.out.println("Enter the number of people in apartment No."+(i+1)); 
			 Building[i]=input.nextInt();
		 }  
		 int summation=0;
		 for(int i=0;i<Building.length;i++) { 
			 summation+=Building[i];
		 } 
		 System.out.println("The number of people in the building is "+summation);
		int avg=summation/numOfapart; 
		System.out.println("The avg num of people per apartment is "+avg); 
		int count1=0;// number of apartments have people above the average
		int count2=0;// number of apartments have people below the average
		for(int i=0;i<Building.length;i++) { 
			if(Building[i]>avg) { 
				count1++;
			} 
			else if(Building[i]<avg) { 
				count2++;
			}
		} 
		System.out.println("The number of apartments above avg is "+count1);
		System.out.println("The number of apartments below avg is "+count2);
		
		
		input.close();
	}

}
/////////////////////////////////والتالي هو حل الفرع الثاني من السؤال الأول : 
import java.util.Scanner;
public class Building { 
	public static void main(String[] args) { 
		Scanner input=new Scanner(System.in); 
		System.out.println("Enter the number of appartments :"); 
		int rows=input.nextInt(); 
		double [][] Building=new double[rows][]; 
		 for(int i=0;i<Building.length;i++) { 
			 System.out.println("Enter the number of people in apartment "+(i+1));  
			 int x=input.nextInt();
			 Building[i]=new double[x]; 
		 }  
		 for(int i=0;i<rows;i++) { 
			 for(int j=0;j<Building[i].length;j++) { 
				 System.out.println("Enter The ages of people respectively "); 
				 Building[i][j]=input.nextInt();
			 }
		 } 
		 averageAges(Building);
		input.close();
	} 
	public static void averageAges(double [][] Building ) { 
		double sum=0; 
		double avg=0;  
		int numOfPeople=0;
		for(int i=0;i<Building.length;i++) { 
			for(int j=0;j<Building[i].length;j++) { 
				sum+=Building[i][j];
			}
		} 
		for(int i=0;i<Building.length;i++) { 
			numOfPeople+=Building[i].length; 
			//This for loop is to find the number of people in the Whole Building
		} 
		avg=sum/numOfPeople; 
		System.out.println("The average of ages = "+avg); 
	}

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
 

Question Two: Linear Search :  

import java.util.Scanner;
public class Search { 
	public static void main(String[] args) { 
		Scanner input=new Scanner(System.in); 
		System.out.println("Enter the number of elements you want to enter "); 
		int size=input.nextInt(); 
		int [] numbers=new int [size];  
		System.out.println("Enter "+size+" numbers");
		for(int i=0;i<size;i++) { 
			numbers[i]=input.nextInt();
		} 
		System.out.println("What is the Key element ?"); 
		int key=input.nextInt(); 
		int i= LinearSearch(numbers,key); 
		if(i==-1) { 
			System.out.println("The number"+key+" is not in your array !");
		} 
		else { 
			System.out.println("The element "+numbers[i]+"is exist in the array and its index is"+i);
		}
		input.close();
	} 
	// This is the body of the linear search method
        public static int LinearSearch(int []numbers,int key) { 
        	for(int i=0;i<numbers.length;i++) { 
        		if(numbers[i]==key) 
        			return i;
        	}
        	
        		return -1;
        }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
Question Three : (Student Class) 

السؤال كثير سهل وأغلبه كوبي بيست من المانيوال هو بس شوية  إضافات لأنه مقدمة للاب الجاي 




// This Code is just a copy paste from the lab manual
 public class Student {
private int studentId;
private String studentName;
public Student() {
}
public Student(int stId, String stName) {
studentId = stId;
studentName = stName;
}
public void setStudentId(int number) {
studentId = number;
}
public int getStudentId() {
return studentId;
}
public void setStudentName(String name) {
studentName = name;
}
public String getStudentName() {
return studentName;
}
}
/////////Now This is the code for the new class (Driver Class to test the Student class ): 
public class Driver { 
	public static void main(String []args) { 
		// create an array of four students  
		/* 
		 * to create an array of students the process here is very close to that we
		 * were doing to create an array of integers of doubles or any data type
		 */
		Student [] array=new Student[4]; 
		array[0]=new Student(1200043,"Sewar"); 
		array[1]=new Student(1201816,"Manar");  
		array[2]=new Student(1200000,"Ahmad");  
		array[3]=new Student(1200049,"Alaa");  
		for(int i=0;i<array.length;i++) {  
			/* 
			 * we use getters to access the attributes of objects
			 */
			System.out.println("Student NO."+(i)+" name :"+array[i].getStudentName());  
			
			System.out.println(" ID :"+array[i].getStudentId());
		}
		
		
	}

}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

LAB NO.5 :    Object-Oriented-Programming 


Question One : Employee Class: 

// This is the class Employee and we will write here all the data attributes  
// for the Employees objects that we will create them in the Driver class to test
public class Employee { 
	// data field or data attributes as shown in the UML in the lab manual 
	private int departmentNO; 
	private String name; 
	private long ID; 
	java.util.Date birthDate; 
	java.util.Date hireDate; 
	private double basicSalary; 
	// Now we will implement the constructors also as shown in the lab manual 
	//1. No argument constructor 
	public Employee() { 
		
	} 
	// 2. parameterised constructor  
	public Employee(int newDep,String newName,long newId,java.util.Date newBirthDate,java.util.Date 
			newHireDate,double newBasicSalary) { 
		this.departmentNO=newDep; 
		this.name=newName; 
		this.ID=newId; 
		this.birthDate=newBirthDate; 
		this.hireDate=newHireDate; 
		this.basicSalary=newBasicSalary;
	} 
	/* 
	 * these are setters and getters as shown in the lab manual 
	 * you can generate them automatically by using source list above
	 */
	public int getDepartmentNO() {
		return departmentNO;
	}
	public void setDepartmentNO(int departmentNO) {
		this.departmentNO = departmentNO;
	}
	public long getID() {
		return ID;
	}
	public void setID(long iD) {
		ID = iD;
	}
	public double getBasicSalary() {
		return basicSalary;
	}
	public void setBasicSalary(double basicSalary) {
		this.basicSalary = basicSalary;
	}  
	public String getName() {
		return name;
	}
	public java.util.Date getBirthDate() {
		return birthDate;
	}
	public java.util.Date getHireDate() {
		return hireDate;
	}
	
	// if you look to the UML in the lab manual you will see that you want to  
	// implement a method to print all the informations about the employees  
	// it will be done like this  
	public void printEmployeeInformation() { 
		System.out.println("the employee "+this.getName()+" has ID ="+this.getID()+" \n and birthdate" 
				+this.getBirthDate()+" HireDate"+this.getHireDate()+" and the basic salary"+this.getBasicSalary());
	}
	

}
// and this is the Driver class you will write it in a separate file 

import java.util.Date;
public class Driver1 { 
	public static void main(String [] args) { 
		// here we will create an array of Employees  
		Employee [] emp=new Employee[4]; 
		emp[0]=new Employee(290,"Sewar",1200043,new Date(6,4,2002),new Date(15,5,1894),3500); 
		emp[1]=new Employee(291,"Qamar",1210397,new Date(30,9,2003),new Date(11,6,1900),3000);
		emp[2]=new Employee(299,"Bushra",12345,new Date(15,2,2006),new Date(15,4,1800),3100);
		emp[3]=new Employee(290,"Mary",1200043,new Date(30,6,2009),new Date(24,6,1755),3200);  
		largestSalary(emp).printEmployeeInformation();
		System.out.println(" has the largest Salary . ");
		
	}
       public static Employee largestSalary(Employee [] emp) { 
    	   Employee empWithLargestSalary=emp[0]; 
    	   for(int i=0;i<emp.length;i++) { 
    		   if(emp[i].getBasicSalary()>empWithLargestSalary.getBasicSalary()) 
    			   empWithLargestSalary=emp[i];
    	   } 
    	   return empWithLargestSalary;
       }
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Question Two : 

// this is the MyArray class 

public class MyArray { 
	// the internal of this class is an array of integers 
	int [] array;
	// the constructors as shown in the lab manual are only a parameterised constructor: 
	public MyArray(int [] newArray) { 
		array=newArray;
	} 
	// this is the min method that will return the minimum element in the array 
	public int min() { 
		int minimum=array[0]; 
		for(int i=0;i<array.length;i++) { 
			if(array[i]<minimum) 
				minimum=array[i];
		} 
		return minimum;
	}  
	// this is the max method that will return the maximum element in the array 
	public int max() { 
		int maximum=array[0]; 
		for(int i=0;i<array.length;i++) { 
			if(array[i]>maximum) 
				maximum=array[i];
		} 
		return maximum;
	} 
	// this is the avg method that will return the average of the values in the array 
	public double avg() { 
		int sum=0; 
		double average; 
		for(int i=0;i<array.length;i++) { 
			sum+=array[i];
		} 
		average=sum/(array.length); 
		return average;
	} 
	public void printArray() {  
		System.out.println("The array elements are : ");
		for(int i=0;i<array.length;i++) { 
			System.out.print(" "+array[i]+" ");
		}
	}  
	
	public int getSize() {  
		System.out.println();
		return array.length;
	}
	

}
/////////Now this is the Driver class you will write it in another file(separately): 

public class Driver2 { 
	public static void main(String[] args) { 
		// create an array of objects to put it as an argument when we will create an object 
		// of type MyArray
		int [] array= {3,7,9,11,14}; 
		// create an object of type MyArray: 
		MyArray obj=new MyArray(array); 
		System.out.println("The minimum number in the array is "+obj.min());
		System.out.println("The maximum number in the array is "+obj.max());
		System.out.println("The average of the numbers in the array is "+obj.avg()); 
		obj.printArray(); 
		System.out.println("The size of the array is "+obj.getSize());
		
	}

}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Question Three: (The cities question): 
// we will implement this class according to the UML in the lab manual
public class City { 
	// data field 
	private String cityName; 
	private double longitude; 
	private double latitude; 
	private int tempreture; 
	 
	// constructors: 
	public City() { 
		
	} 
	public City(String newName, double newLongitude,double newLatitude,int newTempreture) { 
		cityName=newName; 
		longitude=newLongitude; 
		latitude=newLatitude; 
		tempreture=newTempreture;
	} 
	// Now we will generate the setters and getters for the data attributes automatically 
	public String getCityName() {
		return cityName;
	}
	public void setCityName(String cityName) {
		this.cityName = cityName;
	}
	public double getLongitude() {
		return longitude;
	}
	public void setLongitude(double longitude) {
		this.longitude = longitude;
	}
	public double getLatitude() {
		return latitude;
	}
	public void setLatitude(double latitude) {
		this.latitude = latitude;
	}
	public int getTempreture() {
		return tempreture;
	}
	public void setTempreture(int tempreture) {
		this.tempreture = tempreture;
	}
	
	public void printCityInof() {
		System.out.print ("City ["+cityName+" , longitude= " + longitude + ", latitude=" + latitude + ", tempreture="
				+ tempreture + "]");
	}
	

}
/////////Now this is the Driver Class: 

public class Driver3 { 
	public static void main(String[] args) { 
		// create an array of cities 
		City [] array=new City[4]; 
		array[0]=new City("California",40,120,25);
		array[1]=new City("Washington",50,120,27);
		array[2]=new City("Texas",30,105,29);
		array[3]=new City("Florida",30,80,20); 
		belowAverage(array,26);
		
	} 
	public static void belowAverage(City[] array,int avgTemp) { 
		for(int i=0;i<array.length;i++) { 
			if(array[i].getTempreture()<avgTemp) { 
				array[i].printCityInof(); 
			System.out.println();}
		}
	}

}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 

LAB NO.6 : Strings and StringBuilders 

/////////// Question One: in this question you want to build two classes one of them is to put inside it all your methods and these methods are 
// static type and in Tester class you will test your methods 
// note : your methods in MyString class will be static so you dont have to instanciate objects to use them... as you was do in math class 

////////////The solution : 


//this is MyString class: 

public class MyString { 
	
	
	public static String reverseString(String message) { 
		StringBuilder stb=new StringBuilder(message); 
		stb.reverse(); 
		String st=stb.toString(); 
		return st;
	} 
	public static boolean isPalindrom(String message) { 
		String cleaning=filter(message); 
		StringBuilder st=new StringBuilder(cleaning); 
		String rev=st.reverse().toString(); 
		return (cleaning.equals(rev));
		
	}  
	public static String filter(String s) { 
		StringBuilder stb=new StringBuilder(); 
		for(int i=0;i<s.length();i++) { 
			if(Character.isLetterOrDigit(s.charAt(i))) 
				stb.append(s.charAt(i));
		} 
		return stb.toString().toLowerCase();
	}  
	public static String shortHanded(String str) { 
		str=str.replaceAll("you"," U"); 
		str=str.replaceAll("for"," 4"); 
		str=str.replaceAll("to"," 2"); 
		str=str.replaceAll("and"," &");  
		str=str.replaceAll(" U ","j1"); 
		str=str.replaceAll(" I ","j2"); 
		str=str.replaceAll("[ioueaIOUEA]"," "); 
		str=str.replaceAll("j1"," U"); 
		str=str.replaceAll("j2"," I");
		return str;
		
	} 
	public static int numOfSent(String st) { 
		String [] array=st.split("[.,!,?,,,]"); 
		int count =0; 
		for(int i=0;i<array.length;i++) { 
			count++;
		} 
		return count;
	} 
	
	public static int numOfWords(String s) { 
		String [] array=s.split(" "); 
		int count =0; 
		for(int i=0;i<array.length;i++) {
			if(array[i].length()>=3) 
				count++;
		} 
		return count;
	}
	
	

}
///////////////// and Now this is The Tester class ,, implement it in a separated file : 


public class TestString { 
	public static void main(String [] args) { 
		System.out.println(MyString.reverseString("Hello")); 
		System.out.println(MyString.isPalindrom("madam I'm adam"));
		System.out.println(MyString.shortHanded("if you are  "
				+ "one for them and I will to")); 
		System.out.println("The number of sent is "+ 
				MyString.numOfSent("Hi! How are you? I hope you are "
						+ "fine.")); 
		System.out.println("The number of sent is "+ 
				MyString.numOfWords("Sewar is One of  "
						+ "IT collegue students"));
	}

}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Question Two : Encrypt: 

//// The Solution : is just One class with main method


public class Encrypt { 
	public static void main(String [] args) { 
		
		
		String toUpper=toUpperMethod("I Love java"); 
		String rev=reverseString(toUpper); 
		String toNum=toNumbers(rev);
		String addStars=beginAndEnd(toNum); 
		System.out.println("your encrypted sentence is :"+addStars);
	
	} 
	public static String toUpperMethod(String s) { 
		return s.toUpperCase();
	}
 
	public static String reverseString(String s) { 
		StringBuilder stb=new StringBuilder(s); 
		return stb.reverse().toString();
	} 
	public static String toNumbers(String s) {  
		
		s=s.replace('S', '$');  
		s=s.replace('L', '1'); 
		s=s.replace('O', '0'); 
		return s;
		
	} 
	public static String beginAndEnd(String s) { 
		String s2=" *** "+s+" *** "; 
		return s2;
	}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 

LAB NO.7: Inheritance and Polymorphism 

///////////Question one :(Account Class ): 
//////هذا اللاب هو سؤال واحد فقط ونريد إنشاء ثلاثة كلاسات وكلاس الفحص سؤال سهل جدا وسريع: 

//////////////////// Solution : 

/////////////////////Class number one : 


public class Account { 
	 
	protected int id=0; 
	protected double balance=0; 
	protected java.util.Date dateCreated; 
	
	public Account() {  
		 	  dateCreated=new java.util.Date(); 
		 	  dateCreated.getTime(); 
	} 
	public Account(int id,double balance) { 
		this.id=id; 
		this.balance=balance; 
		dateCreated=new java.util.Date(); 
	 	  dateCreated.getTime(); 
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public double getBalance() {
		return balance;
	}
	public void setBalance(double balance) {
		this.balance = balance;
	}
	public java.util.Date getDateCreated() {
		return dateCreated;
	}
	  
	public double withDraw(double specificAmount) { 
		 
		  
		 if(specificAmount<balance) {
		 balance=balance-specificAmount; 
		 return balance; 
		 } 
		 else {
			 return balance; 
		 }
	} 
	public double deposite(double specificAmount) { 
		return balance+=specificAmount;
	}
	@Override
	public String toString() {
		return "Account [id=" + id + ", balance=" + balance +
				", dateCreated=" + dateCreated.toString() + "]";
	}  
	
	

}
///////////////////////////////////////////////////////////////////////// and this is class number Two : 


public class Checking extends Account { 
	
	private double overDraft=1000; 
	  
	public Checking() { 
		
	} 
	public Checking(int id,double balance) { 
		super(id,balance);
	}
	@Override
	public double withDraw(double specificAmount) { 
		if(balance-specificAmount>0) { 
			balance =balance-specificAmount; 
			return balance;
		} 
		else if(balance -specificAmount<0) { 
			this.balance+=overDraft; 
			if(balance-specificAmount>0) { 
				balance-=specificAmount; 
				return balance;
			} 
			else {
				return balance;
		}  }
		else  {
			balance=0;
			return balance;
		}
	}
	@Override
	public String toString() {
		return "Checking [overDraft=" + overDraft + 
				", id=" + id + ", balance=" + balance + ", dateCreated="
				+ dateCreated + "]";
	} 
	

}
/////////////////////////////////////////////////////////////////////////Class number three :


public class Saving extends Account{ 
	 
	public Saving(int id,double balance) { 
		super(id,balance);
	} 
	@Override 
	public double withDraw(double specificAmount) { 
		if(balance-specificAmount>0) { 
			balance=balance-specificAmount; 
			return balance;
		} 
		else
			return balance;
	}
	@Override
	public String toString() {
		return "Saving [id=" + id + ", balance=" + balance + ", dateCreated=" + dateCreated + "]";
	} 
	

}

////////////////////////////////////////////////////////////// class number four (Driver): 


public class TestAccount { 
	public static void main(String [] args) { 
		Account a1=new Account(1200043,1000);  
		a1.deposite(1000); 
		a1.withDraw(1500);
		System.out.println(a1.toString()); 
		Checking c1=new Checking(120123,1500); 
		c1.deposite(100); 
		System.out.println(c1.toString()); 
		c1.withDraw(1700); 
		System.out.println(c1.toString()); 
		Saving s1=new Saving(1200000,3000); 
		s1.withDraw(4000); 
		System.out.println(s1.toString());
	}

}
////////////////////////////////////// Note: يمكنك تغيير القيم التي تريدها في الكلاس الأخير وهو كلاس الفحص حتى تتأكد من الية عمل جميع الميثودس  
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

LAB NO.8 : 

//Question One (Employees classes) :
// The solution : 

// Note that this exercise defines six Classes ,the five classes in the UML notation in the lab manual and the Test class : 

// class number one : 


public abstract class Employee implements Comparable<Employee>{ 
	
	public String firstName; 
	public String lastName; 
	public int ID;  
	
	public Employee() { 
		
	} 
	public Employee(String firstName,String lastName,int ID) { 
		this.firstName=firstName; 
		this.lastName=lastName; 
		this.ID=ID;
	}  
	public abstract double earning();
	@Override 
	public int compareTo(Employee emp) { 
		if(emp.earning()>this.earning()) 
			return 1; 
		else if (emp.earning()>this.earning())  
			return -1; 
		else return 0;
	}
}
////////////////////////////////////////////////// class number Two : 


public class SalariedEmployee extends Employee{ 
	
	public double weeklySalary; 
	
	public SalariedEmployee() { 
		
	} 
	public SalariedEmployee(String firstName,String lastName,int ID,
			double weeklySalary) { 
		super(firstName,lastName,ID); 
		this.weeklySalary=weeklySalary;
	}
	public double getWeeklySalary() {
		return weeklySalary;
	}
	public void setWeeklySalary(double weeklySalary) {
		this.weeklySalary = weeklySalary;
	}  
	
	public double earning() { 
		return (getWeeklySalary()*4);
	}
	@Override
	public String toString() {
		return "SalariedEmployee [weeklySalary=" + 
	weeklySalary 
				+ ", earning()=" + earning() + "]";
	} 
	
	
	

}
////////////////////////////////////////////////////////////////////////////// Class Number Three : 


public class HourlyEmployee extends Employee { 
	
	public double wage; 
	public int numOfHoursWorked;
	
	public HourlyEmployee() { 
		
	} 
	public HourlyEmployee(String firstName,String lastName,int ID,
			double wage,int numOfHoursWorked) { 
		super(firstName,lastName,ID); 
		this.wage=wage; 
		this.numOfHoursWorked=numOfHoursWorked;
	}
	public double getWage() {
		return wage;
	}
	public void setWage(double wage) {
		this.wage = wage;
	}
	public int getNumOfHoursWorked() {
		return numOfHoursWorked;
	}
	public void setNumOfHoursWorked(int numOfHoursWorked) {
		this.numOfHoursWorked = numOfHoursWorked;
	} 
	
	@Override 
	public double earning() { 
		return (getWage()*getNumOfHoursWorked());
	}
	@Override
	public String toString() {
		return "HourlyEmployee [wage=" + wage + ", numOfHoursWorked=" 
	+ numOfHoursWorked + ", getWage()=" + getWage()
				+ ", getNumOfHoursWorked()=" + getNumOfHoursWorked() +
				", earning()=" + earning() + "]";
	}

}
////////////////////////////////////////////////////////////////////////////////////// class number four :


public class CommisionEmployee extends Employee { 
	
	public double rate; 
	public double grossSales; 
	
	public CommisionEmployee() {
		
	}

	public CommisionEmployee(String firstName, String lastName, int ID
			,double rate,double grossSales) {
		super(firstName, lastName, ID); 
		this.rate=rate; 
		this.grossSales=grossSales;
	}

	public double getRate() {
		return rate;
	}

	public void setRate(double rate) {
		this.rate = rate;
	}

	public double getGrossSales() {
		return grossSales;
	}

	public void setGrossSales(double grossSales) {
		this.grossSales = grossSales;
	}   
	
	@Override 
	public double earning() {
		 return (getRate()*getGrossSales());
	}

	@Override
	public String toString() {
		return "CommisionEmployee [rate=" + rate + ", grossSales=" 
	+ grossSales + ", getRate()=" + getRate()
				+ ", getGrossSales()=" + getGrossSales() +
				", earning()=" + earning() + "]";
	}
	
	
	

}
///////////////////////////////////////////////////////////////////////// class number five : 


public class BaseCommisionEmployee extends CommisionEmployee{ 
	
	public double baseSalary;

	public BaseCommisionEmployee() {
		
	}

	public BaseCommisionEmployee(String firstName, String lastName, 
			int ID, double rate, double grossSales,double base) {
		super(firstName, lastName, ID, rate, grossSales); 
		this.baseSalary=base;
	}   
	public double getBaseSalary() { 
		return baseSalary;
	}
	// implement getSalary 
	@Override 
	public double earning() { 
		return(getRate()*getGrossSales()+getBaseSalary());
	}

	@Override
	public String toString() {
		return "BaseCommisionEmployee [baseSalary=" + 
	baseSalary + ", getBaseSalary()=" + getBaseSalary()
				+ ", earning()=" + earning() + "]";
	} 
	
	
	
	

}
//////////////////////////////////////////////////////////////// class number six and this is the last class for Testing (Driver) : 

public class TestEmployee {

	public static void main(String[] args) {
		
		Employee [] emp= {new SalariedEmployee("Sewar"," AbuEid",120,1000),
				new CommisionEmployee("Qamar","Arab",133,10,1200),
				new HourlyEmployee("Bushra","Wesam",100,30,10),
				new BaseCommisionEmployee("Mariam","Wesam",122,15,1000,20)
				,new HourlyEmployee("Lana","Amjad",110,15,250)};
		System.out.println("The total earnings is "+totalEarnings(emp)); 
		sort(emp);

	} 
	public static double totalEarnings(Employee [] a) { 
		double total=0;
		for(int i=0;i<a.length;i++) {
			total+=a[i].earning();
		} 
		return total;
	} 
	public static void sort(Object [] a) { 
		// This method sort the array in the decreasing order
		 Object temp=a[0];
		for(int i=0;i<a.length-1;i++) { 
			 for(int j=i+1;j<a.length;j++) {
			if(a[i] instanceof Employee) { 
				int n=((Employee)a[i]).compareTo((Employee)a[j]); 
				if(n==1) { 
					// swapping
					temp=a[i]; 
					a[i]=a[j];
					a[j]=temp;
				}
			} 
			 }
		} 
		for(int i=0;i<a.length;i++) { 
			System.out.println(a[i].toString());
		}
	}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 

Question Two :(Shape classes): 

////Solution : in this exercise you want to implement Four Classe as follows :
/*  
1.Shape class : this class is an abstract class includes an abstract method : getArea() that you want to Override it in Circle and Rectangle classes
2. Circle Class 
3. Rectangle class  
4. TestShape  
then in the TestShape class you want to create an arrayList that contain five shapes Circles and Rectangles then you will Sort it and print it as Shown in the code
Finally you want to note that Shape class implements Combarable interface so you want to override the compareTo method in this Class  
*/  

/////////////The first Class : 

public abstract class Shape implements Comparable<Shape> { 
	
	private String color; 
	private  boolean filled; 
	
	public Shape() { 
		
	} 
	public Shape(String color,boolean filled) { 
		this.color=color; 
		this.filled=filled;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public boolean isFilled() {
		return filled;
	}
	public void setFilled(boolean filled) {
		this.filled = filled;
	}
	@Override
	public String toString() {
		return "Shape [color=" + color + ", filled=" + filled + "]";
	}   
	 
	public abstract double getArea();  
	public abstract String ClassName();
	
	@Override 
	public int compareTo(Shape s) { 
		if(s.getArea()> this.getArea()) 
			return 1; 
		else if(s.getArea()<this.getArea()) 
			return -1; 
		else 
			return 0;
	}
  
}
////////////////////////////////////////The second class : 

public class Circle extends Shape { 
	
	private double radius; 
	
	public Circle() { 
		
	}
 
	public Circle(double radius,String color,boolean filled) { 
		super(color,filled); 
		this.radius=radius;
	}

	public double getRadius() {
		return radius;
	}

	public void setRadius(double radius) {
		this.radius = radius;
	} 
	@Override 
	public double getArea() { 
		return Math.PI*getRadius()*getRadius();
	} 
	@Override
	public String ClassName() { 
		return "Circle";
	}
} 
///////////////////////////// The third class : 


public class Rectangle extends Shape { 
	
	private double width; 
	private double length; 
	
	public Rectangle() { 
		
	} 
	public Rectangle(double width,double length) { 
		this.length=length; 
		this.width=width;
	}
	public double getWidth() {
		return width;
	}
	public void setWidth(double width) {
		this.width = width;
	}
	public double getLength() {
		return length;
	}
	public void setLength(double length) {
		this.length = length;
	} 
	@Override
	 public double getArea() { 
		return getWidth()*getLength();
	}  
	@Override
	public String ClassName() { 
		return "Rectangle";
	}

}
/////////////////////////////////////////////////////////// The fourth class : 

import java.util.*;
public class TestShape { 
	public static void main(String [] args) { 
		
		ArrayList<Shape> shapes=new ArrayList<>(); 
		shapes.add(new Circle(4,"red",false));  
		shapes.add(new Circle(10,"Black",true));  
		shapes.add(new Rectangle(5,7));  
		shapes.add(new Rectangle(1.5,0.3));  
		shapes.add(new Circle(3.5,"Orange",false)); 
		
		java.util.Collections.sort(shapes); 
		for(int i=0;i<shapes.size();i++) { 
			System.out.println((shapes.get(i)).ClassName()+" "
		+(shapes.get(i)).getArea());
		}
	}

}
//////////////////////////////////////////////////////////////////////////////////////////////////////////// 

LAB NO.9: Exeption handling and Text I/O : 

// Question One : (Converting Binary String to decimal value ) 

// The solution : 

import java.util.Scanner;
public class BinaryToDecimal {

	public static void main(String[] args) {
		
       Scanner input=new Scanner(System.in); 
        
       System.out.println("Enter the Binary String "); 
       String binaryString=input.next(); 
       try { 
    	   BinToDec(binaryString);
       } 
       catch(NumberFormatException ex) { 
    	   System.out.println(ex.getMessage());
       }
       
       input.close();
		
	} 
	public static void BinToDec(String binaryString) { 
	 
		int number =Integer.parseInt(binaryString);  
		int sum=0,count=0; 
		int check;
		while(number !=0) { 
			 check=number%10; 
			if(check!=0&&check!=1) { 
				throw new NumberFormatException("The String is not binary !"); 
			} 
			sum+=(check*Math.pow(2, count)); 
			count++;
			number=number/10;
		}  
		System.out.println("The decimal value is "+sum);
		
	}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
// Question Two : 
// solution :you can implement  this question by creating two classes as follows : 

//////////////////////////////////////// class number one : 


public class Circle { 
	
	private double radius; 
	private String color; 
	
	public Circle() { 
		
	} 
	public Circle(double radius,String color) { 
		this.radius=radius; 
		this.color=color;
	}
	public double getRadius() {
		return radius;
	}
	public void setRadius(double radius) { 
		if(radius<=0) { 
			throw new IllegalArgumentException("The radius can not be negative !");
		}
		this.radius = radius;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	} 
	

}
///////////////////////////////////////////////////////////////////////////////////// class Number two (Driver Class ): 


public class Driver {

	public static void main(String[] args) {
		 
		Circle c1=new Circle();
		try { 
			c1.setRadius(7); 
			System.out.println("The radius is set to "+c1.getRadius());
			c1.setRadius(-2); 
			System.out.println("The radius is set to "+c1.getRadius());
		} 
		catch(IllegalArgumentException ex) { 
			System.out.println(ex.getMessage());
		}

	}

}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 

Question Three : 

// in this example you want to use files to read and write data on them , I write a comments for you to help to understand : 

// Solution : 

import java.io.*; // for using File class methods and the PrintWriter Class
import java.util.*;// for using Scanner Class
public class StudentsAverage {

	public static void main(String[] args) throws IOException{
		 
		// Create File object  
		File myFile=new File("students.txt"); 
		// Check whether the file is exist 
		if(!myFile.exists()) { 
			System.out.println("The file is not exist !"); 
			System.exit(0);
		} 
		// create a Scanner object to read file 
		Scanner sc=new Scanner(myFile); 
		// create a printWriter to write on file
 
		PrintWriter out=new PrintWriter(new File ("output.txt")); 
		while(sc.hasNext()) { 
			String name=sc.next(); 
			double mark1=sc.nextDouble(); 
			double mark2=sc.nextDouble(); 
			double mark3=sc.nextDouble();  
			double avg=(mark1+mark2+mark3)/3;
			out.println(name+" : "+avg); 
			
		}
		sc.close(); 
		out.close();// This is an important step , you must close the printWriter 
	}

}
//////////////////////// Now , you want to create a text file in a default package in your project and name it : students.text and copy these info in it : 

Sewar 99 93 85
Qamar 100 99 80
Bushra 95 87 90 

///////////// Finally you want to go to the location of your work, you will find a file call output.txt created automatically open it you shoulde find these results: 

Sewar : 92.33333333333333
Qamar : 93.0
Bushra : 90.66666666666667

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

LAB NO.10 : Java Fx Basics  

Question One : Note: this question will be completed in the next lab, here I solved it completely .you will divide this solution for two labs .

// The solution : 

package application;
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.RadioButton;
import javafx.scene.control.ToggleGroup;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Pane;
import javafx.scene.paint.Color;
import javafx.scene.shape.Circle;
import javafx.scene.shape.Rectangle;
import javafx.scene.text.Font;
import javafx.stage.Stage; 

public class QuestionOne extends Application { 
	 
	@Override
	public void start(Stage stage) { 
		 
		try {  
			Pane lightPane=new Pane(); 
			// create the rectangle and do its properties 
			Rectangle r=new Rectangle(80,250);  
			r.setStroke(Color.BLACK); 
			r.setFill(null);
			r.setLayoutX(150); 
			r.setLayoutY(50);  
			// create the three circles: 
			
			Circle c1=new Circle(); 
			c1.setRadius(25); 
			c1.setLayoutX(188); 
			c1.setLayoutY(100); 
			c1.setStroke(Color.BLACK); 
			c1.setFill(null);  
			
			
			Circle c2=new Circle(); 
			c2.setRadius(25); 
			c2.setLayoutX(188); 
			c2.setLayoutY(170); 
			c2.setStroke(Color.BLACK); 
			c2.setFill(null); 
			
			Circle c3=new Circle(); 
			c3.setRadius(25); 
			c3.setLayoutX(188); 
			c3.setLayoutY(240); 
			c3.setStroke(Color.BLACK); 
			c3.setFill(null); 
			
			// Create Three Radio Buttons : 
			RadioButton rbtnred=new RadioButton("Red");  
			rbtnred.setFont(Font.font(15));
			RadioButton rbtnyellow=new RadioButton("Yellow"); 
			rbtnyellow.setFont(Font.font(15));
			RadioButton rbtngreen=new RadioButton("Green");  
			rbtngreen.setFont(Font.font(15));
			// Create a Toggle group for the Radio buttons  
			ToggleGroup group=new ToggleGroup(); 
			rbtnred.setToggleGroup(group); 
			rbtnyellow.setToggleGroup(group); 
			rbtngreen.setToggleGroup(group);  
			// HBox to but The radio buttons in it  
			HBox hbox=new HBox(15);
			hbox.getChildren().addAll(rbtnred,rbtnyellow,rbtngreen); 
			hbox.setLayoutX(120); 
			hbox.setLayoutY(400);
			lightPane.getChildren().addAll(r,c1,c2,c3,hbox);  
			
			//// Handling Event for the radio Buttons 
			
			rbtnred.setOnAction(e->{c1.setFill(Color.RED); 
			c2.setFill(null); 
			c3.setFill(null);});
			rbtnyellow.setOnAction(e->{c2.setFill(Color.YELLOW); 
			c1.setFill(null);
			c3.setFill(null);
			}); 
			rbtngreen.setOnAction(e->{c3.setFill(Color.color(0,1,0)); 
			c1.setFill(null);
			c2.setFill(null);
			});
			
			///////////////////////
			
			
			Scene sc=new Scene(lightPane,400,500); 
			stage.setScene(sc); 
			stage.setTitle("Traffic signal"); 
			stage.show();
			} 
		catch(Exception ex) { 
			ex.printStackTrace();
		}
	} 
	public static void main(String [] args ) { 
		launch(args);
	}

} 

////////////////////////////////////////////////////////////////////////////////////////////////
Question Two : 

// The solution : 

package application; 

import javafx.application.Application;

import javafx.scene.Scene;
import javafx.scene.layout.GridPane;
import javafx.scene.paint.Color;
import javafx.scene.shape.Rectangle;
import javafx.stage.Stage; 

public class ChessBoard extends Application{  
	@Override
	public void start(Stage primaryStage) { 
             GridPane pn=new GridPane(); 
             int count=0; 
             for(int i=0;i<8;i++) { 
            	 count++;
            	  for(int j=0;j<8;j++) { 
            		  Rectangle r=new Rectangle(25,25); 
            		  if(count%2==0) 
            			  r.setFill(Color.WHITE);
            		      pn.add(r, i, j); 
            		      count++;
            	  }
             }
             Scene sc=new Scene(pn,200,200);
              primaryStage.setTitle("Chess Board");
              primaryStage.setResizable(false);
              primaryStage.setScene(sc);
              primaryStage.show();
        
	}
	
	public static void main(String[] args) { 
		launch(args);
	}
	

}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////  

Question Three : Note: this question will be completed in the next lab, here I solved it completely .you will divide this solution for two labs .


// The solution : 

package application; 
import javafx.application.Application;
import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.control.TextField;
import javafx.scene.control.Label;
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;
import javafx.scene.control.RadioButton;
import javafx.scene.control.ToggleGroup;
import javafx.geometry.Pos;
import javafx.geometry.Insets;
import javafx.scene.input.KeyCode;

public class SettingOfAText extends Application {
	 TextField txt = new TextField();
	 TextField txtSize = new TextField();

	@Override 
	public void start(Stage primaryStage) {
		
		txt.setText("Java is Amazing ! "); 
		// set the position for text Fields
		txt.setAlignment(Pos.BOTTOM_CENTER);
		txtSize.setAlignment(Pos.BOTTOM_RIGHT);
		txtSize.setPrefColumnCount(3);
		txt.setPrefColumnCount(12);
		txtSize.setText("12");

		// Create  radio buttons
		RadioButton rbtnLeft = new RadioButton("Left");
		RadioButton rbtnCenter = new RadioButton("Center");
		RadioButton rbtnRight = new RadioButton("Right");
	 //	rbtnCenter.setSelected(true);

		// Create a toggle group for the radio button
		ToggleGroup group = new ToggleGroup();
		rbtnLeft.setToggleGroup(group);
		rbtnCenter.setToggleGroup(group);
		rbtnRight.setToggleGroup(group);
		
	
		HBox hb1 = new HBox(10);
		hb1.getChildren().addAll(rbtnLeft, rbtnCenter, rbtnRight);
		hb1.setAlignment(Pos.BOTTOM_LEFT);
 
		// this hbox is for the label and the textField that contains the size
		HBox hb2 = new HBox(5); 
		Label lb=new Label("column Size :");
		hb2.getChildren().addAll(lb, txtSize);

		HBox hb3 = new HBox(5);
		hb3.setAlignment(Pos.CENTER); 
		Label lb2=new Label("Text Field : ");
		hb3.getChildren().addAll(lb2, txt);

		HBox hbox = new HBox(10);
		hbox.getChildren().addAll(hb1, hb2);

		// Create a vBox and place nodes in it
		VBox pane = new VBox(10);
		pane.setPadding(new Insets(10, 10, 10, 10));
		pane.getChildren().addAll(hb3, hbox);

		/* 
		 * Handling with the radio Buttons
		 */
		rbtnLeft.setOnAction(e -> {
			if (rbtnLeft.isSelected()) {
				txt.setAlignment(Pos.BOTTOM_LEFT);
			}
		});

		rbtnCenter.setOnAction(e -> {
			if (rbtnCenter.isSelected()) {
				txt.setAlignment(Pos.BOTTOM_CENTER);
			}
		});

		rbtnRight.setOnAction(e -> {
			if (rbtnRight.isSelected()) {
				txt.setAlignment(Pos.BOTTOM_RIGHT);
			}
		});

		txtSize.setOnKeyPressed(e -> {
			if (e.getCode() == KeyCode.ENTER) // you must press enter to display your new size
			{
				txt.setPrefColumnCount(Integer.parseInt(
					txtSize.getText()));
			}
		});

		// Create a scene and place it in the stage
		Scene scene = new Scene(pane);
		primaryStage.setTitle("Exercise_16_06"); 
		primaryStage.setScene(scene); 
		primaryStage.show(); 
	}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////  

LAB NO.11 : 

// Question 1 & 2 are solved above .... in the previous lab 


////// Question Three : 


package application;
	
import java.io.File;
import java.io.FileWriter;
import java.io.PrintWriter;
import javafx.application.Application;
import javafx.geometry.Insets;
import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.RadioButton;
import javafx.scene.control.TextField;
import javafx.scene.control.ToggleGroup;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.HBox;


public class Main extends Application {
	@Override
	public void start(Stage primaryStage) {
		try { 
			// Creating GridPane and specify its properties
			GridPane root = new GridPane(); 
			root.setHgap(10); 
			root.setVgap(10); 
			root.setPadding(new Insets(15,15,15,15)); 
			// create the UI as shown in the lab manual and put them in the grid pane 
			Label lb1=new Label("StudentID :"); 
			TextField txt1=new TextField();  
			root.add(lb1,0, 0); 
			root.add(txt1, 1, 0); 
			Label lb2=new Label("Student Name :"); 
			TextField txt2=new TextField(); 
			root.add(lb2, 0, 1); 
			root.add(txt2, 1, 1); 
			Label lb3=new Label("Average :"); 
			root.add(lb3, 0, 2);  
			// Three radio buttons for the averages :  
			
			RadioButton rbtn1=new RadioButton("Excellent"); 
			RadioButton rbtn2=new RadioButton("very good"); 
			RadioButton rbtn3=new RadioButton("Good"); 
			/// creating the toggle group for the three radio buttons : 
			ToggleGroup group=new ToggleGroup(); 
			rbtn1.setToggleGroup(group); 
			rbtn2.setToggleGroup(group); 
			rbtn3.setToggleGroup(group); 
			HBox hb=new HBox(5); 
			hb.getChildren().addAll(rbtn1,rbtn2,rbtn3); 
			root.add(hb, 1, 2);
			Label lb4=new Label("Departement Name :"); 
			TextField txt4=new TextField();  
			root.add(lb4, 0, 3); 
			root.add(txt4, 1, 3); 
			Button btn=new Button("Add "); 
			root.add(btn, 0, 4);
			// Button Handling  
			  
			FileWriter myWriter=new FileWriter(new File ("result.txt"));
			PrintWriter write=new PrintWriter(myWriter); 
			
			btn.setOnAction(e->{  
				String avg;
				
				int id=Integer.parseInt(txt1.getText());  
				String name=txt2.getText(); 
				if(rbtn1.isSelected()) { 
					 avg="Excellent";
				} 
				else if(rbtn2.isSelected()){ 
					 avg="VeryGood";
				}
				else if(rbtn3.isSelected()){ 
					 avg="Good";
				} 
				else { 
					 avg="No average has been choosen";
				} 
				String depName=txt4.getText();
				write.println("Name : "+name+" ID : "+id+" Average : "
						+ avg+" departement Name : "+depName);  
				
				write.close(); 
				
			});
			Scene scene = new Scene(root,450,250);
			primaryStage.setScene(scene); 
			primaryStage.setTitle("Add Student ");
			primaryStage.show();
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		launch(args);
	}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////