In Java, access modifiers are used to specify the visibility of classes, methods, and variables. By using access modifiers, you can control how these members are accessed by other classes and methods. This is an important feature of object-oriented programming because it allows you to encapsulate and protect your code from external interference. In this tutorial, we will discuss the four access modifiers in Java: default, private, public, and protected. We will explain how they work and when to use them, as well as how they affect inheritance in Java. By the end of this tutorial, you will have a solid understanding of access modifiers and how to use them to write better code in Java.
Default access modifier
In Java, if no access modifier is specified for a class, method, or variable, it is assigned the default access modifier. The default access modifier is also known as the package-private access modifier, because it restricts access to members within the same package.
Here are some key points to keep in mind when using the default access modifier:
- Members with default access can be accessed by any other class or interface within the same package.
- Members with default access cannot be accessed by classes or interfaces in other packages, even if they are subclasses of the defining class.
- The default access modifier is often used for classes or methods that are not intended to be used outside of the package. This helps to encapsulate implementation details and prevent unintended dependencies.
Here is an example of a class with default access:
package com.example;
class MyClass {
int x;
void myMethod() {
// implementation details
}
}
In this example, the MyClass class has default access, because no access modifier is specified. This means that it can be accessed by other classes within the com.example package, but not by classes outside of that package.
To summarize, the default access modifier is a useful tool for controlling access to members within a package, and can help to maintain encapsulation and reduce dependencies. However, it is important to be aware of its limitations and use more restrictive access modifiers when necessary.
Private access modifier
The private access modifier is the most restrictive access modifier in Java. When a method or variable is declared as private, it can only be accessed within the class in which it is defined. Other classes, even subclasses, cannot access private members of a class.
Here is an example of a class with a private member variable and a public method that can access and modify that variable:
public class Person {
private String name;
public Person(String name) {
this.name = name;
}
public void printName() {
System.out.println("Name: " + name);
}
public void setName(String name) {
this.name = name;
}
}
In this example, the name variable is declared as private, which means that it can only be accessed from within the Person class. However, the printName method is declared as public, which means that it can be called from any other class.
Here’s an example of how this class could be used in another class:
public class Main {
public static void main(String[] args) {
Person person = new Person("John");
person.printName(); // prints "Name: John"
person.setName("Jane");
person.printName(); // prints "Name: Jane"
//person.name = "Jim"; // error: name has private access in Person
}
}
As you can see, the Main class can create an instance of the Person class and call its public methods, but it cannot directly access the private name variable.
Using the private access modifier is a good way to encapsulate implementation details of a class and prevent other classes from accessing and modifying its internal state directly. This helps to ensure that the class behaves as intended and prevents bugs that could arise from external manipulation of its state.
Public access modifier
The public access modifier is the least restrictive of all the access modifiers in Java. When a class, method, or variable is declared as public, it can be accessed from anywhere in the program, including from other packages. This means that any class can create an instance of a public class or access its public members.
Here’s an example of a public class in Java:
public class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void sayHello() {
System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
}
}
In this example, the Person class is declared as public, which means it can be accessed from anywhere in the program. The name and age variables are also declared as public, which means they can be accessed and modified from anywhere in the program. The sayHello() method is also declared as public, which means it can be called from anywhere in the program.
Here’s an example of how to create an instance of the Person class and call its sayHello() method:
Person person = new Person("John", 30);
person.sayHello();
When this code is executed, it will create a new Person object with the name “John” and age 30, and then call the sayHello() method, which will print “Hello, my name is John and I am 30 years old.” to the console.
While the public access modifier can be useful for creating classes, methods, and variables that can be accessed from anywhere in the program, it can also lead to certain security and maintainability issues. For example, if a variable is declared as public, it can be accessed and modified by any other class in the program, which can make it difficult to track down bugs or maintain the code over time. It’s generally recommended to use the public access modifier only for those members that truly need to be accessed from outside the class, and to use more restrictive access modifiers (such as protected or private) for members that should be kept internal to the class.
Protected access modifier
The protected access modifier allows access to members within the same package or subclass, but not from unrelated classes outside the package or subclass. Protected members are similar to package-private members in that they are not accessible outside the package, but they can be inherited by subclasses.
To declare a member as protected, use the protected keyword before the member declaration. For example:
package mypackage;
public class MyClass {
protected int myProtectedInt;
protected void myProtectedMethod() {
// do something
}
}
In this example, the myProtectedInt variable and myProtectedMethod() method are declared as protected. They can be accessed from within the same package or any subclass, but not from outside the package.
package mypackage;
public class MySubclass extends MyClass {
public void myMethod() {
myProtectedInt = 10; // can access protected variable from superclass
myProtectedMethod(); // can access protected method from superclass
}
}
In this example, the MySubclass class extends the MyClass class and inherits the protected members from the superclass. The myMethod() method can access the protected variable and method from the superclass because it is a subclass.
It is important to note that protected members can be accessed by any subclass, even if the subclass is in a different package. However, protected members cannot be accessed from an unrelated class outside the package, even if it extends the class that declares the protected member.
Protected members should be used when you want to make members available to subclasses, but not to unrelated classes. They are commonly used when implementing class hierarchies and when you want to provide access to internal state or behavior within the class hierarchy.
Static Access Modifier
The static keyword is used to create class-level variables and methods that can be accessed without the need for an instance of the class. When a variable or method is declared as static, it is associated with the class itself rather than with instances of the class.
Here’s an example of how to declare a static variable in Java:
public class MyClass {
public static int count = 0;
// ...
}
In this example, the count variable is declared as public and static, which means that it can be accessed directly from the class MyClass without the need for an instance of MyClass.
Similarly, you can declare a static method as follows:
public class MyClass {
public static void doSomething() {
// ...
}
// ...
}
In this example, the doSomething method is declared as public and static, which means that it can be called directly from the class MyClass without the need for an instance of MyClass.
Note that the static keyword can also be used to create static blocks, which are executed when the class is loaded. However, the details of static blocks are beyond the scope of this tutorial.
If you’re interested in learning more about the static keyword, check out our tutorial on “The static Keyword in Java“.
Access Modifiers with Nested Classes
In Java, it is possible to define a class inside another class, known as a nested class. Access modifiers apply to nested classes just like they apply to regular classes, but there are some additional rules to keep in mind.
Private Nested Classes
A private nested class is only accessible within the enclosing class. This means that it cannot be accessed from outside the enclosing class, including from subclasses.
public class OuterClass {
private class PrivateInnerClass {
// Private nested class
}
}
Protected Nested Classes
A protected nested class is accessible within the enclosing class and its subclasses, as well as from other classes in the same package.
public class OuterClass {
protected class ProtectedInnerClass {
// Protected nested class
}
}
Public Nested Classes
A public nested class is accessible from any class, including from classes in different packages.
public class OuterClass {
public class PublicInnerClass {
// Public nested class
}
}
Default (Package-Private) Nested Classes
A default (package-private) nested class is accessible within the enclosing class and other classes in the same package. It cannot be accessed from outside the package, including from subclasses in other packages.
public class OuterClass {
class DefaultInnerClass {
// Default (package-private) nested class
}
}
Summary
When declaring a nested class in Java, you can use the same access modifiers as you would for a regular class. However, the visibility of a nested class also depends on its enclosing class and the package it is in. It is important to choose the appropriate access modifier for your nested class to ensure that it is only accessible where it is intended to be used.
Access Modifiers with Inheritance
In Java, access modifiers also affect the way that inheritance works. When a subclass extends a superclass, it inherits all of the public and protected members of the superclass. However, private members of the superclass are not inherited and cannot be accessed directly by the subclass.
Protected Access Modifier
The protected access modifier allows members of a class to be accessed by subclasses, as well as other classes in the same package. When a subclass inherits a protected member from its superclass, the member becomes a member of the subclass.
Here’s an example that demonstrates how protected members can be inherited in Java:
public class Animal {
protected int numLegs;
public Animal(int numLegs) {
this.numLegs = numLegs;
}
}
public class Dog extends Animal {
public Dog(int numLegs) {
super(numLegs);
}
public void bark() {
System.out.println("Woof!");
}
public void printNumLegs() {
System.out.println("This dog has " + numLegs + " legs.");
}
}
In this example, the Animal class has a protected member numLegs, which is inherited by the Dog class. The Dog class can access the numLegs member directly, and can also use it in its own methods.
Private Access Modifier
Private members of a class cannot be accessed by subclasses, even if the subclasses are in the same package. This means that if a superclass has a private member, the member is not visible to any of its subclasses.
Here’s an example that demonstrates how private members are not inherited in Java:
public class Animal {
private String species;
public Animal(String species) {
this.species = species;
}
public String getSpecies() {
return species;
}
}
public class Dog extends Animal {
public Dog(String species) {
super(species);
}
public void bark() {
System.out.println("Woof!");
}
public void printSpecies() {
// This will not compile, since species is a private member of Animal
System.out.println("This dog is a " + species);
}
}
In this example, the Animal class has a private member species, which is not visible to the Dog class. When the Dog class tries to access the species member using the printSpecies method, a compile error occurs.
Final Access Modifier
The final access modifier can be used to prevent a class or method from being overridden by a subclass. When a class or method is declared as final, it cannot be modified or extended by any subclass.
Here’s an example that demonstrates how the final access modifier can be used in Java:
public final class Animal {
private String species;
public Animal(String species) {
this.species = species;
}
public final String getSpecies() {
return species;
}
}
public class Dog extends Animal {
// This will not compile, since Animal is declared as final
}
In this example, the Animal class is declared as final, which means that it cannot be extended by any subclass. When the Dog class tries to extend the Animal class, a compile error occurs.
Inheritance is an important concept in object-oriented programming, and access modifiers play an important role in determining how inheritance works in Java. By understanding how access modifiers affect inheritance, you can create more robust and maintainable Java code.
Conclusion
In Java, access modifiers are keywords that determine the accessibility of classes, methods, and variables. By controlling the access to these members, access modifiers provide an important mechanism for encapsulation and information hiding in object-oriented programming. In this tutorial, we have covered the four access modifiers in Java: default, private, public, and protected. We have also seen how these access modifiers affect inheritance in Java. By understanding these concepts, you can write better code that is more secure and easier to maintain.
Frequently asked questions
- Can a private method be overridden in Java?
No, a private method cannot be overridden in Java. This is because a private method is not visible outside of its class and therefore cannot be accessed by any subclass, including the one that is trying to override it. In other words, private methods are not inherited by subclasses and are not part of the contract of the class, so they cannot be overridden. - Can you use access modifiers in interfaces in Java?
Yes, you can use access modifiers in interfaces in Java. The access modifiers that can be used in interfaces are public and default. All interface methods are by default public and abstract, and all interface variables are public, static, and final. However, if you want to limit the accessibility of an interface method or variable, you can use the default access modifier. By using the default access modifier, the method or variable can only be accessed by classes in the same package as the interface. If you use the public access modifier, the method or variable can be accessed by any class in any package. - Can a public method be overloaded in Java?
Yes, a public method can be overloaded in Java. Method overloading in Java is a technique that allows a class to have multiple methods with the same name but different parameters. When you call an overloaded method, Java chooses the appropriate method based on the number and type of arguments you provide. Access modifiers such as public, private, and protected do not affect whether a method can be overloaded or not. - Why is it important to use access modifiers in Java?
Using access modifiers in Java is important for several reasons. Firstly, it helps you to encapsulate your code and hide implementation details from other classes and methods, which can improve the security and maintainability of your code. Additionally, it allows you to control how other classes and methods can access and interact with your code, which can prevent unintended side effects and improve the overall structure of your program. By using access modifiers effectively, you can ensure that your code is well-organized, easy to understand, and less prone to errors and bugs.