Packaes & interfaces
Download as PPTX, PDF•0 likes•144 views
This document discusses key concepts in Java including packages, access specifiers, interfaces, multiple inheritance, extending interfaces, and the differences between abstract classes and interfaces. Packages allow grouping of related classes and interfaces. Access specifiers determine visibility of classes, interfaces, and members. Interfaces define behaviors without implementations, and classes implement interfaces. Multiple inheritance is supported through interfaces in Java. Interfaces can extend other interfaces. Abstract classes contain abstract and concrete methods while interfaces contain only abstract methods.
![/*defining a package*/
package Demo_Package;
public class Demo_Pack
{ public void demo_142()
{ System.out.println("hello world"); }
}
/*importing a package*/
import Demo_Package.*;
public class Demo_1
{
public static void main(String[] y)
{
Demo_Pack p=new Demo_Pack();
p.demo_142();
}
}](https://image.slidesharecdn.com/packaesinterfaces-160715060325/85/Packaes-interfaces-3-320.jpg)
![interface Demo_ //interface declaration
{ int int_variable=10;
void demo(); // no method body
}
//implementing interface
public class Demo_interface implements Demo_
{ public void demo() //interface body implemented
{ System.out.println("hellow interface"); }
public static void main(String[] args)
{ Demo_interface d=new Demo_interface();
d.demo();
}
}](https://image.slidesharecdn.com/packaesinterfaces-160715060325/85/Packaes-interfaces-7-320.jpg)
![Multiple inheritance in java
interface Demo_Interface
{ void Demo_Interface(); }
class Demo
{ void Demo_Print_method()
{ System.out.println("the class Demo method called"); }
}
public class Multiple_Inheritance extends Demo implements Demo_Interface
{ public void Demo_Interface()
{ System.out.println("hello Demo_INterface method called"); }
public static void main(String[] args)
{ Multiple_Inheritance MI=new Multiple_Inheritance();
MI.Demo_Print_method(); //class method called
MI.Demo_Interface(); //interface method called
}
}](https://image.slidesharecdn.com/packaesinterfaces-160715060325/85/Packaes-interfaces-8-320.jpg)
![Extending interface
interface News_Paper_Color
{ void News_Paper_Color(); }
interface Magazine_Paper_Color extends News_Paper_Color
{ void Magazine_Paper_Color(); }
public class Multiple_Inheritance implements Magazine_Paper_Color
{ public void News_Paper_Color()
{ System.out.println("the New Papaer Color red"); }
public void Magazine_Paper_Color()
{ System.out.println("the magazinge paper color yellow"); }
public static void main(String[] args)
{
/*
* we can not create objects for interface class
*/
//News_Paper_Color n=new News_Paper_Color();
Multiple_Inheritance Mi=new Multiple_Inheritance();
Mi.News_Paper_Color();
Mi.Magazine_Paper_Color();
}
}](https://image.slidesharecdn.com/packaesinterfaces-160715060325/85/Packaes-interfaces-9-320.jpg)
Packaes & interfaces
- 1. Packages Access Specifiers Interfaces Multiple Inheritance Extending Interface Interface vs Abstract Practice Questions
- 2. Packages • Packages in Java is a mechanism to encapsulate a group of classes, interfaces and sub packages. • Many implementations of Java use a hierarchical file system to manage source and class files. • example: java.lang Syntax Package <package name> This statement should be used in the beginning of the program
- 3. /*defining a package*/ package Demo_Package; public class Demo_Pack { public void demo_142() { System.out.println("hello world"); } } /*importing a package*/ import Demo_Package.*; public class Demo_1 { public static void main(String[] y) { Demo_Pack p=new Demo_Pack(); p.demo_142(); } }
- 4. Access Specifiers • private: accessible only in the class • no modifier: so-called “package” access — accessible only in the same package • protected: accessible (inherited) by subclasses, and accessible by code in same package • public: accessible anywhere the class is accessible, and inherited by subclasses
- 5. Interface • Interface is a pure abstract class • syntactically similar to classes, but you cannot create instance of an Interface • Their methods are declared without any body. • When you create an interface it defines what a class can do without saying anything about how the class will do it Syntax for declaring interface • Interface <interface_name> • {…}
- 6. • Syntax for Declaring interface Interface <interface_name> {…} • Syntax for implementing interface Classname implements <interface_name> {…}
- 7. interface Demo_ //interface declaration { int int_variable=10; void demo(); // no method body } //implementing interface public class Demo_interface implements Demo_ { public void demo() //interface body implemented { System.out.println("hellow interface"); } public static void main(String[] args) { Demo_interface d=new Demo_interface(); d.demo(); } }
- 8. Multiple inheritance in java interface Demo_Interface { void Demo_Interface(); } class Demo { void Demo_Print_method() { System.out.println("the class Demo method called"); } } public class Multiple_Inheritance extends Demo implements Demo_Interface { public void Demo_Interface() { System.out.println("hello Demo_INterface method called"); } public static void main(String[] args) { Multiple_Inheritance MI=new Multiple_Inheritance(); MI.Demo_Print_method(); //class method called MI.Demo_Interface(); //interface method called } }
- 9. Extending interface interface News_Paper_Color { void News_Paper_Color(); } interface Magazine_Paper_Color extends News_Paper_Color { void Magazine_Paper_Color(); } public class Multiple_Inheritance implements Magazine_Paper_Color { public void News_Paper_Color() { System.out.println("the New Papaer Color red"); } public void Magazine_Paper_Color() { System.out.println("the magazinge paper color yellow"); } public static void main(String[] args) { /* * we can not create objects for interface class */ //News_Paper_Color n=new News_Paper_Color(); Multiple_Inheritance Mi=new Multiple_Inheritance(); Mi.News_Paper_Color(); Mi.Magazine_Paper_Color(); } }
- 10. Abstract Class Interface Abstract class is a class which contain one or more abstract methods, which has to be implemented by its sub classes. Interface is a Java Object containing method declaration but no implementation. The classes which implement the Interfaces must provide the method definition for all the methods. Abstract class is a Class prefix with an abstract keyword followed by Class definition. Interface is a pure abstract class which starts with interface keyword. Abstract class can also contain concrete methods. Whereas, Interface contains all abstract methods and final variable declarations. Abstract classes are useful in a situation that Some general methods should be implemented and specialization behavior should be implemented by child classes. Interfaces are useful in a situation that all properties should be implemented.