Introduksjon til Naming Convention i Java
I denne artikkelen skal vi gjennomgå noen navnekonvensjoner som bør følges spesielt i Java for kodeopprettholdbarhet og lesbarhetsformål, som hjelper en programmerer til å forstå og endre koden skrevet av en annen programmerer. Vi kan betrakte det som en retningslinje som man kan følge mens man tildeler navn til ens klasser, variabel eller metoder eller grensesnitt, etc. og gjør det til en god praksis når man skriver koder. Navnekonvensjonene som vi vil diskutere i denne artikkelen er foreslått og praktisert av mange Java-programmerere og støttet av Netscape og Sun Microsystems også.
Syntaks i Java Naming Conventions
I programmeringsspråk for Java brukes kamel-case-stilen til å skrive navn på metoder / funksjoner, variabler og tittel-stil for klasser og grensesnitt. La oss gå gjennom og forstå reglene som man bør følge mens man navngir et element / enhet i Java-programmeringsspråk:
- Mens vi tilordner navn til klasser, må vi huske på at klassene navnene skal være et substantiv og starte med en stor bokstav.
Syntaks: public class Employee ( //code snippet )
- Når det gjelder grensesnitt, skal det være et adjektiv (som beskriver substantivet (en klasse som implementerer det)) og begynne med en stor bokstav. I noen tilfeller kan et grensesnittnavn også være et substantiv, når de representerer en familie med klasser, eks: Kart, Liste osv.
Syntaks: interface Printable ( //code snippet )
- Et metodenavn skal begynne med et verb (definere en handling som metoden skal implementere) og begynne med en liten bokstav.
Syntaks: void printDetails() ( //code snippet )
- Mens variabler bør være meningsfulle, som betyr hvilken type informasjon den lagrer om det er et navn, en adresse, eller et telefonnummer osv. Når vi skriver navn på variabler, må vi sørge for at det ikke begynn med spesialtegn som en dollar ($) eller et underskriftstegn (_), og navnet skal ikke ha noen mellomrom og begynne med en liten bokstav.
Syntaks: int eid, sal;string firstName, lastName;
- Navn på konstante variabler skal være store bokstaver (alle UPPERCASE), og atskilt med et understrekningstegn (_), navnet består av mer enn ett ord.
Syntaks: static final int MIN_SAL = 20000;
- Vi vet at Java bruker alle små bokstaver for å tildele pakkenavn, og vi bør følge den samme navnekonvensjonen mens vi også navngir våre pakker.
Syntaks: package src.employeedetails;
- Oppregninger i java-koden din skal bokstaveliggjøre, dvs. alle store bokstaver.
Syntaks: enum JobPost ( MANAGER, ANALYST, HR, ADMIN, ENGINEER )
- Merknader i java kan være et substantiv, verb eller adjektiv og skal følge tittel-stil for å navngi merknadene.
Syntaks: public @interface Documented ()
Eksempler i Java Naming Conventions
La oss nå skrive en fullstendig kode ved å bruke de ovennevnte kodebitene som gjør det mer meningsfylt og hjelper oss å forstå hvorfor det er viktig å følge navnekonvensjoner når vi skriver programkode på ethvert programmeringsspråk:
Eksempel 1
Kode:
package src.employeedetails;
interface Printable (
void printDetails(); )
public class Employee implements Printable (
int eid;
double sal;
String firstName, lastName;
// Default Constructor
Employee() (
eid=0; sal=0.0;
firstName = "Anonymous"; lastName = "Anonymous";
)
// Parameterized Constructor
Employee(int eid, double sal, String firstName, String lastName) (
this.eid = eid; this.sal = sal;
this.firstName = firstName; this.lastName = lastName;
)
public void printDetails() (
System.out.println("Employee ID:" + eid + "\n" +
"Employee First Name:" + firstName + "\n" +
"Employee Last Name:" + lastName + "\n" +
"Employee Salary:" + sal + "\n" );
)
public static void main(String args()) (
Employee emp = new Employee(1, 22368.50, "Alan", "Hope");
emp.printDetails();
)
)
Produksjon:
Eksempel 2
Kode:
package src.customerdetails;
interface Printable ( void printDetails(); )
public class Customer implements Printable (
int custid;
long mobNo;
String fullName, emailAddr;
// Default Constructor
Customer() (
custid=0; mobNo=0;
fullName = "Anonymous"; emailAddr = " ";
)
// Parameterized Constructor
Customer(int custid, long mobNo, String fullName, String emailAddr) (
this.custid = custid; this.mobNo = mobNo;
this.fullName = fullName; this.emailAddr = emailAddr;
)
public void printDetails() (
System.out.println("Customer ID:" + custid + "\n" +
"Customer Full Name:" + fullName + "\n" +
"Customer Email Address:" + emailAddr + "\n" +
"Customer Mobile Number:" + mobNo + "\n" );
)
public static void main(String args()) (
Customer cust = new Customer (1, 987451036, "Alan Hope", " ");
cust.printDetails();
)
)
Utgang 1:
Utgang 2:
Fordeler med Java Naming Conventions
Nedenfor er noen fordeler ved Java-navnekonvensjonen:
- Reduksjon i skriftlig forvirring eller feilaktig kode.
- Forbedring av kodelesbarhet.
- Mindre tid brukt på å finne ut hva koden gjør.
- Forbedring av vedlikehold av kode.
- Produser en konsistent kode i hele applikasjonen.
Konklusjon
Neste gang du skriver en Java-kode, må du forsikre deg om at klasser, grensesnitt, pakker, metoder og felt som du definerer og implementerer, har navn som følger Java-navnekonvensjoner. Husk at de som følger navnekonvensjoner på hvilket som helst programmeringsspråk er det første trinnet for å skrive ren og konsekvent kode, og er sannsynligvis den første beste fremgangsmåten som alle programmerere bør følge.
Anbefalte artikler
Dette er en guide til Java Naming Conventions. Her diskuterer vi klasser, grensesnitt, pakker, metoder og felt som definerer og implementerer Java navnekonvensjoner. Du kan også gå gjennom andre relaterte artikler for å lære mer -
- Objekt i PHP
- Firkanter i Java
- Rekursjon i Java
- Factorial i Java
- Variabler i JavaScript
- Arrays i Java-programmering
- Liste over R-pakker
- Working and Top 3 Enum Methods in C #
- Komplett guide til Factorial i C #