บทช่วยสอน การปรับเปลี่ยน Java ที่ดีที่สุดในปี 2024 ในบทช่วยสอนนี้ คุณสามารถเรียนรู้ ปรับปรุงการควบคุมการเข้าถึง,ปรับปรุงที่ไม่ใช่การเข้าถึง,
ภาษา Java ให้ปรับเปลี่ยนจำนวนมากแบ่งออกเป็นประเภทต่อไปนี้:
ปรับปรุงใช้ในการกำหนดชั้นเรียนวิธีการหรือตัวแปรมักจะอยู่ในระดับแนวหน้าของคำสั่ง ผ่านตัวอย่างต่อไปนี้แสดงให้เห็นถึง:
public class className { // th. } private boolean myFlag; static final double weeks = 9.5; protected static final int BOXWIDTH = 42; public static void main(String[] arguments) { // 方法体 }
Java คุณสามารถใช้อักขระควบคุมการเข้าถึงเพื่อป้องกันการเข้าถึงการเรียนตัวแปรวิธีการและการก่อสร้าง Java สนับสนุนสี่สิทธิการเข้าถึงที่แตกต่างกัน
โดยค่าเริ่มต้นยังเป็นที่รู้จักเป็นค่าเริ่มต้นมองเห็นได้ภายในแพคเกจเดียวกันไม่ได้ใช้ปรับแต่งใด ๆ
เอกชนเพื่อปรับปรุงส่วนตัวมีการระบุที่มองเห็นภายในระดับเดียวกัน
นอกจากนี้ในการสั่งซื้อเพื่อระบุตัวปรับแต่งสาธารณะสามารถมองเห็นได้ทุกชั้น
การป้องกันเพื่อปรับปรุงการคุ้มครองระบุว่าสำหรับการเรียนและ subclasses ทั้งหมดภายในแพคเกจเดิมที่มองเห็น
ใช้ตัวแปรและวิธีการในการประกาศปรับปรุงการเข้าถึงเริ่มต้นสำหรับชั้นภายในแพคเกจเดียวกันจะมองเห็นได้ อินเตอร์เฟซที่จะประกาศตัวแปรโดยปริยายเป็นแบบคงที่สุดท้ายของประชาชนและอินเตอร์เฟซที่วิธีการเข้าถึงเริ่มต้นสำหรับประชาชน
ตัวอย่าง:
คำสั่งดังต่อไปนี้เช่นตัวแปรและวิธีการไม่สามารถใช้ปรับแต่งใด ๆ
String version = "1.5.1"; boolean processOrder() { return true; }
ปรับปรุงการเข้าถึงเอกชนเป็นระดับที่เข้มงวดมากที่สุดในการเข้าถึงมันถูกประกาศเป็นวิธีเอกชนตัวแปรและเป็นสร้างคลาสเท่านั้นที่สามารถเข้าถึงและเรียนและอินเตอร์เฟซที่ไม่สามารถได้รับการประกาศเป็นส่วนตัว
ตัวแปรที่ประกาศเป็นประเภทการเข้าถึงส่วนตัวสามารถเข้าถึงนอกชั้นเรียนผ่าน Class วิธีทะเยอทะยานสาธารณะ
ปรับปรุงการเข้าถึงเอกชนใช้เป็นหลักสำหรับรายละเอียดการดำเนินการป้องกันและชั้นข้อมูลที่อยู่เบื้องหลังระดับ
เรียนต่อไปนี้ใช้ปรับปรุงการเข้าถึงส่วนตัว:
public class Logger { private String format; public String getFormat() { return this.format; } public void setFormat(String format) { this.format = format; } }
ตัวอย่างเช่นรูปแบบตัวแปรระดับ Logger เป็นตัวแปรส่วนตัวเพื่อให้ชั้นเรียนอื่น ๆ ไม่สามารถรับและตั้งค่าของตัวแปร เพื่อที่จะสามารถใช้งานตัวแปรระดับอื่น ๆ กำหนดสองวิธีการสาธารณะ: getFormat () (ผลตอบแทนในรูปแบบค่า) และ setFormat (String) (การตั้งค่ารูปแบบ)
มันถูกประกาศเป็นที่สาธารณะการเรียนวิธีการก่อสร้างและอินเตอร์เฟซที่สามารถเป็นชนิดอื่น ๆ ของการเข้าถึง
หากเข้าชมหลายชั้นเรียนร่วมกันของประชาชนในแพคเกจที่แตกต่างกันคุณจะต้องนำเข้าแพคเกจที่เหมาะสมอยู่ระดับประชาชน เพราะระดับมรดกชั้นวิธีส่วนกลางทั้งหมดและตัวแปรที่สามารถสืบทอดโดย subclasses ของมัน
ฟังก์ชั่นดังต่อไปนี้ใช้การควบคุมการเข้าถึงของประชาชน:
public static void main(String[] arguments) { // th. }
โปรแกรม Java หลัก () วิธีการจะต้องตั้งค่าให้กับประชาชนมิฉะนั้น, Java ล่ามจะไม่สามารถทำงานได้ในชั้นเรียน
ถูกประกาศเป็นตัวแปรที่มีการป้องกันวิธีการและการก่อสร้างในแพคเกจเดียวกันสามารถชนิดอื่น ๆ ของการเข้าถึงและสามารถเข้าถึงได้ในแพคเกจ subclasses ที่แตกต่างกัน
ปรับปรุงการเข้าถึงการป้องกันไม่สามารถแก้ไขได้ในชั้นเรียนและการเชื่อมต่อวิธีการและตัวแปรสมาชิกสามารถประกาศเป็นป้องกัน แต่ตัวแปรสมาชิกและวิธีการสมาชิกของอินเตอร์เฟซไม่สามารถประกาศได้รับการคุ้มครอง
subclasses สามารถเข้าถึงการประกาศปรับปรุงวิธีการป้องกันและตัวแปรเพื่อให้เราสามารถป้องกันไม่เกี่ยวข้องกับการเรียนโดยใช้วิธีการเหล่านี้และตัวแปร
ชั้นผู้ปกครองต่อไปนี้ใช้ปรับปรุงการเข้าถึงการป้องกัน subclasses แทนที่ openSpeaker () วิธีการระดับผู้ปกครอง
class AudioPlayer { protected boolean openSpeaker(Speaker sp) { // 实现细节 } } class StreamingAudioPlayer { boolean openSpeaker(Speaker sp) { // 实现细节 } }
หาก openSpeaker () วิธีการจะประกาศเป็นส่วนตัวแล้วนอกเหนือไปจากระดับ AudioPlayer ไม่สามารถเข้าถึงวิธีการ หาก openSpeaker () จะประกาศให้เป็นสาธารณะแล้วทุกชั้นจะสามารถเข้าถึงวิธีการ ถ้าเราต้องการที่จะทำให้กระบวนการมองเห็น subclasses ของชั้นแล้ววิธีการที่ถูกประกาศเป็นการป้องกัน
โปรดทราบวิธีต่อไปนี้ได้รับการถ่ายทอดกฎ:
ระดับผู้ปกครองประกาศเป็นวิธีการของประชาชนใน subclass ยังต้องเป็นสาธารณะ
ระดับผู้ปกครองประกาศเป็นวิธีการคุ้มครองใน subclass หรือประกาศให้เป็นป้องกันทั้งการประกาศให้เป็นสาธารณะ คุณไม่สามารถได้รับการประกาศเป็นส่วนตัว
ระดับผู้ปกครองประกาศเป็นวิธีส่วนตัวไม่สามารถสืบทอด
เพื่อให้บรรลุจำนวนของคุณสมบัติอื่น ๆ , Java ยังมีจำนวนของการปรับเปลี่ยนที่ไม่สามารถเข้าถึง
ปรับปรุงคงถูกนำมาใช้ในการสร้างวิธีการเรียนและตัวแปรระดับ
ปรับปรุงครั้งสุดท้ายที่ใช้ในการตกแต่งชั้นเรียนวิธีการและตัวแปรระดับการแก้ไขสุดท้ายไม่สามารถสืบทอดวิธีการแก้ไขของชั้นไม่สามารถจะได้รับมรดกนิยามใหม่ของตัวแปรการปรับเปลี่ยนคงไม่สามารถได้รับการแก้ไข
ปรับปรุงบทคัดย่อใช้ในการสร้างคลาสนามธรรมและวิธีการที่เป็นนามธรรม
ตรงกันและมีความผันผวนปรับเปลี่ยนส่วนใหญ่สำหรับหัวข้อการเขียนโปรแกรม
ตัวแปรคงที่:
คำสำคัญคงถูกนำมาใช้ในการประกาศตัวแปรคงเป็นอิสระของวัตถุที่ไม่ว่ากี่วัตถุชั้นเป็น instantiated ก็เป็นเพียงหนึ่งสำเนาของตัวแปรคง ตัวแปรคงรู้จักกันเป็นตัวแปรระดับ ตัวแปรท้องถิ่นไม่สามารถประกาศเป็นตัวแปรคงที่
วิธีการแบบคงที่:
คำสำคัญคงถูกนำมาใช้ในการประกาศวัตถุเป็นอิสระจากวิธีการคง วิธีการคงไม่สามารถใช้ตัวแปรระดับไม่คงที่ วิธีการแบบคงที่จะได้รับข้อมูลจากรายการพารามิเตอร์และจากนั้นคำนวณข้อมูล
การเข้าถึงตัวแปรระดับและวิธีการที่สามารถนำมาใช้โดยตรง classname.variablename และ classname.methodname ของการเข้าถึง
ในตัวอย่างต่อไปนี้คงปรับปรุงใช้ในการสร้างวิธีการเรียนและตัวแปรระดับ
public class InstanceCounter { private static int numInstances = 0; protected static int getCount() { return numInstances; } private static void addInstance() { numInstances++; } InstanceCounter() { InstanceCounter.addInstance(); } public static void main(String[] arguments) { System.out.println("Starting with " + InstanceCounter.getCount() + " instances"); for (int i = 0; i < 500; ++i){ new InstanceCounter(); } System.out.println("Created " + InstanceCounter.getCount() + " instances"); } }
ตัวอย่างของผลการดำเนินการแก้ไขดังกล่าวข้างต้นมีดังนี้
Started with 0 instances Created 500 instances
ตัวแปรสุดท้าย:
ตัวแปรสุดท้ายสามารถเริ่มต้นได้อย่างชัดเจนและเริ่มต้นได้เพียงครั้งเดียว ตามที่ประกาศเป็นวัตถุสุดท้ายไม่สามารถชี้ไปที่วัตถุที่แตกต่างกัน แต่เป้าหมายสุดท้ายที่ข้อมูลสามารถเปลี่ยนแปลงได้ ว่าวัตถุอ้างอิงสุดท้ายไม่สามารถเปลี่ยนแปลงได้ แต่ค่าที่สามารถเปลี่ยนแปลงได้
ปรับปรุงครั้งสุดท้ายมักจะใช้ร่วมกันเพื่อสร้างแบบคงที่คงที่ระดับปรับปรุง
ตัวอย่าง:
public class Test{ final int value = 10; // 下面是声明常量的实例 public static final int BOXWIDTH = 6; static final String TITLE = "Manager"; public void changeValue(){ value = 12; //将输出一个错误 } }
วิธีการเรียนสุดท้ายสืบทอดโดย subclasses แต่ไม่สามารถปรับเปลี่ยนคลาสย่อย
วัตถุประสงค์หลักของวิธีการเพื่อป้องกันไม่ให้การประกาศครั้งสุดท้ายของวิธีนี้คือการปรับเปลี่ยน
ดังต่อไปนี้โดยใช้วิธีการปรับปรุงการประกาศครั้งสุดท้าย
public class Test{ public final void changeName(){ // 方法体 } }
ชั้นเรียนสุดท้ายไม่สามารถสืบทอดระดับที่ไม่สามารถได้รับมรดกใด ๆ ในลักษณะของชั้นสุดท้าย
ตัวอย่าง:
public final class Test { // 类体 }
ระดับนามธรรม:
ระดับนามธรรมไม่สามารถใช้ในการยกตัวอย่างวัตถุวัตถุประสงค์เพียงอย่างเดียวของคำสั่งเป็นระดับนามธรรมสำหรับการขยายตัวในอนาคตของชั้นนี้
ชั้นไม่สามารถแก้ไขนามธรรมและครั้งสุดท้าย ถ้าชั้นมีวิธีนามธรรมชั้นเรียนจะต้องได้รับการประกาศให้เป็นระดับนามธรรมมิฉะนั้นรวบรวมข้อผิดพลาด
ระดับนามธรรมอาจจะมีวิธีการที่เป็นนามธรรมและวิธีการที่ไม่ใช่นามธรรม
ตัวอย่าง:
abstract class Caravan{ private double price; private String model; private String year; public abstract void goFast(); //抽象方法 public abstract void changeColor(); }
ไม่มีวิธีการคือการดำเนินการวิธีนามธรรม, การดำเนินงานเฉพาะของวิธีการที่ให้บริการโดย subclasses วิธีการที่เป็นนามธรรมไม่สามารถประกาศเป็นครั้งสุดท้ายและเข้มงวด
ประเภทรองใด ๆ ที่สืบทอดระดับนามธรรมต้องใช้วิธีการที่เป็นนามธรรมทั้งหมดของคลาสแม่เว้นแต่ subclass ยังเป็นระดับนามธรรม
ถ้าชั้นมีจำนวนของวิธีการที่เป็นนามธรรมชั้นจะต้องได้รับการประกาศให้เป็นระดับนามธรรม ระดับนามธรรมไม่สามารถมีวิธีการที่เป็นนามธรรม
ประกาศวิธีนามธรรมจบลงด้วยอัฒภาคตัวอย่างเช่น: ตัวอย่างนามธรรมสาธารณะ ();
ตัวอย่าง:
public abstract class SuperClass{ abstract void m(); //抽象方法 } class SubClass extends SuperClass{ //实现抽象方法 void m(){ thththth. } }
วิธี Synchronized คำหลักที่จะประกาศในเวลาเดียวกันการเข้าถึงด้ายเพียงคนเดียว ปรับปรุงข้อมูลให้ตรงกันสามารถนำไปใช้ในสี่ของการปรับเปลี่ยนการเข้าถึง
ตัวอย่าง:
public synchronized void showDetails(){ ththth. }
วัตถุต่อเนื่องมีการแก้ไขโดยตัวแปรเช่นชั่วคราว, Java เครื่องเสมือน (JVM) ที่จะข้ามตัวแปรที่โดยเฉพาะอย่างยิ่ง
ปรับการรวมอยู่ในความหมายของคำสั่งตัวแปรสำหรับการเรียนชนิดข้อมูล preprocessing และตัวแปร
ตัวอย่าง:
public transient int limit = 55; // will not persist public int b; // will persist
ระเหยตัวแปรสมาชิกปรับเปลี่ยนทุกครั้งที่มีการเข้าถึงหัวข้อที่ถูกบังคับให้อีกครั้งอ่านค่าของตัวแปรสมาชิกจากหน่วยความจำที่ใช้ร่วมกัน นอกจากนี้เมื่อมีการเปลี่ยนแปลงสมาชิกตัวแปรด้ายถูกบังคับให้เปลี่ยนค่าเขียนกลับไปยังหน่วยความจำที่ใช้ร่วมกัน เพื่อที่ว่าในเวลาใด ๆ สองหัวข้อที่แตกต่างกันมักจะเห็นค่าเดียวกันของตัวแปรสมาชิก
อ้างอิงวัตถุระเหยอาจเป็นโมฆะ
ตัวอย่าง:
public class MyRunnable implements Runnable { private volatile boolean active; public void run() { active = true; while (active) // 第一行 { // 代码 } } public void stop() { active = false; // 第二行 } }
ภายใต้สถานการณ์ปกติด้ายเรียกเมธอด run () (ในหัวข้อเปิด Runnable) ในหัวข้ออื่นหยุดโทร () วิธีการ ถ้าค่าที่ใช้งานอยู่ในแถวแรกของบัฟเฟอร์ที่ถูกนำมาใช้ในแถวที่สองเมื่อวงจรที่ใช้งานอยู่เป็นเท็จไม่หยุด
อย่างไรก็ตามโค้ดข้างต้นเราจะใช้การปรับเปลี่ยนการใช้งานมีความผันผวนดังนั้นวงจรจะหยุด