Nilalaman

• Tsart ng paghahambing
• Kahulugan ng Mga Pakete
• Kahulugan ng Interface
• Konklusyon:

Ang mga package at Interfaces ay parehong kumikilos bilang isang lalagyan. Ang nilalaman sa mga pakete at mga interface ay maaaring magamit ng mga klase sa pamamagitan ng pag-import at pagpapatupad nito nang naaayon. Ang pangunahing pagkakaiba sa pagitan ng mga pakete at mga interface ay ang isang package ay naglalaman ng isang pangkat ng mga klase at mga interface samantalang, ang isang interface ay naglalaman ng mga pamamaraan at larangan. Pag-aralan ang ilang iba pang mga pagkakaiba sa tulong ng tsart ng paghahambing.

1. Tsart ng paghahambing
2. Kahulugan
3. Pangunahing Pagkakaiba
4. Konklusyon

Tsart ng paghahambing

Batayan para sa Paghahambing	Mga package	Mga pagitan
Pangunahing	Ang mga package ay isang pangkat ng mga klase at / o magkasama.	Ang mga pagitan ay isang pangkat ng mga abstract na pamamaraan at palaging patlang.
Keyword	Ang mga package ay nilikha gamit ang keyword na "Package".	Ang interface ay nilikha gamit ang "Interface" keyword.
Syntax	package package_name; pampublikong klase class_name { . (katawan ng klase) . }	interface interface_name { variable na deklarasyon; paraan ng pagpapahayag; }
Pag-access	Maaaring mai-import ang isang package	Ang isang interface ay maaaring mapalawak ng isa pang interface at ipinatupad ng klase.
I-access ang keyword	Maaaring mai-import ang mga package gamit ang "import" na keyword.	Maaaring maipatupad ang mga agwat gamit ang "implement" na keyword.

Kahulugan ng Mga Pakete

Ang mga package ay koleksyon o mga grupo ng iba't ibang klase at interface. Ang mga klase sa mga pakete ay nauugnay sa bawat isa sa ilang saklaw o sa pamamagitan ng mana. Maaari ka ring lumikha ng iyong package at gamitin ito para sa iyong programa.

Paglikha ng isang pakete

Para sa paglikha ng isang package sundin lamang ang mga sumusunod na hakbang.

1. Magbukas ng isang file at pagkatapos ay ideklara ang pangalan ng package sa tuktok ng file, tulad ng pangalan ng package ay ang pangalan na nais mong ibigay sa package.
2. Susunod, tinukoy mo ang isang klase na nais mong ilagay sa pakete, at tandaan na ipinahayag mo ito sa publiko.
3. I-save ang file bilang isang .java file at pagkatapos ay i-compile ang file, pagkatapos ".class" ay nakuha para sa file na iyon.
4. Upang lumikha ng isang package para sa file na ito ang utos na ginamit ay "javac -d. file_name.java. Maaari mong makita na ang package ay nilikha na naglalaman ng isang ".class" file sa kasalukuyang direktoryo. Upang ilagay ito sa direktoryo ng magulang gamitin ang "javac -d. . file_name.java ”utos.
5. Maaari ka ring lumikha ng isang subpackage sa pamamagitan ng pagpapahayag ng pangalan ng subpackage tulad ng sa tuktok ng file.

package Mypackage; public class myclass {public void displayMypackage () {system.out.ln ("paraan ng pagpapakitaMypackage ng class myclass ng package Mypackage"); }

Gamit ang Pakete

Ang mga pakete na nilikha o magagamit sa direktoryo ay maaaring magamit sa programa sa pamamagitan ng paggamit ng isang import statement.Ang keyword na ginamit upang mag-import ng anumang pakete sa iyong programa ay "import". Ang pahayag ng pag-import ay maaaring isulat sa dalawang paraan, o masasabi mong mayroong dalawang paraan upang ma-access ang anumang pakete. Una, kung nais mong gumamit ng isang partikular na klase mula sa isang pakete, Ang keyword na "import" ay sinusundan ng pangalan ng pakete na sinundan ng dot operator at pangalan ng klase na nais mong gamitin mula sa pakete. Pangalawa, kung nais mong gumamit ng maraming mga klase na nilalaman sa mga pakete, pagkatapos ang pag-import ng keyword ay sinusundan ng pangalan ng pakete na sinusundan ng tuldok at ang "*" operator.

import package_name. pangalan ng klase; o import package_name. *;

Sa itaas na code, makikita mo ang * sign na nagpapahiwatig na ang pangalawang pamamaraan ay nag-import ng lahat ng mga klase na nilalaman sa mga pakete.

Ngayon, tingnan natin ang paggamit ng package na may isang halimbawa.

import ang Mypackage. myclass {class TestMypackage {public static void main (string args) {myclass ob1 = new myclass (); ob1.displayMypackage (); }} // output paraan ng pagpapakitaMypackage ng class myclass ng package Mypackage.

Sa itaas na code, ang klase ng TestMypackage ay na-import ang package Mypackage at ginamit ang paraan ng displayMypackage ().

Kahulugan ng Interface

Ang interface ay isang uri ng isang klase, ngunit, naiiba sa isang kahulugan na ang mga pamamaraan na ipinahayag sa interface ay abstract na nangangahulugang ang mga pamamaraan ay ipinahayag lamang ngunit hindi tinukoy. Ang mga patlang sa interface ay palaging pampubliko, static, pangwakas. Ang mga patlang ay dapat na masimulan sa oras ng pagpapahayag. Ang mga pamamaraan na ipinahayag ng interface ay tinukoy ng klase na nagpapatupad ng interface na ayon sa kahilingan nito. Tulad ng mga pamamaraan sa interface ay hindi nagsasagawa ng anumang pag-andar, kaya walang paggamit ng paglikha ng anumang bagay ng interface. Samakatuwid, walang bagay na maaaring nilikha para sa interface.

Ang interface ay maaari ring magmana ng iba pang interface ngunit, ang klase na nagmamana ng nasabing interface ay dapat ding ipatupad ang lahat ng mga pamamaraan ng minana na interface. Dahil ang mga patlang ay sinisimulan sa oras ng kanilang deklarasyon sa interface, kaya hindi na kailangan ng tagabuo sa interface, samakatuwid, ang interface ay hindi naglalaman ng anumang tagabuo. Tingnan natin ang halimbawa ng paglikha at paggamit ng isang interface.

interface Area {float pi = 3.14; float find_area (float a, float b) {} class Circle na nagpapatupad ng Area {float find_area (float a, float b) {return (pi * a * a); } Mga Hugis sa Klase {pampublikong static na walang bisa (string args) {Area A = bagong Area (); Bilog C = bagong bilog (); A = C; lumutang F = Area. hanapin_area (10,10); system.out.ln ("Area ng bilog ay:" + F); }

Sa itaas na code, gumawa kami ng isang Area Area, at ipinatupad ng klase Circle ang Area Area. Ang patlang na "pi" ay sinimulan sa interface sa oras ng pagpapahayag nito. Tinukoy ng klase Circle ang abstract na pamamaraan ng lugar ng klase ayon sa kinakailangan nito.

1. Ang isang pakete ay isang pangkat ng mga klase at mga interface nang magkakasabay, ang isang interface ay isang pangkat ng mga abstract na pamamaraan.
2. Ang package ay nilikha gamit ang isang keyword package samantalang, isang interface ay nilikha gamit ang isang keyword interface.
3. Kung ang isang klase o isang interface sa loob ng isang pakete ay gagamitin ang pakete na mai-import habang ang isang interface ay dapat ipatupad.

Konklusyon:

Ang parehong mga pakete at interface ay ang mga lalagyan. Binabawasan ng package ang laki ng code dahil na-import lamang namin ang klase na gagamitin sa halip na muling tukuyin ito.Samantalang ang interface ay binabawasan ang mga pagkalito na naganap habang maraming mga namamana dahil sa kaso ng maraming mga pamana ang namamana ng klase ay hindi dapat magpasya na kahulugan ng aling pamamaraan na dapat nitong magmana sa halip ay tinukoy nito ang sarili nito.