Static Imports

• Static Import is a new feature introduced in Java 5.
• Using normal import statements, you can access classes from other package s.
• Using static import statements, you can access public static members of a class directly.

Normal Imports

Syntax

import <PackageName>.<ClassName>;

import <PackageName>.*;

Example

import com.javaindia.p1.Hello;

import com.javaindia.p1.*;

Explanation

• In case 1, only the Hello class of package p1 will be accessed.
• In case 2, all classes of package p1 will be accessed.

Static Imports

Syntax

Import specific static member

import static  <PackageName>.<ClassName>.<StaticMember>;

Import all static members

import static  <PackageName>.<ClassName>.*;

Examples

import static com.javaindia.p1.Hello.A;

import static com.javaindia.p1.Hello.m1;

import static com.javaindia.p1.Hello.*;

Explanation

• In case 1, only the public static variable A of class Hello will be accessed.
• In case 2, only the public static method m1() of class Hello will be accessed.
• In case 3, all public static members of class Hello will be accessed.

Hello.java

package com.javaindia.p1;

public class Hello {

  public static int A = 90;

  public static void m1() {
    System.out.println("Hello -> m1()");
  }

  static void m2() {
    System.out.println("Hello -> m2()");
  }
}

m2() is package-private (not public), so it cannot be accessed outside the package using static import.

Hai.java

package com.javaindia.p1;

public class Hai {

  public int B = 80;

  public static void m3() {
    System.out.println("Hai -> m3()");
  }

  static void m4() {
    System.out.println("Hai -> m4()");
  }
}

B is an instance variable, not static.

m4() is package-private (not public).

Static Import Overview

Important Notes

Feature	Description
Normal import	Imports classes/interfaces
Static import	Imports static members
Accessible members	Only public static members
Cannot import	Instance members using static import
* in static import	Imports all public static members

Quick Difference

Normal Import	Static Import
Imports classes	Imports static members
Example: import java.util.Scanner;	Example: import static java.lang.Math.*;
Access using class name	Access directly without class name

Example:

System.out.println(Math.sqrt(25));

With static import:

import static java.lang.Math.*;

System.out.println(sqrt(25));

Lab472.java

package com.javaindia.p2;

import static com.javaindia.p1.Hai.m3;
import static com.javaindia.p1.Hello.A;
import static com.javaindia.p1.Hello.m1;

public class Lab472 {

  public static void main(String args[]) {
    System.out.println(A);

    m1();

    m3();
  }
}

Explanation

• Static variable A is accessed directly.
• Static method m1() from Hello is accessed directly.
• Static method m3() from Hai is accessed directly.

Lab473.java

package com.javaindia.p2;

import static com.javaindia.p1.Hai.*;
import static com.javaindia.p1.Hello.*;

public class Lab473 {

  public static void main(String args[]) {
    System.out.println(A);

    m1();

    m3();
  }
}

Explanation

• imports all public static members.
• Members can be accessed directly without class names.

Lab474.java

package com.javaindia.p2;

import static com.javaindia.p1.Hai.*;
import static com.javaindia.p1.Hello.*;

public class Lab474 {

  public static void main(String args[]) {
    System.out.println(B);

    m2();

    m4();
  }
}

Explanation

This program gives errors because:

• B is an instance variable, not static.
• m2() and m4() are not public static methods accessible through static import.

Lab475.java

package com.javaindia.p2;

import static com.javaindia.p1.Hai.*;
import static com.javaindia.p1.Hello.*;

public class Lab475 {

  public static void main(String args[]) {
    Hello hello = new Hello();

    Hai hai = new Hai();
  }
}

Explanation

• Static import cannot import classes themselves.
• Hello and Hai class names are not accessible through static import.
• This program results in compilation error unless normal import is used.

Lab476.java

package com.javaindia.p2;

import static com.javaindia.p1.Hello.m1;

public class Lab476 {

  public static void main(String args[]) {
    m1();
  }

  static void m1() {
    System.out.println("Lab -> m1()");
  }
}

Explanation

• Local class method m1() has higher priority than imported static method.
• Therefore current class method is executed.

Output

Lab -> m1()

Lab477.java

package com.javaindia.p2;

import static java.lang.System.*;

public class Lab477 {

  public static void main(String args[]) {
    out.println("Hello Guys");
  }
}

Explanation

• out is a public static member of System.
• Because of static import, System.out can be written simply as out.

Output

Hello Guys

Hello.java

package com.javaindia.p1;

public class Hello {

  public static void m1() {
    System.out.println("Hello -> m1()");
  }

  public static void show() {
    System.out.println("Hello -> show()");
  }
}

Hai.java

package com.javaindia.p1;

public class Hai {

  public static void m2() {
    System.out.println("Hai -> m2()");
  }

  public static void show() {
    System.out.println("Hai -> show()");
  }
}

Static Import Access Flow

Important Notes

Feature	Description
Static import	Imports public static members only
Cannot import	Instance variables or instance methods
Local method priority	Current class method overrides imported static method
System.out shortcut	Possible using import static java.lang.System.*;
* usage	Imports all public static members

Lab478.java

package com.javaindia.p2;

import static com.javaindia.p1.Hai.*;
import static com.javaindia.p1.Hello.*;

public class Lab478 {

  public static void main(String args[]) {
    m1();

    m2();
  }
}

Explanation

• m1() is imported from Hello.
• m2() is imported from Hai.
• Both methods are public static methods, so they can be accessed directly.

Lab479.java

package com.javaindia.p2;

import static com.javaindia.p1.Hai.*;
import static com.javaindia.p1.Hello.*;

public class Lab479 {

  public static void main(String args[]) {
    show();
  }
}

Explanation

This program gives ambiguity error because:

• Both Hello and Hai contain a static method named show().
• Compiler cannot decide which show() method to call.

Lab480.java

package com.javaindia.p2;

import static com.javaindia.p1.Hai.show;
import static com.javaindia.p1.Hello.show;

public class Lab480 {

  public static void main(String args[]) {
    System.out.println("Hello Guys");
  }
}

Explanation

• Compilation error occurs.
• Two static methods with same name show are imported explicitly.
• This creates ambiguity even if method is not called.

Lab481.java

package com.javaindia.p2;

import static com.javaindia.p1.Hai.show;
import static com.javaindia.p1.Hello.show;

public class Lab481 {

  public static void main(String args[]) {
    show();
  }
}

Explanation

• Ambiguity problem occurs.
• Compiler cannot identify whether show() belongs to Hello or Hai.

Lab482.java

package com.javaindia.p2;

import com.javaindia.p1.*;

public class Lab482 {

  public static void main(String args[]) {
    Hello.show();

    Hai.show();
  }
}

Explanation

• Normal import is used instead of static import.
• Methods are accessed using class names.
• No ambiguity problem occurs.

Lab483.java

package com.javaindia.p2;

import static java.lang.Math.*;

public class Lab483 {

  public static void main(String args[]) {
    System.out.println(PI);

    System.out.println(sqrt(16));
  }
}

Explanation

• PI static constant is imported from Math.
• sqrt() static method is imported from Math.
• Both can be accessed directly.

Output

3.141592653589793
4.0