ജാവ പ്രോഗ്രാമിങ്ങിന്റെ അടിസ്ഥാനങ്ങൾ - ആരംഭകർക്കായുള്ള പഠനം
പാഠപദ്ധതി
1. ജാവയുടെ പരിചയം
ജാവ എന്നത് എന്താണ്?
ജാവയുടെ ചരിത്രം
ജാവയുടെ പ്രയോഗങ്ങൾ
2. ജാവയുടെ സ്ഥാപനം
ജാവ ഡവലപ്പ്മെന്റ് കിറ്റ് (JDK) ഇൻസ്റ്റാൾ ചെയ്യുക
ഇന്റഗ്രേറ്റഡ് ഡവലപ്പ്മെന്റ് എൻവയൺമെന്റ് (IDE) പരിചയം
Hello World പ്രോഗ്രാമിന്റെ ആവിഷ്കരണം
3. അടിസ്ഥാന തത്വങ്ങൾ
ഡാറ്റാ ടൈപ്പുകൾ: Primitive Data Types (int, float, char, boolean)
വ്യത്യസ്ത തരത്തിലുള്ള ചരങ്ങൾ (Variables)
Operators: Arithmetic, Relational, Logical Operators
4. നിയന്ത്രണ ഘടനകൾ
If-else പ്രസ്താവന
Switch-case പ്രസ്താവന
Looping: For Loop, While Loop, Do-While Loop
5. ഫംഗ്ഷനുകൾ
ഫംഗ്ഷന്റെ അടിസ്ഥാനം
Parameterized Functions
Return Type
6. ഓബ്ജക്റ്റ്-oriented programming (OOP) അടിസ്ഥാനങ്ങൾ
ക്ലാസുകൾ & ഓബ്ജക്റ്റുകൾ
ഇൻഹറിറ്റൻസ്
പൊളിമോർഫിസം
ഇൻകാപ്സുലേഷൻ
7. എക്സസ്പ്ഷനുകൾ & ഹാൻഡ്ലിംഗ്
എക്സസ്പ്ഷനുകളുടെ അടിസ്ഥാനം
Try-catch ബ്ലോക്കുകൾ
Finally & Throw
8. ജാവയിൽ ഡാറ്റാ സ്ട്രക്ടറുകൾ
Arrays
ArrayList
HashMap
9. ലൈനുകളുടെ വായന & എഴുത്ത്
ഫയൽ ഇന്റർവ്യൂ
BufferedReader & PrintWriter
10. പ്രോജക്ട് വർക്ക്
ചെറിയ പ്രോഗ്രാമുകൾ വികസിപ്പിക്കുക
ജാവയിലെ പ്രയോഗങ്ങൾ എങ്ങനെ ഉപയോഗപ്പെടുത്താം
കൂടുതൽ പഠനത്തിന്
ജാവയുടെ ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ
ഓൺലൈൻ കോഴ്സുകൾ & ട്യൂട്ടോറിയലുകൾ
1. ജാവയുടെ പരിചയം
1.1. ജാവ എന്നത് എന്താണ്?
പ്രോഗ്രാമിങ് ഭാഷകളുടെ വർഗ്ഗീകരണം
ജാവയുടെ സവിശേഷതകൾ:
Platform Independence
Object-Oriented
Robustness
Security
Multithreading
1.2. ജാവയുടെ ചരിത്രം
ജാവയുടെ രൂപകൽപ്പന
1995-ൽ ജാവയുടെ ആദ്യമായിട്ടുള്ള റിലീസ്
ജാവയുടെ വികസനത്തിൽ പ്രധാന ഓർമ്മകൾ
1.3. ജാവയുടെ പ്രയോഗങ്ങൾ
വെബ് ഡെവലപ്പ്മെന്റ്: JSP, Servlets
മൊബൈൽ ആപ്പുകൾ: Android Development
എന്റർപ്രൈസ് ആപ്പ്ലിക്കേഷനുകൾ: Java EE
ഗെയിമുകൾ: Java-based game development
2. ജാവയുടെ സ്ഥാപനം
2.1. ജാവ ഡവലപ്പ്മെന്റ് കിറ്റ് (JDK) ഇൻസ്റ്റാൾ ചെയ്യുക
JDK vs JRE vs JVM
JDK ഡൗൺലോഡ് ചെയ്യുക
ഇൻസ്റ്റലേഷൻ സമാപനം
2.2. IDE പരിചയം
IDE-യുടെ പ്രാധാന്യം
Eclipse ഇൻസ്റ്റാൾ ചെയ്യുക:
Workspace സെറ്റപ്പ്
Project creation
IntelliJ IDEA പരിചയം:
Community vs Ultimate Edition
Basic configuration
NetBeans: Installation and features
2.3. Hello World പ്രോഗ്രാമിന്റെ ആവിഷ്കരണം
Source code structure
Compilation and execution
Error handling: Compilation errors vs Runtime errors
3. അടിസ്ഥാന തത്വങ്ങൾ
3.1. ഡാറ്റാ ടൈപ്പുകൾ
Primitive Data Types:
Integer Types: byte, short, int, long
Floating-point Types: float, double
Character Type: char
Boolean Type: boolean
Non-Primitive Data Types:
Strings
Arrays
Classes and Interfaces
3.2. ചരങ്ങൾ (Variables)
Variable types: local, instance, static
Naming conventions and best practices
Type casting: Implicit and Explicit
3.3. Operators
Arithmetic Operators: Addition, Subtraction, Multiplication, Division, Modulus
Relational Operators: Equal to, Not equal, Greater than, Less than
Logical Operators: AND, OR, NOT
Bitwise Operators: AND, OR, XOR, Complement, Shift operators
Ternary Operator: Syntax and usage
4. നിയന്ത്രണ ഘടനകൾ
4.1. If-else പ്രസ്താവന
Simple if statement
If-else statement: Syntax and examples
Nested if statements: Use cases and examples
4.2. Switch-case പ്രസ്താവന
Syntax and flow of control
Fall-through behavior
Default case usage
4.3. Looping
For Loop: Syntax, initialization, condition, and increment
Enhanced for loop (for-each)
While Loop: Syntax, condition checking
Do-While Loop: Syntax, guarantee of execution
Break and continue statements: Usage and examples
5. ഫംഗ്ഷനുകൾ
5.1. ഫംഗ്ഷന്റെ അടിസ്ഥാനം
Function declaration: Syntax and components
Function calling: By value vs by reference
5.2. Parameterized Functions
Passing parameters: Value types vs reference types
Return statements: Returning multiple values
5.3. Return Type
Different return types and their significance
Void functions: Definition and usage
6. ഓബ്ജക്റ്റ്-oriented programming (OOP) അടിസ്ഥാനങ്ങൾ
6.1. ക്ലാസുകൾ & ഓബ്ജക്റ്റുകൾ
Class definition: Syntax and components
Creating and instantiating objects
Constructor overloading and usage
6.2. ഇൻഹറിറ്റൻസ്
Understanding the inheritance hierarchy
Superclass and subclass concepts
Method overriding and the @Override annotation
Types of inheritance: Single, Multilevel, Hierarchical
6.3. പൊളിമോർഫിസം
Compile-time vs runtime polymorphism
Method overloading: Examples and use cases
Method overriding: Examples and use cases
6.4. ഇൻകാപ്സുലേഷൻ
Access modifiers: public, private, protected
Getters and Setters: Why and how to use them
Benefits of encapsulation
7. എക്സസ്പ്ഷനുകൾ & ഹാൻഡ്ലിംഗ്
7.1. എക്സസ്പ്ഷനുകളുടെ അടിസ്ഥാനം
What are exceptions?
Types of exceptions: Checked vs unchecked
Common exceptions in Java (NullPointerException, ArrayIndexOutOfBoundsException)
7.2. Try-catch ബ്ലോക്കുകൾ
Syntax of try-catch
Catching multiple exceptions
Nested try-catch blocks
7.3. Finally & Throw
Finally block usage and examples
The throw statement: Syntax and examples
Custom exceptions: Creating and using
8. ജാവയിൽ ഡാറ്റാ സ്ട്രക്ടറുകൾ
8.1. Arrays
Declaring and initializing arrays
Multidimensional arrays: Definition and examples
Array operations: Traversing, sorting, and searching
8.2. ArrayList
Understanding the ArrayList class
Common methods: add(), remove(), get(), set()
Iterating over ArrayList: Using for loop and enhanced for loop
8.3. HashMap
Understanding HashMap: Key-value pairs
Common methods: put(), get(), remove(), keySet(), entrySet()
Iterating over HashMap: Using for loop and enhanced for loop
9. ലൈനുകളുടെ വായന & എഴുത്ത്
9.1. ഫയൽ ഇന്റർവ്യൂ
Reading from files: InputStream and FileReader
Writing to files: OutputStream and FileWriter
9.2. BufferedReader & PrintWriter
Using BufferedReader for efficient reading
Using PrintWriter for formatted writing
Practical examples: Reading and writing text files
10. പ്രോജക്ട് വർക്ക്
10.1. ചെറിയ പ്രോഗ്രാമുകൾ വികസിപ്പിക്കുക
Simple calculator: Addition, subtraction, multiplication, division
Number guessing game: User input, random number generation, game logic
10.2. ജാവയിലെ പ്രയോഗങ്ങൾ എങ്ങനെ ഉപയോഗപ്പെടുത്താം
Real-world applications of Java: Use in software development
Suggestions for future projects: Building a personal project portfolio
കൂടുതൽ പഠനത്തിന്
11.1. ജാവയുടെ ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ
11.2. ഓൺലൈൻ കോഴ്സുകൾ & ട്യൂട്ടോറിയലുകൾ
Recommended websites and resources for further learning
Unit 1: ജാവയുടെ പരിചയം
1.1. ജാവ എന്നത് എന്താണ്?
പ്രോഗ്രാമിങ്ങിന്റെ അടിസ്ഥാനങ്ങൾ
ജാവ ഒരു ജനറൽ-പർപ്പോസ്, ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് പ്രോഗ്രാമിങ്ങ് ഭാഷയാണ്, അതിന്റെ സവിശേഷതകൾ കാരണം ഇന്ന് ലോകത്തിൽ ഏറ്റവും അധികം ഉപയോഗിക്കുന്ന ഭാഷകളിൽ ഒന്നാണ്.
ജാവയുടെ സവിശേഷതകൾ:
Platform Independence: ജാവ പ്രോഗ്രാമുകൾ 'Write Once, Run Anywhere' എന്ന സിദ്ധാന്തത്തിൽ പ്രവർത്തിക്കുന്നു, അതായത്, ഒരു കമ്പ്യൂട്ടറിൽ എഴുതിയ പ്രോഗ്രാം മറ്റൊരു കമ്പ്യൂട്ടറിൽ പ്രവർത്തിപ്പിക്കാമെന്നു പറയുന്നു. ജാവ കോഡ് ജാവ ബൈറ്റ് കോഡിലേക്ക് കംപൈൽ ചെയ്യപ്പെടുകയും, അത് ജാവ വെർച്വൽ മെഷീനിൽ (JVM) പ്രവർത്തിക്കുന്നു.
Object-Oriented: ജാവ ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് പ്രോഗ്രാമിങ്ങിന്റെ സിദ്ധാന്തങ്ങൾ പിന്തുടരുന്നു, കൂടാതെ ക്ലാസുകൾ, ഒബ്ജക്റ്റുകൾ, ഇൻഹറിറ്റൻസ്, ഇൻകാപ്സുലേഷൻ, എന്നിവയെ പിന്തുണയ്ക്കുന്നു.
Robustness: ജാവ തെറ്റുകൾ പരിരക്ഷിക്കുന്നതിനായി കർശനമായ നിയമങ്ങൾ പ്രയോഗിക്കുന്നു.
Security: ജാവ സുരക്ഷിതമായ പ്രോഗ്രാമുകൾ എഴുതാൻ അനുവദിക്കുന്നു, പ്രത്യേകിച്ചും നെറ്റ്‌വർക്കിംഗ് പ്രയോഗങ്ങളിൽ.
Multithreading: ജാവ നിരവധി ത്രെയ്ഡുകൾ (Threads) ഒരു സമയം പ്രവർത്തിപ്പിക്കാൻ കഴിയും, ഇത് വേഗതയും പ്രകടനവും മെച്ചപ്പെടുത്തുന്നു.
ഉദാഹരണം:
java
Copy code
public class Example {
public static void main(String[] args) {
System.out.println("Hello, Java!");
}
}
ഈ കോഡ് "Hello, Java!" എന്ന സന്ദേശം കൺസോളിൽ പ്രിന്റ് ചെയ്യുന്നു.
1.2. ജാവയുടെ ചരിത്രം
ജാവയുടെ രൂപകൽപ്പന
ജാവ 1991-ൽ സൺ മൈക്രോസിസ്റ്റംസ് (Sun Microsystems) എഞ്ചിനീയർമാരായ ജേസ് ഹസ്ലി, ഡഗ് കുക്ക്ല്, എവാൻ സോദെർ എന്നിവർ ചേർന്ന് വികസിപ്പിച്ച ഒരു ഭാഷയാണ്. ഇത് ആദ്യം "ഓക്ക (Oak)" എന്ന പേരിലാണ് അറിയപ്പെടിയത്, പിന്നീട് 1995-ൽ "ജാവ" എന്ന പേരിലേക്ക് മാറി.
പ്രധാന വെളിപ്പെടുത്തലുകൾ:
Java 1.0 (1996): ജാവയുടെ ആദ്യത്തെ ഔദ്യോഗിക റിലീസ്.
Java 2 (1998): Swing UI toolkit, Collections framework എന്നിവയെ ഉൾപ്പെടുത്തുന്നു.
Java 5 (2004): Generics, Metadata, Enumerated types എന്നിവ പരിചയപ്പെടുത്തി.
Java 8 (2014): Lambdas, Streams API, Date and Time API എന്നിവ.
1.3. ജാവയുടെ പ്രയോഗങ്ങൾ
വെബ് ഡെവലപ്പ്മെന്റ്: JSP (JavaServer Pages) & Servlets ഉപയോഗിച്ച് ഡYNAMIC വെബ് പേജുകൾ നിർമ്മിക്കാൻ സാധ്യമാണ്.
മൊബൈൽ ആപ്പുകൾ: Android പ്ലാറ്റ്ഫോമിൽ ജാവ ഉപയോഗിച്ച് ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കാൻ സാധ്യമാണ്.
എന്റർപ്രൈസ് ആപ്പ്ലിക്കേഷനുകൾ: Java EE (Enterprise Edition) വഴി വലിയ, സ്കേലബിൾ അപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കാം.
ഗെയിമുകൾ: Java-യിൽ ഗെയിമുകൾ നിർമ്മിക്കുന്നതിന് ഉപയോഗിക്കുന്നു, ഉദാഹരണത്തിന്, Minecraft.
ഉദാഹരണം:
java
Copy code
public class WebApp {
public static void main(String[] args) {
System.out.println("Web application is running!");
}
}
ഈ കോഡ് വെബ് ആപ്ലിക്കേഷൻ ലോഗിക് പ്രതിനിധീകരിക്കുന്നു.
Unit 1: Summary
ജാവ: ഒബ്ജക്റ്റ്-ഓറിയന്റഡ്, പ്ലാറ്റ്ഫോം ഇൻഡിപെൻഡന്റ് പ്രോഗ്രാമിങ്ങ് ഭാഷ.
ചരിത്രം: 1991-ൽ വികസിപ്പിച്ച് 1995-ൽ പുറത്തിറക്കിയപ്പോൾ പ്രാദേശികമായും അന്താരാഷ്ട്രമായി വ്യാപിച്ചു.
പ്രയോഗങ്ങൾ: വെബ്, മൊബൈൽ, എന്റർപ്രൈസ്, ഗെയിം ഡെവലപ്പ്മെന്റ്.
Unit 2: ജാവയുടെ സ്ഥാപനം
2.1. ജാവ ഡവലപ്പ്മെന്റ് കിറ്റ് (JDK) ഇൻസ്റ്റാൾ ചെയ്യുക
JDK എന്താണ്?
JDK (Java Development Kit) ജാവ പ്രോഗ്രാമുകൾ വികസിപ്പിക്കാൻ വേണ്ടതായ ഒരു സമാഹാരം ആണ്. ഇതിൽ JRE (Java Runtime Environment) കൂടാതെ, ജാവ കോഡുകൾ കംപൈൽ ചെയ്യാൻ ആവശ്യമായ നിരവധി ഉപകരണങ്ങളും ഉൾക്കൊള്ളുന്നു.
JDK vs JRE vs JVM
JDK: Java Development Kit, കോഡ് വികസിപ്പിക്കുന്നതിനുള്ള കിറ്റ്.
JRE: Java Runtime Environment, ജാവ പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കാൻ വേണ്ടിയുള്ള runtime.
JVM: Java Virtual Machine, ജാവ ബൈറ്റ് കോഡുകൾ പ്രവർത്തിപ്പിക്കാൻ ഉപയോഗിക്കുന്ന സോഫ്റ്റ്വെയർ.
ഇൻസ്റ്റലേഷന്റെ ഘട്ടങ്ങൾ:
Oracle JDK അല്ലെങ്കിൽ OpenJDK ഡൗൺലോഡ് ചെയ്യുക.
ഇൻസ്റ്റലേഷൻ ഫയൽ പ്രവർത്തിപ്പിക്കുക.
ഇൻസ്റ്റലേഷൻ പൂർത്തിയാക്കുക.
JDK സജ്ജമാക്കിയതിനു ശേഷം, കമാൻഡ് പ്രോംപ്റ്റിൽ 'java -version' അല്ലെങ്കിൽ 'javac -version' എന്ന കമാൻഡ് നൽകുക.
ഉദാഹരണം:
bash
Copy code
java -version
ഈ കമാൻഡ് ജാവയുടെ ആധികാരിക പതിപ്പ് പ്രദർശിപ്പിക്കും.
2.2. IDE പരിചയം
IDE-യുടെ പ്രാധാന്യം
IDE (Integrated Development Environment) ജാവ കോഡുകൾ എഴുതാനും, കംപൈൽ ചെയ്യാനും, പിശക് തിരുത്താനും ഒരേ സ്ഥലത്ത് നിരവധി ഉപകരണങ്ങൾ നൽകുന്നു. ഇത് ഡെവലപ്പർമാർക്ക് ഫലപ്രദമായ രീതിയിൽ കോഡിംഗ് നടത്താൻ സഹായിക്കുന്നു.
Eclipse ഇൻസ്റ്റാൾ ചെയ്യുക:
Eclipse IDE സന്ദർശിക്കുക.
Appropriate Eclipse package (e.g., Eclipse IDE for Java Developers) ഡൗൺലോഡ് ചെയ്യുക.
ZIP ഫയൽ extract ചെയ്യുക.
eclipse.exe പ്രവർത്തിപ്പിക്കുക.
Workspace സെറ്റപ്പ്:
Eclipse ആദ്യമായി തുറക്കുമ്പോൾ, workspace സെറ്റ് ചെയ്യാൻ ആവശ്യപ്പെടും. ഇത് പ്രോഗ്രാമുകൾ സൂക്ഷിക്കാൻ ഉപയോഗിക്കുന്ന ഫോൾഡർ ആണ്.
Project creation:
File -> New -> Java Project.
Project Name നൽകുക (ഉദാ: HelloWorld).
Finish ക്ലിക്ക് ചെയ്യുക.
IntelliJ IDEA പരിചയം:
IntelliJ IDEA സന്ദർശിക്കുക.
Community Edition ഡൗൺലോഡ് ചെയ്ത് ഇൻസ്റ്റാൾ ചെയ്യുക.
New Project -> Java -> Project Name -> Finish.
NetBeans:
NetBeans IDE സന്ദർശിക്കുക.
Installer റൺ ചെയ്ത്, Java SE ഉപയോഗിച്ച് ഒരു പുതിയ പ്രോജക്റ്റ് സൃഷ്ടിക്കുക.
ഉദാഹരണം: Eclipse ഉപയോഗിച്ച് ഒരു പുതിയ Java Project സൃഷ്ടിക്കാൻ, മുകളിൽ പറയപ്പെട്ട നടപടികൾ പിന്തുടരുക.
2.3. Hello World പ്രോഗ്രാമിന്റെ ആവിഷ്കരണം
പ്രോഗ്രാമിന്റെ ഘടന
ജാവയിൽ ഒരു പ്രോഗ്രാമിന്റെ അടിസ്ഥാന ഘടനയിൽ ക്ലാസ്, മെയിൻ മെതഡുകൾ, സ്റ്റേറ്റ്മെന്റുകൾ എന്നിവ ഉൾപ്പെടുന്നു.
Example:
java
Copy code
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
കോഡ് വിശദീകരണം:
public class HelloWorld: HelloWorld എന്ന ക്ലാസ് പ്രസ്താവിക്കുന്നു.
public static void main(String[] args): ജാവ പ്രോഗ്രാമിന്റെ പ്രാരംഭമായ മെത്തഡ്.
System.out.println("Hello, World!");: കൺസോളിൽ "Hello, World!" പ്രിന്റ് ചെയ്യുന്നു.
കോഡ് എഴുതുക, കംപൈൽ ചെയ്യുക, പ്രവർത്തിപ്പിക്കുക:
IDE-യിൽ ഒരു പുതിയ Java ക്ലാസ് സൃഷ്ടിക്കുക.
മുകളിൽ കൊടുത്തിരിക്കുന്ന കോഡ് പകർത്തുക.
Save ചെയ്ത്, Run (ഇനിമുതൽ Ctrl+R) പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുക.
Error Handling:
Compilation errors: Syntax തെറ്റുകൾ (e.g., class name mismatches).
Runtime errors: Code execution സമയം സംഭവിക്കുന്ന തെറ്റുകൾ.
ഉദാഹരണം:
Compilation error:
java
Copy code
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!) // Missing closing quote
}
}
Runtime error:
java
Copy code
public class HelloWorld {
public static void main(String[] args) {
int num = 5 / 0; // Division by zero
}
}
ഈ കോഡുകൾ compilers-ൽ പിശക് കാണിക്കും, അങ്ങനെ തെറ്റുകൾ എങ്ങനെ പരിഹരിക്കാം എന്നതിൽ ശ്രദ്ധ ചെലുത്തുക.
Unit 2: Summary
JDK: Java Development Kit, Java പ്രോഗ്രാമുകൾ വികസിപ്പിക്കാൻ ആവശ്യമായ ടൂൾ.
IDE: Integrated Development Environment, Java കോഡ് എഴുതാൻ, കംപൈൽ ചെയ്യാൻ, പിശക് തിരുത്താൻ ഉപയോഗിക്കുന്നു.
Hello World: ഒരു അടിസ്ഥാന പ്രോഗ്രാമിന്റെ ഉദാഹരണം, ജാവയിൽ പ്രോഗ്രാമുകൾ എങ്ങനെ എഴുതാം, പ്രവർത്തിപ്പിക്കാം എന്നതിനെക്കുറിച്ച് പഠനത്തിന്റെ തുടക്കം.
Unit 3: അടിസ്ഥാന തത്വങ്ങൾ
3.1. ഡാറ്റാ ടൈപ്പുകൾ
ഡാറ്റാ ടൈപ്പുകളുടെ പരിചയം
ജാവയിൽ, ഡാറ്റാ ടൈപ്പുകൾ എന്നത് പ്രോഗ്രാമിൽ സൂക്ഷിക്കുന്ന ഡാറ്റയുടെ തരങ്ങളെ സൂചിപ്പിക്കുന്നു. ജാവയിൽ പ്രിമിറ്റീവ് (primitive) ഡാറ്റാ ടൈപ്പുകളും, നോൺ-പ്രിമിറ്റീവ് (non-primitive) ഡാറ്റാ ടൈപ്പുകളും ഉണ്ട്.
Primitive Data Types:
byte: 8-bit signed integer.
short: 16-bit signed integer.
int: 32-bit signed integer.
long: 64-bit signed integer.
float: 32-bit floating point.
double: 64-bit floating point.
char: 16-bit Unicode character.
boolean: true അല്ലെങ്കിൽ false.
Non-Primitive Data Types:
Strings: Characters’ sequences.
Arrays: A collection of similar data types.
Classes and Interfaces: User-defined types.
ഉദാഹരണം:
java
Copy code
public class DataTypesExample {
public static void main(String[] args) {
byte a = 100; // 8-bit
short b = 10000; // 16-bit
int c = 100000; // 32-bit
long d = 100000L; // 64-bit
float e = 10.5f; // 32-bit floating point
double f = 20.5; // 64-bit floating point
char g = 'A'; // 16-bit Unicode
boolean h = true; // true/false
System.out.println("Byte value: " + a);
System.out.println("Short value: " + b);
System.out.println("Int value: " + c);
System.out.println("Long value: " + d);
System.out.println("Float value: " + e);
System.out.println("Double value: " + f);
System.out.println("Char value: " + g);
System.out.println("Boolean value: " + h);
}
}
3.2. ചരങ്ങൾ (Variables)
Variable Types:
Local Variable: Method, constructor, or block inside declared.
Instance Variable: Declared inside a class but outside any method.
Static Variable: Declared with the static keyword; shared among all instances of a class.
Variable Naming Conventions:
First letter should be lowercase.
No special characters except underscores (_).
No spaces allowed.
Type Casting:
Implicit Casting: Automatically done by the Java compiler (widening).
Explicit Casting: Done manually by the programmer (narrowing).
ഉദാഹരണം:
java
Copy code
public class VariableExample {
// Instance variable
int instanceVariable = 50;
// Static variable
static int staticVariable = 100;
public void display() {
// Local variable
int localVariable = 25;
System.out.println("Instance Variable: " + instanceVariable);
System.out.println("Static Variable: " + staticVariable);
System.out.println("Local Variable: " + localVariable);
}
public static void main(String[] args) {
VariableExample obj = new VariableExample();
obj.display();
// Implicit casting
int intVar = 10;
double doubleVar = intVar; // Implicit conversion
System.out.println("Implicit Casting: " + doubleVar);
// Explicit casting
double doubleVal = 9.78;
int intVal = (int) doubleVal; // Explicit conversion
System.out.println("Explicit Casting: " + intVal);
}
}
3.3. Operators
Operator Types:
Arithmetic Operators: +, -, *, /, % (Addition, Subtraction, Multiplication, Division, Modulus)
Relational Operators: ==, !=, >, <, >=, <= (Comparison)
Logical Operators: &&, ||, ! (AND, OR, NOT)
Bitwise Operators: &, |, ^, ~, <<, >> (Bitwise AND, OR, XOR, Complement, Shift)
Ternary Operator: condition ? expression1 : expression2
ഉദാഹരണം:
java
Copy code
public class OperatorsExample {
public static void main(String[] args) {
// Arithmetic Operators
int a = 10, b = 20;
System.out.println("Addition: " + (a + b)); // 30
System.out.println("Subtraction: " + (a - b)); // -10
System.out.println("Multiplication: " + (a * b)); // 200
System.out.println("Division: " + (b / a)); // 2
System.out.println("Modulus: " + (b % a)); // 0
// Relational Operators
System.out.println("a == b: " + (a == b)); // false
System.out.println("a != b: " + (a != b)); // true
// Logical Operators
boolean x = true, y = false;
System.out.println("x && y: " + (x && y)); // false
System.out.println("x || y: " + (x || y)); // true
// Bitwise Operators
int num1 = 5; // 0101
int num2 = 3; // 0011
System.out.println("Bitwise AND: " + (num1 & num2)); // 1 (0001)
// Ternary Operator
int max = (a > b) ? a : b;
System.out.println("Maximum: " + max); // 20
}
}
Unit 3: Summary
ഡാറ്റാ ടൈപ്പുകൾ: Primitive (byte, short, int, long, float, double, char, boolean) and Non-Primitive (Strings, Arrays, Classes).
Variable Types: Local, Instance, Static, and conventions for naming.
Operators: Arithmetic, Relational, Logical, Bitwise, and Ternary operators with examples.
Unit 4: നിയന്ത്രണ സമിതി (Control Statements)
4.1. if-else സമിതികൾ
if Statement
if സമിതിയിൽ, നിർദ്ദേശം ശരിയാണെങ്കിൽ മാത്രം പ്രവർത്തനങ്ങൾ നടത്തുന്നു.
if-else Statement
if ശൈലിയ്ക്ക് വ്യത്യസ്തമായ else ബ്ലോക്ക് ചേർക്കുന്നത്, നിർദ്ദേശം ശരിയല്ലെങ്കിൽ മറ്റു പ്രവർത്തനങ്ങൾ നടത്താൻ സഹായിക്കുന്നു.
Syntax:
java
Copy code
if (condition) {
// statements if condition is true
} else {
// statements if condition is false
}
ഉദാഹരണം:
java
Copy code
public class IfElseExample {
public static void main(String[] args) {
int number = 10;
if (number > 0) {
System.out.println("Positive Number");
} else {
System.out.println("Negative Number");
}
}
}
വിവരണം: ഈ പ്രോഗ്രാമിൽ, നമ്പർ 0-ൽ കൂടുതലാണെങ്കിൽ "Positive Number" എന്ന സന്ദേശം പ്രിന്റ് ചെയ്യും. ഇല്ലെങ്കിൽ "Negative Number" പ്രിന്റ് ചെയ്യും.
4.2. switch-case സമിതി
switch Statement
switch സംവരണത്തിൽ, വിവിധ കേസുകളുമായി ഒരു എളുപ്പത്തിൽ ടെസ്റ്റ് ചെയ്യാൻ കഴിയും. അത് if-else സമിതിയ്ക്ക് ഒരു പ്രത്യേക ആപേക്ഷികമായ വ്യത്യാസമാണ്.
Syntax:
java
Copy code
switch (expression) {
case value1:
// statements
break;
case value2:
// statements
break;
default:
// default statements
}
ഉദാഹരണം:
java
Copy code
public class SwitchCaseExample {
public static void main(String[] args) {
int day = 3;
switch (day) {
case 1:
System.out.println("Monday");
break;
case 2:
System.out.println("Tuesday");
break;
case 3:
System.out.println("Wednesday");
break;
default:
System.out.println("Invalid day");
}
}
}
വിവരണം: ദിവസം 3 ആയപ്പോൾ, "Wednesday" എന്ന സന്ദേശം പ്രിന്റ് ചെയ്യും. മറ്റു ദിവസങ്ങൾക്ക് ക്രമത്തിൽ വരുന്ന കേസുകൾ വഴി സ്കിപ്പുചെയ്യും.
4.3. ലൂപ്പുകൾ (Loops)
For Loop
for ലൂപ് പ്രത്യേകിച്ച് നേരത്തെ അറിയപ്പെടുന്ന സരലോകങ്ങൾക്കും ഉദ്ദേശങ്ങൾക്കും ഉപയോഗിക്കുന്നു.
Syntax:
java
Copy code
for (initialization; condition; increment/decrement) {
// statements
}
ഉദാഹരണം:
java
Copy code
public class ForLoopExample {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
System.out.println("Iteration: " + i);
}
}
}
വിവരണം: 1 മുതൽ 5 വരെയുള്ള സംഖ്യകൾ പ്രിന്റ് ചെയ്യുന്നു.
While Loop
while ലൂപ്പ്, ഒരു നിബന്ധന ശരിയാണെങ്കിൽ മാത്രമാണ് പ്രവർത്തിക്കുന്നത്.
Syntax:
java
Copy code
while (condition) {
// statements
}
ഉദാഹരണം:
java
Copy code
public class WhileLoopExample {
public static void main(String[] args) {
int count = 1;
while (count <= 5) {
System.out.println("Count: " + count);
count++;
}
}
}
വിവരണം: count 1 മുതൽ 5 വരെയുള്ള സംഖ്യകൾ പ്രിന്റ് ചെയ്യുന്നു, count മാറ്റുന്നവ.
Do-While Loop
do-while ലൂപ്പ്, ശരിയായ രീതിയിൽ പ്രവർത്തനങ്ങൾ നടത്താൻ, ശരിവെട്ടിയാൽ കൂടാതെ, പ്രാഥമികമായി ഒരു സമയം പ്രവർത്തിക്കുന്നു.
Syntax:
java
Copy code
do {
// statements
} while (condition);
ഉദാഹരണം:
java
Copy code
public class DoWhileLoopExample {
public static void main(String[] args) {
int count = 1;
do {
System.out.println("Count: " + count);
count++;
} while (count <= 5);
}
}
വിവരണം: count 1 മുതൽ 5 വരെയുള്ള സംഖ്യകൾ പ്രിന്റ് ചെയ്യുന്നു, count മാറ്റുന്നവ.
Unit 4: Summary
if-else: Conditional statements that execute blocks of code based on a true/false condition.
switch-case: A control statement that handles multiple cases for variable evaluation.
Loops: for, while, and do-while loops are used for repeated execution of code blocks.
Unit 5: മേത്തഡുകൾ (Methods)
5.1. Methods-ന്റെ ആവിഷ്കരണം
Methods-യുടെ പരിചയം
Methods, കൃത്യമായ പ്രവർത്തനങ്ങൾ ചെയ്യുന്നതിനുള്ള ബ്ലോക്കുകളാണ്. പ്രോഗ്രാമിൽ ആവർത്തിക്കുന്ന പ്രവർത്തനങ്ങൾക്കായുള്ള കോഡ് പുനരുപയോഗിക്കാനുള്ള മാർഗമാണ്.
Method Syntax:
java
Copy code
returnType methodName(parameterType parameterName) {
// method body
return value; // optional
}
ഉദാഹരണം:
java
Copy code
public class MethodExample {
// A method that adds two numbers
public int add(int a, int b) {
return a + b;
}
public static void main(String[] args) {
MethodExample obj = new MethodExample();
int sum = obj.add(5, 10); // method call
System.out.println("Sum: " + sum);
}
}
വിവരണം: add എന്ന മെത്തഡ് രണ്ട് സംഖ്യകൾ കൂട്ടിച്ചേർക്കുന്നു, അവയെ ലാഭിച്ച്, main മെത്തഡിൽ വിളിക്കുന്നു.
5.2. Method Overloading
Method Overloading
Method Overloading, ഒരേ പേരിലുള്ള പക്ഷേ വ്യത്യസ്ത പാരാമീറ്റർ തരം അല്ലെങ്കിൽ എണ്ണം ഉള്ള methods സൃഷ്ടിക്കുന്ന പ്രക്രിയയാണ്.
Syntax:
java
Copy code
returnType methodName(parameterType1 parameterName1) {
// method body
}
returnType methodName(parameterType1 parameterName1, parameterType2 parameterName2) {
// method body
}
ഉദാഹരണം:
java
Copy code
public class OverloadingExample {
// Method with two int parameters
public int add(int a, int b) {
return a + b;
}
// Method with three int parameters
public int add(int a, int b, int c) {
return a + b + c;
}
public static void main(String[] args) {
OverloadingExample obj = new OverloadingExample();
System.out.println("Sum of two numbers: " + obj.add(5, 10)); // Calls the first method
System.out.println("Sum of three numbers: " + obj.add(5, 10, 15)); // Calls the second method
}
}
വിവരണം: ഈ ഉദാഹരണത്തിൽ, add മെത്തഡ് രണ്ട് വ്യത്യസ്ത പതിപ്പുകൾ ഒരേ പേരിൽ, എന്നാൽ വ്യത്യസ്ത പാരാമീറ്ററുകളുമായി സൃഷ്ടിക്കുന്നു.
5.3. Return Statement
Return Statement
Return statement, ഒരു method-ൽ നിന്ന് നിർദ്ദേശിച്ച മൂല്യം തിരിച്ചുകൊടുക്കാൻ ഉപയോഗിക്കുന്നു.
Syntax:
java
Copy code
return value; // optional return type must match method's return type
ഉദാഹരണം:
java
Copy code
public class ReturnExample {
// Method that returns the square of a number
public int square(int num) {
return num * num; // returning the square of num
}
public static void main(String[] args) {
ReturnExample obj = new ReturnExample();
int result = obj.square(5); // method call
System.out.println("Square: " + result);
}
}
വിവരണം: square എന്ന മെത്തഡ്, ഒരു സംഖ്യയുടെ ചതുരം കണക്കാക്കുന്നു, അത് main മെത്തഡിൽ വിളിച്ച് പ്രിന്റ് ചെയ്യുന്നു.
5.4. Parameter Types
Parameter Types
Methods-ൽ പാരാമീറ്ററുകൾ (parameters) നൽകുന്നതിന്, ഇവ method-ന്റെ പ്രവർത്തനത്തിനായി ആവശ്യമായ ഡാറ്റാ നൽകുന്നു.
Formal Parameters: Method-ൽ നിർവചിച്ചിരിക്കുന്ന പാരാമീറ്ററുകൾ.
Actual Parameters: Method-നെ വിളിക്കുമ്പോൾ, നൽകുന്ന മൂല്യങ്ങൾ.
ഉദാഹരണം:
java
Copy code
public class ParameterExample {
// Method with parameters
public void displayMessage(String message) {
System.out.println("Message: " + message);
}
public static void main(String[] args) {
ParameterExample obj = new ParameterExample();
obj.displayMessage("Hello, World!"); // passing an argument
}
}
വിവരണം: displayMessage എന്ന മെത്തഡിൽ, ഒരു പാരാമീറ്റർ message നൽകുന്നു, അത് main മെത്തഡിൽ ആവിഷ്കരിച്ച് പ്രിന്റ് ചെയ്യുന്നു.
5.5. Varargs
Varargs (Variable Arguments)
Java-യിൽ, Varargs ഒരു method-ൽ ഒരു പേരു മാത്രമുള്ള പാരാമീറ്ററുകളെ നേരിടാൻ കഴിയും, എന്നാൽ അവയുടെ എണ്ണം നിർവചിക്കേണ്ടതില്ല.
Syntax:
java
Copy code
public void methodName(dataType... parameterName) {
// method body
}
ഉദാഹരണം:
java
Copy code
public class VarargsExample {
// Method that accepts variable number of arguments
public void printNumbers(int... numbers) {
for (int num : numbers) {
System.out.println(num);
}
}
public static void main(String[] args) {
VarargsExample obj = new VarargsExample();
obj.printNumbers(1, 2, 3, 4, 5); // passing multiple arguments
}
}
വിവരണം: printNumbers എന്ന മെത്തഡ്, ഒട്ടുമിക്ക സംഖ്യകൾ സ്വീകരിച്ച്, അവയെ പ്രിന്റ് ചെയ്യുന്നു.
Unit 5: Summary
Methods: Code blocks that perform specific tasks and allow code reuse.
Method Overloading: Same method name with different parameters.
Return Statement: Used to return a value from a method.
Parameter Types: Used to pass data to methods.
Varargs: Allow methods to accept variable numbers of arguments.
Unit 6: ക്ലാസ്സുകളും ഒബ്ജക്റ്റുകളും (Classes and Objects)
6.1. ക്ലാസ്സിന്റെ പരികൽപ്പന (Class Definition)
ക്ലാസ്സ് എന്താണ്?
ക്ലാസ്സ്, ഒരു പ്രത്യേക തരം ഒബ്ജക്റ്റുകൾ നിർവചിക്കുന്ന ഒരു ടേംബർ (template) ആണ്. ക്ലാസ്സുകൾ, പ്രോഗ്രാമുകൾ നിർമ്മിക്കാൻ ഉപയോഗിക്കുന്ന ഡാറ്റാ മെമ്പർ (data members) & മെത്തഡുകൾ (methods) എന്നിവയുടെ ഗ്രൂപ്പാണ്.
Syntax:
java
Copy code
class ClassName {
// data members (attributes)
// methods (functions)
}
ഉദാഹരണം:
java
Copy code
public class Dog {
// Attributes
String breed;
int age;
// Method to display dog information
void displayInfo() {
System.out.println("Breed: " + breed);
System.out.println("Age: " + age);
}
}
വിവരണം: Dog എന്ന ക്ലാസ്സിൽ, breed (കുട്രായുടെ തരത്തിന്) & age (കുട്രായുടെ വയസ്സിന്) എന്ന രണ്ടു ഡാറ്റാ മെമ്പറുകൾ & displayInfo എന്നൊരു മെത്തഡ് അടങ്ങിയിരിക്കുന്നു.
6.2. ഒബ്ജക്റ്റുകളുടെ ആവിഷ്കരണം (Object Creation)
ഒബ്ജക്റ്റ്
ഒബ്ജക്റ്റുകൾ, ക്ലാസ്സിൽ നിർവചിച്ച വിവരങ്ങളും പ്രവർത്തനങ്ങളും ഉപയോഗിക്കുന്ന ഒരു പ്രത്യേക ഘടകമാണ്.
Syntax:
java
Copy code
ClassName objectName = new ClassName();
ഉദാഹരണം:
java
Copy code
public class ObjectCreationExample {
public static void main(String[] args) {
// Creating an object of Dog class
Dog myDog = new Dog();
// Setting values
myDog.breed = "Labrador";
myDog.age = 5;
// Calling method to display dog information
myDog.displayInfo();
}
}
വിവരണം: myDog എന്ന ഒബ്ജക്റ്റ് Dog ക്ലാസ്സിന്റെ ഒരു ഉദാഹരണമാണ്. breed & age ന്റെ മൂല്യങ്ങൾ സജ്ജീകരിക്കുകയും, displayInfo മെത്തഡ് വിളിക്കുകയും ചെയ്യുന്നു.
6.3. Access Modifiers
Access Modifiers
Access Modifiers, ക്ലാസ്സുകളിൽ ഡാറ്റാ മെമ്പറുകൾക്കും മെത്തഡുകൾക്കും ലഭ്യത നിയന്ത്രിക്കാൻ ഉപയോഗിക്കുന്നു.
Types:
Public: Any class can access.
Private: Only the class itself can access.
Protected: Accessed within the same package and subclasses.
Default: Accessed only within the same package.
ഉദാഹരണം:
java
Copy code
public class AccessModifierExample {
// Public variable
public String name;
// Private variable
private int age;
// Method to set age
public void setAge(int a) {
age = a; // Can access private variable
}
// Method to display information
public void display() {
System.out.println("Name: " + name);
System.out.println("Age: " + age);
}
}
വിവരണം: name എന്നത് പബ്ലിക്ക് ആണ്, അത് പുറത്തുനിന്നും സജീവമായിരിക്കുന്ന ഒബ്ജക്റ്റുകൾക്ക് ആക്സസ് ചെയ്യാൻ കഴിയും, age എന്നത് പ്രൈവറ്റ് ആണെന്ന് മാത്രമാണ് ആക്റ്റീവ് ക്ലാസ്സിന് ആക്സസ്.
6.4. Constructor-ന്റെ പരിചയം
Constructor
Constructor, ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുമ്പോൾ തന്നെ ക്ഷണിക്കപ്പെടുന്ന പ്രത്യേക രീതിയാണ്. ഇത് ക്ലാസ്സിന്റെ നാമത്തിൽ നിർവചിക്കണം.
Syntax:
java
Copy code
ClassName(parameters) {
// constructor body
}
ഉദാഹരണം:
java
Copy code
public class Car {
String model;
int year;
// Constructor
public Car(String m, int y) {
model = m;
year = y;
}
// Method to display car details
void displayDetails() {
System.out.println("Model: " + model);
System.out.println("Year: " + year);
}
}
വിവരണം: Car ക്ലാസ്സിൽ, ഒരു constructor നിർവചിക്കുന്നു. ഈ constructor, model & year ന്റെ മൂല്യങ്ങൾ സജ്ജീകരിക്കാൻ ഉപയോഗിക്കുന്നു.
6.5. Method Overriding
Method Overriding
Superclass (അമ്മക്ലാസ്സ്) ൽ നിർവചിച്ച മെത്തഡുകൾ, subclass (പിതൃക്ലാസ്സ്) ൽ പുനർ നിർവചിച്ചിരിക്കുന്നത് ആണ്.
Syntax:
java
Copy code
class Parent {
void display() {
System.out.println("Display from Parent class");
}
}
class Child extends Parent {
@Override
void display() {
System.out.println("Display from Child class");
}
}
ഉദാഹരണം:
java
Copy code
public class MethodOverridingExample {
public static void main(String[] args) {
Child child = new Child();
child.display(); // Calls the overridden method
}
}
വിവരണം: Child ക്ലാസ്സിൽ display മെത്തഡ് പുനർ നിർവചിക്കപ്പെട്ടു, ഇത് Parent ക്ലാസ്സിൽ ഉള്ള display മെത്തഡിനെ പുനർ നിർവചിക്കുന്നു.
Unit 6: Summary
Classes: Blueprints for creating objects with attributes and methods.
Objects: Instances of classes that hold data and methods.
Access Modifiers: Control access to class members.
Constructors: Special methods used for initializing objects.
Method Overriding: Allows subclass to provide specific implementation of a method that is already defined in its superclass.
Unit 7: ഉല്പാദനം (Inheritance)
7.1. ഉല്പാദനത്തിന്റെ പരിചയം (Introduction to Inheritance)
ഉല്പാദനം എന്താണ്?
ഉല്പാദനം, ഒരു ക്ലാസ് (subclass) മറ്റൊരു ക്ലാസിന്റെ (superclass) ഘടകങ്ങൾ (members) & സ്വഭാവങ്ങൾ (properties) ആപേക്ഷികമായി പുനരുപയോഗിക്കാൻ അനുമതി നൽകുന്ന പ്രക്രിയയാണ്. ഇതിന്റെ മുഖ്യ ലക്ഷ്യം കോഡ് പുനരുപയോഗവും, പരിരക്ഷയും & വിതരണവും (modularity) എന്നിവയാണ്.
ഉദാഹരണം:
java
Copy code
// Superclass
class Animal {
void eat() {
System.out.println("Eating...");
}
}
// Subclass
class Dog extends Animal {
void bark() {
System.out.println("Barking...");
}
}
വിവരണം: Animal എന്ന superclass-ൽ eat എന്ന ഒരു മെത്തഡ് ഉണ്ട്. Dog എന്ന subclass, Animal ക്ലാസ്സിനെ ആനുകൂല്യം ചെയ്യുന്നു, അതായത് eat എന്ന മെത്തഡ്, Dog ക്ലാസ്സിൽ പ്രാപ്യമാണ്.
7.2. ഉല്പാദന തരം (Types of Inheritance)
Single Inheritance
ഒരൊരു superclass-നും, ഒരൊരു subclass-നും ഇടയിൽ ഉള്ള ബന്ധമാണ്.
ഉദാഹരണം:
java
Copy code
class Vehicle {
void start() {
System.out.println("Vehicle started");
}
}
class Car extends Vehicle {
void drive() {
System.out.println("Car is driving");
}
}
Multilevel Inheritance
ഒരു superclass, ഒരു subclass, ആ subclass-നു ശേഷം മറ്റൊരു subclass-ഉം ഉണ്ട്.
ഉദാഹരണം:
java
Copy code
class Animal {
void sound() {
System.out.println("Animal makes sound");
}
}
class Dog extends Animal {
void bark() {
System.out.println("Dog barks");
}
}
class Puppy extends Dog {
void weep() {
System.out.println("Puppy weeps");
}
}
Hierarchical Inheritance
ഒരു superclass-നു രണ്ടിലധികം subclass-കൾ ഉണ്ടാകുന്ന ഘടനയാണ്.
ഉദാഹരണം:
java
Copy code
class Shape {
void draw() {
System.out.println("Drawing shape");
}
}
class Circle extends Shape {
void area() {
System.out.println("Calculating area of circle");
}
}
class Rectangle extends Shape {
void area() {
System.out.println("Calculating area of rectangle");
}
}
Multiple Inheritance
ഒരു subclass-ൻറെ ഭാഗമായിക്കൊണ്ടിരിക്കുന്ന രണ്ട് superclass-കൾ. (Java-യിൽ ഇതിന് Interfaces ഉപയോഗിക്കുന്നു)
ഉദാഹരണം:
java
Copy code
interface CanRun {
void run();
}
interface CanBark {
void bark();
}
class Dog implements CanRun, CanBark {
public void run() {
System.out.println("Dog can run");
}
public void bark() {
System.out.println("Dog barks");
}
}
7.3. super() സ്രോതസ്സുകളുടെ ഉപയോഗം
super()
super() ഉപയോജിക്കുന്നത് superclass-ൽ നിന്നും data members & methods ആക്കാൻ സഹായിക്കുന്നു.
Syntax:
java
Copy code
super();
ഉദാഹരണം:
java
Copy code
class Animal {
Animal() {
System.out.println("Animal constructor called");
}
}
class Dog extends Animal {
Dog() {
super(); // calls the constructor of Animal
System.out.println("Dog constructor called");
}
}
public class SuperExample {
public static void main(String[] args) {
Dog myDog = new Dog();
}
}
വിവരണം: Dog ക്ലാസ്സിന്റെ constructor-ൽ super() ഉപയോഗിച്ച് Animal ക്ലാസ്സിന്റെ constructor-നെ വിളിക്കുന്നു, ഇത് superclass constructor-ന്റെ പ്രവർത്തനം നടത്താൻ സഹായിക്കുന്നു.
7.4. Method Overriding in Inheritance
Method Overriding
Superclass-ൽ നിർവചിച്ച മെത്തഡുകൾ, subclass-ൽ പുനർ നിർവചിക്കാൻ കഴിയും.
Syntax:
java
Copy code
class Superclass {
void display() {
System.out.println("Display from Superclass");
}
}
class Subclass extends Superclass {
@Override
void display() {
System.out.println("Display from Subclass");
}
}
ഉദാഹരണം:
java
Copy code
public class MethodOverridingExample {
public static void main(String[] args) {
Subclass obj = new Subclass();
obj.display(); // Calls the overridden method
}
}
വിവരണം: Subclass-ൽ display മെത്തഡ് പുനർ നിർവചിച്ചിരിക്കുന്നു, superclass-ൽ നിന്ന് inheritance ചെയ്തിരിക്കുന്നു.
7.5. Final Keyword with Inheritance
final Keyword
final നിഷ്ക്രിയമായ (final) ക്ലാസ്സ്, മെത്തഡ്, അല്ലെങ്കിൽ പാരാമീറ്റർ സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്നു.
final class: Cannot be inherited.
final method: Cannot be overridden.
final variable: Its value cannot be changed.
ഉദാഹരണം:
java
Copy code
final class FinalClass {
void display() {
System.out.println("This is a final class");
}
}
// class Subclass extends FinalClass { // This will cause a compile-time error
// }
class RegularClass {
final void show() {
System.out.println("This method cannot be overridden");
}
}
class SubRegularClass extends RegularClass {
// void show() { // This will cause a compile-time error
// System.out.println("Trying to override");
// }
}
വിവരണം: FinalClass ഒരു final ക്ലാസ്സ് ആണ്, അതിനെ കീഴിൽ കൊണ്ടുപോകാൻ കഴിയില്ല. show എന്ന final മെത്തഡ്, subclass-ൽ പുനർ നിർവചിക്കാനാകും.
Unit 7: Summary
Inheritance: Allows one class to inherit properties and methods from another.
Types of Inheritance: Single, Multilevel, Hierarchical, and Multiple Inheritance (via interfaces).
super(): Calls the constructor of the superclass.
Method Overriding: Redefining a superclass method in a subclass.
final Keyword: Used to restrict inheritance, method overriding, and variable reassignment.
Unit 8: ഇന്റർഫേസുകളും ആബ്സ്ട്രാക്റ്റ് ക്ലാസ്സുകളും (Interfaces and Abstract Classes)
8.1. ഇന്റർഫേസുകളുടെ പരിചയം (Introduction to Interfaces)
ഇന്റർഫേസ് എന്താണ്?
ഇന്റർഫേസ്, ഒരുപാട് മെത്തഡുകൾ മാത്രമേ ഉണ്ടാകൂ, എന്നാൽ അവയുടെ ശരീരവും (body) ഇല്ല. ഇത് ക്ലാസ്സുകൾക്ക് പ്രായോഗികമായി തിരിച്ചറിഞ്ഞുവരുന്ന ഒരേ രൂപം നൽകുന്നു. ഇന്റർഫേസുകൾ ഒരു ക്ലാസ്സിന്റെ ഇടയിൽ ബന്ധം നിർമ്മിക്കാൻ സഹായിക്കുന്നു.
Syntax:
java
Copy code
interface InterfaceName {
// abstract methods
void method1();
void method2();
}
ഉദാഹരണം:
java
Copy code
interface Animal {
void eat(); // abstract method
void sleep(); // abstract method
}
class Dog implements Animal {
public void eat() {
System.out.println("Dog eats");
}
public void sleep() {
System.out.println("Dog sleeps");
}
}
വിവരണം: Animal എന്ന ഇന്റർഫേസിൽ eat & sleep എന്ന മെത്തഡുകൾ നിർവചിച്ചിട്ടുണ്ട്. Dog ക്ലാസ്സ് ഈ ഇന്റർഫേസിനെ നടപ്പാക്കുന്നു (implements) അതിന്റെ മെത്തഡുകൾ നൽകി.
8.2. ഇന്റർഫേസിന്റെ പ്രത്യേകതകൾ (Features of Interfaces)
Multiple Inheritance:
ഒരു ക്ലാസ് ഒന്നിലധികം ഇന്റർഫേസുകൾ നടപ്പാക്കാൻ കഴിയും.
ഉദാഹരണം:
java
Copy code
interface CanRun {
void run();
}
interface CanBark {
void bark();
}
class Dog implements CanRun, CanBark {
public void run() {
System.out.println("Dog can run");
}
public void bark() {
System.out.println("Dog barks");
}
}
Default Methods:
Java 8 മുതൽ, ഇന്റർഫേസുകളിൽ default methods ഉൾപ്പെടുത്താൻ സാധിക്കുന്നു, ഇവയുടെ ശരീരം ഉണ്ടായിരിക്കാം.
ഉദാഹരണം:
java
Copy code
interface Vehicle {
default void start() {
System.out.println("Vehicle is starting");
}
}
class Car implements Vehicle {
// Overrides default method
public void start() {
System.out.println("Car is starting");
}
}
Static Methods:
ഇന്റർഫേസുകളിൽ static methods എഴുതാം.
ഉദാഹരണം:
java
Copy code
interface MathOperations {
static int add(int a, int b) {
return a + b;
}
}
public class StaticMethodExample {
public static void main(String[] args) {
int sum = MathOperations.add(5, 10);
System.out.println("Sum: " + sum);
}
}
8.3. ആബ്സ്ട്രാക്റ്റ് ക്ലാസ്സിന്റെ പരിചയം (Introduction to Abstract Classes)
ആബ്സ്ട്രാക്റ്റ് ക്ലാസ്സ് എന്താണ്?
ആബ്സ്ട്രാക്റ്റ് ക്ലാസ്സ്, അംഗങ്ങളുടെയും മെത്തഡുകളുടെയും അർത്ഥം നൽകാത്ത ക്ലാസ്സാണ്. ഇതിൽ ഒരു അല്ലെങ്കിൽ കൂടുതൽ abstract methods ഉണ്ടായിരിക്കാം. ക്ലാസ്സുകൾക്ക് superclass-ൽ നിന്നും അവനെ അനുബന്ധിക്കാനാകും.
Syntax:
java
Copy code
abstract class AbstractClass {
abstract void display(); // abstract method
}
ഉദാഹരണം:
java
Copy code
abstract class Shape {
abstract void draw(); // abstract method
}
class Circle extends Shape {
void draw() {
System.out.println("Drawing a circle");
}
}
വിവരണം: Shape എന്ന ആബ്സ്ട്രാക്റ്റ് ക്ലാസ്സിൽ draw എന്ന മെത്തഡ് abstract ആയി നിർവചിച്ചിരിക്കുന്നു. Circle ക്ലാസ്സ് ഈ abstract method-നെ പുനർ നിർവചിക്കുന്നു.
8.4. ആബ്സ്ട്രാക്റ്റ് ക്ലാസ്സുകളും ഇന്റർഫേസുകളും തമ്മിലുള്ള വ്യത്യാസം (Difference between Abstract Classes and Interfaces)
ഉദാഹരണം:
java
Copy code
abstract class Animal {
abstract void sound();
}
interface Walk {
void walk();
}
class Dog extends Animal implements Walk {
void sound() {
System.out.println("Dog barks");
}
public void walk() {
System.out.println("Dog walks");
}
}
വിവരണം: Dog ക്ലാസ്സ്, Animal എന്ന abstract class-ൽ നിന്നും പുനർ നിർമ്മിച്ചു, കൂടാതെ Walk എന്ന ഇന്റർഫേസിനെ നടപ്പാക്കുന്നു.
8.5. Abstract Method and Interface Method Implementation
Abstract Method Implementation
Abstract methods superclass-ൽ നിർവചിക്കപ്പെടുന്നു, എന്നാൽ subclass-ൽ പുനർ നിർവചിക്കപ്പെടുന്നു.
Interface Method Implementation
Interface-ൽ method-കൾ superclass-ൽ നിന്നുള്ള inheritance-നു പകരം, direct class-ൽ നിന്നാണ് implement ചെയ്യേണ്ടത്.
ഉദാഹരണം:
java
Copy code
abstract class Vehicle {
abstract void start();
}
interface Operate {
void operate();
}
class Car extends Vehicle implements Operate {
void start() {
System.out.println("Car is starting");
}
public void operate() {
System.out.println("Car is being operated");
}
}
വിവരണം: Car ക്ലാസ്സ്, Vehicle abstract class-ൽ നിന്നും start എന്ന abstract method-നു ആസ്പദമായി പ്രവർത്തിക്കുന്നു, കൂടാതെ Operate ഇന്റർഫേസിലെ operate method-നെ implement ചെയ്യുന്നു.
Unit 8: Summary
Interfaces: Define methods that must be implemented by classes.
Features of Interfaces: Multiple inheritance, default methods, static methods.
Abstract Classes: Classes that cannot be instantiated and may contain abstract methods.
Difference: Key distinctions between abstract classes and interfaces regarding methods, variables, inheritance, etc.
Method Implementations: Abstract methods are implemented in subclasses, while interface methods are implemented directly in the class.
Unit 9: അവ്യവസ്ഥ കൈകാര്യം ചെയ്യല് (Exception Handling)
9.1. അവ്യവസ്ഥകളെ കുറിച്ച് പരിചയം (Introduction to Exceptions)
അവ്യവസ്ഥകൾ എന്താണ്?
അവ്യവസ്ഥകൾ, പ്രോഗ്രാമിന്റെ പ്രവർത്തന സമയത്ത് സംഭവിക്കുന്ന പിഴവുകളാണ്. ഈ പിഴവുകൾ സാധാരണയായി പ്രോഗ്രാമിന്റെ പ്രവർത്തനം തടയുകയും ചെയ്യുന്നു.
ഉദാഹരണം:
java
Copy code
public class ExceptionExample {
public static void main(String[] args) {
int a = 5;
int b = 0;
int result = a / b; // This will cause an ArithmeticException
System.out.println(result);
}
}
വിവരണം: ഈ കോഡിൽ, b = 0 ആകുന്നതിനാൽ, a / b എന്ന ഭാഗം ArithmeticException ഉല്പാദിപ്പിക്കുന്നു.
9.2. Exceptions-ന്റെ തരം (Types of Exceptions)
Checked Exceptions:
Compile-time exceptions, ജാവ പ്രോഗ്രാമിൽ സ്പഷ്ടമായി കൈകാര്യം ചെയ്യണം.
ഉദാഹരണം:
java
Copy code
import java.io.*;
public class CheckedExceptionExample {
public static void main(String[] args) {
try {
FileReader fr = new FileReader("nonexistentfile.txt");
} catch (IOException e) {
System.out.println("Checked Exception: " + e.getMessage());
}
}
}
Unchecked Exceptions:
Runtime exceptions, പ്രോഗ്രാമിന്റെ പ്രവർത്തന സമയത്ത് സംഭവിക്കുന്നു.
ഉദാഹരണം:
java
Copy code
public class UncheckedExceptionExample {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
System.out.println(arr[5]); // ArrayIndexOutOfBoundsException
}
}
Error:
JVM-ൽ സംഭവിക്കുന്ന grave errors, normally not handled by the program.
ഉദാഹരണം:
StackOverflowError
9.3. Exception Handling Mechanism
Try-Catch Block
Try-catch block ഉപയോഗിച്ച് exceptions കൈകാര്യം ചെയ്യാം.
Syntax:
java
Copy code
try {
// Code that may throw an exception
} catch (ExceptionType e) {
// Handling code
}
ഉദാഹരണം:
java
Copy code
public class ExceptionHandlingExample {
public static void main(String[] args) {
try {
int a = 5;
int b = 0;
int result = a / b; // This will cause an ArithmeticException
} catch (ArithmeticException e) {
System.out.println("Arithmetic Exception: Cannot divide by zero");
}
}
}
വിവരണം: try ബ്ലോക്കിൽ ArithmeticException ഉണ്ടാകുമ്പോൾ, catch ബ്ലോക്ക് പ്രവർത്തിക്കുന്നു, resulting in a user-friendly message.
9.4. Multiple Catch Blocks
Multiple Catch Blocks
ഒരു try block-ൽ നിരവധി catch blocks ഉപയോഗിച്ച് വ്യത്യസ്ത exceptions കൈകാര്യം ചെയ്യാൻ കഴിയും.
Syntax:
java
Copy code
try {
// Code that may throw multiple exceptions
} catch (ExceptionType1 e1) {
// Handling code for ExceptionType1
} catch (ExceptionType2 e2) {
// Handling code for ExceptionType2
}
ഉദാഹരണം:
java
Copy code
public class MultipleCatchExample {
public static void main(String[] args) {
try {
int a = 5;
int b = 0;
int result = a / b; // ArithmeticException
int[] arr = {1, 2, 3};
System.out.println(arr[5]); // ArrayIndexOutOfBoundsException
} catch (ArithmeticException e) {
System.out.println("Arithmetic Exception: Cannot divide by zero");
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Array Index Out Of Bounds Exception");
}
}
}
വിവരണം: ഈ ഉദാഹരണത്തിൽ, try ബ്ലോക്കിൽ രണ്ട് വ്യത്യസ്ത exceptions സംഭവിക്കാം, ഓരോ catch block-ലും ഓരോ exception-നായി വ്യത്യസ്തമായ സന്ദേശങ്ങൾ നൽകുന്നു.
9.5. Finally Block
Finally Block
finally block, try-catch block-നു ശേഷം എപ്പോഴും പ്രവർത്തിക്കുന്നു, exception ഉണ്ടാകുന്നുണ്ടാകുന്നില്ല എന്ന് മനസ്സിലാക്കിയാലും.
Syntax:
java
Copy code
try {
// Code that may throw an exception
} catch (ExceptionType e) {
// Handling code
} finally {
// This block always executes
}
ഉദാഹരണം:
java
Copy code
public class FinallyExample {
public static void main(String[] args) {
try {
int a = 5;
int b = 0;
int result = a / b; // This will cause an ArithmeticException
} catch (ArithmeticException e) {
System.out.println("Arithmetic Exception: Cannot divide by zero");
} finally {
System.out.println("This block always executes");
}
}
}
വിവരണം: finally block-ൽ ഉള്ള കോഡ്, exception ഉണ്ടായിരുന്നാലും പ്രവർത്തിക്കും.
9.6. Throw and Throws Keywords
Throw
throw keyword, നിർദ്ദിഷ്ട exception-കളെ പ്രേരിപ്പിക്കാൻ ഉപയോഗിക്കുന്നു.
Syntax:
java
Copy code
throw new ExceptionType("Exception message");
ഉദാഹരണം:
java
Copy code
public class ThrowExample {
static void checkAge(int age) {
if (age < 18) {
throw new ArithmeticException("Not eligible to vote");
} else {
System.out.println("Eligible to vote");
}
}
public static void main(String[] args) {
checkAge(16); // This will throw an exception
}
}
Throws
throws keyword, method signature-ൽ exception-കൾ പ്രസ്തുതപ്പെടുത്താൻ ഉപയോഗിക്കുന്നു.
Syntax:
java
Copy code
void methodName() throws ExceptionType {
// code
}
ഉദാഹരണം:
java
Copy code
public class ThrowsExample {
static void checkAge(int age) throws ArithmeticException {
if (age < 18) {
throw new ArithmeticException("Not eligible to vote");
}
}
public static void main(String[] args) {
try {
checkAge(16); // This will throw an exception
} catch (ArithmeticException e) {
System.out.println("Caught Exception: " + e.getMessage());
}
}
}
വിവരണം: checkAge method-ൽ throws ഉപയോഗിച്ചാൽ, caller method-ൽ exception കൈകാര്യം ചെയ്യാൻ ആവശ്യമാണ്.
Unit 9: Summary
Exceptions: Errors that occur during the execution of a program.
Types of Exceptions: Checked exceptions, Unchecked exceptions, and Errors.
Exception Handling Mechanism: Using try-catch blocks to handle exceptions.
Multiple Catch Blocks: Handling multiple exceptions from a single try block.
Finally Block: Executes whether or not an exception occurs.
Throw and Throws: Throwing an exception using throw and declaring exceptions using throws.
Unit 10: കളക്ഷൻ ഫ്രെയിംവർക്കു (Collections Framework)
10.1. കളക്ഷൻ എന്താണ്? (What is a Collection?)
കളക്ഷൻ:
Java-യിൽ, കളക്ഷൻ എന്നത് ഒന്നിലധികം ബാക്കി (objects) കൈകാര്യം ചെയ്യുന്നതിന് ഉപകരണങ്ങളുടെ ഒരു സമാഹാരം ആണ്. ഇത് ആണവമായ വിവരങ്ങളെ (data) സൂക്ഷിക്കുന്നതിനും കൈകാര്യം ചെയ്യുന്നതിനുമുള്ള സമർത്ഥമായ മാർഗമാണ്.
ഉദാഹരണം:
java
Copy code
import java.util.ArrayList;
public class CollectionExample {
public static void main(String[] args) {
ArrayList<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Mango");
System.out.println(fruits);
}
}
വിവരണം: ഈ ഉദാഹരണത്തിൽ, ArrayList എന്ന കളക്ഷൻ ഉപയോഗിച്ച്, നമ്മൾ 3 വിവിധ ഫലങ്ങൾ (fruits) ചേർക്കുന്നു.
10.2. കളക്ഷൻ ഫ്രെയിംവർക്കിന്റെ ഘടകങ്ങൾ (Components of Collections Framework)
Interfaces:
Collection: ആകെ കളക്ഷന്റെ അടിസ്ഥാന ഇൻറർഫേസ്.
List: Ordered collection (elements can be accessed by their index).
Set: Unordered collection (no duplicate elements allowed).
Map: Collection of key-value pairs.
Implementations:
ArrayList: Dynamic array implementation.
LinkedList: Doubly linked list implementation.
HashSet: Hash table based implementation of Set.
TreeSet: Sorted set implementation.
HashMap: Hash table based implementation of Map.
TreeMap: Sorted map implementation.
Algorithms:
Predefined methods to perform operations on collections, like sorting, searching, etc.
10.3. List Interface
List Interface:
Ordered collection, elements can be accessed by their index.
Implementations:
ArrayList
LinkedList
ഉദാഹരണം:
java
Copy code
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class ListExample {
public static void main(String[] args) {
List<String> arrayList = new ArrayList<>();
arrayList.add("Apple");
arrayList.add("Banana");
arrayList.add("Mango");
System.out.println("ArrayList: " + arrayList);
List<String> linkedList = new LinkedList<>();
linkedList.add("Orange");
linkedList.add("Grapes");
System.out.println("LinkedList: " + linkedList);
}
}
വിവരണം: ഈ ഉദാഹരണത്തിൽ, ArrayList & LinkedList ഉപയോഗിച്ച് നാം ഫലങ്ങൾ ചേർക്കുന്നു.
10.4. Set Interface
Set Interface:
Unordered collection, no duplicate elements are allowed.
Implementations:
HashSet
TreeSet
ഉദാഹരണം:
java
Copy code
import java.util.HashSet;
import java.util.Set;
public class SetExample {
public static void main(String[] args) {
Set<String> hashSet = new HashSet<>();
hashSet.add("Apple");
hashSet.add("Banana");
hashSet.add("Apple"); // Duplicate, will not be added
System.out.println("HashSet: " + hashSet);
}
}
വിവരണം: HashSet ഉപയോഗിച്ച്, ഡുപ്പ്ലിക്കേറ്റ് ഫലങ്ങൾ ചേർക്കാൻ ശ്രമിച്ചാൽ, അത് ഒഴിവാക്കപ്പെടും.
10.5. Map Interface
Map Interface:
Collection of key-value pairs. Keys must be unique.
Implementations:
HashMap
TreeMap
ഉദാഹരണം:
java
Copy code
import java.util.HashMap;
import java.util.Map;
public class MapExample {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);
map.put("Mango", 3);
System.out.println("Map: " + map);
}
}
വിവരണം: HashMap ഉപയോഗിച്ച്, നാം കീ-വാല്യു പെയർ സമാഹരിക്കുന്നു.
10.6. Collections Utility Class
Collections Class:
It provides utility methods for collections, such as sorting, searching, and more.
ഉദാഹരണം:
java
Copy code
import java.util.ArrayList;
import java.util.Collections;
public class CollectionsExample {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Banana");
list.add("Apple");
list.add("Mango");
Collections.sort(list);
System.out.println("Sorted List: " + list);
}
}
വിവരണം: Collections.sort method ഉപയോഗിച്ച്, നാം ഒരു ലിസ്റ്റ് ക്രമീകരിക്കുന്നു.
Unit 10: Summary
Collections: A framework to handle groups of objects.
Components: Interfaces, Implementations, and Algorithms.
List Interface: An ordered collection that allows duplicates.
Set Interface: An unordered collection that does not allow duplicates.
Map Interface: A collection of key-value pairs.
Collections Utility Class: Provides utility methods for collections.
Posts
Hello, my name is Jack Sparrow. I'm a 50 year old self-employed Pirate from the Caribbean.
No comments:
Post a Comment