Java static class Example

In this example, we will discuss about static classes in Java. First of all, let’s give a short explanation of the static modifier. For example, if a field or a method in a class has the static modifier in its declaration , then it is always associated with the class as a whole, rather than with any object of the class.

In the code below we have declared a class named Vehicle, a class field member named vehicleType and a method namedgetVehicleType(), both declared as static.

1	public class Vehicle {

2

3	private static String vehicleType;

4

5	public static String getVehicleType(){

6	return vehicleType;

7

}

8

9

}

The static modifier allows us to access the variable vehicleType and the method getVehicleType() using the class name itself, as follows:

Vehicle.vehicleType
Vehicle.getVehicleType()

Something similar happens to classes that are declared static, but in order to explain this better, we must first explain the inner classes or generally, the nested classes, because ONLY nested classes can be static.

Java supports the concept of nested classes. Nested classes are classes that can be defined within the body of another class. An example of a nested class is illustrated below:

1	class OuterClass {

2

//code

3	class NestedClass {

4

//code

5

}

6

}

The OuterClass which contains another class can be also called top-level class.

Nested classes are further divided into two categories: static and non-static. Nested classes that are declared static are called static nested classes. Non-static nested classes are just called inner classes.

1	class OuterClass {

2

//code

3	static class StaticNestedClass {

4

//code

5

}

6	class InnerClass {

7

//code

8

}

9

}

• What’s the difference between nested static classes and non-static (inner) classes?
The main difference is that inner class requires instantiation of the outer class so as to be initialized and it is always associated with an instance of the enclosing class. On the other hand nested static class is not associated with any instance of the enclosing class. Nested static classes are declared with the static keyword, which means than can be accessed like any other static member of class, as we shown before.

1. Example of nested classes

Create a java class named OuterClass.java with the following code:

OuterClass.java

01	package com.javacodegeeks.javabasics.staticclass;

02

03	public class OuterClass {

04

05	public static void main(String[] args) {

06

07	//nested static class doesn't need instantiation of the outer class

08	OuterClass.NestedStaticClass nestedStatic = new OuterClass.NestedStaticClass();

09	nestedStatic.printMethodNestedStatic();

10

11	//inner class needs instantiation of the outer class

12	OuterClass outer = new OuterClass();

13	OuterClass.InnerClass inner = outer.new InnerClass();

14	inner.printMethodInner();

15

}

16

17	// Static nested class

18	public static class NestedStaticClass {

19

20	public void printMethodNestedStatic() {

21	System.out.println("Method of nested static class");

22

}

23

}

24

25	// inner (non-static nested) class

26	public class InnerClass {

27

28	public void printMethodInner() {

29	System.out.println("Method of inner(non-static nested) class");

30

}

31

}

32

33

}

As we can observe in the above code, we have declared a class named OuterClass which is considered to be the outer class or otherwise, the top level class. Also, we can see that we have declared two more nested classes (they are enclosed in the outer class), one of which is static and the other one is non-static. Finally, we have declared a main method in the outer class, which is static as always (Really, why is that? The answer is that we can call it without creating any instance of class which contains this main method). We can see that the method of the nested static class can be accessed without creating an object of the OuterClass, whereas the method of the inner class needs instantiation of the OuterClass in order to get accessed.

Output:

Method of nested static class
Method of inner(non-static nested) class

Soft Assertions using TestNG

All of us write various automation tests for the application that we test in our every day work. One thing that has been debated the most is the use of soft assertions. Before we dive deep into the debate, a quick look at the two types of assertions.

Hard Assertions (or simply Assertions)

Tests immediately fail and stop executing the moment a failure occurs in the assertion. You may want to use a hard assert if you want to verify if you have logged in correctly and fail the test if you haven’t as there is no point in proceeding further if the test if the pre-condition itself fails.

Soft Assertions

Tests don’t stop running even if an assertion condition fails, but the test itself is marked as a failed test to indicate the right result. This is useful if you are doing multiple validations in a form (well.. you may actually question why you should be doing multiple validations in the first place which is probably a separate topic by itself), you may actually want to complete all the validations and fail the test once all validations are complete in case of failures.

Now.. there are multiple ways of doing soft asserts. You can write your own custom logic using the regular assert, but trap any exceptions and make the test proceed further. Or, you can use the TestNG library (for Java) which does this magic for you.

Here is how you initialize the TestNG assertions…

123456789

package automation.tests;   import org.testng.asserts.Assertion; import org.testng.asserts.SoftAssert;   public class MyTest { private Assertion hardAssert = new Assertion(); private SoftAssert softAssert = new SoftAssert(); }

view rawgistfile1.java hosted with ❤ by GitHub

Here is a sample test for a Hard Assertion…

1234	@Test public void testForHardAssert() { hardAssert.assertTrue(false); }

view rawgistfile1.java hosted with ❤ by GitHub

Here is a sample test for Soft Assertion which does not fail the test…

1234	@Test public void testForSoftAssertWithNoFailure() { softAssert.assertTrue(false); }

view rawgistfile1.java hosted with ❤ by GitHub

And here is a soft assertion that actually marks the test as a failure…

123456

@Test public void testForSoftAssertionFailure() { softAssert.assertTrue(false); softAssert.assertEquals(1, 2); softAssert.assertAll(); }

view rawgistfile1.java hosted with ❤ by GitHub

If you look at the above test, the softAssert.assertAll() does the trick. This method collates all the failures and decides whether to fail the test or not at the end. So instead of writing a custom logic, the TestNG library itself offers the facility to perform Soft Assertions in your test.