How to create a static class

[Vaishu Mol]

Hi friends,
Im new to java codes. Im learning from the basic things.

How to create a static class. My coding goes like this :

package com.learning.sampleclass;

public static class Sample {
int i = 10;
String name = "Class";
void run(){
System.out.println("Integer : " + i);
}
void stop() {
System.out.println("Application closed......");
}

}
public class HelloClass {

/**
* @param args
*/
public static void main(String[] args) {

Sample sample = new Sample();
sample.run();
sample.i=20;
sample.run();
sample.stop();


}

}

But im getting an error that "Illegeal modifier for the class Sample".
How to create a static class?

[W. Joe Smith]

Here is a quote from a JavaWorld article (linked here):

Top-level classes
You declare a top-level class at the top level as a member of a package. Each top-level class corresponds to its own java file sporting the same name as the class name.

A top-level class is by definition already top-level, so there is no point in declaring it static; it is an error to do so. The compiler will detect and report this error.

[Vaishu Mol]

Thanks a lot buddy

[Vaishu Mol]

And im coming with another doubt :-)

What is the use of inner class?

[David Newton]

Please UseCodeTags when posting code or configuration. Unformatted code and configuration is very difficult to read. You can edit your post to include them by using the button.

Inner classes might be used where only the containing class cares about their definition/implementation. Anonymous inner classes can be used for one-off implementations, used to create closures, and so on.

[Vaishu Mol]

Here my sample innerclass code :

package com.learning.innerclass;

class Calculator {
	int a, b;
	
	//Add method to add 2 numbers
	public void add(InputClass i) {
		a = i.first_num;
		b = i.sec_num;		
		System.out.println("Addition is :" + (a+b));
	}

	//Subtraction method to subtract two numbers
	public void sub(InputClass i) {
		a = i.first_num;
		b = i.sec_num;		
		System.out.println("Subtraction : " + (a-b));
	}
	//Inner class goes here. 
	public static class InputClass {
		int first_num, sec_num;
		InputClass(int a, int b){
			first_num = a;
			sec_num = b;
		}		
	}
}

public class SampleInnerClass {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Calculator calc = new Calculator();
		calc.add(new Calculator.InputClass(10, 5));
		calc.sub(new Calculator.InputClass(20, 10));
		
		

	}

}

And here my top level class code goes :

package com.learning.innerclass;

class Calculator {
	int a, b;
	
	//Add method to add 2 numbers
	public void add(int i, int j) {
		a = i;
		b = j;		
		System.out.println("Addition is :" + (a+b));
	}

	//Subtraction method to subtract two numbers
	public void sub(int i, int j) {
		a = i;
		b = j;		
		System.out.println("Subtraction : " + (a-b));
	}

}

public class SampleInnerClass {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Calculator calc = new Calculator();
		calc.add(10, 20);
		calc.sub(20, 10);
		
		

	}

}

My question is Which one is better code when compare with JVM?
Why we are coming to inner class even we can do the same program without using innerclass?
Please help me friends.

[Ramakrishna Gutha]

Vaishu Mol wrote
What is the use of inner class?

Before addressing your question, first we should address below questions.

1. Is my class have more responsibilities (violating single responsibility principle)?
2. If yes, are the responsibilities private to my class ?

If the responsibilities are private to the class, then separate the extra responsibility from the outer class and put it in the nested/inner class.

Why and when to use nested/inner classes ?

1. Use nested/inner classes for better organization of the class, but don't overuse it.
2. If your class has an extra responsibility and if the scope is within the class, then go ahead and use nested/inner classes.
3. Writing a method adds a behavior to the outer class and writing a nested/inner class makes your outer class think about its own responsibility.
4. You gain all the advantages of OOP using inner classes where necessary.

Fallow the link for more info http://onjava.com/pub/a/onjava/excerpt/HardcoreJava_chap06/index2.html

I hope this is cleared.

Regards
GRK

[David Newton]

Those are quote tags, not code tags.

[Ramakrishna Gutha]

One should be really careful when posting the content, improper content may lead to be confusing among new folks.

[Campbell Ritchie]

David Newton wrote:Those are quote tags, not code tags.

Agree. Changed them, and got rid of the coloured and large text.

[Campbell Ritchie]

Ramakrishna Gutha wrote:One should be really careful when posting the content, improper content may lead to be confusing among new folks.

Agree. I can see some serious errors in your code, I am afraid.

[Ramakrishna Gutha]

Campbell,

I haven't posted any code.

Thanks
GRK

[Campbell Ritchie]

I meant the code you had commented about. Very sorry for the confusion.