0Pricing
Java Academy · บทเรียน

การจับคู่รูปแบบสำหรับ instanceof

ผูกตัวแปรขณะตรวจสอบชนิด

การจับคู่รูปแบบสำหรับ instanceof เป็นบทเรียน Java Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Java Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Java Academy มีบทเรียนทั้งหมด 4 บทเรียน

การจับคู่รูปแบบสำหรับการตรวจสอบชนิด

วิธีเดิมในการใช้ instanceof คือการตรวจสอบแล้วจึงแปลงชนิด การจับคู่รูปแบบจะรวมการตรวจสอบและการแปลงชนิดไว้ในขั้นตอนเดียว พร้อมผูกตัวแปรที่มีชนิดไว้เมื่อการตรวจสอบผ่าน

โค้ดส่วนเกินแบบเดิม

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

public class Main {
    public static void main(String[] args) {
        Object obj = "hello";
        if (obj instanceof String) {
            String s = (String) obj;
            System.out.println(s.length());
        }
    }
}

รูปแบบใหม่

รูปแบบชนิด จะประกาศตัวแปรไว้ในบรรทัดเดียวกัน: if (obj instanceof String s) เมื่อเงื่อนไขเป็นจริง s จะเป็นค่าที่แปลงชนิดแล้วอยู่แล้ว

public class Main {
    public static void main(String[] args) {
        Object obj = "hello";
        if (obj instanceof String s) {
            System.out.println(s.length());
        }
    }
}

ตัวแปรที่ผูกไว้

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

การใช้ในเงื่อนไข

ภายในเงื่อนไข if เดียวกัน คุณสามารถใช้ตัวแปรรูปแบบหลัง && ได้ เพราะรับประกันแล้วว่าการจับคู่สำเร็จในแขนงนั้น

public class Main {
    public static void main(String[] args) {
        Object obj = "developer";
        if (obj instanceof String s && s.length() > 5) {
            System.out.println("Long string: " + s);
        }
    }
}

การปฏิเสธและขอบเขตตามการไหลของโค้ด

เมื่อใช้การปฏิเสธ ขอบเขตจะเปลี่ยนอย่างเหมาะสม หลังจาก if (!(obj instanceof String s)) return; ตัวแปร s จะอยู่ในขอบเขตตลอดส่วนที่เหลือของเมธอด เพราะโค้ดจะทำงานต่อเมื่อการจับคู่สำเร็จเท่านั้น

public class Main {
    static int safeLength(Object obj) {
        if (!(obj instanceof String s)) {
            return -1;
        }
        return s.length();
    }

    public static void main(String[] args) {
        System.out.println(safeLength("abc"));
        System.out.println(safeLength(42));
    }
}

การแทนที่ equals และการแปลงชนิด

ตัวอย่างการใช้งานที่เหมาะสมคือการเขียนทับ equals โดยตรวจสอบชนิดและผูกตัวแปรในบรรทัดเดียว จากนั้นจึงเปรียบเทียบฟิลด์ต่าง ๆ

public class Main {
    static final class Point {
        final int x, y;
        Point(int x, int y) { this.x = x; this.y = y; }
        public boolean equals(Object o) {
            return o instanceof Point p && p.x == x && p.y == y;
        }
        public int hashCode() { return x * 31 + y; }
    }

    public static void main(String[] args) {
        System.out.println(new Point(1, 2).equals(new Point(1, 2)));
        System.out.println(new Point(1, 2).equals(new Point(3, 4)));
    }
}

การจัดการชนิดที่หลากหลาย

แขนง else if ที่เชื่อมต่อกันพร้อมรูปแบบช่วยให้คุณเลือกการทำงานตามชนิดที่เป็นไปได้หลายชนิดได้อย่างเป็นระเบียบ

public class Main {
    static String describe(Object obj) {
        if (obj instanceof Integer i) {
            return "int " + (i * 2);
        } else if (obj instanceof String s) {
            return "string of length " + s.length();
        } else {
            return "unknown";
        }
    }

    public static void main(String[] args) {
        System.out.println(describe(21));
        System.out.println(describe("hello"));
        System.out.println(describe(3.14));
    }
}

ค่าว่างไม่เคยจับคู่ได้

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

public class Main {
    public static void main(String[] args) {
        Object obj = null;
        if (obj instanceof String s) {
            System.out.println("matched: " + s);
        } else {
            System.out.println("null or not a String");
        }
    }
}

โค้ดที่กระชับและปลอดภัยยิ่งขึ้น

การจับคู่รูปแบบช่วยนำการแปลงชนิดที่ซ้ำซ้อนออก จำกัดขอบเขตเพื่อไม่ให้คุณใช้ตัวแปรผิดที่ และอ่านได้เกือบเหมือนภาษาอังกฤษ นี่คือรูปแบบที่ควรใช้ใน Java สมัยใหม่

นำทุกอย่างมารวมกัน

ตัวกระจายงานขนาดเล็กสำหรับจัดรูปแบบข้อมูลนำเข้าที่แตกต่างกันโดยใช้รูปแบบ

public class Main {
    static String format(Object o) {
        if (o instanceof Double d) return String.format("%.1f", d);
        if (o instanceof Integer i) return Integer.toString(i);
        if (o instanceof String s && !s.isBlank()) return s.trim();
        return "n/a";
    }

    public static void main(String[] args) {
        System.out.println(format(3.14159));
        System.out.println(format(99));
        System.out.println(format("  spaced  "));
        System.out.println(format(null));
    }
}

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจของคุณเกี่ยวกับรูปแบบ instanceof

สรุปทบทวน

คุณได้เรียนรู้การจับคู่รูปแบบสำหรับ instanceof

  • รวมการตรวจสอบชนิดและการแปลงชนิดไว้ในนิพจน์เดียว
  • ตัวแปรของรูปแบบมีขอบเขตเฉพาะบริเวณที่พิสูจน์แล้วว่าจับคู่ได้
  • รูปแบบจะไม่จับคู่กับค่าว่าง จึงหลีกเลี่ยงข้อผิดพลาด NullPointerException
  • ช่วยทำให้การเขียนทับ equals และการเลือกการทำงานตามชนิดเรียบง่ายขึ้น

คำถามที่พบบ่อย

บทเรียน “การจับคู่รูปแบบสำหรับ instanceof” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การจับคู่รูปแบบสำหรับ instanceof” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Java Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Java Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การจับคู่รูปแบบสำหรับ instanceof”

ผูกตัวแปรขณะตรวจสอบชนิด คุณปฏิบัติ Java Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Java Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Java Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “การจับคู่รูปแบบสำหรับ instanceof” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Java Academy นี้ได้ไหม

ได้ บทเรียน Java Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. การจับคู่รูปแบบสำหรับ instanceof
  2. รูปแบบเรคคอร์ด
  3. รูปแบบเรคคอร์ดซ้อน
  4. รูปแบบใน switch
← กลับไปที่ Java Academy