If I have this code.
public class Test{
{
class People {
}
}
public static void main(String[] args) {
People person = new People();//Compile ERROR
}
}
I can't create instance of People.
Does that mean Initializer Block can't be used for defining classes?
(Adding a second answer as my wrong one had three upvotes already.)
You can declare a class within an initializer block - but its scope is that initializer block, just like if you declared it in a method. So this works:
public class Test {
{
class People {
}
People people = new People();
System.out.println("In initializer block!");
}
public static void main(String[] args) {
new Test();
}
}
I can't say I've ever done this before though, nor can I imagine myself wanting to do it any time soon. Note that this is a local class, which is always implicitly an inner class. (Although if you declare a local class in a static method, there's no enclosing instance, just to make the terminology slightly weird...)
If you want to create a class which code outside the initializer block can "see", you need to declare it outside the initializer block. (Just like any other declaration - if you declared a variable within the initializer block, you wouldn't expect to be able to see it outside would you?)
static, as you suggested earlier and other answers suggest.
You need to make the inner class static:
static class People {
The initializer block (defined by the extra brackets) changes the scope of the declared class, so it will not be visible outside, much like a variable would not be. So, the only place where a People object can be created, is within the block itself, e.g.
{
class People {
}
People person = new People();
}
Without the initializer block, there are 2 options you can follow:
People class as staticIn the first case, the only thing that changes is the line
static class People
For the second case, the main method would look something like
public static void main(String[] args) {
People person = new Test().new People();
}
You can do
Test t = new Test();
People person = t. new People();
Because People otherwise has no enclosing instance
EDIT:
Since the class definition is in an initialization block, it is only visible and useable locally, INSIDE the initialization block (which makes it a peculiar place to define a class). The People class can't be visible in main since there is no visible type for People. The approach I outlined above would only work if there were no initialization block around the class definition.
People is local class which belongs to initializing block scope only.
person object in mainperson object is accessible from main, and since OP is creating the object in main, I'm assuming he wants to use it there.Person class is declared inside initialization block (like in OP example) then there is no Test.Person type. That is why OP is asking "Does that mean Initializer Block can't be used for defining classes?". What you are saying in your answer it is perfectly fine, just use instance of outer class, while it is not. That is why Jon Skeet removed his first answer which was similar to yours.Yes we can declare initializer block and scope of the class People will be within it.Update the code as below :
public class Test {
{
class People {
/// Stuff
}
People people = new People(); // Create object of People
System.out.println("Initializer block");
}
public static void main(String[] args) {
Test obj = new Test();
}
}
