static vs final java, both are known access modifiers in Java doing different functionalities (used for different jobs).1. static: static keyword can be applied to instance variables and methods

but not to classes. When applied, variables and methods can be called without the help of an object. When a method or variable is called without object, encapsulation is not maintained. That is, with static variables and methods, encapsulation does not exist.

2. final: final keyword can be applied to all constructs – variables, methods and classes. When applied, final behaves very differently with each with different functionalities.

Let us explore static vs final java programmatically.

I) Usage of static KeywordGenerally, an instance variable or method requires an object to call with. But static variables and methods do not require an object. Observe, the following code.

1234567891011121314151617

public class Employee{  int age = 45;                     // non-static variable  static double salary = 8877.66;   // static variable

  public static void display()     // static method  {    System.out.println("Hello World");  }

  public static void main(String args[])  {    // System.out.println(age);     // raises error, it is non-static and requires object    System.out.println(salary);     // works fine as salary is static, object not required    display();             // works fine as display() is static, object not required  }}

In the above code, age is non-static and requires an object to call with. Observe, the main() method. salary being static does not require an object. Similarly with static display() method. It is called wihtout the need of an object.II) Usage of final KeywordAs stated earlier, the final keyword can be applied in three places – variables, methods and classes. When applied it behaves differently.

1. A final variable cannot be reassigned.2. A final method cannot be overridden.3. A final class cannot be inherited.

But one thing can be found in common among the above three, "final means something cannot be done".

a) final with variablesA final variable works like a constant of C/C++. That is, a final variable cannot be reassigned. Java does not support const keyword and its place uses final keyword.

12345678910111

public class Bank{  public static void main(String args[])  {    int rupees = 500;     // non-final can be reassigned    System.out.println("rupees before reassigned: " + rupees);    rupees = 600;     // non-final    System.out.println("rupees after reassigned: " + rupees);

    final double $rate = 61.5;     // final cannot be reassigned    System.out.println("$ Rate is Rs." + $rate);    // $rate = 62.8;     // raises error  }}

21314

The variable rupees is not final and thereby reassigned with a new value of 600. $rate is finaland thereby cannot be reassigned.b) final with methodsIf the super class does not permit the subclass to override, it simply declares the method as final. The final methods of super class cannot be overridden by subclass.

123456789101112131415

class Manager{  public final void doSomeThing()   // observe final  {    System.out.println("Do it right now");  }}public class Worker extends Manager{  public static void main(String args[])  {    Worker w1 = new Worker();    w1.doSomeThing();  }}

In the super class Manager, doSomeThing() is declared final. The subclass Worker is not permitted to override. Try once, it raises compilation error. If the super class have non-final methods (not shown in the code), the subclass can feel free to override at its convenience.c) final with classesThe programmer may not like a class to be inherited by other classes because he would like to allow the accessibility throgh composition not by inheritance.

123456789101112

final class Fruit    // observe, final class{  String nature = "Seedless";}public class Mango                 // extends Fruit raises compilation error{  public static void main(String args[])  {    Fruit f1 = new Fruit();    System.out.println("Fruit type is " + f1.nature);  }}

In the above code, Fruit is declared as final and thereby Mango cannot extend it. Then how it can make use of Fruit class methods? Simply by creating an object of Fruit and calling Fruitclass methods. This is known as composition.

What is Composition in Java?Creating an object of other class in our class and calling other class variables and methods is known as composition (known as has-a relationship as one class "has a" object of other class). Here, object and method or variable belong to the same class. In contrast, in inheritance object belongs to subclass and variable or method belong to super class.

Interfaces

An interface is a contract: the guy writing the interface says, "hey, I accept things looking that way", and the guy using the interface says "Ok, the class I write looks that way".An interface is an empty shell, there are only the signatures of the methods, which implies that the methods do not have a body. The interface can't do anything. It's just a pattern.E.G (pseudo code):

// I say all motor vehicles should look like this:interface MotorVehicle{ void run();

int getFuel();}

// my team mate complies and writes vehicle looking that wayclass Car implements MotorVehicle{

int fuel;

void run() { print("Wrroooooooom"); }

int getFuel() { return this.fuel; }}Implementing an interface consumes very little CPU, because it's not a class, just a bunch of names, and therefore there is no expensive look-up to do. It's great when it matters such as in embedded devices.

Abstract classes

Abstract classes, unlike interfaces, are classes. They are more expensive to use because there is a

look-up to do when you inherit from them.

Abstract classes look a lot like interfaces, but they have something more : you can define a behavior for them. It's more about a guy saying, "these classes should look like that, and they have that in common, so fill in the blanks!".

e.g:

// I say all motor vehicles should look like this :abstract class MotorVehicle{

int fuel;

// they ALL have fuel, so why not let others implement this? // let's make it for everybody int getFuel() { return this.fuel; }

// that can be very different, force them to provide their // implementation abstract void run();

}

// my team mate complies and writes vehicle looking that wayclass Car extends MotorVehicle{ void run() { print("Wrroooooooom"); }}

Implementation

While abstract classes and interfaces are supposed to be different concepts, the implementations make that statement sometimes untrue. Sometimes, they are not even what you think they are.

In Java, this rule is strongly enforced, while in PHP, interfaces are abstract classes with no method declared.

In Python, abstract classes are more a programming trick you can get from the ABC module and is actually using metaclasses, and therefore classes. And interfaces are more related to duck typing in this language and it's a mix between conventions and special methods that call descriptors (the __method__ methods).

As usual with programming, there is theory, practice, and practice in another language :-)

share improve this answer edited Apr 29 '15 at 13:32

nbro

3,04641030

149 practical explanation is always the best ! – Sarfraz Dec 16 '09 at 10:34

2 The key point about interfaces is not so much that they say what a class does, but allow objects that can Wizzle to make themselves useful to code that needs a Wizzler. Note that in many cases neither the person who writes the thing that can Wizzle, nor the person who needs a Wizzler, will be the person who writes the interface. – supercat Mar 27 '13 at 21:28

30 I don't think that CPU consumption is the highlight-worthy point on interfaces.21:40

1 @AshwinP - see this question, specificially this answer

Now I understand that Declare method in interface is implicit Public, But when we implement it should be as Public otherwise it is Protected. Right @Xynariz – AshwinP

show 10 more comments

up vot

e394down vote

The key technical differences between an abstract class and an interface are: Abstract classes can have constants, members, method stubs (methods without a

body) and defined methods, whereas interfaces can only have constants and methods stubs.

Methods and members of an abstract class can be defined with any visibility, whereas all methods of an interface must be defined as public (they are defined public by default).

When inheriting an abstract class, a concrete child class must define the abstract methods, whereas an an abstract class can extend another abstract class and abstract methods from the parent class don't have to be defined.

Similarly, an interface extending another interface is not responsible for implementing methodsfrom the parent interface. This is because interfaces cannot define any implementation.

A child class can only extend a single class (abstract or concrete), whereas an interface can extend or a class can implement multiple other interfaces.

A child class can define abstract methods with the same or less restrictive visibility, whereas a class implementing an interface must define the methods with the exact same visibility (public).

share improve this answer edited Feb 10 at 2:11 answered Dec 16 '09 at 10:11

Justin Johnson

20.3k74073

52 i think this is the best answer because it highlights all of the key differences. an example's not really necessary. – Joshua Kersey Jul 10 '11 at 18:01

1 And normally with classes you can instantiate an object from it unlike the abstract classes whichinstantiated. – SASM Jul 9 '13 at 20:48

I thought a class that implement the interface need to define all the methods in the interface? –'13 at 12:33

@Jiazzyuser If an abstract class implements an interface, it does not have to actually define the interface's methods.

That requirement can be deferred to inheriting/child concrete classes. However, a concrete class must implement all interface methods that are not implemented by its parent class. I'll add example to illustrate this point.Johnson Jan 28 '14 at 20:44

1 "When inheriting an abstract class, the child class must define the abstract methods, whereas an interface can extend another interface and methods don't have to be defined." - This is not true. Just as an interface can extend an interface without defining methods, an abstract class can inherit an abstract class without defining methods. – Nick Mar 10 '14 at 17:21

show 7 more comments

up vot

e56down vote

An explanation can be found here: http://www.developer.com/lang/php/article.php/3604111/PHP-5-OOP-Interfaces-Abstract-Classes-and-the-Adapter-Pattern.htmAn abstract class is a class that is only partially implemented by the programmer. It may contain one or more abstract methods. An abstract method is simply a function definition that serves to tell the programmer that the method must be implemented in a child class.

An interface is similar to an abstract class; indeed interfaces occupy the same namespace as classes and abstract classes. For that reason, you cannot define an interface with the same name as a class. An interface is a fully abstract class; none of its methods are implemented and instead of a class sub-classing from it, it is said to implement that interface.Anyway I find this explanation of interfaces somewhat confusing. A more common definition is: An interface defines a contract that implementing classes must fulfill. An interface definition consists of signatures of public members, without any implementing code.share improve this answer edited Dec 16 '09 at 8:24 answered Dec 16 '09 at 8:18

Konamiman

26.9k1372104

3 This is the most correct answer, since PHP interfaces differ from other languages in that PHP interfaces ARE abstract classes under the hood, whereas other languages' interfaces are signatures that classes must match. They behave the same as long as there are no errors though. – Tor Valamo Dec 16 '09 at 8:55

1 True, for PHP it's the real best anwser. But it's harder to get from the text blob than from a simple snippet.

satis Dec 16 '09 at 12:15

From the definitions you provided, they look the same except for one detail: and interface is 100% abstract, while an abstract class is partially abstract and can have some method implementations (perhaps all methods can have implementations?). – jww Aug 23 '14 at 4:02

add a comment

up vot

e43down vote

Interface contains only definition / signature of functionality, and if we have some common functionality as well as common signature then there is a need of abstract class so through abstract class we can provide behavior as well as functionality both in the same time, developer inheriting abstract class can use this functionality and need to fill only in the blank.

Taken From :-

http://www.dotnetbull.com/2011/11/difference-between-abstract-class-and.htmlhttp://www.dotnetbull.com/2011/11/what-is-abstract-class-in-c-net.html http:// www.dotnetbull.com/2011/11/what-is-interface-in-c-net.htmlshare improve this answer answered Sep 15 '13 at 8:59

Vivek

1,76486

3 You need to say what language this applies to ("Abstract class does not support multiple inheritance" is far from being universally true) – Ben Voigt Mar 7 '14 at 4:16

Last comparison is confusing as per table! Methods in interface can't be static but variables are static final Implemented methods in abstract class can be static – PK' Mar 9 '14 at 4:29

Typo it not Cunstructor .. Its Constructor.. – Orion Jul 18 '14 at 10:57

Member of the interface must be static final . Last statement is wrong. – Nepster Aug 5 '14 at 8:21

add a comment

up vot

e15down vote

Some important differences:

In the form of a table:

As stated by Joe from javapapers:1.Main difference is methods of a Java interface are implicitly abstract and cannot have implementations. A Java abstract class can have instance methods that implements a default behavior.

2.Variables declared in a Java interface is by default final. An abstract class may contain non-final variables.

3.Members of a Java interface are public by default. A Java abstract class can have the usual flavors of class members like private, protected, etc..

4.Java interface should be implemented using keyword “implements”; A Java abstract class should be extended using keyword “extends”.

5.An interface can extend another Java interface only, an abstract class can extend another Java class and implement multiple Java interfaces.

6.A Java class can implement multiple interfaces but it can extend only one abstract class.

7.Interface is absolutely abstract and cannot be instantiated; A Java abstract class also cannot be instantiated, but can be invoked if a main() exists.

8.In comparison with java abstract classes, java interfaces are slow as it requires extra indirection.

Abstract class Interface

1) Abstract class can have abstract and non-abstractmethods.

Interface can have only abstract methods.

2) Abstract class doesn't support multiple inheritance. Interface supports multiple inheritance

3) Abstract class can have final, non-final, static and non-static variables.

Interface has only static and final variables

4) Abstract class can have static methods, main method and constructor.

Interface can't have static methods, main method or constructor.

5) Abstract class can provide the implementation of interface.

Interface can't provide the implementation of abstract class.

6) The abstract keyword is used to declare abstract class. The interface keyword is used to declare interface.

7) Example:public abstract class Shape{public abstract void draw();}

Example:public interface Drawable{void draw();}

Simply, abstract class achieves partial abstraction (0 to 100%) whereas interface achieves fully abstraction (100%).

Example of abstract class and interface in Java

Let's see a simple example where we are using interface and abstract class both.

1. //Creating interface that has 4 methods  2. interface A{  3. void a();//bydefault, public and abstract  

4. void b();  5. void c();  6. void d();  7. }  8.   9. //Creating abstract class that provides the implementation of one method of A interface  10. abstract class B implements A{  11. public void c(){System.out.println("I am C");}  12. }  13.   14. //Creating subclass of abstract class, now we need to provide the implementation of rest of t

he methods  15. class M extends B{  16. public void a(){System.out.println("I am a");}  17. public void b(){System.out.println("I am b");}  18. public void d(){System.out.println("I am d");}  19. }  20.   21. //Creating a test class that calls the methods of A interface  22. class Test5{  23. public static void main(String args[]){  24. A a=new M();  25. a.a();  26. a.b();  27. a.c();  28. a.d();  29. }}  

n this tutorial we will discuss the difference between overloading and overriding in Java.

If you are new to these terms then refer the following posts:

1. Method overloading in java

2. Method overriding in java

Overloading vs Overriding in Java1. Overloading happens at compile-time while Overriding happens at runtime: The binding of

overloaded method call to its definition has happens at compile-time however binding of

overridden method call to its definition happens at runtime.

2. Static methods can be overloaded which means a class can have more than one static

method of same name. Static methods cannot be overridden, even if you declare a same

static method in child class it has nothing to do with the same method of parent class.

3. The most basic difference is that overloading is being done in the same class while for

overriding base and child classes are required. Overriding is all about giving a specific

implementation to the inherited method of parent class.

4. Static binding  is being used for overloaded methods anddynamic binding is being used for

overridden/overriding methods.

5. Performance: Overloading gives better performance compared to overriding. The reason

is that the binding of overridden methods is being done at runtime.

6. private and final methods can be overloaded but they cannot be overridden. It means a

class can have more than one private/final methods of same name but a child class

cannot override the private/final methods of their base class.

7. Return type of method does not matter in case of method overloading, it can be same or

different. However in case of method overriding the overriding method can have more

specific return type (refer this).

8. Argument list should be different while doing method overloading. Argument list should be

same in method Overriding.

Overloading example//A class for adding upto 5 numbersclass Sum{ int add(int n1, int n2) { return n1+n2; } int add(int n1, int n2, int n3) { return n1+n2+n3; } int add(int n1, int n2, int n3, int n4) { return n1+n2+n3+n4; } int add(int n1, int n2, int n3, int n4, int n5) { return n1+n2+n3+n4+n5; } public static void main(String args[]) {

Sum obj = new Sum(); System.out.println("Sum of two numbers: "+obj.add(20, 21)); System.out.println("Sum of three numbers: "+obj.add(20, 21, 22)); System.out.println("Sum of four numbers: "+obj.add(20, 21, 22, 23)); System.out.println("Sum of five numbers: "+obj.add(20, 21, 22, 23, 24)); }}

Output:

Sum of two numbers: 41Sum of three numbers: 63Sum of four numbers: 86Sum of five numbers: 110

Here we have 4 versions of same method add. We are overloading the

method add() here.

Overriding examplepackage beginnersbook.com;class CarClass{ public int speedLimit() { return 100; }}class Ford extends CarClass{ public int speedLimit() { return 150; } public static void main(String args[]) { CarClass obj = new Ford(); int num= obj.speedLimit(); System.out.println("Speed Limit is: "+num); }}

Output:

Speed Limit is: 150

Difference between method and constructor in JavaWhat is difference between method and constructor in Java is very common questions on beginner level Java interviews with 2 to 3 year experience. Since constructor is kind of special and it has it's own properties which separates it from any normal Java method, this question make sense. Main difference between Constructor and Method is that, you need to call method explicitly but constructor is called implicitly by Java programming language during object instantiation. It doesn't mean you can not call Constructor; if you have overloaded constructor than you can call them using  this keyword as this() constructor, you can even call super class constructor using super() keyword, in-fact that is done automatically by Java compiler if no explicitly constructor is called and that is known as constructor chaining in Java. Like many other beginner level questions e.g. Vector vs ArrayList, We will see difference between method and constructor in Java in point form to understand important properties of each of them clearly.

Method vs Constructor in Java

Both method and constructor wraps bunch of code but constructor is very different than normal method in Java. Before seeing difference between Constructor and Method, let's see some common things between them.

1) Both method and Constructor can be overloaded or overridden in Java. Though calling mechanism of Constructor is different than method. you can call an overloaded constructor as this(argument) or super(argument) based upon whether its declared on same class or super class but for calling overloaded method or overridden method, you simply use method name.

2) You can make your constructor public, protected, private similar to your method in Java. By the way If you are not familiar with access modifier in Java than see Difference between public, protected and private keyword in Java.

Now let's see some important difference between method and constructor in Java :

1) First difference between method vs constructor in Java is that name of constructor must be same with name of the Class but there is no such requirement for method in Java. methods can have any arbitrary name in Java.

2) Second difference between method and constructor in Java is that constructor doesn't have any return type but method has return type and return something unless its void.

3) Third difference between constructor and method in Java is that Constructors are chained and they are called in a particular order, there is no such facility for methods.

4) Unlike method, constructor, yet declared in class doesn't considered as member of Class. Constructors are not inherited by child classes but methods are inherited by child classes until they are made private. on which case they are only visible in class on which they are declared. Similarly private constructor means you can not create object of that class from outside, this is one of the technique used to implement Singleton pattern in Java.

5) Another difference between method and constructor in Java is that special keyword this and super is used to call constructor explicitly. no such thing for method, they have there own name which can be used to call them.

That's all on difference between method and constructor in Java. You can compare method vs Constructor on different points but  main thing is that they are used for object initialization, while method is used to perform a small unit of task.

Read more: 

Types of inheritance in Java: Single,Multiple,Multilevel & HybridBY: CHAITANYA | LAST UPDATED: DECEMBER 6, 2013

Below are Various types of inheritance in Java. We will see each one of them one by

one with the help of examples and flow diagrams.

1) Single Inheritance

Single inheritance is damn easy to understand. When a class extends another one

class only then we  call it a single inheritance. The below flow diagram shows that class

B extends only one class which is A. Here A is a parent class of B and B would be

a child class of A.

Single Inheritance example program in Java

Class A

{

public void methodA()

{

System.out.println("Base class method");

}

}

Class B extends A

{

public void methodB()

{

System.out.println("Child class method");

}

public static void main(String args[])

{

B obj = new B();

obj.methodA(); //calling super class method

obj.methodB(); //calling local method

}

}

2) Multiple Inheritance

“Multiple Inheritance” refers to the concept of one class extending (Or inherits) more

than one base class. The inheritance we learnt earlier had the concept of one base

class or parent. The problem with “multiple inheritance” is that the derived class will

have to manage the dependency on two base classes.

Note 1: Multiple Inheritance is very rarely used in software projects. Using Multiple

inheritance often leads to problems in the hierarchy. This results in unwanted

complexity when further extending the class.

Note 2: Most of the new OO languages like Small Talk, Java, C# do not support Multiple inheritance. Multiple Inheritance is supported in C++.

3) Multilevel Inheritance

Multilevel inheritance refers to a mechanism in OO technology where one can inherit

from a derived class, thereby making this derived class the base class for the new

class. As you can see in below flow diagram C is subclass or child class of B and B is a

child class of A. For more details and example refer – Multilevel inheritance in Java.

Multilevel Inheritance example program in Java

Class X

{

public void methodX()

{

System.out.println("Class X method");

}

}

Class Y extends X

{

public void methodY()

{

System.out.println("class Y method");

}

}

Class Z extends Y

{

public void methodZ()

{

System.out.println("class Z method");

}

public static void main(String args[])

{

Z obj = new Z();

obj.methodX(); //calling grand parent class method

obj.methodY(); //calling parent class method

obj.methodZ(); //calling local method

}

}

4) Hierarchical Inheritance

In such kind of inheritance one class is inherited by many sub classes. In below

example class B,C and D inherits the same class A. A isparent class (or base class) of B,C & D. Read More at – Hierarchical Inheritance in java with example

program.

5) Hybrid Inheritance

In simple terms you can say that Hybrid inheritance is a combination

of Single and Multiple inheritance. A typical flow diagram would look like below. A

hybrid inheritance can be achieved in the java in a same way as

multiple inheritance can be!! Using interfaces. yes you heard it right. By

using interfaces you can have multiple as well as hybrid inheritance in Java.

Read the full article here – hybrid inheritance in java with example