How to declare public class in Java

Introduction

Understanding how to declare public classes is a fundamental skill in Java programming. This tutorial provides comprehensive guidance on creating public classes, explaining their syntax, purpose, and practical implementation in object-oriented development. Whether you're a beginner or an intermediate programmer, mastering public class declarations will enhance your Java programming capabilities.

Public Class Basics

What is a Public Class?

In Java, a public class is a fundamental building block of object-oriented programming. It is a class that can be accessed from any other class, regardless of the package it belongs to. The public keyword allows for maximum visibility and accessibility of the class.

Key Characteristics

A public class in Java has several important characteristics:

Basic Syntax

graph LR
    A[public] --> B[class]
    B --> C[ClassName]
    C --> D[{ Class Body }]

Here's a simple example of a public class declaration:

public class MyFirstClass {
    // Class members and methods go here
}

Important Rules

1. Only one public class is allowed per source file
2. The file name must exactly match the public class name
3. The public class is visible to all other classes

Example in Ubuntu Environment

Let's create a simple public class in Ubuntu:

## Create a new Java file
nano MyPublicClass.java

public class MyPublicClass {
    // Public method accessible from other classes
    public void displayMessage() {
        System.out.println("Welcome to LabEx Java Programming!");
    }

    // Main method for demonstration
    public static void main(String[] args) {
        MyPublicClass obj = new MyPublicClass();
        obj.displayMessage();
    }
}

When to Use Public Classes

Public classes are typically used when:

• Creating reusable components
• Designing library or framework classes
• Implementing core application logic
• Sharing classes across different packages

By understanding public classes, you'll have a solid foundation for Java programming and object-oriented design.

Syntax and Declaration

Basic Syntax Structure

The syntax for declaring a public class in Java follows a specific pattern:

graph LR
    A[Access Modifier] --> B[class]
    B --> C[Class Name]
    C --> D[{ Class Body }]

Detailed Declaration Syntax

public class ClassName {
    // Class members
    // Constructors
    // Methods
}

Declaration Rules and Components

Complete Example in Ubuntu

Let's demonstrate a comprehensive public class declaration:

## Create Java file in Ubuntu
nano PersonClass.java

public class PersonClass {
    // Instance variables
    private String name;
    private int age;

    // Constructor
    public PersonClass(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Public method
    public void displayInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }

    // Main method for execution
    public static void main(String[] args) {
        PersonClass person = new PersonClass("LabEx Student", 25);
        person.displayInfo();
    }
}

Advanced Declaration Patterns

Nested Public Classes

public class OuterClass {
    public class InnerPublicClass {
        // Nested public class implementation
    }
}

Abstract Public Classes

public abstract class AbstractPersonClass {
    // Abstract method
    public abstract void performAction();
}

Compilation and Execution

## Compile the Java file
javac PersonClass.java

## Run the compiled class
java PersonClass

Best Practices

1. Use meaningful and descriptive class names
2. Follow CamelCase naming convention
3. Keep classes focused and modular
4. Use appropriate access modifiers
5. Document class purpose and functionality

By mastering these syntax and declaration techniques, you'll write more structured and professional Java code in your LabEx programming journey.

Practical Usage Examples

Real-World Public Class Scenarios

1. User Management System

public class User {
    private String username;
    private String email;

    public User(String username, String email) {
        this.username = username;
        this.email = email;
    }

    public void registerUser() {
        System.out.println("User " + username + " registered successfully!");
    }
}

2. Banking Application

public class BankAccount {
    private double balance;
    private String accountNumber;

    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }

    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("Deposit successful. New balance: $" + balance);
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("Withdrawal successful. Remaining balance: $" + balance);
        }
    }
}

Class Interaction Example

graph TD
    A[User Class] -->|Creates| B[BankAccount Class]
    B -->|Manages| C[Deposit Method]
    B -->|Manages| D[Withdraw Method]

Practical Usage Patterns

Complex Example: Library Management System

public class Book {
    private String title;
    private String author;
    private boolean isAvailable;

    public Book(String title, String author) {
        this.title = title;
        this.author = author;
        this.isAvailable = true;
    }

    public void borrowBook() {
        if (isAvailable) {
            isAvailable = false;
            System.out.println("Book '" + title + "' has been borrowed.");
        } else {
            System.out.println("Book is currently unavailable.");
        }
    }

    public void returnBook() {
        isAvailable = true;
        System.out.println("Book '" + title + "' has been returned.");
    }
}

Ubuntu Demonstration

## Create Java file
nano BookManagement.java

## Compile the Java file
javac BookManagement.java

## Run the application
java BookManagement

Advanced Usage Techniques

1. Implement interfaces
2. Use inheritance
3. Create utility classes
4. Design singleton patterns
5. Develop modular applications

LabEx Learning Approach

By exploring these practical examples, LabEx students can:

• Understand real-world class implementations
• Learn object-oriented programming concepts
• Develop problem-solving skills
• Create complex software solutions

Best Practices

• Keep classes focused on single responsibilities
• Use meaningful method and variable names
• Implement proper encapsulation
• Handle potential exceptions
• Write clean, readable code

Summary

Declaring public classes in Java is a critical aspect of object-oriented programming. By following proper syntax and understanding access modifiers, developers can create well-structured, modular code that promotes encapsulation and code organization. This tutorial has equipped you with essential knowledge to effectively declare and utilize public classes in your Java projects.