B3.1.3 Distinguishing Between Static and Non-Static Variables and Methods Notes

Understanding Static Variables and Methods

1. Static variables and methods belong to the class itself, not to any specific instance.
2. They are shared across all instances of the class.

Characteristics of Static Variables

1. Shared Across Instances: Only one copy exists, shared by all instances.
2. Class-Level Access: Accessed using the class name, not an instance.
3. Memory Efficiency: Stored in a fixed location, reducing memory usage.

Characteristics of Static Methods

1. No Instance Required: Can be called without creating an object.
2. Access to Static Members: Can only directly access static variables and other static methods.
3. Utility Functions: Often used for operations that don't depend on instance data.

Understanding Non-Static Variables and Methods

Non-static variables and methods are associated with specific instances of a class.

Characteristics of Non-Static Variables

1. Instance-Specific: Each object has its own copy.
2. Unique State: Used to store data unique to each instance.
3. Accessed via Instances: Accessed through the object that owns them.

Characteristics of Non-Static Methods

1. Instance Required: Must be called on an object.
2. Access to Instance Data: Can access both static and non-static variables.
3. Behavior Definition: Define the actions an object can perform.

Key Differences Between Static and Non-Static

1. Ownership:
   1. Static: Belongs to the class.
   2. Non-Static: Belongs to the instance.
2. Access:
   1. Static: Accessed via the class name.
   2. Non-Static: Accessed via an instance.
3. Memory:
   1. Static: Single copy shared by all instances.
   2. Non-Static: Separate copy for each instance.
4. Use Cases:
   1. Static: Shared data or utility functions.
   2. Non-Static: Instance-specific data and behavior.

When to Use Static vs. Non-Static

Use Static Variables and Methods When:

1. Shared Data: When data or behavior is common to all instances.
2. Utility Functions: For operations that don't depend on instance data.
3. Constants: To define constants that are the same for all instances.

Use Non-Static Variables and Methods When:

1. Instance-Specific Data: When each object needs its own copy of data.
2. Object Behavior: To define actions that depend on the object's state.

class Book:
    # Static/class variable (shared by all instances)
    total_books = 0

    def __init__(self, title, author):
        # Non-static (instance) variables
        self.title = title
        self.author = author
        Book.total_books += 1   # Increment shared static variable

    # Non-static (instance) method
    def get_details(self):
        return f"Title: {self.title}, Author: {self.author}"

    # Static method (can be called on class or object)
    @staticmethod
    def get_total_books():
        return Book.total_books

b1 = Book("1984", "George Orwell")
b2 = Book("Brave New World", "Aldous Huxley")

print(b1.get_details())                 # Non-static call
print("Total books:", Book.get_total_books())  # Static call

public class Book {
    // Non-static fields (unique per object)
    private String title;
    private String author;

    // Static field (shared across all Book objects)
    private static int totalBooks = 0;

    // Constructor
    public Book(String title, String author) {
        this.title = title;
        this.author = author;
        totalBooks++; // increments shared count
    }

    // Non-static method
    public String getDetails() {
        return "Title: " + title + ", Author: " + author;
    }

    // Static method
    public static int getTotalBooks() {
        return totalBooks;
    }
}

public class Main {
    public static void main(String[] args) {
        Book b1 = new Book("1984", "George Orwell");
        Book b2 = new Book("Brave New World", "Aldous Huxley");

        System.out.println(b1.getDetails());                 // Non-static call
        System.out.println("Total books: " + Book.getTotalBooks()); // Static call
    }
}

Analyzing the Code

1. Static Variable: booksBorrowed/books_borrowed
   1. Purpose: Tracks the total number of books borrowed.
   2. Access: Updated by the borrowBook method and accessed by the getBooksBorrowed/get_books_borrowed static method.
2. Non-Static Variables: title and author
   1. Purpose: Store data unique to each book.
   2. Access: Managed through instance methods and the constructor.

Practical Considerations

1. Performance: Static variables can improve performance by reducing memory usage, but excessive use can lead to unintended side effects if not managed carefully.
2. Design: Use static methods for utility functions that do not require instance data, such as mathematical calculations or data validation.
3. Encapsulation: Static variables should be accessed through static methods to maintain encapsulation and control over how they are modified.