Java Programming Comprehensive Study Guide - Blue Crest College Department of Blue Crest College Sierra Leone

Introduction to Java Programming at Blue Crest College

  • Institutional Context: These notes originate from the Faculty IT Department at Blue Crest College, Sierra Leone, specifically from April 28, 2023.

  • Flavors of Java:

    • Core Java (J2SE): Focuses on software development. It is the foundation for all interview questions related to the language.

    • Advanced Java (J2EE): Used for developing Web Applications.

    • Android Java (J2ME): Designed for Mobile Application development.

  • Features and Rationale for Learning Java:

    • Simple and Easy: Designed to be learned and used with ease.

    • Open Source: The language is freely available for use and modification.

    • Platform Independent: Programs can run on various operating systems without modification.

    • Secure: Security is high due to the use of bytecode.

    • Embedded: Suitable for embedded systems.

    • Compiled and Interpreted: A Java program is first compiled into bytecode. This bytecode is then given to an interpreter, and the Java Virtual Machine (JVM) understands the bytecode to run the program successfully.

    • Robust: Features a garbage collector that automatically destroys unused objects in memory. It also boasts a large library and framework support.

/

/

Defining Java and Its History

  • Definition: Java is a class-based, high-level, object-oriented programming language.

  • Development and Ownership:

    • Developed by James Gosling and his associates in 1995.

    • The first version (JDK 1.0) was released on January 23, 1996, by Sun Microsystems.

    • Java was a product of Sun Microsystems until 2010, after which it became an Oracle-based product.

    • The version JDK 16 was released on March 16, 2021, by Oracle.

  • Etymology and Facts:

    • The language was initially named "Oak."

    • The name "Java" refers to a type of coffee in Indonesia.

    • There is no official full form for the name "Java."

Basic Syntax and Components

  • The Main Method Structure:

    • class class_name {\text{class class\_name \{}

    • public static void main (String args [])\text{public static void main (String args [])}

    • {\text{\{}

    • // code\text{// code}

    • }\text{\}}

    • }\text{\}}

  • Keywords in the Main Method:

    • Public: Access modifier meaning anyone can access the class or method.

    • Static: Allows the execution of the class without creating an object.

    • Void: Indicates the method will not return any values.

    • String: The 'S' is capitalized because String is a class. In "String args[]", it refers to command line arguments being passed as parameters.

    • Array[]: Indicates an array variable.

  • Comments:

    • Single-line: Denoted by ///\text{/}.

    • Multi-line: Denoted by /* ... *//\text{* ... *}/.

Installation and Environment Setup

  • Prerequisites: Install the latest version of the Java JDK and the Eclipse IDE.

  • Download Steps:

    1. Open a browser and search for "Java JDK download."

    2. Navigate to the first link (www.oracle.com).

    3. Select the version for Windows and download the .exe file.

    4. Run the downloaded .exe file and follow the "next" prompts; the install takes approximately 10 to 15 seconds.

  • Setting Environment Variables:

    1. Click the Windows button and search for "System Environment Variables."

    2. Click "Environment Variables," select the "Path" variable, and click "Edit."

    3. Navigate to "This PC" -> "C: Drive" -> "Program Files" -> "Java" -> "jdk 20."

    4. Copy the file path up to the "bin" folder.

    5. In the Environment Variables window, click "New" and paste the path.

    6. Create a second variable by clicking "New." Name the variable "JAVA_HOME" (all caps) and for the value, paste the same path but excluding the "bin" folder.

  • Eclipse IDE Setup:

    1. Search for "Eclipse IDE download" and download the x86-64 version.

    2. Create a folder on the desktop named "java."

    3. When launching Eclipse, select that folder as the workspace. All subsequent programs will save to the "java full course" folder on the desktop.

Compilation and Execution Workflow

  • Process Flow:

    1. First.java: The source code file.

    2. Javac: The Java compiler compiles the source code.

    3. First.class: The resulting bytecode file.

    4. JVM: The Java Virtual Machine executes the bytecode.

    5. Output: The final result of the program.

Java Data Types

  • Definition: Data types specify the sizes and values stored in variables.

  • Primitive Data Types:

    • Boolean: For true/false values.

    • Character: char.

    • Numeric Integral: byte, short, int, long.

    • Numeric Floating-point: float, double.

  • Non-Primitive Data Types:

    • Includes Classes, Interfaces, Strings, and Arrays.

Variables, Keywords, and Identifiers

  • Variables: Named memory locations stores different values.

    • Declaration Requirements: Must specify the datatype and the data_name.

    • Types of Variables:

      1. Local Variables: Declared inside a method.

      2. Instance Variables: Declared inside a class but outside methods.

      3. Static Variables: Declared with the static keyword.

      4. Final Variables: Values that cannot be changed.

  • Example Code for Variables:

    • public class second {\text{public class second \{}

    • int a=10; // instance variable\text{int a=10; // instance variable}

    • static double b=20.5; // static variable\text{static double b=20.5; // static variable}

    • public static void main(String[] args) {\text{public static void main(String[] args) \{}

    • boolean c=true; // local variable\text{boolean c=true; // local variable}

    • second s=new second();\text{second s=new second();}

    • System.out.println(s.a);\text{System.out.println(s.a);}

    • System.out.println(b);\text{System.out.println(b);}

    • System.out.println(c);\text{System.out.println(c);}

    • }\text{\}}

    • }\text{\}}

  • Keywords: Reserved words with predefined meanings in the compiler. They are case-sensitive (e.g., int is valid, but INT is not; a and A are different).

    • Common Keywords: abstract, assert, boolean, break, byte, case, catch, char, class, const, continue, default, do, double, else, enum, extends, final, finally, float, for, goto, if, implements, import, instanceof, int, interface, long, native, new, package, private, protected, public, return, short, static, strictfp, super, switch, synchronized, this, throw, throws, transient, try, void, volatile, while.

  • Identifiers: Names given to variables, methods, or classes (e.g., int a;, void m1;, class A;).

Input and Output Operations

  • Input: Handled via the Scanner class found in java.util.Scanner.

    • Syntax: Scanner obj-name = new Scanner(System.in);\text{Scanner obj-name = new Scanner(System.in);}

    • Scanner Methods:

      • nextInt(): for integer values.

      • nextLine(): for string values.

      • nextDouble(): for double values.

  • Output: Handled via the System class found in java.lang.System.

    • Syntax: System.out.print(" ");\text{System.out.print(" ");}

  • Sample Addition Program:

    • import java.util.Scanner;\text{import java.util.Scanner;}

    • public class A {\text{public class A \{}

    • public static void main(String[ ] args) {\text{public static void main(String[ ] args) \{}

    • int a,b,c;\text{int a,b,c;}

    • System.out.print("Enter any Two Numbers: ");\text{System.out.print("Enter any Two Numbers: ");}

    • Scanner s=new Scanner(System.in);\text{Scanner s=new Scanner(System.in);}

    • a=s.nextInt();\text{a=s.nextInt();}

    • b=s.nextInt();\text{b=s.nextInt();}

    • c=a+b;\text{c=a+b;}

    • System.out.print("Sum any Two Numbers: "+c);\text{System.out.print("Sum any Two Numbers: "+c);}

    • }\text{\}}

    • }\text{\}}

Control Flow: Conditional Statements

  • if statement: Used to test a single condition.

    • Syntax: if(condition) { //code; }\text{if(condition) \{ //code; \}}

    • Program Example (Password Check):

      • if(pwd==2731) { System.out.println("My Name: = akhilesh"); ... }\text{if(pwd==2731) \{ System.out.println("My Name: = akhilesh"); ... \}}

  • if-else statement: Executes two different statements based on a single condition.

    • Syntax: if(condition) { Statement 1; } else { Statement 2; }\text{if(condition) \{ Statement 1; \} else \{ Statement 2; \}}

  • else-if statement: Used for multiple conditions involving one if block, multiple else-if blocks, and a final else block.

    • Grading Example:

      • marks >= 60 && marks <= 100 -> First Division.

      • marks >= 45 && marks < 60 -> Second Division.

      • marks >= 33 && marks < 45 -> Third Division.

      • Otherwise -> Failed.

  • Nested if-else: Defining an if-else block inside another if-else block.

    • Example (Maximum of Three Numbers): Uses nested logic to compare num1, num2, and num3 to find the largest value.

Control Flow: Looping Statements

  • Loop Definition: Used to repeat certain statements multiple times.

  • for loop:

    • Syntax: for(initialization; condition; incr / decr) { //code; }\text{for(initialization; condition; incr / decr) \{ //code; \}}

    • Example: Printing a multiplication table by iterating from i=1\text{i=1} to \text{i<=10}.

  • while loop:

    • Syntax: while(condition) { //code; }\text{while(condition) \{ //code; \}}

    • Example: Logic provided checks if a number is even (num % 2 == 0\text{num \% 2 == 0}) or odd within a while loop until a logic break occurs.

  • do-while loop:

    • Syntax: do { statement; } while(condition);\text{do \{ statement; \} while(condition);}

    • Note: Executes the body at least once before checking the condition.

  • for-each loop:

    • Syntax: for(datatype var1 : var2) { statement; }\text{for(datatype var1 : var2) \{ statement; \}}

    • Example: Iterating through an array int a[] = {10, 20, 30, 40, 50}\text{int a[] = \{10, 20, 30, 40, 50\}}.

Jump Statements and Switch

  • Jump Keywords:

    • Break: Exits the loop immediately.

    • Continue: Skips the current iteration and continues with the next.

    • Return: Exits from a method.

  • Switch Statement: A multiple-choice selection statement.

    • Syntax:

      • switch (expression) {\text{switch (expression) \{}

      • case 1: statement 1; break;\text{case 1: statement 1; break;}

      • case 2: statement 2; break;\text{case 2: statement 2; break;}

      • default: statement;\text{default: statement;}

      • }\text{\}}

Operators, Methods, and Arrays

  • Operators:

    • Arithmetic: Addition, subtraction, etc.

    • Relational: Comparisons (e.g., greater than).

    • Logical: AND, OR, NOT.

    • Increment/Decrement: Pre-increment (++a++a), Post-increment (a++a++), Pre-decrement (−−a--a), Post-decrement (a−−a--).

    • Assignment: Used to assign values.

    • Ternary: Shorthand for if-else.

  • Methods: Blocks of code that take input, process it, and provide output.

    • Benefits: Code reusability; they only run when called.

    • Pre-defined Methods: print(), sort(), nextInt(), sleep(), concat().

    • User-defined Methods: Created by the programmer (e.g., add(), sum(), learn()).

  • Arrays: Objects containing similar data types in contiguous memory.

    • Index: Always starts at 0.

    • Syntax: int a[] = new int[5];\text{int a[] = new int[5];} or int a[] = {10, 20, 30};\text{int a[] = \{10, 20, 30\};}.

    • Types: 1D Array and 2D Array.

  • Strings: A pre-defined class that can be used as a data type. They represent a sequence of characters.

    • Immutability: Strings in Java are immutable, meaning they cannot be changed once created.

Overview of Object-Oriented Programming (OOPs)

  • Key Concepts:

    • Class: A virtual blueprint or group of elements with common properties and behavior.

    • Object: A real-world entity based on a class.

    • Access Specifiers: Control visibility.

    • Constructor: Special method to initialize objects.

    • Keywords: super and this.

    • Blocks: Instance blocks and Static blocks.

    • Core Pillars: Encapsulation, Abstraction, Inheritance, Polymorphism.

    • Advanced Topics: Exception Handling, File Handling, Multithreading, Packages, Collections.