static assignment java method

Static Variables in Java – Why and How to Use Static Methods

Static variables and static methods are two important concepts in Java.

Whenever a variable is declared as static, this means there is only one copy of it for the entire class, rather than each instance having its own copy. A static method means it can be called without creating an instance of the class.

Static variables and methods in Java provide several advantages, including memory efficiency, global access, object independence, performance, and code organization.

In this article, you will learn how static variables work in Java, as well as why and how to use static methods.

The Static Keyword in Java

The static keyword is one of the most essential features in the Java programming language. We use it to define class-level variables and methods.

Here is an example of how to use the static keyword:

As you can see above, we declared the count variable as a static variable, while we declared the printCount method as a static method.

When a variable is declared static in Java programming, it means that the variable belongs to the class itself rather than to any specific instance of the class. This means that there is only one copy of the variable in memory, regardless of how many instances of the class are created.

Here's an example. Say we have a Department class that has a static variable called numberOfWorker . We declare and increment the static variable at the constructor level to show the value of the static variable whenever the class object is created.

The results of the above code show that as we create new Department objects, the static variable numberOfWorker retains its value.

When we print out the value of numberOfWorker in the console, we can see that it retains its value across all instances of the Department class. This is because there is only one copy of the variable in memory, and any changes to the variable will be reflected across all instances of the class.

We can also use the static keyword to define static methods.

Static methods are methods that belong to the class rather than to any specific instance of the class. Static methods can be called directly on the class itself without needing to create an instance of the class first. See the code below:

In the above code, the Calculation class has two static methods. The declared static methods can be called directly on the Calculation class without creating an instance of the class first. That is to say, you do not need to create an object of the Calculation class before you access the static add and multiply classes.

The main() method in Java is an example of a static method. The main() method is a special static method that is the entry point for Java applications. The Math class in Java also provides many static methods that perform mathematical operations.

The above code shows that the entry point for Java applications is a static method. It also shows that the max() method is a static method of the Math class and does not require an instance of the Math class to be created.

As you can see, static methods can be useful in providing utility functions that do not necessitate the creation of a class object.

The static keyword is a powerful tool in Java that can help solve many programming challenges. It aids in memory consumption management, improves code consistency, and helps speed up applications.

To prevent unforeseen issues from cropping up in the code, it is crucial to use the static keyword wisely and be aware of its limitations.

Code that relies heavily on static variables and methods can be harder to test because it introduces dependencies between different parts of the program. Static variables and methods can introduce hidden dependencies between different parts of the program, making it harder to reason about how changes in one part of the code might affect other parts.

Code that relies heavily on static variables can also be less flexible and harder to extend over time. Static variables can also lead to concurrency issues if multiple threads access and modify the same variable at the same time.

Lastly, if a static variable is not properly released or disposed of when it is no longer needed, it can lead to memory leaks and other performance issues over time.

By using static variables and methods appropriately, you can create efficient and maintainable code that will be easier to work with over time.

Happy coding!

Technical Writer and Software Developer

If you read this far, thank the author to show them you care. Say Thanks

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started

Use Cases for Static Methods in Java

Last updated: January 8, 2024

Java applications have a notoriously slow startup and a long warmup time. The CRaC (Coordinated Restore at Checkpoint) project from OpenJDK can help improve these issues by creating a checkpoint with an application's peak performance and restoring an instance of the JVM to that point.

To take full advantage of this feature, BellSoft provides containers that are highly optimized for Java applications. These package Alpaquita Linux (a full-featured OS optimized for Java and cloud environment) and Liberica JDK (an open-source Java runtime based on OpenJDK).

These ready-to-use images allow us to easily integrate CRaC in a Spring Boot application:

Improve Java application performance with CRaC support

Modern software architecture is often broken. Slow delivery leads to missed opportunities, innovation is stalled due to architectural complexities, and engineering resources are exceedingly expensive.

Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.

With Orkes Conductor managed through Orkes Cloud, developers can focus on building mission critical applications without worrying about infrastructure maintenance to meet goals and, simply put, taking new products live faster and reducing total cost of ownership.

Try a 14-Day Free Trial of Orkes Conductor today.

Azure Container Apps is a fully managed serverless container service that enables you to build and deploy modern, cloud-native Java applications and microservices at scale. It offers a simplified developer experience while providing the flexibility and portability of containers.

Of course, Azure Container Apps has really solid support for our ecosystem, from a number of build options, managed Java components, native metrics, dynamic logger, and quite a bit more.

To learn more about Java features on Azure Container Apps, you can get started over on the documentation page .

And, you can also ask questions and leave feedback on the Azure Container Apps GitHub page .

Whether you're just starting out or have years of experience, Spring Boot is obviously a great choice for building a web application.

Jmix builds on this highly powerful and mature Boot stack, allowing devs to build and deliver full-stack web applications without having to code the frontend. Quite flexibly as well, from simple web GUI CRUD applications to complex enterprise solutions.

Concretely, The Jmix Platform includes a framework built on top of Spring Boot, JPA, and Vaadin , and comes with Jmix Studio, an IntelliJ IDEA plugin equipped with a suite of developer productivity tools.

The platform comes with interconnected out-of-the-box add-ons for report generation, BPM, maps, instant web app generation from a DB, and quite a bit more:

>> Become an efficient full-stack developer with Jmix

DbSchema is a super-flexible database designer, which can take you from designing the DB with your team all the way to safely deploying the schema .

The way it does all of that is by using a design model , a database-independent image of the schema, which can be shared in a team using GIT and compared or deployed on to any database.

And, of course, it can be heavily visual, allowing you to interact with the database using diagrams, visually compose queries, explore the data, generate random data, import data or build HTML5 database reports.

>> Take a look at DBSchema

Get non-trivial analysis (and trivial, too!) suggested right inside your IDE or Git platform so you can code smart, create more value, and stay confident when you push.

Get CodiumAI for free and become part of a community of over 280,000 developers who are already experiencing improved and quicker coding.

Write code that works the way you meant it to:

>> CodiumAI. Meaningful Code Tests for Busy Devs

The AI Assistant to boost Boost your productivity writing unit tests - Machinet AI .

AI is all the rage these days, but for very good reason. The highly practical coding companion, you'll get the power of AI-assisted coding and automated unit test generation . Machinet's Unit Test AI Agent utilizes your own project context to create meaningful unit tests that intelligently aligns with the behavior of the code. And, the AI Chat crafts code and fixes errors with ease, like a helpful sidekick.

Simplify Your Coding Journey with Machinet AI :

>> Install Machinet AI in your IntelliJ

Since its introduction in Java 8, the Stream API has become a staple of Java development. The basic operations like iterating, filtering, mapping sequences of elements are deceptively simple to use.

But these can also be overused and fall into some common pitfalls.

To get a better understanding on how Streams work and how to combine them with other language features, check out our guide to Java Streams:

Download the E-book

Do JSON right with Jackson

Get the most out of the Apache HTTP Client

Get Started with Apache Maven:

Working on getting your persistence layer right with Spring?

Explore the eBook

Building a REST API with Spring?

Get started with Spring and Spring Boot, through the Learn Spring course:

Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:

>> The New “REST With Spring Boot”

Get started with Spring and Spring Boot, through the reference Learn Spring course:

>> LEARN SPRING

Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.

I built the security material as two full courses - Core and OAuth , to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project .

You can explore the course here:

>> Learn Spring Security

Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot .

Get started with Spring Data JPA through the guided reference course:

>> CHECK OUT THE COURSE

1. Overview

Static methods are common to most object-oriented programming languages, including Java. What differentiates static from instance methods is that they have no object that owns them. Instead, static methods are defined on the class level and can be used without creating instances .

In this tutorial, we’ll look at the definition of static methods in Java, as well as their limitations. Then we’ll look at common use cases for using static methods and recommend when it makes sense to apply them in our code.

Finally, we’ll see how to test static methods and how to mock them.

2. Static Methods

Instance methods are resolved polymorphically based on the runtime type of the object. On the other hand, static methods are resolved at compile-time based on the class in which they are defined.

2.1. Class-level

A static method in Java is a part of the class definition. We can define a static method by adding the static  keyword to a method:

To access static methods, we use the class name followed by a dot and the name of the method :

We should note that this static method has access to the static state of the  StaticCounter class. Often static methods are stateless, but they can work with class-level data as part of various techniques, including the singleton pattern .

Although it’s also possible to reference static methods using objects, this antipattern is often flagged as an error by tools such as Sonar .

2.2. Limitations

As static methods don’t operate on instance members , there are a few limitations we should be aware of:

• A static method cannot reference instance member variables directly
• A static method cannot call an instance method directly
• Subclasses cannot override static methods
• We cannot use keywords this and super in a static method

Each of the above results in a compile-time error. We should also note that if we declare a static method with the same name in a subclass, it doesn’t override but instead hides the base class method .

3. Use Cases

Let’s now have a look at common use cases when it makes sense to apply static methods in our Java code.

3.1. Standard Behaviour

Using static methods makes sense when we are developing methods with standard behavior that operates on their input arguments.

The String operations from Apache StringUtils are a great example of this:

Another good example is the Collections class, as it contains common methods that operate on different collections:

3.2. Reuse Across Instances

A valid reason for using static methods is when we reuse standard behavior across instances of different classes .

For example, we commonly use Java Collections and Apache StringUtils in our domain and business classes:

As these functions don’t have a state of their own and are not bound to a particular part of our business logic, it makes sense to hold them in a module where they can be shared.

3.3. Not Changing State

Since static methods cannot reference instance member variables, they are a good choice for methods that don’t require any object state manipulation.

When we use static methods for operations where the state is not managed, then method calling is more practical. The caller can call the method directly without having to create instances.

When we share state by all instances of the class, like in the case of a static counter, then methods that operate on that state should be static. Managing a global state can be a source of errors, so Sonar will report a critical issue when instance methods write directly to static fields.

3.4. Pure Functions

A function is called pure if its return value depends only on the input parameters passed . Pure functions get all the data from their parameters and compute something from that data.

Pure functions do not operate on any instance or static variables. Therefore, executing a pure function should also have no side effects.

As static methods do not allow overriding and referencing instance variables, they are a great choice for implementing pure functions in Java.

4. Utility Classes

Since Java doesn’t have a specific type set aside for housing a set of functions, we often create a utility class. Utility classes provide a home for pure static functions . Instead of writing the same logic over and over, we can group together pure functions which we reuse throughout the project.

A utility class in Java is a stateless class that we should never instantiate. Therefore, it’s recommended to declare it final , so it cannot be subclassed (which wouldn’t add value). Also, in order to prevent anyone from trying to instantiate it, we can add a private constructor :

We should note that all methods we put in the utility class should be static .

Let’s check how we can unit test and mock static methods in Java.

5.1. Unit Testing

Unit testing of well-designed, pure static methods with JUnit is quite simple. We can use the class name to call our static method and pass some test parameters to it.

Our unit under test will compute the result from its input parameters. Therefore, we can make assertions on the result and test for different input-output combinations :

5.2. Mocking

Most of the time, we don’t need to mock static methods, and we can simply use the real function implementation in our tests. The need to mock static methods typically hints at a code design issue.

If we must, then we can mock static functions using Mockito . However, we will need to add an additional mockito-inline dependency to our pom.xml:

Now, we can use the  Mockito.mockStatic   method to mock invocations to static method calls:

6. Conclusion

In this article, we explored common use cases for using static methods in our Java code. We learned the definition of static methods in Java, as well as their limitations.

Also, we explored when it makes sense to use static methods in our code. We saw that static methods are a good choice for pure functions with standard behavior that are getting reused across instances but not changing their state. Finally, we looked at how to test and mock static methods.

As always, the complete source code is available over on GitHub .

Looking for the ideal Linux distro for running modern Spring apps in the cloud?

Meet Alpaquita Linux : lightweight, secure, and powerful enough to handle heavy workloads.

This distro is specifically designed for running Java apps . It builds upon Alpine and features significant enhancements to excel in high-density container environments while meeting enterprise-grade security standards.

Specifically, the container image size is ~30% smaller than standard options, and it consumes up to 30% less RAM:

>> Try Alpaquita Containers now.

Explore the secure, reliable, and high-performance Test Execution Cloud built for scale. Right in your IDE:

Basically, write code that works the way you meant it to.

AI is all the rage these days, but for very good reason. The highly practical coding companion, you'll get the power of AI-assisted coding and automated unit test generation . Machinet's Unit Test AI Agent utilizes your own project context to create meaningful unit tests that intelligently aligns with the behavior of the code.

Learn Java practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn java interactively, java introduction.

• Get Started With Java
• Your First Java Program
• Java Comments

Java Fundamentals

• Java Variables and Literals
• Java Data Types (Primitive)
• Java Operators
• Java Basic Input and Output
• Java Expressions, Statements and Blocks

Java Flow Control

• Java if...else Statement
• Java Ternary Operator
• Java for Loop
• Java for-each Loop
• Java while and do...while Loop
• Java break Statement
• Java continue Statement
• Java switch Statement
• Java Arrays
• Java Multidimensional Arrays
• Java Copy Arrays

Java OOP(I)

• Java Class and Objects
• Java Methods
• Java Method Overloading
• Java Constructors

Java Static Keyword

• Java Strings

Java Access Modifiers

• Java this Keyword

Java final keyword

• Java Recursion
• Java instanceof Operator

Java OOP(II)

• Java Inheritance
• Java Method Overriding
• Java Abstract Class and Abstract Methods
• Java Interface
• Java Polymorphism
• Java Encapsulation

Java OOP(III)

Java Nested and Inner Class

Java Nested Static Class

• Java Anonymous Class
• Java Singleton Class
• Java enum Constructor
• Java enum Strings
• Java Reflection
• Java Package
• Java Exception Handling
• Java Exceptions
• Java try...catch
• Java throw and throws
• Java catch Multiple Exceptions
• Java try-with-resources
• Java Annotations
• Java Annotation Types
• Java Logging
• Java Assertions
• Java Collections Framework
• Java Collection Interface
• Java ArrayList
• Java Vector
• Java Stack Class
• Java Queue Interface
• Java PriorityQueue
• Java Deque Interface
• Java LinkedList
• Java ArrayDeque
• Java BlockingQueue
• Java ArrayBlockingQueue
• Java LinkedBlockingQueue
• Java Map Interface
• Java HashMap
• Java LinkedHashMap
• Java WeakHashMap
• Java EnumMap
• Java SortedMap Interface
• Java NavigableMap Interface
• Java TreeMap
• Java ConcurrentMap Interface
• Java ConcurrentHashMap
• Java Set Interface
• Java HashSet Class
• Java EnumSet
• Java LinkedHashSet
• Java SortedSet Interface
• Java NavigableSet Interface
• Java TreeSet
• Java Algorithms
• Java Iterator Interface
• Java ListIterator Interface

Java I/o Streams

• Java I/O Streams
• Java InputStream Class
• Java OutputStream Class
• Java FileInputStream Class
• Java FileOutputStream Class
• Java ByteArrayInputStream Class
• Java ByteArrayOutputStream Class
• Java ObjectInputStream Class
• Java ObjectOutputStream Class
• Java BufferedInputStream Class
• Java BufferedOutputStream Class
• Java PrintStream Class

Java Reader/Writer

• Java File Class
• Java Reader Class
• Java Writer Class
• Java InputStreamReader Class
• Java OutputStreamWriter Class
• Java FileReader Class
• Java FileWriter Class
• Java BufferedReader
• Java BufferedWriter Class
• Java StringReader Class
• Java StringWriter Class
• Java PrintWriter Class

Additional Topics

• Java Keywords and Identifiers
• Java Operator Precedence
• Java Bitwise and Shift Operators
• Java Scanner Class
• Java Type Casting
• Java Wrapper Class
• Java autoboxing and unboxing
• Java Lambda Expressions
• Java Generics
• Nested Loop in Java
• Java Command-Line Arguments

Java Tutorials

• What is a static keyword in Java?

In Java, if we want to access class members, we must first create an instance of the class. But there will be situations where we want to access class members without creating any variables.

In those situations, we can use the static keyword in Java. If we want to access class members without creating an instance of the class, we need to declare the class members static.

The Math class in Java has almost all of its members static. So, we can access its members without creating instances of the Math class. For example,

In the above example, we have not created any instances of the Math class. But we are able to access its methods: abs() and pow() and variables: PI and E .

It is possible because the methods and variables of the Math class are static.

• Static Methods

Static methods are also called class methods. It is because a static method belongs to the class rather than the object of a class.

And we can invoke static methods directly using the class name. For example,

Here, we can see that the static method can be accessed directly from other classes using the class name.

In every Java program, we have declared the main method static . It is because to run the program the JVM should be able to invoke the main method during the initial phase where no objects exist in the memory.

Example 1: Java static and non-static Methods

In the above program, we have declared a non-static method named multiply() and a static method named add() inside the class StaticTest .

Inside the Main class, we can see that we are calling the non-static method using the object of the class ( st.multiply(2, 2) ). However, we are calling the static method by using the class name ( StaticTest.add(2, 3) ).

• Static Variables

In Java, when we create objects of a class, then every object will have its own copy of all the variables of the class. For example,

Here, both the objects test1 and test2 will have separate copies of the variable age. And, they are different from each other.

However, if we declare a variable static, all objects of the class share the same static variable. It is because like static methods, static variables are also associated with the class. And, we don't need to create objects of the class to access the static variables. For example,

Here, we can see that we are accessing the static variable from the other class using the class name.

Example 2: Java static and non-static Variables

In the above program, we have declared a non-static variable named min and a static variable named max inside the class Test .

Inside the Main class, we can see that we are calling the non-static variable using the object of the class ( obj.min + 1 ). However, we are calling the static variable by using the class name ( Test.max + 1 ).

Note : Static variables are rarely used in Java. Instead, the static constants are used. These static constants are defined by static final keyword and represented in uppercase. This is why some people prefer to use uppercase for static variables as well.

Access static Variables and Methods within the Class

We are accessing the static variable from another class. Hence, we have used the class name to access it. However, if we want to access the static member from inside the class, it can be accessed directly. For example,

Here, we are able to access the static variable and method directly without using the class name. It is because static variables and methods are by default public. And, since we are accessing from the same class, we don't have to specify the class name.

• Static Blocks

In Java, static blocks are used to initialize the static variables. For example,

Here we can see that we have used a static block with the syntax:

The static block is executed only once when the class is loaded in memory. The class is loaded if either the object of the class is requested in code or the static members are requested in code.

A class can have multiple static blocks and each static block is executed in the same sequence in which they have been written in a program.

Example 3: Use of static block in java

In the above program. as soon as the Main class is loaded,

• The value of a is set to 23 .
• The first static block is executed. Hence, the string First Static block is printed and the value of b is set to a * 4 .
• The second static block is executed. Hence, the string Second Static block is printed and the value of max is set to 30 .
• And finally, the print statements inside the method display() are executed.
• Nested Static Class

In Java, we can declare a class inside another class. Such classes are known as nested classes. Nested classes are of 2 types:

• Static Nested Classes
• Non-static Nested Classes

For example,

To learn more, visit the Java Nested Class .

Table of Contents

• Static Variables and Methods within the Class

Sorry about that.

Related Tutorials

Java Tutorial

Java Tutorial

Java methods, java classes, java file handling, java how to's, java reference, java examples, java static keyword.

❮ Java Keywords

A static method can be accessed without creating an object of the class first:

Try it Yourself »

Definition and Usage

The static keyword is a non-access modifier used for methods and attributes. Static methods/attributes can be accessed without creating an object of a class.

Related Pages

Read more about modifiers in our Java Modifiers Tutorial .

COLOR PICKER

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail: [email protected]

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

Top Tutorials

Top references, top examples, get certified.

Java Static – Variable, Method, Block, Class and Import Statement

Static keyword in java can be applied on variables, methods, blocks, import and inner classes. Learn the effect of using static keyword in detail.

Lokesh Gupta

January 25, 2022

Static keyword in java can be applied on variables, methods, blocks, import and inner classes. In this tutorial, we will learn the effect of using static keyword in these places with examples.

1. Static Variable

To declare a variable static, use static keyword in variable declaration. static variable syntax is:

For example, a public static variable of Integer type is declared in this way.

The most important thing about static variables is that they belong to class level . What it means is that there can be only one copy of variable in runtime .

When you define a static variable in class definition, each instance of class will have access to that single copy. Separate instances of class will not have their own local copy, like they have for non-static variables.

Notice how we changed the value to 30, and both objects now see the updated value which is 30.

Another thing you should have noticed that how we are able to access static variable with its classname i.e. DataObject.staticVar . We don’t need to create any instance to access static variables. It clearly shows that static variables belong to class scope .

2. Static Method

To declare a static method, use static keyword in method declaration. Static method syntax is:

Few things to remember.

• You can access only static variables inside static methods . If you try to access any non-static variable, the compiler error will be generated with message “ Cannot make a static reference to the non-static field nonStaticVar “.
• Static methods can be accessed via it’s class reference, and there is no need to create an instance of class. Though you can access using instance reference as well but it will have not any difference in comparison to access via class reference.
• Static methods also belong to class level scope.

3. Static Import Statement

The normal import declaration imports classes from packages, so that they can be used without package reference. Similarly the static import declaration imports static members from classes and allowing them to be used without class reference.

A static import statement also comes in two flavors: single-static import and static-import-on-demand . A single-static import declaration imports one static member from a type. A static-import-on-demand declaration imports all static members of a type.

For example, System.out is

Read More: Static Import Statements in Java

4. Static Block

Static blocks are portion of class initialization code, which are wrapped with static keyword.

Static blocks are executed when the class is loaded in the memory. A class can have multiple static blocks and these will be executed in the same sequence in which they appear in class definition.

5. Static Class

In Java, you can have a static class as inner class . Just like other static members, nested classed belong with class scope so the inner static class can be accessed without having an object of outer class.

Please note that an static inner class cannot access the non-static members of outer class. It can access only static members from outer class.

Let’s summarize everything about static keyword usage in Java.

• Static members belong to class. No need to create class instance to access static members.
• Static members (variables and methods) can be accessed inside static methods and static blocks only.
• Non-static members cannot be accessed inside static methods, blocks and inner classes.
• A class can have multiple static blocks and they will be executed in order they appear in class definition.
• A class can be static only if its declared as inner class inside outer class.
• Static imports can be used to import all static members from a class. These members can be referred without any class reference.

Happy Learning !!

References:

Class members Nested classes

Weekly Newsletter

Stay Up-to-Date with Our Weekly Updates. Right into Your Inbox.

Maven Custom Archetype from Eclipse Project

How to install python packages in sublime text.

HowToDoInJava provides tutorials and how-to guides on Java and related technologies.

It also shares the best practices, algorithms & solutions and frequently asked interview questions.

Tutorial Series

Privacy Policy

REST API Tutorial

Static Variable in Java: What is Static Block & Method [Example]

• Static Variables
• Static Methods
• Static Blocks Of Code.

Let’s look at static variables and static methods first.

What is Static Variable in Java?

Static variable in Java is variable which belongs to the class and initialized only once at the start of the execution. It is a variable which belongs to the class and not to object(instance ). Static variables are initialized only once, at the start of the execution. These variables will be initialized first, before the initialization of any instance variables.

• A single copy to be shared by all instances of the class
• A static variable can be accessed directly by the class name and doesn’t need any object

What is Static Method in Java?

Static method in Java is a method which belongs to the class and not to the object. A static method can access only static data. It is a method which belongs to the class and not to the object(instance). A static method can access only static data. It cannot access non-static data ( instance variables ).

• A static method can call only other static methods and can not call a non-static method from it.
• A static method can be accessed directly by the class name and doesn’t need any object
• A static method cannot refer to “this” or “super” keywords in anyway

Note: main method is static, since it must be accessible for an application to run, before any instantiation takes place.

Example: How to call static variables & methods

Step 1) Copy the following code into a editor

Step 2) Save & Compile the code. Run the code as, java Demo .

Step 3) Expected output show below

Following diagram shows, how reference variables & objects are created and static variables are accessed by the different instances.

Step 4) It is possible to access a static variable from outside the class using the syntax ClassName.Variable_Name . Uncomment line # 7 & 8 . Save , Compile & Run . Observe the output.

Step 5) Uncomment line 25,26 & 27 . Save , Compile & Run.

What is Static Block in Java?

The static block is a block of statement inside a Java class that will be executed when a class is first loaded into the JVM . A static block helps to initialize the static data members , just like constructors help to initialize instance members.

Following program is the example of java static block.

Example: How to access static block

you will get following output of the program.

• Program to Print Prime Number From 1 to 100 in Java
• Palindrome Number Program in Java Using while & for Loop
• Bubble Sort Algorithm in Java: Array Sorting Program & Example
• Insertion Sort Algorithm in Java with Program Example
• Selection Sorting in Java Program with Example
• Abstract Class vs Interface in Java – Difference Between Them
• 100+ Java Interview Questions and Answers (2024)
• JAVA Tutorial PDF: Basics for Beginners (Download Now)

The Java Tutorials have been written for JDK 8. Examples and practices described in this page don't take advantage of improvements introduced in later releases and might use technology no longer available. See Java Language Changes for a summary of updated language features in Java SE 9 and subsequent releases. See JDK Release Notes for information about new features, enhancements, and removed or deprecated options for all JDK releases.

Understanding Class Members

In this section, we discuss the use of the static keyword to create fields and methods that belong to the class, rather than to an instance of the class.

Class Variables

When a number of objects are created from the same class blueprint, they each have their own distinct copies of instance variables . In the case of the Bicycle class, the instance variables are cadence , gear , and speed . Each Bicycle object has its own values for these variables, stored in different memory locations.

Sometimes, you want to have variables that are common to all objects. This is accomplished with the static modifier. Fields that have the static modifier in their declaration are called static fields or class variables . They are associated with the class, rather than with any object. Every instance of the class shares a class variable, which is in one fixed location in memory. Any object can change the value of a class variable, but class variables can also be manipulated without creating an instance of the class.

For example, suppose you want to create a number of Bicycle objects and assign each a serial number, beginning with 1 for the first object. This ID number is unique to each object and is therefore an instance variable. At the same time, you need a field to keep track of how many Bicycle objects have been created so that you know what ID to assign to the next one. Such a field is not related to any individual object, but to the class as a whole. For this you need a class variable, numberOfBicycles , as follows:

Class variables are referenced by the class name itself, as in

This makes it clear that they are class variables.

You can use the Bicycle constructor to set the id instance variable and increment the numberOfBicycles class variable:

Class Methods

The Java programming language supports static methods as well as static variables. Static methods, which have the static modifier in their declarations, should be invoked with the class name, without the need for creating an instance of the class, as in

A common use for static methods is to access static fields. For example, we could add a static method to the Bicycle class to access the numberOfBicycles static field:

Not all combinations of instance and class variables and methods are allowed:

• Instance methods can access instance variables and instance methods directly.
• Instance methods can access class variables and class methods directly.
• Class methods can access class variables and class methods directly.
• Class methods cannot access instance variables or instance methods directly—they must use an object reference. Also, class methods cannot use the this keyword as there is no instance for this to refer to.

The static modifier, in combination with the final modifier, is also used to define constants. The final modifier indicates that the value of this field cannot change.

For example, the following variable declaration defines a constant named PI , whose value is an approximation of pi (the ratio of the circumference of a circle to its diameter):

Constants defined in this way cannot be reassigned, and it is a compile-time error if your program tries to do so. By convention, the names of constant values are spelled in uppercase letters. If the name is composed of more than one word, the words are separated by an underscore (_).

The Bicycle Class

After all the modifications made in this section, the Bicycle class is now:

About Oracle | Contact Us | Legal Notices | Terms of Use | Your Privacy Rights

Copyright © 1995, 2022 Oracle and/or its affiliates. All rights reserved.

Java Tutorial

Control statements, java object class, java inheritance, java polymorphism, java abstraction, java encapsulation, java oops misc.

• Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Transact-SQL

Reinforcement Learning

R Programming

React Native

Python Design Patterns

Python Pillow

Python Turtle

Preparation

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

Cloud Computing

Data Science

Machine Learning

B.Tech / MCA

Data Structures

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

C Programming

Control System

Data Mining

Data Warehouse

The main method

• 9. Composition
• 10. Heap and Stack
• 11. Inheritance
• 12. Overriding
• 13. Overloading
• 14. Polymorphism
• 15. Method Invocation
• 17. Abstract Class
• 18. Interface

Unit 8: Class Methods

Learning Objectives

Students should

• understand the differences between instance methods and class methods.
• be able to define and use a class method.
• know that the main method is the entry point to a Java program.
• the modifies and parameters required for a main method.

Static Methods

Let's suppose that, in our program, we wish to assign a unique integer identifier to every Circle object ever created. Without using class fields, we might attempt the following.

Then, on every instantiation of circle, we will have to explicitly supply the latest value for id .

Of course this can be tedious and prone to error especially if we may instantiate Circle in multiple places. Then we will have to ensure that the latest value of id is communicated on these places correctly.

As an improvement, we may actually just let the value of the latest id be stored in the class Circle itself as a class field.

Then, each time we instantiate a circle, we have to: (i) retrieve the value of lastId and (ii) update the value of lastId .

While better, this is still prone to error as it relies on the fact that the client should not forget to use and update. Furthermore, it requires the client to update it correctly and not just set the value of lastId to some random value. But this can be done better if this is the responsibility of the implementer instead. This can be done with the use of class method.

• On Line 5, we added a new instance field id to store the identifier of the circle. Note that, since the identifier of a circle should not change once it is created, we use the keyword final here.
• On Line 6, we added a new class field lastId to remember that the lastId of the latest circle instance. This field is maintained as part of the class Circle and is initialized to 0. Now this class field is private instead of public because it is only accessed and updated within the constructor.
• On Line 15 and 16, as part of the constructor, we initialize id to lastId and increment lastId . We explicitly access lastId through Circle to make it clear that lastId is a class field.

Note that all of the above are done privately beneath the abstraction barrier. In other words, the class field that we have added is actually set to private . Additionally, now it does not matter what the client does, the value of lastId will correctly reflect the number of circle that has been created. The client need not even know about the existence of this class field.

Since lastId is incremented by one every time a circle is created, we can also interpret lastId as the number of circles created so far. On Line 22-24, we added a method getNumOfCircles to return its value.

The interesting thing here is that we declare getNumOfCircles with a static keyword. Similar to a static field, a static method is associated with a class, not to an instance of the class. Such method is called a class method . A class method is always invoked without being attached to an instance, and so it cannot access its instance fields or call other of its instance methods. The reference this has no meaning within a class method. Furthermore, just like a class field, a class method should be accessed through the class. For example, Circle . getNumOfCircles () .

Other examples of class methods include the methods provided in java.lang.Math : sqrt , min , etc. These methods can be invoked through the Math class: e.g., Math.sqrt(x) .

Non-Static from Static

Recap that for static fields ( i.e., class fields ), we only have exactly one instance of it throughout the lifetime of the program. More generally, a field or method with modifier static belongs to the class rather than the specific instance. In other words, they can be accessed/updated ( for fields, assuming proper access modifier ) or invoked ( for methods, assuming proper access modifier ) without even instantiating the class.

Think for a moment about the consequence of this. If we have not instantiate the class, it means that there is no instance. The keyword this captures the current instance . If there is no instance, the keyword this cannot be referring to any instance. Therefore, it is not reasonable to assign a specific value to this keyword.

Since we have no reasonable value for this within the context of static method, Java actually prevents the use of this from any method with static modifier.

Try it out, you will get the following error.

The opposite is not true. We can access class fields from non-static methods.

The most common class method you will use is probably the main method.

will invoke the main method defined within the class Hello to kick start the execution of the program.

You have learned what public and static means. The return type void indicates that main must not return a value. We have discussed what final means on a field, but are not ready to explain what final means on a method yet. In fact, this is an optional modifier for the main method.

The main method takes in an array ( [] ) of strings as parameters. These are the command-line arguments that we can pass in when invoking java . String ( or java.lang.String ) is another class provided by the Java library that encapsulates a sequence of characters.

What is Needed for the Main Method

Minimally, the main method should

• have the public access modifier
• be a class method with static modifier
• not return anything ( i.e., the return type is void )
• be named main
• takes only an array of String ( i.e., String[] ) as its parameter.

From here, we can see that the final keyword is not necessary. Additionally, the order of the modifiers can be different although for good practice, you should follow our Coding Style . Finally, the name of the parameter can be different but we usually use args for simplicity.

Class Diagram ( Part 3 )

Static fields and/or methods are represented by underline in class diagram. The current version of Circle has the following class diagram.

If the number of constructs for class diagram is getting too much, do not worry, we will have a unit added to the Java Guide specifically to revise class diagram with application on designing solutions to problems.

• ▼Java Exercises
• ▼Java Basics
• Basic Part-I
• Basic Part-II
• ▼Java Data Types
• Java Enum Types
• ▼Java Control Flow
• Conditional Statement
• Recursive Methods
• ▼Java Math and Numbers
• ▼Object Oriented Programming
• Java Constructor
• Java Static Members
• Java Nested Classes
• Java Inheritance
• Java Abstract Classes
• Java Interface
• Java Encapsulation
• Java Polymorphism
• Object-Oriented Programming
• ▼Exception Handling
• Exception Handling Home
• ▼Functional Programming
• Java Lambda expression
• ▼Multithreading
• Java Thread
• Java Multithreading
• ▼Data Structures
• ▼Strings and I/O
• File Input-Output
• ▼Date and Time
• ▼Advanced Concepts
• Java Generic Method
• ▼Algorithms
• ▼Regular Expressions
• Regular Expression Home
• ▼JavaFx Exercises
• JavaFx Exercises Home
• ..More to come..

Java Methods: Exercises, Practice, Solution

Java method exercises [23 exercises with solution].

[ An editor is available at the bottom of the page to write and execute the scripts.   Go to the editor ]

1. Write a Java method to find the smallest number among three numbers. Test Data: Input the first number: 25 Input the Second number: 37 Input the third number: 29 Expected Output:

Click me to see the solution

2. Write a Java method to compute the average of three numbers. Test Data: Input the first number: 25 Input the second number: 45 Input the third number: 65 Expected Output:

3. Write a Java method to display the middle character of a string. Note: a) If the length of the string is odd there will be two middle characters. b) If the length of the string is even there will be one middle character. Test Data: Input a string: 350 Expected Output:

4. Write a Java method to count all vowels in a string. Test Data: Input the string: w3resource Expected Output:

5. Write a Java method to count all the words in a string. Test Data: Input the string: The quick brown fox jumps over the lazy dog. Expected Output:

6. Write a Java method to compute the sum of digits in an integer. Test Data: Input an integer: 25 Expected Output:

7. Write a Java method to display the first 50 pentagonal numbers. Note: A pentagonal number is a figurate number that extends the concept of triangular and square numbers to the pentagon, but, unlike the first two, the patterns involved in the construction of pentagonal numbers are not rotationally symmetrical. Expected Output:

8. Write a Java method to compute the future investment value at a given interest rate for a specified number of years. Sample data (Monthly compounded) and Output: Input the investment amount: 1000 Input the rate of interest: 10 Input number of years: 5

Expected Output:

9. Write a Java method to print characters between two characters (i.e. A to P). Note: Prints 20 characters per line

10. Write a Java method to check whether a year (integer) entered by the user is a leap year or not.

11. Write a Java method to check whether a string is a valid password. Password rules: A password must have at least ten characters. A password consists of only letters and digits. A password must contain at least two digits.

12. Write a Java method (takes n as input) to display an n-by-n matrix.

13. Write Java methods to calculate triangle area.

14. Write a Java method to create a pentagon's area.

15. Write a Java method to display the current date and time.

16. Write a Java method to find all twin prime numbers less than 100.

17. Write a Java method to count the number of digits in an integer with the value 2. The integer may be assumed to be non-negative.

18. Write a Java method that accepts three integers and checks whether they are consecutive or not. Returns true or false.

19. Write a Java method that accepts three integers and returns true if one is the middle point between the other two integers, otherwise false.

20. Write a Java method for extracting the first digit from a positive or negative integer.

21. Write a Java method to display the factors of 3 in a given integer.

22. Write a Java method to check whether every digit of a given integer is even. Return true if every digit is odd otherwise false.

23. Write a Java method that checks whether all the characters in a given string are vowels (a, e,i,o,u) or not. Return true if each character in the string is a vowel, otherwise return false.

Java Code Editor

More to Come !

Do not submit any solution of the above exercises at here, if you want to contribute go to the appropriate exercise page.

Follow us on Facebook and Twitter for latest update.

• Weekly Trends and Language Statistics

• Java Course
• Java Arrays
• Java Strings
• Java Collection
• Java 8 Tutorial
• Java Multithreading
• Java Exception Handling
• Java Programs
• Java Project
• Java Collections Interview
• Java Interview Questions
• Spring Boot

Difference between static and non-static method in Java

A static method is a method that belongs to a class, but it does not belong to an instance of that class and this method can be called without the instance or object of that class. Every method in java defaults to a non-static method without static keyword preceding it. Non-static methods can access any static method and static variable, without creating an instance of the object.

Difference between Static and Non-Static Methods

Let us clarify the differences Below are the various important differences among these pointers as follows:

• Accessing members and methods
• Calling process
• Binding process
• Overriding process
• Memory allocation

1. Accessing members and methods

A static method can only access static data members and static methods of another class or the same class but cannot access non-static methods and variables. Also, a static method can rewrite the values of any static data member.

A non-static method can access static data members and static methods as well as non-static members and methods of another class or the same class, and also can change the values of any static data member

Example 2:

2. Calling process 

The memory of a static method is fixed in the ram, for this reason, we don’t need the object of a class in which the static method is defined to call the static method. To call the method we need to write the class name followed by the name of the method

Syntax: Calling of static methods

The memory of the non-static method is not fixed in the ram, so we need a class object to call a non-static method. To call the method we need to write the name of the method followed by the class object name

Syntax: Calling of non-static methods

3. Binding process 

In the static method, the method use compile-time or early binding. For this reason, we can access the static method without creating an instance. In a non-static method, the method use runtime or dynamic binding. So that we cannot access a non-static method without creating an instance. 

4. Overriding 

In the static method, we cannot override a static method, because of early binding. 

Output:  

In the non-static method, we can override a non-static method. Because for override we need runtime polymorphism, which happens only in runtime binding. 

Output: Error

5. Memory allocation 

In the static method, memory allocation happens only once, because the static keyword fixed a particular memory for that method in ram. So when the method is called every time in a program, each time that particular memory is used. For that reason, less memory is allocated.

In the non-static method, here memory allocation happens when the method is invoked and the memory is allocated every time when the method is called. So much memory is used here. Now, lastly plotting table in order to grasp altogether

Please Login to comment...

Similar reads.

• Java-Functions
• Static Keyword

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

static assignment calling the method twice

Hmmm... I m not able to come up with a better title for this question

I m not able to understand why calling a static method and assigning it's value to another static member is calling the method getValue() twice.

If I move the static assignment after main method, it is not loading twice. I know this is stupid, but am I missing something obvious?

Test online: https://ideone.com/pgRbff

2 Answers 2

Let's step through a few key lines.

prints "Loading value..." and sets flag to a non-null value.

Then this line:

sets flag back to null .

prints "Loading value..." again and sets flag to a non-null value again.

Then main runs, and this line:

doesn't print anything, because flag is set to a non-null value.

• This is correct. OP, you can verify this by swapping the declarations of value1 and flag , and noting that "Loading value..." is only printed once. –  Vikram Commented Oct 23, 2016 at 7:23
• 1 @Kamal: This has nothing to do with the evils of static variables. This is just a design smell. –  Makoto Commented Oct 23, 2016 at 7:27
• Aaahh.. I knew I m being stupid here... How did I miss it... My head is showing signs of deprived sleep... lol... Thanks again... –  manikanta Commented Oct 23, 2016 at 7:27

This is good question. Classloader follow some rule to load a class, static statements load first and create memory for that at class area in heap memory.

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged java static or ask your own question .

• The Overflow Blog
• Ryan Dahl explains why Deno had to evolve with version 2.0
• Featured on Meta
• We've made changes to our Terms of Service & Privacy Policy - July 2024
• Bringing clarity to status tag usage on meta sites
• Feedback requested: How do you use tag hover descriptions for curating and do...
• What does a new user need in a homepage experience on Stack Overflow?

Hot Network Questions

• How common is it for external contractors to manage internal teams, and how can we navigate this situation?
• Do linguists have a noun for referring to pieces of commendatory language, as a sort of antonym of 'pejoratives'?
• The twin prime problem and the Jurkat-Richert Theorem
• Which BASIC dialect first featured a single-character comment introducer?
• Is "UN law" a thing?
• Is the Garmin Edge 530 still a good choice for a beginner in 2024?
• Reference of "she"
• How to make outhouses less icky?
• How old were Phineas and Ferb? What year was it?
• On intersection theory on toric varieties
• Second Argument of \fontsize{}{}\selectfont Not Working in a Pspicture
• What is the origin of this quote on telling a big lie?
• What is this surface feature near Shackleton crater classified as?
• I can't select a certain record with like %value%
• Is there a good explanation for the existence of the C19 globular cluster with its very low metallicity?
• Can objective morality be derived as a corollary from the assumption of God's existence?
• Why name the staves in LilyPond's "published" "Solo piano" template?
• Retroactively specifying `-only` or `-or-later` for GPLv2 in an adopted project
• Why would an incumbent politician or party need to be re-elected to fulfill a campaign promise?
• What prevents applications from misusing private keys?
• What should I [34/F] do about my rude and mean supervisor [60s/F] when I want to finish my PhD?
• Arranging people in a jeep.
• Should I be able to see light from a IR Led with my own eyes?
• Is math a bad discipline for teaching jobs or is it just me?