คอฟฟี่เบรค #121. Classpath ใน Java คืออะไรและจะติดตั้งได้อย่างไร? ความไม่เปลี่ยนรูปใน Java

Classpath ใน Java คืออะไรและจะติดตั้งได้อย่างไร?

ที่มา: สื่อ การรู้พื้นฐานของการเขียนโปรแกรมและขั้นตอนการดำเนินการของไฟล์โปรแกรมช่วยให้เราเข้าใจภาษา การรู้ พารามิเตอร์ Classpathเป็นหนึ่งในแนวคิดพื้นฐานที่ Java Developer ทุกคนควรรู้ วันนี้เราจะมาพูดถึงว่า classpath ( Classpath ) คืออะไร วิธีการตั้งค่า และวิธีที่มันช่วย JVM รันไฟล์คลาส

Classpath คืออะไร?

Classpathเป็นหนึ่งในพารามิเตอร์พื้นฐานใน Java แต่ผู้ที่มาใหม่มักเข้าใจผิดในการเขียนโปรแกรม เพื่อให้ง่ายขึ้นClasspathเป็นเพียงชุดของเส้นทางที่คอมไพเลอร์ Java และ JVM ต้องค้นหาคลาสที่จำเป็นเพื่อคอมไพล์หรือดำเนินการคลาสอื่น

Classpath ช่วย JVM ในการรันไฟล์คลาสได้อย่างไร

เริ่มต้นด้วยตัวอย่าง สมมติว่าเรามีไฟล์ Main.javaซึ่งอยู่ใน โฟลเดอร์ /Users/vikram/Documents/test-java/src/com/programming/v1/Main.java

package com.programming.v1;

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello classpath");
    }
}

สมมติว่าเราอยู่ใน/Users/vikram/Documentsและต้องการคอมไพล์คลาสนี้:

javac test-java/src/com/programming/v1/Main.java

ตอนนี้ ในการรันไฟล์คลาสนี้ เราต้องบอก Java Virtual Machine ว่าจะหา ไฟล์ .class ได้ที่ไหน โดยใช้classpathหรือ แฟล็ก cpใน คำ สั่ง java

vg@lp1 Documents % java -cp "test-java/src" com.programming.v1.Main
Hello classpath
vg@lp1 Documents % java -classpath "test-java/src" com.programming.v1.Main
Hello classpath

พารามิเตอร์แรกคือโฟลเดอร์รูทที่เขียนแพ็คเกจ พารามิเตอร์ตัวที่สองคือชื่อแพ็กเกจที่มีชื่อคลาส เมื่อคำสั่ง Java ถูกดำเนินการ Java Virtual Machine จะค้นหาใน โฟลเดอร์ test-java/srcจากนั้นโหลดคลาสหลักเพื่อดำเนินการ

วิธีการตั้งค่าตัวแปร Classpath

ตัวแปรClasspathสามารถตั้งค่าได้ดังแสดงด้านล่างบนเครื่อง Linux:

export CLASSPATH="test-java/src"

Classpath บนเครื่อง Windows สามารถเพิ่ม/อัพเดตได้โดยใช้ตัวแปรสภาพแวดล้อม เมื่อตั้งค่าตัวแปรสภาพแวดล้อมแล้ว คำสั่ง javaจะสามารถดำเนินการได้ดังภาพด้านล่าง:

vg@lp1 Documents % java com.programming.v1.Main
Hello classpath

นั่นคือทั้งหมดที่ต้องรู้เกี่ยวกับClasspath ขอบคุณสำหรับการอ่าน!

ความไม่เปลี่ยนรูปใน Java

แหล่งที่มา: ตัวแปร สื่อ ใน Java มีสองประเภท: ดั้งเดิมและการอ้างอิง ทุกอย่างใน Java ถูกส่งผ่านตามค่า แต่ในกรณีของประเภทการอ้างอิง ข้อมูลต้นฉบับสามารถอัปเดตได้โดยใช้ที่อยู่หน่วยความจำที่ส่งผ่าน คีย์เวิร์ดสุดท้ายถูกใช้เพื่อทำให้ตัวแปรทำหน้าที่เป็นค่าคงที่ กล่าวคือ หลีกเลี่ยงการกำหนดใหม่ วิธีนี้ใช้ได้ดีกับเวอร์ชันพื้นฐานที่ไม่มีหน่วยความจำฮีป ในขณะที่ประเภทการอ้างอิงมีเพียงการกำหนดใหม่เท่านั้นที่ถูกจำกัด และสถานะภายในสามารถเปลี่ยนแปลงได้ สิ่งนี้สามารถนำไปสู่ปัญหาการทำงานพร้อมกันและสภาพการแข่งขันมากมาย ดังนั้นการรวมคุณลักษณะที่ไม่เปลี่ยนรูปแบบในประเภทปกติใน Java จึงให้ประโยชน์มากมาย

ประโยชน์ของความไม่เปลี่ยนรูปใน Java

1. ความปลอดภัยของด้าย

ประเภทที่ไม่เปลี่ยนรูปมีภูมิคุ้มกันต่อสภาวะการแข่งขันในสภาพแวดล้อมแบบมัลติเธรด เนื่องจากอ็อบเจ็กต์จะยังคงสอดคล้องกันหลังจากถูกสร้างขึ้น หลายเธรดไม่สามารถเปลี่ยนสถานะภายในได้ ดังนั้นจึงไม่จำเป็นต้องซิงโครไนซ์

2. ประเภทพื้นฐาน

สตริงใน Java Standard Library เป็นตัวอย่างที่ดีของคลาสพื้นฐาน นี่เป็นคลาสที่เรียบง่ายและไม่เปลี่ยนรูปซึ่งสามารถใช้เพื่อสร้างโดเมนตรรกะทางธุรกิจนอกเหนือจากคลาสนั้นได้ ในทำนองเดียวกัน ประเภทที่ไม่เปลี่ยนรูปสามารถทำหน้าที่เป็นประเภทฐานที่ดีที่จะสร้างได้

ลักษณะเฉพาะ

1. ฟิลด์ส่วนตัวและรอบชิงชนะเลิศ

ฟิลด์ที่มีสถานะของออบเจ็กต์นั้นเป็นแบบส่วนตัวและเป็นขั้นสุดท้าย การมองเห็น แบบส่วนตัวป้องกันการเข้าถึงฟิลด์โดยตรง ในขณะที่การมองเห็นขั้นสุดท้ายช่วยให้แน่ใจว่าฟิลด์นั้นได้รับการกำหนดเพียงครั้งเดียว

2. ไม่มีวิธีการแก้ไข

ไม่สามารถเข้าถึงสนามส่วนตัว นอกชั้นเรียนได้ โดยทั่วไปแล้ว วิธีการเข้าถึง (getters) และวิธีแก้ไข (setters) ตามลำดับ ได้รับการจัดเตรียมไว้เพื่ออ่านและเขียนลงในฟิลด์ เพื่อให้มั่นใจถึงความสอดคล้องกัน ไม่อนุญาตให้ใช้ตัวแก้ไข

3. ชั้นเรียนสุดท้าย

การอนุญาตให้สืบทอดคลาสอาจทำให้ความไม่เปลี่ยนรูปเสียหาย คลาสย่อยที่ขยายคลาสที่ไม่เปลี่ยนรูปอาจส่งผลต่อสถานะของอ็อบเจ็กต์ ดังนั้นชั้นเรียนจึงถือเป็นที่ สิ้นสุด

4. สำเนาการป้องกัน

ในระหว่างการสร้างอ็อบเจ็กต์ แทนที่จะกำหนดอาร์กิวเมนต์จากตัวสร้างโดยตรงไปยังฟิลด์ส่วนตัว การสร้างสำเนาเชิงลึก (หรือสำเนาที่ไม่เปลี่ยนรูป) ของอาร์กิวเมนต์จะให้การแก้ไขจากภายนอก หากอาร์กิวเมนต์ตัวใดตัวหนึ่งเป็นประเภทการอ้างอิง ก็สามารถจัดการได้อย่างง่ายดายที่ฝั่งผู้เรียก การสร้างสำเนาป้องกันช่วยให้คุณหลีกเลี่ยงการยักย้ายนี้ได้ ในทำนองเดียวกัน สำหรับผู้เข้าถึง (getters) แทนที่จะอ้างอิงถึงฟิลด์ภายในโดยตรง สำเนาของฟิลด์นั้นสามารถแชร์ได้อย่างอิสระ

การนำไปปฏิบัติ

พนักงาน

import java.time.LocalDate;
import java.util.List;

import static java.util.List.copyOf;

public final class Employee {

    private final long id;
    private final String name;
    private final LocalDate joinDate;
    private final List<String> achievements;

    public Employee(long id,
                    String name,
                    LocalDate joinDate,
                    List<String> achievements) {
        this.id = id;
        this.name = name;
        this.joinDate = joinDate;
        this.achievements = copyOf(achievements);
    }

    public long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public LocalDate getJoinDate() {
        return joinDate;
    }

    public List<String> getAchievements() {
        return achievements;
    }
}

• ไม่ใช่ทุกฟิลด์ที่มีสำเนาป้องกันในตัวสร้าง นี่เป็นเพราะว่าidเป็นค่าดั้งเดิม และชื่อและ ฟิลด์ joinDateเป็นประเภทที่ไม่เปลี่ยนรูป ผู้โทรไม่สามารถเปลี่ยนแปลงได้และจะยังคงไม่เปลี่ยนแปลง ในขณะที่ฟิลด์ความสำเร็จจำเป็นต้องมีสำเนาของอาร์กิวเมนต์ที่ทำโดยใช้ เมธอด List.copyOf เนื่องจากcopyOfส่งคืนList ที่ไม่เปลี่ยน รูป

• ในทำนองเดียวกัน วิธีการเข้าถึงจะส่งคืนฟิลด์โดยตรงแทนที่จะส่งสำเนาเชิงป้องกัน เนื่องจากฟิลด์ทุกประเภทไม่เปลี่ยนรูป (รวมถึงAchievement ) ดังนั้นจึงไม่สามารถแก้ไขนอกคลาสได้

การปรับปรุง

ก่อนจาวา 16

การดำเนินงานของพนักงานสามารถปรับปรุงได้ด้วยห้องสมุดเช่นลอมบอก ซึ่งจะช่วยลดคำฟุ่มเฟือยในโค้ดและช่วยให้ดูสะอาดตายิ่งขึ้น ไลบรารี่มาพร้อมกับคำอธิบายประกอบเพื่อย่อโค้ดมาตรฐานให้สั้นลง @Value (คำอธิบายประกอบ) สามารถใช้เพื่อสร้าง getters และ Constructor สำหรับอาร์กิวเมนต์ทั้งหมด นอกจากนี้ยังสร้าง คลาส สุดท้าย และ ฟิลด์ส่วนตัวและขั้นสุดท้าย ตามหมายเหตุ มันยังสร้าง วิธี การtoString , เท่ากับและhashCode การใช้งานพนักงานสามารถเขียนใหม่ได้โดยใช้@Valueดังที่แสดงด้านล่าง:

import lombok.Value;

import java.time.LocalDate;
import java.util.List;

import static java.util.List.copyOf;

@Value
public class Employee {

    long id;
    String name;
    LocalDate joinDate;
    List<String> achievements;

    public Employee(long id,
                    String name,
                    LocalDate joinDate,
                    List<String> achievements) {
        this.id = id;
        this.name = name;
        this.joinDate = joinDate;
        this.achievements = copyOf(achievements);
    }
}

ชวา 16 และใหม่กว่า

การเปิดตัว Java 16 นำเสนอ ฟังก์ชัน บันทึกใหม่ คลาสเหล่านี้ (ตามที่ระบุโดย JEP) เป็นคลาสที่ทำหน้าที่เป็นพาหะของข้อมูลที่ไม่เปลี่ยนรูปอย่างโปร่งใส และอาจถือเป็นสิ่งอันดับที่ระบุได้ คลาสEmployeeสามารถนำไปใช้ใหม่ได้เป็นบันทึก Employeeดังที่แสดงด้านล่าง

import java.time.LocalDate;
import java.util.List;

import static java.util.List.copyOf;

public record Employee(long id,
                       String name,
                       LocalDate joinDate,
                       List<String> achievements) {

    public Employee(long id,
                    String name,
                    LocalDate joinDate,
                    List<String> achievements) {
        this.id = id;
        this.name = name;
        this.joinDate = joinDate;
        this.achievements = copyOf(achievements);
    }
}

ข้อบกพร่อง

ปัญหาเดียวของความไม่เปลี่ยนรูปคือหน่วยความจำและการประมวลผลเพิ่มเติมที่จำเป็นต้องมีการปรับเปลี่ยนเล็กน้อย แต่ละครั้งที่คุณต้องสร้างออบเจ็กต์ใหม่ซึ่งอาจมีราคาแพงมาก เพื่อแก้ไขข้อเสียเปรียบนี้ คุณสามารถใช้กลไกต่างๆ เช่น การแคชและการบันทึกผลลัพธ์