static and non static
static
- static is class specific
static variable: only one copy of it exists, and all objects share that one copy.
static method: Can be called using the class name directly, doesn't need an object.
what can be static java?
1.varibles(fields)
class Student{
static String college = "Jaya College";
}
- static methods(class-level method)
used when:
- you don't need to use object data(this)
- you want to call it without creating an object.
`class Utility
{
static void printMessage()
{
System.out.println("hell from static method");
}
}
//calling using Utility.printMessage();
`
3.Static Blocks(Runs only once when class is loaded)
used to : initialize static variable
class Example
{
static int data;
static {
data =100;
System.out.println("Static block executed");
}
}
4.static Nested class
use when : you want a class inside another class without needing the outer class object.
`
class Outer {
static class Inner {
void show() {
System.out.println("Inside static nested class");
}
}
}
`
call using:
Outer.Inner obj = new Outer.Inner();
obj.show();
you cannot use static :
Local varibales (int x=5; inside a method) static
Constructor static
Classes (top-level) static ( unless they are nested inside another class)
Example
class car {
static int car =4;
}
// now whether you create 1 object or 100 , all cars shares the same number of weels
//static = belongs to class, shared by all, only one copy.
public class MyClass2 {
static int val =1;
public static void main(String[] args) {
MyClass2 obj1 = new MyClass2();
MyClass2 obj2 = new MyClass2();
obj1.val=10;
System.out.println("obj1 val:"+obj1.val);
System.out.println("obj2 val:"+obj2.val);
}
}
output:
obj1 val:10
obj2 val:10
//
non static
- non-static is instance specific
- if a variable is non-static ,then every object has its own separate copy that mean Non-static members belong to the object, it gets own copy of non static variables and can use non-static method.
Example: 1
public class MyClass {
int val =1;
public static void main(String[] args) {
MyClass obj1 = new MyClass();
MyClass obj2 = new MyClass();
obj1.val=10; // change value for obj1
System.out.println("obj1 val:"+obj1.val);
System.out.println("obj2 val:"+obj2.val);
// non-static = belongs to object, each object has its own value.
}
}
output:
obj1 val:10
obj2 val:1
- non-static variables (instance variable)
use when: Each object should have it own values.
example 2:
class Student
String name;
int id;
Student (String name ,int id)
{
this.name =name;
this.id = id;
}
void display()
{
System.out.println(name +" "+id);
}
public class Test {
public static void main(String[] args)
{
Student s1 = new Student("John", 1);
Student s2 = new Student("Emma", 2);
s1.display(); //John
s2.display(); //Emma
}
}
- Non-static Method (Instance Method) used when you want to work with object data like name,id you need use this keyword
class Car {
String brand;
void showBrand() { // non-static method
System.out.println("Brand: " + brand);
}
}
//you must to create object to call it:
public class Test {
public static void main(String[] args)
{
Car c = new Car();
c.brand="Tata";
c.showBrand();
}
}
- you can not use non-static members inside static methods directly.
class Example {
int x = 10; // non-static
static void show() {
// System.out.println(x); // Error
}
}
//To access x, you must create an object:
static void show {
Example e shwo = new Example();
System.out.println(e.x);
}
What does “belong to class” mean?
- It means the variable or method is shared by all objects of that class.
- You don’t need to create an object to access it.
- Use the static keyword.
What does “belong to object” mean?
- It means each object has its own copy of that variable or method.
- You need to create an object to use it.
- Do not use static keyword.
why can not use to static in class(top-level)?
because not belong to any another class, only for static variable ,block,methods ,inner class
now see top level-class valid and invalid modifiers for class
Valid Modifiers for Top-Level Classes:
1.public -> class is accessible from anywhere
2.default -> no keyword=package-private, used only within the same package.
3.abstract -> class cannot-be instantiated(can not create object) ,must be inherited(extend) and If the subclass does NOT implement all abstract methods,
then the subclass must also be declared abstract. Abstract class can have normal methods too.
// we will detail info of abstraction concept
Why can't we create an object of an abstract class?
Abstract class is incomplete- it might have abstract methods(with out body). you must create a subclass that completes those methods. so that's why doesn't allow you to create object directly.
Why abstract class cannot achieve 100% abstraction?
Because:
- An abstract class can contain concrete methods (with body).
- So, not everything is hidden from the user.
- That’s why it cannot achieve 100% abstraction. You can say: Abstract class = Partial abstraction
Why interface can achieve 100% abstraction?
Because:
- All methods in an interface are abstract by default (before Java 8).
- You cannot write method body (in older versions).
- It only contains method declarations, no implementations. So, the user only sees "what to do", not "how".
Animal a = new Animal(); // Error: Cannot instantiate abstract class
Animal a = new Dog(); // Allowed: Dog is a subclass of Animal/
4.final -> class cannot be extended( no sub classing) like not is-relationship or prevent inheritance
Invalid Modifiers for Top-Level Classes:
1.private -> No class can see it in the world, so it's useless.
2.protected -> used for members only (variable and methods), not for top-level class
3.static -> Only for inner class, not outer class.
how and where static, instance, and local variables and methods are called, accessed, and hold values.
class Variable {
int instancevar=10;
static int staticVar =20;
public static void main(String[] args) {
//local variable must be initialized
int localVar=30;
System.out.println("Local variable"+localVar);
System.out.println("Static Varibale:"+staticVar);
//accessing instace variable -> directely not allowed
//System.out.println("Instace variable:"+obj1.instancevar);
Variable obj1= new Variable();
System.out.println("Instace variable:"+obj1.instancevar);
obj1.instanceMethod();
}
static void staticMethod()
{
System.out.println("inside static method");
System.out.println("Static Varibale:"+staticVar);
Variable obj1= new Variable();
System.out.println("Instace variable:"+obj1.instancevar);
}
void instanceMethod()
{
System.out.println("inside instace method");
staticMethod();
System.out.println("Static Varibale:"+staticVar);
System.out.println("Instace variable:"+instancevar);
}
}
Note:-
- Static Method: Can only access static members directly.
- To access instance members, create an object.
- Instance Method: Can access both static and instance members directly.
- Local Variables: Only exist inside the method, and must be initialized.
Example:-
public class StaticandNonStatic_Example {
static int staticCounter =0;
int instanceCounter = 0 ;
//static method
public static void staticMethod()
{
System.out.println("Inside static method");
// Access static variable directely
System.out.println("static Counter:"+ staticCounter);
// can not access non-static variable directely
//System.out.println(instanceCounter);//error
// can not call non-static method directely
// instanceMethod(); //error
}
// non-static method
public void instanceMethod()
{
System.out.println("Inside Non-static(instance) method");
//
System.out.println("Static counter: "+staticCounter);
System.out.println("Instance Counter: "+instanceCounter);
staticMethod();
}
public static void main(String[] args) {
//
StaticandNonStatic_Example obj1 = new StaticandNonStatic_Example();
StaticandNonStatic_Example obj2 = new StaticandNonStatic_Example();
obj1.instanceMethod();
System.out.println("inside of staticMethod in non-staticCounter "+obj1.instanceCounter);
obj1.instanceCounter =1;
System.out.println("Reassigning value instanceCounter in static method:- "+obj1.instanceCounter);
//System.out.println("Inside of Staticounter"+staticCounter);
}
}
Top comments (0)