Unit 2: Classes, arrays and inheritance

javaclass Student {
    private int roll;              // instance variables (fields)
    private String name;
    private double marks;

    void setData(int r, String n, double m) { roll = r; name = n; marks = m; }
    String grade() { return marks >= 75 ? "A" : marks >= 60 ? "B" : "C"; }
    void show() { System.out.println(roll + " " + name + " " + grade()); }
}

• Access modifiers: private (class only), default (package), protected (package and subclasses), public (everywhere).

javaStudent s1 = new Student();        // new allocates memory on the heap; s1 holds a reference
s1.setData(101, "Aman", 82);
s1.show();
Student s2 = s1;                   // both refer to the same object

• Java is always pass-by-value: primitives copy the value; for objects the reference is copied, so the method can change the object's fields but not make the caller's variable point elsewhere.

javaclass Rectangle {
    int length, width;
    Rectangle() { this(1, 1); }                          // default constructor calls another
    Rectangle(int l, int w) { length = l; width = w; }   // parameterised
    Rectangle(Rectangle r) { this(r.length, r.width); }  // copy-style constructor
    int area() { return length * width; }
}

• A constructor has the class name and no return type, runs automatically on new, and initialises the object. If none is written, Java supplies a default constructor. this refers to the current object.

javaclass Calc {
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; }
    int add(int a, int b, int c) { return a + b + c; }
}

• Same method name, different parameter lists (number, type or order); resolved at compile time — compile-time polymorphism.

javaclass Counter {
    static int count = 0;          // one copy shared by all objects
    Counter() { count++; }
    static int getCount() { return count; }   // called as Counter.getCount()
    static { System.out.println("Static block runs once when the class loads"); }
}

• Static methods can access only static data directly and cannot use this. Math.sqrt() and Integer.parseInt() are static methods.

• Objects with no live references become eligible for garbage collection; the JVM reclaims memory automatically. System.gc() only requests it. Generational collectors (G1) separate young and old objects.

javaint[] a = new int[5];                       // one-dimensional
int[] b = {4, 9, 1, 7};
java.util.Arrays.sort(b);
System.out.println(b.length);               // 4

int[][] m = {{1, 2, 3}, {4, 5, 6}};         // two-dimensional
int[][] jag = new int[3][];                 // jagged: rows of different lengths
jag[0] = new int[1]; jag[1] = new int[2]; jag[2] = new int[3];
for (int[] row : jag) System.out.println(row.length);

javaString s = "Synetic";
s.length(); s.charAt(0); s.toUpperCase(); s.substring(0, 3);   // "Syn"
s.indexOf("t"); s.equals("synetic"); s.equalsIgnoreCase("SYNETIC");
s.replace('S', 's'); s.contains("net"); s.compareTo("Apple");
String t = s.concat(" School");            // Strings are immutable

StringBuilder sb = new StringBuilder("SBS");  // mutable
sb.append(" Ludhiana").reverse();

import java.util.Vector;
Vector<Integer> v = new Vector<>();         // growable, synchronised array
v.add(10); v.add(20); v.add(1, 15);         // [10, 15, 20]
v.remove(Integer.valueOf(20));
System.out.println(v.size() + " " + v.get(0));

• String vs StringBuffer/StringBuilder: String is immutable; StringBuffer is mutable and thread-safe; StringBuilder is mutable and faster. Vector vs ArrayList: Vector is synchronised (legacy); ArrayList is usually preferred.

javaclass Person {
    protected String name;
    Person(String n) { name = n; }
    void display() { System.out.println("Name: " + name); }
}
class Employee extends Person {
    double salary;
    Employee(String n, double s) { super(n); salary = s; }   // call parent constructor
    @Override
    void display() {                                         // method overriding
        super.display();
        System.out.println("Salary: " + salary);
    }
}
Person p = new Employee("Riya", 50000);
p.display();          // dynamic method dispatch: Employee's version runs

• Overriding: same signature in the subclass; decided at run time — run-time polymorphism.

javaabstract class Shape { abstract double area(); }
class Circle extends Shape {
    double r; Circle(double r) { this.r = r; }
    double area() { return Math.PI * r * r; }
}
Shape s = new Circle(2);   // runtime polymorphism
System.out.println(s.area());

javainterface Printable { void print(); }
interface Showable  { default void show() { System.out.println("Showing"); } }

class Report implements Printable, Showable {      // multiple inheritance of type
    public void print() { System.out.println("Printing report"); }
}

java// File: mypack/Fees.java
package mypack;
public class Fees {
    public double total(double tuition, double hostel) { return tuition + hostel; }
}

// File: Main.java
import mypack.Fees;            // or import mypack.*;
public class Main {
    public static void main(String[] a) { System.out.println(new Fees().total(42000, 60000)); }
}

• Compile with javac -d . Fees.java to create the mypack folder. Built-in packages: java.lang (auto-imported), java.util, java.io, java.awt, java.net, java.sql.