Introduktion til Naming Convention i Java

I denne artikel vil vi gennemgå nogle navnekonventioner, der skal følges især i Java med henblik på kodevedligeholdelses- og læsbarhedsformål, der hjælper en programmør med at forstå og ændre koden skrevet af en anden programmør. Vi kan betragte det som en retningslinje, som man kan følge, mens man tildeler navn til ens klasser, variabel eller metoder eller grænseflader osv. Og gør det til en god praksis, mens man skriver koder. Navnekonventionerne, som vi vil diskutere i denne artikel, foreslås og praktiseres af mange Java-programmerere og understøttes også af Netscape og Sun Microsystems.

Syntaks i Java-navnekonventioner

I Java-programmeringssprog bruges camel-case-skrivestilen til at skrive navne på metoder / funktioner, variabler og titel-case-stil til klasser og grænseflader. Lad os gennemgå og forstå reglerne, som man skal følge, mens man navngiver et element / enhed i Java-programmeringssprog:

  • Mens vi tildeler navne til klasser, skal vi huske på, at klassens navne skal være et substantiv og starte med en stor bogstav.

Syntaks: public class Employee ( //code snippet )

  • I tilfælde af grænseflader skal det være et adjektiv (der beskriver substantivet (en klasse, der implementerer det)) og begynde med en stor bogstav. I nogle tilfælde kan et interface-navn også være et substantiv, når de repræsenterer en klasse af klasser, fx: Kort, Liste osv.

Syntaks: interface Printable ( //code snippet )

  • Et metodenavn skal begynde med et verb (definere en handling, som metoden vil implementere), og starte med et lille bogstav.

Syntaks: void printDetails() ( //code snippet )

  • Mens variabler skal være betydningsfulde, hvilket betyder, hvilken slags information det gemmes, om det er et navn, en adresse eller et telefonnummer osv. Når vi skriver navne på variabler, skal vi sørge for, at det ikke begynde med specialtegn som en dollar ($) eller et understregetegn (_), og navnet skal ikke have nogen whitespaces og begynde med en lille bogstav.

Syntaks: int eid, sal;string firstName, lastName;

  • Navne på konstante variabler skal være fulde bogstaver (alle UPPERCASE) og adskilt med et understregningstegn (_), dets navn består af mere end et ord.

Syntaks: static final int MIN_SAL = 20000;

  • Vi ved, at Java bruger alle små bogstaver til at tildele pakkenavne, og vi bør følge den samme navnekonvention, mens vi også navngiver vores pakker.

Syntaks: package src.employeedetails;

  • Tællinger i din java-kode skal skrives med store bogstaver, dvs. alle store bogstaver.

Syntaks: enum JobPost ( MANAGER, ANALYST, HR, ADMIN, ENGINEER )

  • Annotationer i java kan være et substantiv, verb eller adjektiv og skal følge titel-sagstil for navngivning af annotationerne.

Syntaks: public @interface Documented ()

Eksempler i Java-navnekonventioner

Lad os nu skrive en fuld kode ved hjælp af ovenstående kodestykker, der gør det mere meningsfuldt og hjælper os med at forstå, hvorfor det er vigtigt at følge navnekonventioner, når vi skriver applikationskode på ethvert programmeringssprog:

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();
)
)

Produktion:

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();
)
)

Output 1:

Output 2:

Fordele ved Java-navnekonventioner

Nedenfor er nogle fordele ved java-navnekonvention:

  • Reduktion i skriftlig forvirring eller fejlagtig kode.
  • Forbedring af kodelæsbarheden.
  • Mindre tid brugt på at finde ud af, hvad koden gør.
  • Forbedring af vedligeholdelse af kode.
  • Fremstil en ensartet kode i hele applikationen.

Konklusion

Næste gang du skriver en Java-kode skal du sørge for, at klasser, grænseflader, pakker, metoder og felter, som du definerer og implementerer, har navne, der følger Java-navnekonventionerne. Husk, at de, der følger navnekonventioner i ethvert programmeringssprog, er det første skridt til at skrive ren og konsekvent kode og er sandsynligvis den første bedste praksis, som alle programmerere skal følge.

Anbefalede artikler

Dette er en guide til Java-navnekonventioner. Her diskuterer vi klasser, grænseflader, pakker, metoder og felter, der definerer og implementerer Java-navnekonventioner. Du kan også gennemgå vores andre relaterede artikler for at lære mere -

  1. Objekt i PHP
  2. Firkanter i Java
  3. Rekursion i Java
  4. Factorial i Java
  5. Variabler i JavaScript
  6. Arrays i Java-programmering
  7. Liste over R-pakker
  8. Arbejde og top 3 enummetoder i C #
  9. Komplet guide til Factorial i C #

Kategori:

Softwareudvikling