Ano ang Interface sa Java at Paano Ipatupad ito?

' Interface ay isang advanced na antas ng pagkamit ng abstraction sa Java Programming Language. Ang Java interface ay tumutulong sa pagbawas ng pagiging kumplikado sa code at pinapasimple ang kakayahang mabasa . Sa artikulong ito, ipapaliwanag ko sa iyo ang Java Interface sa pamamagitan ng sumusunod na docket.

• Ano ang isang Java Interface?
• Bakit kailangan natin ng isang Interface?
• Pagdeklara ng isang Java Interface: Syntax
• Halimbawa ng Java Interface
• Pugad sa Java Interface
• Pagkakaiba sa pagitan ng klase at Interface
• Mga Advantage at Disadvantages ng Interface
• Mga Pangunahing Punto sa Java Interface

Ano ang isang Java Interface?

Computer Interface ay kilala bilang isang hangganan na naghihiwalay sa dalawa o higit pang mga system. Nagpapalitan ito ng data sa pagitan ng mga sangkap sa isang system na maaaring senyales, utos o mga protokol.

Ang Java Abstraction ay nagbibigay ng pag-andar ng isang partikular na pamamaraan sa pamamagitan ng pagtatago ng pagpapatupad na lohika na nakasulat sa loob ng pamamaraan. Katulad nito, ang Java Interface ay isa ring Abstract Class na nagsasama ng Pamahayag ng Paraan ngunit hindi ang kahulugan nito. Klase nagpapatupad isang Interface upang manahin ang mga abstract na pamamaraan. Kasabay ng mga abstract na pamamaraan, an interface maaari ring isama mga pare-pareho, static na pamamaraan, mga pugad na interface at mga default na pamamaraan.

Mga pagkakatulad sa pagitan ng isang Klase at isang Interface.

Ang isang interface ay ganap na katulad ng isang normal na klase sa Java. Kasama sa isang interface ang mga abstract na pamamaraan at ang mga pamamaraang ito ay idinisenyo upang maipatupad. Ang prosesong ito ay katumbas lamang ng mana, na kung saan ay normal pagdating sa mga klase. Tatalakayin pa namin ang higit pa sa mga pagkakatulad.

• Parehas sa isang klase, ang isang interface ay maaari ring maglaman ng maraming bilang ng mga pamamaraan kung kinakailangan.
• Katulad ng mga klase, nakasulat din ang interface na may a .java file ng extension
• Nakakagulat, ang bytecode para sa isang interface ay lilitaw sa isang .klaseng file
• Ang isang interface ay ipinapakita sa anyo ng isang pakete at ang kani-kanilang bytecode ay nasa isang direktoryo na tumutugma sa pangalan ng package.

Bakit kailangan natin ng isang Interface?

Hindi sinusuportahan ng Java Maramihang Mga Mana, dahil sa kung saan, Hindi papayagan ang mga klase na pahabain ang higit sa isang klase sa isang pagkakataon. Mga klase sa bata hindi maaaring manahin ang mga pag-aari ng maraming klase ng magulang sa isang solong pagkakataon, bilang resulta nito Suliranin sa Diamond. Upang mapagtagumpayan ang isyung ito, Interface ipinakilala. Ipaunawa sa amin ang problemang ito sa pamamagitan ng isang halimbawa.

Ipagpalagay natin na mayroon kaming dalawang mga eroplano, ang isa ay maaaring magdala lamang mga pasahero, yung isa lang posisyon Ngayon, kailangan namin magmamana ang mga pag-aari ng parehong eroplano ng kargamento at eroplano ng pasahero. Hindi suportado ng Java ang solusyon na ito dahil nagtatapos ito sa kalabuan sa pagitan ng dalawang eroplano.

Ngunit, kung maaari mong gawing posible sa pamamagitan ng pagpaparamdam sa Java na nagmamana ito ng isang eroplano at pagpapatupad ang mga pamamaraan na naroroon sa kabilang eroplano. Ito ay tulad ng isang komersyal na Airplane na tumatagal sa parehong mga pasahero at mga bagahe ng kargamento. Ang Interface ay tulad ng paggawa ng isang mas malaking eroplano na maaaring gawin ang parehong mga gawain nang hindi makagambala sa mga bahagi ng bawat isa, sa halip ay paghiram lamang ng mga pamamaraan mula sa Interface Class.

// Class A Code

pakete ng maraming klase A {void msg () {System.out.println ('Hello')}}

// Class B Code

pakete ng maraming klase B {void msg () {System.out.println ('Maligayang pagdating')}}

Class C Code

ang package na maramihang klase C ay umaabot sa A, B {// Hindi ito tatanggapin ng Java, Magtatapon ito ng isang error at ang code ay hindi naisakatuparan. public static void main (String args []) {C obj = bagong C () obj.msg ()}}

Output:

Error Ang partikular na pamamaraang ito ay nagtatapon ng isang pagbubukod. Hindi sinusuportahan ng Java ang Maramihang mga mana. Ang error na ito ay kilala bilang Suliranin sa Diamond 

Subukan natin ang isang solusyon sa pamamagitan ng paggamit ng isang interface, Mga Klase sa Bata maaaring ma-access ang mga pamamaraan mula sa Maramihang Magulang mga klase sa isang solong pagkakataon.

// Interface Code

package MIS public interface solution {public void Hello () public void Welcome ()}

// Class Code

package MIS public class classA nagpapatupad ng solusyon {public void Hello () {java.lang.System.out.println ('Hello world')} public void Welcome () {java.lang.System.out.println ('Maligayang pagdating sa Edureka ')} public static void main (String [] args) {classA Edureka = new classA () Edureka.Hello () Edureka.Welcome ()}}

Output:

Kamusta Mundo

Maligayang pagdating sa Edureka

Pagdeklara ng isang Java Interface: Syntax

interface interface_name {// ideklarang pare-pareho ang mga patlang // ideklara ang mga pamamaraan () // default na mga pamamaraan}

Dumaan tayo sa isang halimbawa sa Java Interface

Halimbawa ng Java Interface

Lumikha tayo ng isang simpleng Calculator batay sa Java Interface.

// Interface Code

package basicoperations pampublikong interface matematika {public void add () public void sub () public void mul () public void div ()}

// Class Code

package basicoperations import java.util.Scanner public class student1 nagpapatupad ng matematika {@Override public void add () {Scanner kb = bagong Scanner (System.in) System.out.println ('Ipasok ang anumang dalawang halaga ng integer upang maisagawa ang karagdagan') int a = kb.nextInt () int b = kb.nextInt () int s = a + b System.out.println ('Kabuuan ng' + a + 'at' + b + 'ay' + s)} @Orride public void sub () {Scanner kb = bagong Scanner (System.in) System.out.println ('Ipasok ang anumang dalawang halaga ng integer upang maisagawa ang substraction') int a = kb.nextInt () int b = kb.nextInt () int s = ab System.out.println ('Pagkakaiba ng' + a + 'at' + b + 'ay' + s)} @Override public void mul () {Scanner kb = bagong Scanner (System.in) System.out.println ('Enter anumang dalawang integer na halaga ng pagpaparami ') int a = kb.nextInt () int b = kb.nextInt () int s = a * b System.out.println (' Produkto ng '+ a +' at '+ b +' ay '+ s)} @Override public void div () {Scanner kb = bagong Scanner (System.in) System.out.println ('Ipasok ang anumang dalawang paghahati ng mga halaga ng integer') int a = kb.nextInt () int b = kb.nextInt () int s = a / b System.out.p rintln ('Quotient of' + a + 'and' + b + 'is' + s)} public static void main (String [] args) {student1 Edureka1 = new student1 () Edureka1.add () Edureka1.sub () Edureka1. mul () Edureka1.div ()}}

Output:

Sa pagsulong pa, matututunan natin ang pugad ng isang Java Interface.

Pugad sa Java Interface

Interface Nesting ay isang proseso ng pagdedeklara ng isang Interface sa loob ng isa pa Umiiral na Interface o pagdedeklara ng isang Interface sa loob ng a Klase. Ang Nested Interface ay kilala rin bilang isang Inner Interface.

Hindi ma-access ang Nested Interface diretso . Samakatuwid, ipinatupad ang Nesting upang malutas ang mga Namespaces sa pamamagitan ng pagpapangkat sa mga ito sa kanilang kaugnay Mga interface at Mga klase. Sa pamamaraang ito,maaari nating tawagan ang Pugad na Interface sa pamamagitan ng Panlabas na Klase o Panlabas na Interface pangalan na sinundan ng a tuldok (.) , at Pangalan ng interface

Subukan natin ang ilang mga halimbawa batay sa Interface Nesting. Una, subukang subukan natin ang pugad a Java Interface sa loob ng isa pa Java Interface tulad ng ipinakita sa ibaba:

// Interface Code

package Nest public interface OuterInterface {void display () interface InnerInterface {void InnerMethod ()}}

// Class Code

ang pakete ng klase ng NestedInterfaceDemo ay nagpapatupad ng OuterInterface.InnerInterface {public void InnerMethod () {int n = 10, t1 = 0, t2 = 1 System.out.print ('Una' + n + 'mga term:') para sa (int i = 1 i & lt = n ++ i) {System.out.print (t1 + '+') int sum = t1 + t2 t1 = t2 t2 = sum} System.out.println ('nPrinting mula sa Nested InnerInterface na pamamaraan ...! n ')} pampublikong static void main (String args []) {OuterInterface.InnerInterface obj = bagong NestedInterfaceDemo () obj.InnerMethod ()}}

Output:

Unang 10 mga termino: 0 + 1 + 1 + 2 + 3 + 5 + 8 + 13 + 21 + 34 + Pagpi-print mula sa Nested InnerInterface na pamamaraan ...!

Ngayon, Subukan nating mag-pugad a Java Interface sa loob ng a Java Class.

// Interface Code

package Nest2 public class EdurekaClass {interface EdurekaInterface {void NestedMethod ()}}

// Class Code

package Nest2 class NestedInterfaceDemo2 nagpapatupad ng EdurekaClass.EdurekaInterface {public void NestedMethod () {String input = 'Edureka' byte [] strAsByteArray = input.getBytes () byte [] resulta = bagong byte [strAsByteArray.length] para sa (intAtr .length i ++) resulta [i] = strAsByteArray [strAsByteArray.length-i-1] System.out.println (bagong String (resulta))} pampublikong static void main (String args []) {EdurekaClass.EdurekaInterface obj = bagong NestedInterfaceDemo2 () obj.NestedMethod ()}}

Output:

akerudE

Bagaman ang isang Interface ay mukhang halos kapareho ng isang Klase, mayroong ilang mga pagkakaiba sa pagitan nila, Talakayin natin ang kanilang mga pagkakaiba.

Pagkakaiba sa pagitan ng Java Class at Java Interface

Mga Advantage at Disadvantages ng Java Interface

Mga kalamangan:

• Sinusuportahan ng Java Interface Maramihang Mana.
• Nagbibigay-daan ang Java Interface sa mga programmer na paghiwalayin ang mga kumplikadong pamamaraang programa at gawing simple ang mga pagtitiwala sa pagitan ng mga bagay.
• Ginagawa ng Java Interface ang mga kasapi ng data at paraan sa isang application na maluwag na maisama.

Mga disadvantages:

• Ang paggamit ng Java Interface ay nagdudulot ng bilis ng pagpapatupad ng aplikasyon.
• Ang Java Interface sa application ay alinman sa paulit-ulit na ginagamit nang malaki o halos hindi nagamit.

Mga Pangunahing Punto sa Java Interface

• Wala sa mga pamamaraang idineklara sa interface ang mayroong isang katawan na nagbibigay ng kumpletong abstraction.
• Hindi posible na lumikha ng isang bagay ng isang interface. Samakatuwid, ang Instantiation ng isang Interface ay hindi posible.
• Ang isang Klase ay maaaring magpatupad ng isang interface sa pamamagitan ng paggamit ng mga pagpapatupad ng keyword. Tingnan natin ito sa pamamagitan ng isang halimbawa.

// Interface Code

kung paano lumikha ng naka-link na listahan sa c

package extInterface pampublikong interface extInterface {public void method1 () public void method2 ()}

// Class Code

package extInterface import java.util.Scanner class Edureka nagpapatupad ng extInterface {public void method1 () {System.out.println ('pagpapatupad ng paraan1') Scanner scanner = bagong Scanner (System.in) System.out.println ('Ipasok ang numero upang makahanap ng parisukat na ugat sa Java: ') double square = scanner.nextDouble () double squareRoot = Math.sqrt (square) System.out.printf (' Square root ng numero:% f ay:% f% n ', square, squareRoot)} pampublikong walang bisa na pamamaraan2 () {System.out.println ('pagpapatupad ng pamamaraan2')} pampubliko na static na walang bisa (String arg []) {extInterface obj = bagong Edureka () obj.method1 ()}}

Output:

pagpapatupad ng pamamaraan1 Ipasok ang numero upang makahanap ng parisukat na ugat sa Java: 16 square root ng numero: 16.0 ay: 4.0

• Maaaring magpatupad ang isang Klase ng maraming mana sa isang solong pagkakataon. Ipaunawa sa amin ito sa pamamagitan ng sumusunod na code.

// Interface 1 Code

package ExtendInt public interface Interface1 {public void armstrong ()}

// Interface 2 Code

package ExtendInt public interface Interface2 {public void prime ()} // Class Code package ExtendInt public class Edureka2 nagpapatupad ng Interface1, Interface2 {public void armstrong () {int c = 0, a, temp int n = 153 // input temp = n habang (n & gt0) {a = n% 10 n = n / 10 c = c + (a * a * a)} kung (temp == c) System.out.println ('armstrong number') iba pa System.out.println ('Not armstrong number') System.out.println ('Extending to Interface 1')} public void prime () {int i, m = 0, flag = 0 int n = 3 // input m = n / 2 if (n == 0 || n == 1) {System.out.println (n + 'ay hindi pangunahin na numero')} iba pa {para sa (i = 2i & lt = mi ++) {kung (n% i == 0) {System .out.println (n + 'ay hindi pangunahing numero') flag = 1 break}} kung (flag == 0) {System.out.println (n + 'ay prime number')}} System.out.println ('Extending sa Interface 2 ')} publiko static void main (String args []) {Interface2 obj = bagong Edureka2 () obj.prime () Interface1 obj1 = bagong Edureka2 () obj1.armstrong ()}}

Output:

Ang 3 ay pangunahing numero ng Pagpapalawak sa Interface 2 numero ng armstrong na Pagpapalawak sa Interface 1

• Hinihiling ng Java Interface ang mga variable na idineklarang maisasagawa sa oras ng pagdedeklara.
• Ang Mga Access Modifier para sa isang interface ay nakatakda sa pampublikong static at panghuli bilang default. Unawain natin ito sa pamamagitan ng isang halimbawa

// Interface Code

package test public interface Subukan {// public int a = 10 // public static final int a = 10 // static int a = 0 // final int a = 10 // int a = 10}

• Ang lahat ng mga pahayag sa itaas ay totoo at wasto sa loob ng isang Interface.
• Ang Java Interface ay may kakayahang pahabain ang anumang bilang ng mga interface, ngunit hindi kailanman maaaring magpatupad ng isa.
• Ang isang klase sa Java ay maaaring magpatupad ng anumang bilang ng mga Interface.
• Hindi maipatupad ng Java Class ang Mga Interface na may parehong pangalan ng pamamaraan at magkakaibang uri ng pagbabalik.
• Kung mayroong dalawa o higit pang mga pamamaraan na may parehong pangalan ng pamamaraan, mayroon nang maraming mga interface, pagkatapos ay sapat na ang pagpapatupad ng pamamaraan nang isang beses. Unawain natin ito sa isang praktikal na halimbawa.

// Interface Code

package same public interface Isang {public void display ()} // Interface Code package same public interface B {public void display ()} // Class Code package same class same impliment A, B {public void display () {System.out .println ('pagpapakita ng data')} pampublikong static void main (String [] args) {same print = new same () print.display ()}}

Output:

Maligayang pagdating sa Edureka E-Learning

Sa pamamagitan nito, natapos na kami sa artikulong ito. Inaasahan kong naiintindihan mo ang kahalagahan ng Interface, Syntax, pagpapaandar, Interface Nesting, Key point ng Java Interface at mga pagpapatakbo na isinagawa gamit ang mga ito.

Ngayon na naintindihan mo ang mga pangunahing kaalaman sa Java, tingnan ang ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online na may isang network na higit sa 250,000 nasiyahan na mga nag-aaral na kumalat sa buong mundo. Ang kurso sa pagsasanay at sertipikasyon ng Java J2EE at SOA ng Edureka ay idinisenyo para sa mga mag-aaral at propesyonal na nais na maging isang Java Developer. Ang kurso ay dinisenyo upang bigyan ka ng isang panimula sa pag-program ng Java at sanayin ka para sa parehong core at advanced na mga konsepto ng Java kasama ang iba't ibang mga balangkas ng Java tulad ng Hibernate & Spring .

May tanong ba sa amin? Nabanggit ito sa seksyon ng mga komento ng blog na 'Java Interface' at babalikan ka namin sa lalong madaling panahon.