สร้างคอมโพเนนต์มุมมองที่กำหนดเอง

Android นำเสนอโมเดลคอมโพเนนต์ที่ซับซ้อนและมีประสิทธิภาพในการสร้าง UI ของคุณ โดยอิงตาม คลาสเลย์เอาต์พื้นฐาน View และ ViewGroup แพลตฟอร์มนี้ประกอบด้วย คลาสย่อย View และ ViewGroup ที่สร้างไว้ล่วงหน้าหลากหลาย เรียกว่าวิดเจ็ตและ ตามลำดับที่คุณนำไปใช้สร้าง UI ได้

รายการวิดเจ็ตบางส่วนที่ใช้ได้ ได้แก่ Button TextView, EditText, ListView, CheckBox, RadioButton, Gallery Spinner และวัตถุประสงค์พิเศษอื่นๆ AutoCompleteTextView, ImageSwitcher และ TextSwitcher

เลย์เอาต์ที่มีให้เลือกใช้มีดังนี้ LinearLayout, FrameLayout, RelativeLayout, และอื่นๆ ดูตัวอย่างเพิ่มเติมได้ที่ เลย์เอาต์ทั่วไป

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

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

• คุณสามารถสร้างประเภท View ที่แสดงผลแบบกำหนดเองทั้งหมด เช่น "ปริมาณ ควบคุม" ลูกบิด ซึ่งแสดงผลโดยใช้กราฟิก 2 มิติ ซึ่งมีลักษณะคล้ายระบบควบคุมอิเล็กทรอนิกส์แบบแอนะล็อก
• คุณสามารถรวมกลุ่มของ View คอมโพเนนต์เข้าเป็นคอมโพเนนต์เดียวใหม่ เช่น สร้างบางอย่าง เช่น ช่องตัวเลือกรวม (ชุดค่าผสมของรายการป๊อปอัปและฟิลด์ข้อความป้อนข้อความอิสระ) การควบคุมตัวเลือกแผงคู่ (แผงด้านซ้ายและขวาที่มีรายการในแต่ละแผงที่คุณสามารถกำหนดใหม่ รายการใดอยู่ในลิสต์ใด) และอื่นๆ
• คุณลบล้างวิธีแสดงผลคอมโพเนนต์ EditText บนหน้าจอได้ แอป NotePad ตัวอย่างจะใช้ส่วนนี้เพื่อให้สร้างหน้ากระดาษโน้ตที่มีหลายบรรทัดได้
• คุณสามารถบันทึกเหตุการณ์อื่นๆ เช่น การกดแป้น และจัดการกับเหตุการณ์เหล่านั้นได้ด้วยวิธีที่กำหนดเอง เช่น สำหรับเกม

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

วิธีการพื้นฐาน

ต่อไปนี้เป็นภาพรวมระดับสูงของสิ่งที่คุณจำเป็นต้องทราบเพื่อสร้าง View ของคุณเอง คอมโพเนนต์

1. ขยายชั้นเรียน View หรือคลาสย่อยที่มีอยู่ด้วยชั้นเรียนของคุณเอง
2. ลบล้างบางเมธอดจาก Superclass เมธอด Superclass ที่จะลบล้างเริ่มต้นด้วย on ตัวอย่างเช่น onDraw(), onMeasure(), และ onKeyDown() เหตุการณ์นี้คล้ายกับเหตุการณ์ on ใน Activityหรือ ListActivity ที่คุณ ลบล้างสำหรับวงจรและฮุกฟังก์ชันการทำงานอื่นๆ
3. ใช้คลาสส่วนขยายใหม่ เมื่อเสร็จสิ้นแล้ว คุณจะใช้คลาสส่วนขยายใหม่แทน ยอดดูที่วิดีโออ้างอิงเป็นหลัก

คอมโพเนนต์ที่กำหนดเองทั้งหมด

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

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

หากต้องการสร้างคอมโพเนนต์ที่ปรับแต่งอย่างเต็มรูปแบบ ให้พิจารณาสิ่งต่อไปนี้

• มุมมองทั่วไปที่คุณสามารถขยายได้คือ View ดังนั้นคุณมักจะเริ่มด้วยการขยาย เพื่อสร้างคอมโพเนนต์ขั้นสูงรายการใหม่
• คุณสามารถจัดเตรียมเครื่องมือสร้างซึ่งสามารถรับแอตทริบิวต์และพารามิเตอร์จาก XML และคุณสามารถ จะใช้แอตทริบิวต์และพารามิเตอร์ดังกล่าวของคุณเอง เช่น สีและช่วงของเครื่องวัด VU หรือ ความกว้างและการชุ่มของเข็ม
• คุณอาจต้องการสร้าง Listener เหตุการณ์ ตัวเข้าถึงพร็อพเพอร์ตี้ และตัวแก้ไขของคุณเอง รวมถึง ลักษณะการทำงานที่ซับซ้อนมากขึ้นในคลาสคอมโพเนนต์
• คุณเกือบจะต้องการลบล้าง onMeasure() และมีแนวโน้มที่จะต้อง ลบล้าง onDraw() หากต้องการให้คอมโพเนนต์แสดงข้อมูล แม้ว่าทั้งคู่จะมี ลักษณะการทำงานเริ่มต้น, onDraw() เริ่มต้นจะไม่ดำเนินการใดๆ และค่าเริ่มต้น onMeasure() จะกำหนดขนาดเป็น 100x100 เสมอ ซึ่งคุณอาจไม่ต้องการ
• นอกจากนี้คุณยังลบล้างเมธอด on อื่นๆ ได้ตามความจำเป็น

ขยาย onDraw() และ onMeasure()

เมธอด onDraw() จะแสดง Canvas ซึ่งคุณสามารถ ติดตั้งใช้งานสิ่งที่คุณต้องการ เช่น กราฟิก 2 มิติ คอมโพเนนต์มาตรฐานหรือที่กำหนดเองอื่นๆ ข้อความที่จัดรูปแบบ หรือ สิ่งอื่นๆ ที่คุณนึกออก

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

ในระดับสูง การติดตั้งใช้งาน onMeasure() จะมีลักษณะดังนี้

• มีการเรียกเมธอด onMeasure() ที่ถูกลบล้างด้วยความกว้างและความสูง ซึ่งถือเป็นข้อกำหนดสำหรับข้อจำกัดเกี่ยวกับความกว้างและความสูง การวัดผลที่คุณสร้าง widthMeasureSpec และ heightMeasureSpec ทั้งรหัสจำนวนเต็มที่แสดงมิติข้อมูล การอ้างอิงฉบับเต็มถึงประเภทของ ข้อกำหนดเหล่านี้ สามารถดูได้ในเอกสารประกอบอ้างอิงภายใต้ View.onMeasure(int, int) เอกสารอ้างอิงนี้ยังอธิบายการดำเนินการวัดทั้งหมดอีกด้วย
• เมธอด onMeasure() ของคอมโพเนนต์จะคำนวณความกว้างและความสูงในการวัด ซึ่งจำเป็นในการแสดงผลคอมโพเนนต์ ต้องพยายามรักษาให้ตรงตามข้อกำหนดที่ผ่านแล้ว แม้ว่าจะเกินเกณฑ์ได้ ในกรณีนี้ ผู้ปกครองจะเลือกสิ่งที่ต้องการได้ ซึ่งรวมถึง สร้างคลิป เลื่อน ส่งข้อยกเว้น หรือขอให้ onMeasure() ลองอีกครั้ง อาจมีข้อกำหนดการวัดที่แตกต่างกัน
• เมื่อมีการคำนวณความกว้างและความสูง เรียกใช้ฟังก์ชัน setMeasuredDimension(int width, int height) เมธอดที่มีการคำนวณ การวัดค่าต่างๆ หากไม่ปฏิบัติตาม ระบบจะยกเว้น

สรุปวิธีการมาตรฐานอื่นๆ ที่เฟรมเวิร์กกำหนดให้มีการดูมีดังนี้

หมวดหมู่	วิธีการ	คำอธิบาย
การสร้างวิดีโอ	ผู้ผลิต	จะมีรูปแบบของตัวสร้างที่เรียกใช้เมื่อมีการสร้างข้อมูลพร็อพเพอร์ตี้จากโค้ด และฟอร์มที่จะเรียกใช้เมื่อมุมมองขยายออกมาจากไฟล์เค้าโครง รูปแบบที่ 2 แยกวิเคราะห์และใช้แอตทริบิวต์ที่กำหนดไว้ในไฟล์การออกแบบ
	onFinishInflate()	การเรียกหลังจากการดูและเด็กทั้งหมดในมุมมองสูงเกินจริงจาก XML
เลย์เอาต์	onMeasure(int, int)	เรียกใช้เพื่อพิจารณาข้อกำหนดด้านขนาดสำหรับมุมมองนี้และทั้งหมด ของลูกๆ ด้วย
	onLayout(boolean, int, int, int, int)	เรียกใช้เมื่อมุมมองนี้ต้องกำหนดขนาดและตำแหน่งให้กับหน่วยย่อยทั้งหมด
	onSizeChanged(int, int, int, int)	มีการเรียกเมื่อขนาดของมุมมองนี้มีการเปลี่ยนแปลง
ภาพวาด	onDraw(Canvas)	เรียกใช้เมื่อมุมมองต้องแสดงผลเนื้อหา
การประมวลผลเหตุการณ์	onKeyDown(int, KeyEvent)	เรียกใช้เมื่อเกิดเหตุการณ์คีย์ดาวน์
	onKeyUp(int, KeyEvent)	เรียกใช้เมื่อเกิดเหตุการณ์สําคัญ
	onTrackballEvent(MotionEvent)	เรียกใช้เมื่อเกิดเหตุการณ์การเคลื่อนไหวของแทร็กบอล
	onTouchEvent(MotionEvent)	เรียกใช้เมื่อเกิดเหตุการณ์การเคลื่อนไหวบนหน้าจอสัมผัส
จดจ่อ	onFocusChanged(boolean, int, Rect)	เรียกใช้เมื่อมุมมองเพิ่มขึ้นหรือสูญเสียการโฟกัส
	onWindowFocusChanged(boolean)	เรียกใช้เมื่อหน้าต่างที่มีมุมมองเพิ่มขึ้นหรือสูญเสียโฟกัส
กำลังแนบ	onAttachedToWindow()	เรียกใช้เมื่อมีการแนบมุมมองกับหน้าต่าง
	onDetachedFromWindow()	เรียกใช้เมื่อแยกมุมมองออกจากหน้าต่าง
	onWindowVisibilityChanged(int)	เรียกใช้เมื่อมีการเปลี่ยนแปลงการเปิดเผยหน้าต่างที่มีมุมมอง

การควบคุมแบบผสม

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

ใน Android มีมุมมองอื่นๆ ที่พร้อมดำเนินการอีก 2 มุมมอง ได้แก่ Spinner และ AutoCompleteTextView อย่างไรก็ตาม แนวคิดนี้สำหรับช่องตัวเลือกรวมก็ถือเป็นตัวอย่างที่ดีเช่นกัน

ในการสร้างคอมโพเนนต์แบบผสม ให้ทำดังนี้

• เช่นเดียวกับ Activity ให้ใช้วิธีการประกาศ (อิงตาม XML) เพื่อสร้างคอมโพเนนต์ที่มีอยู่หรือฝังคอมโพเนนต์แบบเป็นโปรแกรมจากโค้ดของคุณ จุดเริ่มต้นตามปกติคือ Layout อย่างใดอย่างหนึ่ง ดังนั้นให้สร้างคลาสที่ขยาย Layout ในกรณีของช่องตัวเลือกรวม คุณอาจใช้ LinearLayout กับ ในแนวนอน คุณสามารถฝังเลย์เอาต์อื่นๆ ไว้ภายในได้ เพื่อให้คอมโพเนนต์แบบผสม ทั้งซับซ้อนและมีโครงสร้าง
• ในเครื่องมือสร้างสำหรับคลาสใหม่ ให้นำพารามิเตอร์ใดๆ ที่ Superclass คาดหวังและส่งผ่าน ผ่านไปยังตัวสร้างซูเปอร์คลาสก่อน จากนั้น คุณสามารถตั้งค่ามุมมองอื่นๆ ให้ใช้ ภายในคอมโพเนนต์ใหม่ ตรงนี้คือที่ที่คุณสร้างช่อง EditText และ รายการป๊อปอัป คุณอาจใส่แอตทริบิวต์และพารามิเตอร์ของคุณเองลงใน XML ที่ เครื่องมือสร้างสามารถดึงและนำมาใช้
• (ไม่บังคับ) สร้าง Listener สำหรับเหตุการณ์ที่อาจสร้างยอดดูที่มี ตัวอย่างเช่น Listener เมธอดสำหรับ Listener การคลิกรายการในรายการเพื่ออัปเดตเนื้อหาของ EditText หากมีการเลือกรายการไว้
• คุณจะสร้างพร็อพเพอร์ตี้ของคุณเองด้วยตัวเข้าถึงและตัวแก้ไขก็ได้ (ไม่บังคับ) ตัวอย่างเช่น ยอมให้ฟิลด์ ค่าเริ่มต้น EditText จะได้รับการตั้งค่าในคอมโพเนนต์และการค้นหาเนื้อหาเมื่อ ที่จำเป็น
• (ไม่บังคับ) ลบล้าง onDraw() และ onMeasure() ซึ่งโดยปกติจะไม่จำเป็นเมื่อ ขยาย Layout เนื่องจากเลย์เอาต์มีลักษณะการทำงานเริ่มต้นที่อาจทำงานได้ดี
• (ไม่บังคับ) ลบล้างเมธอด on อื่นๆ เช่น onKeyDown() เพื่อเลือกเมธอด ค่าเริ่มต้นจากรายการป๊อปอัปของช่องตัวเลือกรวมเมื่อกดแป้นบางแป้น

การใช้ Layout เป็นพื้นฐานสำหรับการควบคุมที่กำหนดเองนั้นมีข้อดีดังนี้ ซึ่งรวมถึงรายการต่อไปนี้

• คุณสามารถระบุเลย์เอาต์โดยใช้ไฟล์ XML แบบประกาศ เช่นเดียวกับหน้าจอกิจกรรม หรือจะสร้างมุมมองแบบเป็นโปรแกรมและนำไปฝังไว้ในเลย์เอาต์จากโค้ดก็ได้
• เมธอด onDraw() และ onMeasure() และวิธีที่เหลือส่วนใหญ่ เมธอด on มีลักษณะการทำงานที่เหมาะสม คุณจึงไม่ต้องลบล้างเมธอดดังกล่าว
• คุณสามารถสร้างมุมมองแบบผสมที่ซับซ้อน แล้วนำมาใช้ซ้ำได้ราวกับ คอมโพเนนต์เดียว

แก้ไขประเภทมุมมองที่มีอยู่

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

ตัวอย่างเช่น พารามิเตอร์ NotePad แอปตัวอย่างจะแสดงแง่มุมต่างๆ ของการใช้แพลตฟอร์ม Android ส่วนหนึ่งของรายงานเหล่านั้น กำลังขยาย EditText มุมมองเพื่อสร้างกระดาษโน้ตแบบเส้น นี่ไม่ใช่ตัวอย่างที่สมบูรณ์แบบ และ API สำหรับ การทำเช่นนี้อาจเปลี่ยนไป แต่เป็นการแสดงให้เห็นหลักการ

หากคุณยังไม่ได้ดำเนินการ ให้นำเข้าตัวอย่าง NotePad ลงใน Android Studio หรือดู แหล่งที่มาโดยใช้ลิงก์ที่ให้ไว้ โดยเฉพาะอย่างยิ่ง โปรดดูคำจำกัดความของ LinedEditText ในช่วง NoteEditor.java

สิ่งที่ควรทราบในไฟล์นี้

1. คำจำกัดความ

   โดยคลาสจะได้รับการกำหนดด้วยบรรทัดต่อไปนี้
   วันที่ public static class LinedEditText extends EditText

   LinedEditText ระบุเป็นชั้นเรียนภายใน NoteEditor กิจกรรม แต่เป็นแบบสาธารณะเพื่อให้เข้าถึงได้ในฐานะ NoteEditor.LinedEditText จากภายนอกชั้นเรียน NoteEditor

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

   LinedEditText ขยาย EditText ซึ่งเป็นมุมมองที่จะปรับแต่ง สำหรับกรณีนี้ เมื่อเสร็จสิ้น ชั้นเรียนใหม่จะใช้แทน EditText ปกติได้

2. การเริ่มต้นชั้นเรียน

   และเช่นเคย เราจะเรียก Super ก่อน ค่านี้ไม่ใช่ตัวสร้างเริ่มต้น แต่เป็น เป็นพารามิเตอร์ EditText จะสร้างขึ้นด้วยพารามิเตอร์เหล่านี้เมื่อ พองขึ้นจากไฟล์เลย์เอาต์ XML ดังนั้น ผู้สร้างจะต้องนำเครื่องมือดังกล่าวไปส่ง ตัวสร้าง Superclass ได้

3. เมธอดที่ถูกลบล้าง

   ตัวอย่างนี้จะลบล้างเฉพาะเมธอด onDraw() แต่คุณอาจต้องลบล้าง อื่นๆ ขณะสร้างคอมโพเนนต์ที่กำหนดเอง

   สำหรับตัวอย่างนี้ การลบล้างเมธอด onDraw() จะให้คุณวาดเส้นสีน้ำเงินใน แคนวาสของมุมมอง EditText ระบบจะส่งผืนผ้าใบไปยังพื้นที่ที่ถูกลบล้าง onDraw() วิธี มีการเรียกใช้เมธอด super.onDraw() ก่อนแท็ก สิ้นสุดลง ต้องเรียกใช้เมธอด Superclass ในกรณีนี้ ให้เรียกใช้ในตอนท้ายหลังจาก ที่คุณวาดเส้นที่ต้องการรวมไว้

4. คอมโพเนนต์ที่กำหนดเอง

   ตอนนี้คุณมีคอมโพเนนต์ที่กำหนดเองแล้ว แต่คุณจะใช้งานอย่างไร ในตัวอย่าง NotePad ของ คอมโพเนนต์ที่กำหนดเองจะถูกใช้โดยตรงจากการจัดวางแบบประกาศ ดังนั้นดูที่ note_editor.xml ในช่วง res/layout โฟลเดอร์:

   <view xmlns:android="http://schemas.android.com/apk/res/android"
       class="com.example.android.notepad.NoteEditor$LinedEditText"
       android:id="@+id/note"
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       android:background="@android:color/transparent"
       android:padding="5dp"
       android:scrollbars="vertical"
       android:fadingEdge="vertical"
       android:gravity="top"
       android:textSize="22sp"
       android:capitalize="sentences"
   />
   

   ระบบจะสร้างคอมโพเนนต์ที่กำหนดเองเป็นมุมมองทั่วไปใน XML และมีการระบุคลาส เมื่อใช้แพ็กเกจแบบเต็ม คลาสภายในที่คุณกำหนดจะมีการอ้างอิงโดยใช้ สัญลักษณ์ NoteEditor$LinedEditText ซึ่งเป็นวิธีมาตรฐานที่ใช้อ้างอิงภายใน ในภาษาโปรแกรม Java

   หากคอมโพเนนต์มุมมองที่กำหนดเองไม่ได้กำหนดเป็นคลาสภายใน คุณประกาศมุมมองได้ ที่มีชื่อองค์ประกอบ XML และยกเว้นแอตทริบิวต์ class สำหรับ ตัวอย่าง:

   <com.example.android.notepad.LinedEditText
     id="@+id/note"
     ... />
   

   โปรดสังเกตว่าขณะนี้ชั้นเรียน LinedEditText เป็นไฟล์ของชั้นเรียนแยกต่างหากแล้ว เมื่อ อยู่ในคลาส NoteEditor เทคนิคนี้ใช้ไม่ได้

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

การสร้างคอมโพเนนต์ที่กำหนดเองจะซับซ้อนมากตามที่ต้องการ

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