Makindo Medical Notes

Overview of Java Programming

Java is a high-level, class-based, object-oriented programming language that is designed to have as few implementation dependencies as possible. It is widely used for building enterprise-scale applications, web applications, and Android apps. Java's platform independence, strong memory management, and robustness make it a popular choice for developers.

Basic Syntax and Structure

• Comments:
  • Single-line comments start with double slashes (//).

  // This is a single-line comment

  • Multi-line comments are enclosed in /* and */.

  /* 
  This is a multi-line comment 
  spanning multiple lines 
  */

  • Documentation comments are enclosed in / and */.

  / 
   * This is a documentation comment 
   * It can be used to generate documentation 
   */

• Main Method:
  • The entry point of a Java program is the main method.

  public class Main {
   public static void main(String[] args) {
   System.out.println("Hello, World!");
   }
  }

• Data Types:
  • Common data types include int, float, double, char, and boolean.

  int age = 25;
  float height = 5.9f;
  double pi = 3.14159;
  char initial = 'A';
  boolean isActive = true;

Control Structures

• Conditional Statements:
  • if, else if, and else are used for decision making.

  if (age > 18) {
   System.out.println("Adult");
  } else {
   System.out.println("Minor");
  }

• Switch Statement:
  • Used for multi-way branching.

  switch (initial) {
   case 'A':
   System.out.println("Grade A");
   break;
   case 'B':
   System.out.println("Grade B");
   break;
   default:
   System.out.println("Other Grade");
  }

• Loops:
  • for, while, and do-while loops for iteration.

  for (int i = 0; i < 5; i++) {
   System.out.println(i);
  }
  int j = 0;
  while (j < 5) {
   System.out.println(j);
   j++;
  }
  int k = 0;
  do {
   System.out.println(k);
   k++;
  } while (k < 5);

Functions (Methods)

• Defining Methods:
  • Methods are defined using the return type, method name, and parameters.

  public static int add(int a, int b) {
   return a + b;
  }
  public static void main(String[] args) {
   int sum = add(5, 3);
   System.out.println("Sum: " + sum);
  }

• Void Methods:
  • Methods that do not return a value.

  public static void greet() {
   System.out.println("Hello, World!");
  }
  public static void main(String[] args) {
   greet();
  }

Object-Oriented Programming

• Classes and Objects:
  • Classes define the blueprint for objects.
  • Objects are instances of classes.

  class Dog {
   String name;
   int age;
   Dog(String name, int age) {
   this.name = name;
   this.age = age;
   }
   void bark() {
   System.out.println(name + " says woof!");
   }
  }
  public class Main {
   public static void main(String[] args) {
   Dog myDog = new Dog("Buddy", 3);
   myDog.bark();
   }
  }

• Inheritance:
  • Allows a class to inherit attributes and methods from another class.

  class Animal {
   String name;
   void speak() {
   System.out.println("Animal speaks");
   }
  }
  class Dog extends Animal {
   void speak() {
   System.out.println(name + " says woof!");
   }
  }
  public class Main {
   public static void main(String[] args) {
   Dog myDog = new Dog();
   myDog.name = "Buddy";
   myDog.speak();
   }
  }

• Polymorphism:
  • Allows methods to do different things based on the object it is acting upon.

  class Animal {
   void speak() {
   System.out.println("Animal speaks");
   }
  }
  class Dog extends Animal {
   void speak() {
   System.out.println("Dog barks");
   }
  }
  class Cat extends Animal {
   void speak() {
   System.out.println("Cat meows");
   }
  }
  public class Main {
   public static void main(String[] args) {
   Animal myDog = new Dog();
   Animal myCat = new Cat();
   myDog.speak(); // Output: Dog barks
   myCat.speak(); // Output: Cat meows
   }
  }

Interfaces and Abstract Classes

• Interfaces:
  • Define a contract that implementing classes must fulfill.

  interface Animal {
   void speak();
  }
  class Dog implements Animal {
   public void speak() {
   System.out.println("Dog barks");
   }
  }
  class Cat implements Animal {
   public void speak() {
   System.out.println("Cat meows");
   }
  }
  public class Main {
   public static void main(String[] args) {
   Animal myDog = new Dog();
   Animal myCat = new Cat();
   myDog.speak(); // Output: Dog barks
   myCat.speak(); // Output: Cat meows
   }
  }

• Abstract Classes:
  • Cannot be instantiated and may contain abstract methods that must be implemented by subclasses.

  abstract class Animal {
   abstract void speak();
  }
  class Dog extends Animal {
   void speak() {
   System.out.println("Dog barks");
   }
  }
  class Cat extends Animal {
   void speak() {
   System.out.println("Cat meows");
   }
  }
  public class Main {
   public static void main(String[] args) {
   Animal myDog = new Dog();
   Animal myCat = new Cat();
   myDog.speak(); // Output: Dog barks
   myCat.speak(); // Output: Cat meows
   }
  }

Exception Handling

• Try-Catch Blocks:
  • Used to handle exceptions and prevent program crashes.

  try {
   int result = 10 / 0;
  } catch (ArithmeticException e) {
   System.out.println("Cannot divide by zero!");
  }

• Finally Block:
  • Code in the finally block always executes, regardless of whether an exception occurred.

  try {
   int result = 10 / 0;
  } catch (ArithmeticException e) {
   System.out.println("Cannot divide by zero!");
  } finally {
   System.out.println("This will always be printed");
  }

Collections Framework

• Lists:
  • Ordered collections that can contain duplicate elements.

  import java.util.ArrayList;
  import java.util.List;
  public class Main {
   public static void main(String[] args) {
   List fruits = new ArrayList<>();
   fruits.add("Apple");
   fruits.add("Banana");
   fruits.add("Cherry");
   System.out.println(fruits.get(0)); // Output: Apple
   }
  }

• Sets:
  • Unordered collections that do not allow duplicate elements.

  import java.util.HashSet;
  import java.util.Set;
  public class Main {
   public static void main(String[] args) {
   Set uniqueNumbers = new HashSet<>();
   uniqueNumbers.add("One");
   uniqueNumbers.add("Two");
   uniqueNumbers.add("Two"); // Duplicate entry
   System.out.println(uniqueNumbers); // Output: [One, Two]
   }
  }

• Maps:
  • Collections of key-value pairs.

  import java.util.HashMap;
  import java.util.Map;
  public class Main {
   public static void main(String[] args) {
   Map ages = new HashMap<>();
   ages.put("Alice", 30);
   ages.put("Bob", 25);
   System.out.println(ages.get("Alice")); // Output: 30
   }
  }

File I/O

• Reading from a File:

  import java.io.BufferedReader;
  import java.io.FileReader;
  import java.io.IOException;
  public class Main {
   public static void main(String[] args) {
   try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
   String line;
   while ((line = reader.readLine()) != null) {
   System.out.println(line);
   }
   } catch (IOException e) {
   e.printStackTrace();
   }
   }
  }

• Writing to a File:

  import java.io.BufferedWriter;
  import java.io.FileWriter;
  import java.io.IOException;
  public class Main {
   public static void main(String[] args) {
   try (BufferedWriter writer = new BufferedWriter(new FileWriter("example.txt"))) {
   writer.write("Hello, World!");
   } catch (IOException e) {
   e.printStackTrace();
   }
   }
  }

Standard Libraries and Tools

• java.lang:
  • Provides fundamental classes that are automatically imported, such as String, Math, and System.
• java.util:
  • Contains collections framework, legacy collection classes, event model, date and time facilities, and more.
• java.io:
  • Provides classes for system input and output through data streams, serialization, and the file system.
• java.net:
  • Provides classes for implementing networking applications.

Summary

Java is a versatile and widely-used programming language that supports object-oriented programming. Understanding its basic syntax, control structures, functions (methods), object-oriented principles, collections framework, file I/O, and standard libraries is essential for developing robust and efficient applications. Java's platform independence and extensive standard libraries make it a popular choice for building a wide range of applications.