Is Default Package included in the Package Level Access?

Question

I would like to know how the default package is defined in Java.I know how public and private access is defined but I don't know whether there is any default package access that is defined in package level access in java.

The code I tried to execute is:

  class A
  {
    public static void value()
    {
    int a;
    a=5;
    }
    public static void main()
    {
    value();
    }
  }
  class B
  {
    public void greet()
    {
    System.out.println("Value of a is"+a);
    }
  }

The error I got is:

D:\Downloads\pro>javac A.java
A.java:17: error: cannot find symbol
System.out.println("Value of a is"+a);
                                   ^
  symbol:   variable a
  location: class B
1 error

Since both classes belong to the same default package shouldn't class B access class A's members(a)?

I'm asking this question because when I compile java file containing two classes since no modifier is given for classes,java compiler would give package level access as the default access modifier for the classes.Since no package is defined,java compiler would use the default package but I couldn't get whether the default package is included in package level access in java.Could anyone help me.

Answer 1

So finally I got how we could access an variable in another class without creating an object provided both classes rest in the same package.Just make the variable static.

Here's the code:

import java.io.*;
  class A
  {
  static int a=5;
    public void turn()
    {
    System.out.println("value of a is"+a);
    }
  }
  class B
  {
    public static void main(String args[])
    {
    int b;
    b=A.a;
    System.out.println("value of a is"+b);
    }
  }

This shows that classes residing in the same package can access each other's members provided it is static even though it is not public because default package access comes to play.

Answer 2

In your class B, a is not defined.

class B {
    public void greet() {
        System.out.println("Value of a is" + a );//cannot find `a` inside `B`
    }
}

Now coming to accessibility, since your both classes are in same package B class can access public, protected and default(no access modifiers) members of other class like A. But in your case a is a local variable inside the A member method value(), so a variable cannot be accessed outside the method where it was declared.

class A {
    public static void value() {
       int a;//not accessible outside this method
       a=5;
    }
    public static void main() {//FYI: this main is not valid to execute your code, missing here: `String[] args` argument
       value();
       //`a`, is even not accessible here, forget about class `B`
    }
}

Sample code, all are in same package:

class A {
   String bar;
}

class B {
  public foo() {
    A a = new A();//required, as `bar` is instance(non-static) member of class `A`
    a.bar 'hi there';//set value
    System.out.printf("a.bar = %s\n", a.bar);
  }
}

EDIT

Sample code with nested class:

class A {
  int foo;

  class B {
     void setFoo() {
       foo = 45; //accessing member of class `A`
     }
  }
}

Working code:

<pre>
<code>
class A {
  private int foo;
  private B b;

  A() {
  	foo = -1;
  	b = new B();
  }

  class B {
     void setFoo(int foo) {
     	System.out.printf("Inside B's setFoo(), foo = %d\n", foo);
        A.this.foo = foo; //accessing member of class `A`
     }
  }

  int getFoo() {
  	return foo;
  }

  public void setFoo(int foo) {
  	System.out.printf("Inside A's setFoo(), foo = %d\n", foo);
  	b.setFoo(foo);
  }
}

class Ideone{
	public static void main (String[] args)	{
		A a = new A();
		System.out.printf("main(), foo = %d\n", a.getFoo());
		a.setFoo(34);
		System.out.printf("main(), foo = %d\n", a.getFoo());
	}
}
</code>
</pre>

Answer 3

Your program has nothing to do with access specifiers, as you have declared your variable int a inside a method.

Thus it becomes just a local variable. You cannot even use it outside this method in the same class.

If we talk specifically about access specifiers then we can have default access specifier in Java which has scope up to the same package only.

package com;
class A{
    int a; // this is an instance variable
    static int b; //this is a class variable
}

package com;
class B{
    //can use a variable here
    // To use a here, we need new A().a;
    // To use b here, we can do,  A.b
}

package hello;
class C{
    //can't use a variable here
}

Edit

Suppose we create a file with name MyProgram.java on Desktop. Below is the code of this file,

class First{
    int a; // a is an instance variable
    static int b;  // b is a static (class) variable

    void display(){
        int c; // c is a local variable
    }
}

class Second{
    public static void mian(){
        First obj = new First();
        obj.a = 10;  // to access instance variable we need object of the class
        obj.b = 20;  // class variable can also be accessed using the object

        // First.a = 10;  //It won't work as a is instance variable and can be accessed by object only

        // First.b = 20;  // We can also access static variables by class name directly without using any object

        // obj.c = 30;  // It won't work. As c is a local variable of method display and can be used only inside that method.

        // First.c = 30;  //It also won't work as c can only be used inside the method where it is declared.
    }
}

Answer 4

Default access modifier means we do not explicitly declare an access modifier for a class, field, 
method, etc.

A variable or method declared without any access control modifier is available to any other    
class    in the same package. The fields in an interface are implicitly public static final and 
the methods in an interface are by default public.

Answer 5

The default package is the package without a name, all classes without a package declaration at the top of the file fall into it.

It is subject to all normal rules of packages except that you can't reference classes of it from a class inside a package.

For example I have 2 java files:

public class A{
    public static void foo(){System.out.println("fooCalled");}
}

and

package com.example;

public class B{
    public static void main(String[] arg){
        A.foo();//won't compile
    }

}

Then B (or in the qualified form com.example.B) can never call the foo of A without reflection magic.

Answer 6

a is a variable inside the static function value and not visible outside of that function at all. Doesn't have to do with access specifiers.