Introduktion till Naming Convention i Java
I den här artikeln kommer vi att gå igenom några namnkonventioner som bör följas särskilt i Java för att underhålla koder och läsbarhet, som hjälper en programmerare att förstå och ändra koden skriven av en annan programmerare. Vi kan betrakta det som en riktlinje som man kan följa när man tilldelar namn till klasser, variabler eller metoder eller gränssnitt, etc. och gör det till en bra praxis när man skriver koder. Namnkonventionerna som vi kommer att diskutera i denna artikel föreslås och praktiseras av många Java-programmerare och stöds av Netscape och Sun Microsystems också.
Syntax i Java Naming Conventions
I Java-programmeringsspråk används kamel-case-skrivstil för att skriva namn på metoder / funktioner, variabler och rubrikstil för klasser och gränssnitt. Låt oss gå igenom och förstå reglerna som man bör följa när man namnger ett element / enhet i Java-programmeringsspråk:
- Samtidigt som vi tilldelar namn till klasser, bör vi komma ihåg att klassnamnen bör vara ett substantiv och börja med en stor bokstav.
Syntax: public class Employee ( //code snippet )
- När det gäller gränssnitt bör det vara ett adjektiv (som beskriver substantivet (en klass som implementerar det)) och börja med en stor bokstav. I vissa fall kan ett gränssnittsnamn också vara ett substantiv, när de representerar en familj av klasser, ex: karta, lista etc.
Syntax: interface Printable ( //code snippet )
- Ett metodnamn bör börja med ett verb (definiera en åtgärd som metoden kommer att implementera) och börja med en liten bokstav.
Syntax: void printDetails() ( //code snippet )
- Medan variabler bör vara meningsfulla, vilket betyder vilken typ av information den lagrar om det är ett namn, en adress eller ett telefonnummer, etc. När vi skriver namn på variabler måste vi se till att det inte börja med specialtecken som en dollar ($) eller ett understreckstecken (_) och dess namn bör inte ha några blanksteg och börja med en liten bokstav.
Syntax: int eid, sal;string firstName, lastName;
- Namn på konstantvariabler bör vara fullständiga bokstäver (alla UPPERCASE) och separeras med ett understreckstecken (_), dess namn består av mer än ett ord.
Syntax: static final int MIN_SAL = 20000;
- Vi vet att Java använder alla små bokstäver för att tilldela paketnamn och att vi borde följa samma namnkonvention medan vi också namnger våra paket.
Syntax: package src.employeedetails;
- Uppräkningar i din java-kod bör skrivas med stora bokstäver, dvs. alla stora bokstäver.
Syntax: enum JobPost ( MANAGER, ANALYST, HR, ADMIN, ENGINEER )
- Annoteringar i java kan vara ett substantiv, verb eller adjektiv och bör följa rubrikstil för namngivning av kommentarerna.
Syntax: public @interface Documented ()
Exempel i Java-namnkonventioner
Låt oss nu skriva en fullständig kod med ovanstående kodavsnitt som gör det mer meningsfullt och hjälper oss att förstå varför att följa namnkonventioner är viktiga när vi skriver applikationskod på alla programmeringsspråk:
Exempel 1
Koda:
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();
)
)
Produktion:
Exempel 2
Koda:
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();
)
)
Utgång 1:
Utgång 2:
Fördelar med Java-namnkonventioner
Nedan är några fördelar med java-namnkonvention:
- Minskning av skriftlig förvirring eller felaktig kod.
- Förbättring av kodläsbarheten.
- Mindre tid för att räkna ut vad koden gör.
- Förbättring av underhåll av kod.
- Skapa en konsekvent kod i hela applikationen.
Slutsats
Nästa gång du skriver en Java-kod måste du se till att klasser, gränssnitt, paket, metoder och fält som du definierar och implementerar har namn som följer Java-namnkonventionerna. Kom ihåg att de som följer namnkonventioner i alla programmeringsspråk är det första steget att skriva ren och konsekvent kod och är förmodligen den första bästa praxis som alla programmerare bör följa.
Rekommenderade artiklar
Detta är en guide till Java Naming Conventions. Här diskuterar vi klasser, gränssnitt, paket, metoder och fält som definierar och implementerar Java-namnkonventionerna. Du kan också gå igenom våra andra relaterade artiklar för att lära dig mer -
- Objekt i PHP
- Kvadrater i Java
- Rekursion i Java
- Factorial i Java
- Variabler i JavaScript
- Arrays i Java-programmering
- Lista över R-paket
- Working and Top 3 Enum Methods in C #
- Komplett guide till Factorial i C #