Easy Notes Of Java programming unit-1 @Computer Diploma

Description

Java Features and the Java Programming Environment

Java is a high-level, class-based, object-oriented programming language. Its key features include:

• Platform Independence: Java code is compiled into an intermediate form called bytecode, which can run on any machine with a Java Virtual Machine (JVM). This is often summarized by the phrase “Write once, run anywhere.”
• Object-Oriented: Everything in Java is an object, promoting modularity and code reuse through concepts like encapsulation, inheritance, and polymorphism.
• Simple: Java’s syntax is similar to C++, but it removes complex features like explicit pointers and operator overloading.
• Robust: It’s designed for reliability, with strong memory management (garbage collection) and error handling.
• Secure: Java includes security features like a sandbox environment to prevent untrusted code from accessing system resources.

The Java Development Kit (JDK) is the primary programming environment for Java. It includes the JVM (which executes the bytecode), the Java Runtime Environment (JRE) (which contains the JVM and core libraries), and development tools like the compiler (javac).

Defining a Class, Creating Objects, and Accessing Class Members

A class is a blueprint for creating objects. It defines the properties (fields or variables) and behaviors (methods) that an object will have.

// Class definition
class Car {
    // Fields (properties)
    String color;
    int speed;

    // Method (behavior)
    void accelerate() {
        speed += 10;
        System.out.println("Accelerating! Current speed: " + speed);
    }
}

An object is an instance of a class. You create an object using the new keyword.

// Creating an object
Car myCar = new Car();

You access an object’s members (fields and methods) using the dot (.) operator.

// Accessing class members
myCar.color = "blue";
myCar.speed = 0;
myCar.accelerate(); // Calls the accelerate method

Java Tokens and Data Types

Tokens are the smallest units of a program that are meaningful to the compiler. They include:

• Keywords: Reserved words with predefined meanings (e.g., class, public, int).
• Identifiers: Names given to variables, classes, methods, etc. (e.g., myCar, speed).
• Literals: Constant values (e.g., 10, "Hello", true).
• Operators: Symbols that perform operations (e.g., +, -, *, /).
• Separators: Symbols that structure code (e.g., {, }, ;, (, )).

Data types specify the size and type of values a variable can hold. Java has two main categories:

1. Primitive Data Types:
   • Integer: byte, short, int, long
   • Floating-Point: float, double
   • Character: char
   • Boolean: boolean
2. Non-Primitive Data Types: Also called reference types, these refer to objects (e.g., String, Array, Class, Interface).

A symbolic constant is a variable whose value cannot be changed after initialization. It’s declared using the final keyword. final double PI = 3.14159;

The scope of a variable determines where it can be accessed.

• Class/Static Scope: Accessible throughout the class.
• Instance Scope: Accessible within an object.
• Local Scope: Accessible only within the method, block, or loop where it’s declared.

Typecasting is the process of converting one data type to another.

• Widening (Implicit): Automatically converts a smaller type to a larger type. int myInt = 9; double myDouble = myInt;
• Narrowing (Explicit): Requires a cast operator to convert a larger type to a smaller type, as it may result in data loss. double myDouble = 9.78; int myInt = (int) myDouble; // myInt becomes 9

Operators and Expressions Operators perform actions on variables and values.

• Arithmetic: +, -, *, /, %
• Relational: ==, !=, >, <, >=, <=
• Logical: && (AND), || (OR), ! (NOT)
• Assignment: =, +=, -=, *=
• Increment/Decrement: ++, --

Decision Making and Looping Statements

• Decision Making: if, else, if-else if-else, switch statements execute code based on a condition.
• Looping: for, while, do-while, and the enhanced for loop repeat a block of code.

Arrays, Strings, Vectors, and Wrapper Classes

• Arrays: A collection of a fixed number of elements of the same data type. int[] numbers = new int[5]; String[] names = {"Alice", "Bob"};
• Strings: An immutable sequence of characters. You can’t change a String object after it’s created.
• StringBuffer: A mutable (changeable) sequence of characters, used when you need to perform many modifications to a string.
• Vectors: A dynamic array that can grow or shrink. It’s synchronized, meaning it’s thread-safe. ArrayList is a modern, unsynchronized alternative.
• Wrapper Classes: Provide a way to use primitive data types as objects. For each primitive type, there’s a corresponding wrapper class (e.g., int -> Integer, char -> Character). This is essential for using primitives in collections like ArrayList and Vector.

Constructors and Methods

• Methods: Blocks of code that perform a specific task.
• Constructors: Special methods used to initialize objects. They have the same name as the class and do not have a return type.
  • Default Constructor: A constructor with no parameters, automatically provided by the compiler if you don’t define any.
  • Parameterized Constructor: A constructor that accepts one or more parameters.

Method and Constructor Overloading This allows you to have multiple methods or constructors with the same name but different parameters (different number, type, or order of parameters).

Nesting of Methods One method can call another method within the same class.

Command Line Arguments These are arguments passed to a Java program when it’s executed from the command line. They are stored in the String[] args array of the main method.

Garbage Collection An automatic memory management process in Java. The garbage collector automatically reclaims memory from objects that are no longer in use, freeing programmers from manual memory deallocation.

Visibility Control (Access Modifiers) These keywords determine the accessibility of classes, methods, and variables.

• public: Accessible from anywhere.
• protected: Accessible within the same package and by subclasses (even in different packages).
• default (no keyword): Accessible only within the same package.
• private: Accessible only within the class it’s defined in.