Show A class which has the abstract keyword in its declaration is called abstract class. Abstract classes should have zero or more abstract methods. i.e., methods without a body. It can have multiple concrete methods. Abstract classes allow you to create blueprints for concrete classes. But the inheriting class should implement the abstract method. Abstract classes cannot be instantiated. Important Reasons For Using Interfaces
Important Reasons For Using Abstract Class
The interface is a blueprint that can be used to implement a class. The interface does not contain any concrete methods (methods that have code). All the methods of an interface are abstract methods. An interface cannot be instantiated. However, classes that implement interfaces can be instantiated. Interfaces never contain instance variables but, they can contain public static final variables (i.e., constant class variables) Difference between Interface and Abstract Class in JavaAn abstract class permits you to make functionality that subclasses can implement or override whereas an interface only permits you to state functionality but not to implement it. A class can extend only one abstract class while a class can implement multiple interfaces.
Sample code for Interface and Abstract Class in JavaFollowing is sample code to create an interface and abstract class in Java Interface Syntax interface name{ //methods }Java Interface Example: Abstract Class Syntax abstract class name{ // code }Abstract class example: abstract class Shape { int b = 20; abstract public void calculateArea(); } public class Rectangle extends Shape { public static void main(String args[]) { Rectangle obj = new Rectangle(); obj.b = 200; obj.calculateArea(); } public void calculateArea() { System.out.println("Area is " + (b * b)); } }
When used as a declaration modifier, the new keyword explicitly hides a member that is inherited from a base class. When you hide an inherited member, the derived version of the member replaces the base class version. This assumes that the base class version of the member is visible, as it would already be hidden if it were marked as private or, in some cases, internal. Although you can hide public or protected members without using the new modifier, you get a compiler warning. If you use new to explicitly hide a member, it suppresses this warning. You can also use the new keyword to create an instance of a type or as a generic type constraint. To hide an inherited member, declare it in the derived class by using the same member name, and modify it with the new keyword. For example: public class BaseC { public int x; public void Invoke() { } } public class DerivedC : BaseC { new public void Invoke() { } }In this example, BaseC.Invoke is hidden by DerivedC.Invoke. The field x is not affected because it is not hidden by a similar name. Name hiding through inheritance takes one of the following forms:
It is an error to use both new and override on the same member, because the two modifiers have mutually exclusive meanings. The new modifier creates a new member with the same name and causes the original member to become hidden. The override modifier extends the implementation for an inherited member. Using the new modifier in a declaration that does not hide an inherited member generates a warning. ExamplesIn this example, a base class, BaseC, and a derived class, DerivedC, use the same field name x, which hides the value of the inherited field. The example demonstrates the use of the new modifier. It also demonstrates how to access the hidden members of the base class by using their fully qualified names. public class BaseC { public static int x = 55; public static int y = 22; } public class DerivedC : BaseC { // Hide field 'x'. new public static int x = 100; static void Main() { // Display the new value of x: Console.WriteLine(x); // Display the hidden value of x: Console.WriteLine(BaseC.x); // Display the unhidden member y: Console.WriteLine(y); } } /* Output: 100 55 22 */In this example, a nested class hides a class that has the same name in the base class. The example demonstrates how to use the new modifier to eliminate the warning message and how to access the hidden class members by using their fully qualified names. public class BaseC { public class NestedC { public int x = 200; public int y; } } public class DerivedC : BaseC { // Nested type hiding the base type members. new public class NestedC { public int x = 100; public int y; public int z; } static void Main() { // Creating an object from the overlapping class: NestedC c1 = new NestedC(); // Creating an object from the hidden class: BaseC.NestedC c2 = new BaseC.NestedC(); Console.WriteLine(c1.x); Console.WriteLine(c2.x); } } /* Output: 100 200 */If you remove the new modifier, the program will still compile and run, but you will get the following warning: The keyword new is required on 'MyDerivedC.x' because it hides inherited member 'MyBaseC.x'.C# language specificationFor more information, see The new modifier section of the C# language specification. See also |