Intellij Idea - คู่มือฉบับย่อ

IntelliJ เป็นหนึ่งใน Integrated Development En Environment (IDE) ที่ทรงพลังและเป็นที่นิยมมากที่สุดสำหรับ Java ได้รับการพัฒนาและดูแลโดยJetBrainsและพร้อมใช้งานในรูปแบบชุมชนและรุ่นที่ดีที่สุด IDE ที่มีคุณลักษณะนี้ช่วยให้พัฒนาได้อย่างรวดเร็วและช่วยในการปรับปรุงคุณภาพโค้ด

IDE คืออะไรและมีประโยชน์อย่างไร?

IDE ย่อมาจาก Integrated Development Environment เป็นการรวมเครื่องมือหลายอย่างเข้าด้วยกันซึ่งทำให้กระบวนการพัฒนาซอฟต์แวร์ง่ายขึ้นมีประสิทธิภาพและมีข้อผิดพลาดน้อยลง มีประโยชน์ดังต่อไปนี้เหนือโปรแกรมแก้ไขข้อความธรรมดา -

• การรวมเข้ากับเครื่องมือที่มีประโยชน์เช่นคอมไพเลอร์ดีบักเกอร์ระบบควบคุมเวอร์ชันเครื่องมือสร้างเฟรมเวิร์กต่างๆโปรไฟล์แอปพลิเคชันและอื่น ๆ

• รองรับการนำทางโค้ดการเติมโค้ดการสร้างโค้ดใหม่และคุณสมบัติการสร้างโค้ดซึ่งช่วยเพิ่มกระบวนการพัฒนา

• รองรับการทดสอบหน่วยการทดสอบการรวมและการครอบคลุมโค้ดผ่านปลั๊กอิน

• จัดเตรียมชุดปลั๊กอินที่หลากหลายเพื่อเพิ่มประสิทธิภาพ IDE ฟังก์ชันเพิ่มเติม

คุณสมบัติของ IntelliJ

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

เจาะลึก

IntelliJ IDEA เข้าใจและมี deep insight ลงในโค้ดของคุณตลอดจนบริบทของโค้ดเดอร์ซึ่งทำให้โค้ดนั้นไม่ซ้ำกันระหว่าง Java IDEs อื่น ๆ

• Smart code completion- รองรับการเติมโค้ดตามบริบท จะให้รายการสัญลักษณ์ที่เกี่ยวข้องมากที่สุดที่ใช้ในบริบทปัจจุบัน

• Chain code completion - เป็นคุณสมบัติการเติมโค้ดขั้นสูงซึ่งแสดงรายการสัญลักษณ์ที่สามารถเข้าถึงได้ผ่านวิธีการหรือ getters ในบริบทปัจจุบัน

• Static member's completion - ช่วยให้คุณสามารถใช้วิธีการคงที่หรือค่าคงที่และเพิ่มคำสั่งการนำเข้าที่จำเป็นโดยอัตโนมัติเพื่อหลีกเลี่ยงข้อผิดพลาดในการคอมไพล์

• Detecting duplicates - พบชิ้นส่วนรหัสที่ซ้ำกันได้ทันทีและแจ้งเตือน / ข้อเสนอแนะเกี่ยวกับมันให้กับผู้ใช้

• Inspections and quick-fixes- เมื่อใดก็ตามที่ IntelliJ ตรวจพบว่าคุณกำลังทำผิดพลาดการแจ้งเตือนเกี่ยวกับหลอดไฟเล็ก ๆ จะปรากฏขึ้นในบรรทัดเดียวกัน การคลิกจะแสดงรายการคำแนะนำ

นักพัฒนา Ergonomics

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

• Editor-centric environment - ป๊อปอัปด่วนช่วยในการตรวจสอบข้อมูลเพิ่มเติมโดยไม่ต้องออกจากบริบทปัจจุบัน

• Shortcuts for everything - IntelliJ IDEA มีแป้นพิมพ์ลัดสำหรับเกือบทุกอย่างรวมถึงการเลือกอย่างรวดเร็วและการสลับไปมาระหว่างหน้าต่างเครื่องมือและอื่น ๆ อีกมากมาย

• Inline debugger- ดีบักเกอร์แบบอินไลน์ช่วยให้คุณสามารถดีบักแอปพลิเคชันใน IDE เอง ทำให้การพัฒนาและการแก้จุดบกพร่องเป็นไปอย่างราบรื่น

เครื่องมือสำหรับนักพัฒนาซอฟต์แวร์ในตัว

เพื่อช่วยนักพัฒนาในการจัดระเบียบเวิร์กโฟลว์ IntelliJ IDEA ขอเสนอชุดเครื่องมือที่น่าทึ่งซึ่งประกอบด้วยตัวถอดรหัส, การสนับสนุน Docker, โปรแกรมดู bytecode, FTP และเครื่องมืออื่น ๆ อีกมากมาย -

• Version control - IntelliJ รองรับระบบควบคุมเวอร์ชันยอดนิยมเช่น Git, Subversion, Mercurial, CVS, Perforce และ TFS

• Build tools - IntelliJ รองรับ Java และเครื่องมือสร้างอื่น ๆ เช่น Maven, Gradle, Ant, Gant, SBT, NPM, Webpack, Grunt และ Gulp

• Test runner and code coverage- IntelliJ IDEA ช่วยให้คุณทำการทดสอบหน่วยได้อย่างง่ายดาย IDE ประกอบด้วยนักวิ่งทดสอบและเครื่องมือครอบคลุมสำหรับกรอบการทดสอบที่สำคัญ ได้แก่ JUnit, TestNG, Spock, Cucumber, ScalaTest, spec2 และ Karma

• Decompiler- IntelliJ มาพร้อมกับตัวถอดรหัสในตัวสำหรับคลาส Java เมื่อคุณต้องการดูภายในไลบรารีที่คุณไม่มีซอร์สโค้ดสำหรับคุณสามารถทำได้โดยไม่ต้องใช้ปลั๊กอินของบุคคลที่สาม

• Terminal- IntelliJ มีเทอร์มินัลในตัว ขึ้นอยู่กับแพลตฟอร์มของคุณคุณสามารถทำงานกับพรอมต์บรรทัดคำสั่งเช่น PowerShell หรือ Bash

• Database tools- IntelliJ มีเครื่องมือฐานข้อมูลซึ่งช่วยให้คุณเชื่อมต่อกับฐานข้อมูลสด เรียกใช้แบบสอบถาม เรียกดูและอัปเดตข้อมูล และแม้แต่จัดการสคีมาของคุณในอินเทอร์เฟซภาพจาก IDE เอง

• Application server- IntelliJ รองรับแอ็พพลิเคชันเซิร์ฟเวอร์หลัก: Tomcat, JBoss, WebSphere, WebLogic, Glassfish และอื่น ๆ อีกมากมาย คุณสามารถปรับใช้อาร์ติแฟกต์ของคุณบนแอ็พพลิเคชันเซิร์ฟเวอร์และดีบักแอ็พพลิเคชันที่ปรับใช้ใน IDE เอง

• Docker support - ผ่านปลั๊กอินแยกต่างหาก IntelliJ มีหน้าต่างเครื่องมือเฉพาะที่ให้คุณเชื่อมต่อกับเครื่อง Docker ที่ใช้งานอยู่ภายในเครื่อง

การเปรียบเทียบระหว่าง Ultimate และ Community Edition

Ultimate Edition ออกแบบมาเพื่อช่วยในการพัฒนาเว็บและองค์กรในขณะที่ Community Edition ออกแบบมาสำหรับ JVM และ Android Development ให้เราพิจารณาประเด็นสำคัญบางประการที่จะช่วยให้เราเข้าใจการเปรียบเทียบระหว่างสองฉบับ -

ลักษณะเฉพาะ	Ultimate Edition	ฉบับชุมชน
ใบอนุญาต	เชิงพาณิชย์	โอเพนซอร์ส Apache 2.0 เพื่อการพัฒนาเชิงพาณิชย์
Java, Kotlin, Groovy, Scala	ได้รับการสนับสนุน	ได้รับการสนับสนุน
การพัฒนา Android	ได้รับการสนับสนุน	ได้รับการสนับสนุน
Maven, Gradle, SBT	ได้รับการสนับสนุน	ได้รับการสนับสนุน
Git, SVN, Mercurial, CVS	ได้รับการสนับสนุน	ได้รับการสนับสนุน
การตรวจหารายการที่ซ้ำกัน	ได้รับการสนับสนุน	ไม่รองรับ
Perforce, TFS	ได้รับการสนับสนุน	ไม่รองรับ
JavaScript, TypeScript	ได้รับการสนับสนุน	ไม่รองรับ
Java EE, Spring, GWT, Vaadin, Play, Grails, Frameworks อื่น ๆ	ได้รับการสนับสนุน	ไม่รองรับ
เครื่องมือฐานข้อมูล SQL	ได้รับการสนับสนุน	ไม่รองรับ

ในบทนี้เราจะเข้าใจวิธีการติดตั้งและกำหนดค่า IntelliJ IDEA ขั้นตอนแรกของกระบวนการเริ่มต้นด้วยการเลือกรุ่น ตามความต้องการของคุณคุณสามารถดาวน์โหลด Community หรือ Ultimate Edition ได้ ตามชื่อที่แนะนำรุ่นชุมชนนั้นฟรีและเราสามารถใช้เพื่อการพัฒนาเชิงพาณิชย์ได้เช่นกัน อย่างไรก็ตามรุ่น Ultimate เป็นรุ่นที่ต้องชำระเงินและเราสามารถประเมินได้อย่างอิสระสำหรับ30 วัน.

การติดตั้งบน Windows

IntelliJ เข้ากันได้กับ Windows เกือบทุกเวอร์ชันก่อนปี 2003 รายการที่ครอบคลุมจะเป็น: Windows 10/8/7 / Vista / 2003 / XP ขอแนะนำให้คุณปิดแอปพลิเคชันอื่น ๆ ทั้งหมดก่อนที่คุณจะติดตั้ง IntelliJ บน Windows

ความต้องการของระบบ

• แนะนำให้ใช้ความจุ RAM ขั้นต่ำ 2 GB เพื่อประสิทธิภาพที่ราบรื่น

• เพื่อการแสดงภาพที่ดีขึ้นขอแนะนำให้ใช้ความละเอียดหน้าจอ 1024x768

• พื้นที่ดิสก์ขั้นต่ำ 300 MB สำหรับการติดตั้งและเพิ่มเติม 1 GB สำหรับแคช

การดาวน์โหลดและการติดตั้ง

• Downloading - คุณสามารถดาวน์โหลดตัวติดตั้ง windows ได้จากเว็บไซต์ทางการ

• Installation- เริ่มต้นด้วยการติดตั้งตามด้วยขั้นตอนการกำหนดค่า การติดตั้ง IntelliJ นั้นคล้ายกับโปรแกรมสำเร็จรูปอื่น ๆ เพียงดับเบิลคลิกที่โปรแกรมติดตั้งและปฏิบัติตามคำแนะนำบนหน้าจอเพื่อเสร็จสิ้นกระบวนการติดตั้ง

การติดตั้งบน Linux

สำหรับการติดตั้ง IntelliJ บนแพลตฟอร์ม Linux คุณต้องทราบว่า JDK แบบ 32 บิตไม่ได้รวมอยู่ด้วยดังนั้นแนะนำให้ใช้ระบบ 64 บิต

ความต้องการของระบบ

• สภาพแวดล้อมเดสก์ท็อป GNOME, KDE หรือ XFCE

• แนะนำให้ใช้ RAM ขั้นต่ำ 2 GB เพื่อการใช้งานที่ราบรื่น

• พื้นที่ดิสก์ 300 MB สำหรับการติดตั้งและเพิ่ม 1 GB สำหรับแคช

• เพื่อการแสดงภาพที่ดีขึ้นขอแนะนำให้ใช้ความละเอียดหน้าจอ 1024x768

การดาวน์โหลดและการติดตั้ง

• Downloading - คุณสามารถดาวน์โหลด IntelliJ สำหรับ Linux ได้จากเว็บไซต์ทางการ

• Installation- เราได้ดาวน์โหลด tar.gz บันเดิล โปรดทราบว่าในชื่อกลุ่มเคสของเราคือ ideaIC-2017.2.5.tar.gz อาจมีการเปลี่ยนแปลงตามฉบับ / เวอร์ชัน โปรดใช้ชื่อกลุ่มที่เหมาะสม

First extract it using following command:
$ tar xvf ideaIC-2017.2.5.tar.gz It will create new directory with idea-IC-172.4343.14 name. Now change directory to idea-IC-172.4343.14/bin/ and execute idea.sh shell script as shown below: $ cd idea-IC-172.4343.14/bin/
$ ./idea.sh
Follow on-screen instructions to complete installation procedure.

กำหนดค่า IntelliJ

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

Step1- หากคุณใช้รุ่น Ultimate หน้าต่างเปิดใช้งานใบอนุญาตจะปรากฏขึ้น เลือกประเมินตัวเลือกฟรีและคลิกที่ปุ่มประเมินดังที่แสดงในภาพต่อไปนี้

Step 2- ยอมรับข้อตกลงสิทธิ์การใช้งานเพื่อดำเนินการต่อและปฏิบัติตามคำแนะนำบนหน้าจอเพื่อเริ่ม IntelliJ คุณจะเห็นหน้าจอต้อนรับของ IntelliJ

Step 3- ตอนนี้ถึงเวลากำหนดค่า Java Development Kit (ต่อจากนี้เราจะเรียกมันว่า JDK) ด้วย IntelliJ หากยังไม่ได้ติดตั้ง JDK ให้ทำตามคำแนะนำในที่นี้

• บนหน้าจอต้อนรับคลิกที่ 'กำหนดค่า'

• เลือก 'ค่าเริ่มต้นของโครงการ' จากรายการแบบเลื่อนลง

• เลือกตัวเลือก "โครงสร้างโครงการ"

• เลือกตัวเลือก "SDK" จากเมนู "การตั้งค่าแพลตฟอร์ม"

• คลิกที่ไอคอน 'บวก' และเลือกตัวเลือก 'JDK'

• เลือกโฮมไดเร็กทอรีของ JDK และปฏิบัติตามคำแนะนำบนหน้าจอ

ในบทนี้เราจะทำความคุ้นเคยกับ IntelliJ IDEA มากขึ้น เพื่อหารือเกี่ยวกับข้อดีและการทำงานของเครื่องมือใด ๆ ต้องมีความคุ้นเคยกับเครื่องมือนั้นและ IntelliJ ก็ไม่มีข้อยกเว้น

บทนี้ให้ภาพรวมของ IntelliJ บทเริ่มต้นด้วยการอภิปรายเกี่ยวกับองค์ประกอบภาพของ IDE การตั้งค่าคอนฟิกูเรชันและสุดท้ายจบลงด้วยการพูดคุยเกี่ยวกับคุณสมบัติของ JVM และแพลตฟอร์ม

องค์ประกอบภาพ

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

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

2. Tool bar- แถบเครื่องมือมีทางลัดเพื่อรวบรวมแก้ไขข้อบกพร่องและเรียกใช้ตัวเลือกต่างๆ คุณสามารถปรับแต่งได้ตามความต้องการของคุณ

3. Navigation bar- แถบนำทางช่วยให้การนำทางภายในโครงการง่ายขึ้น คุณลักษณะนี้มีประโยชน์เมื่อฐานรหัสเพิ่มขึ้น

4. Tools tab- แท็บเครื่องมือจะแสดงที่ด้านใดด้านหนึ่งของหน้าต่างหลัก จากที่นี่คุณสามารถเข้าถึงเครื่องมือที่สำคัญเช่นฐานข้อมูล Maven / Ant สร้างและอื่น ๆ

5. Project perspective - หน้าต่างมุมมองโครงการแสดงองค์ประกอบต่างๆของโครงการเช่นแพ็คเกจโมดูลคลาสไลบรารีภายนอกและอื่น ๆ

6. Editor window- เป็นสถานที่ที่นักพัฒนาใช้เวลาส่วนใหญ่ หน้าต่างตัวแก้ไขช่วยให้คุณแก้ไข / เขียนโค้ดด้วยการเน้นไวยากรณ์และคุณสมบัติที่มีประโยชน์อื่น ๆ

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

การทำงานกับปลั๊กอิน

ปลั๊กอินช่วยขยายการทำงานของ IntelliJ มีปลั๊กอินจำนวนมากตั้งแต่ฐานข้อมูลการควบคุมเวอร์ชันการทำโปรไฟล์และรายการต่อไปนี้

ขั้นตอนในการจัดการปลั๊กอิน

ทำตามขั้นตอนเหล่านี้เพื่อจัดการปลั๊กอิน -

• ไปที่เมนูไฟล์→การตั้งค่า

• เลือกแท็บปลั๊กอินในบานหน้าต่างด้านซ้าย

• หน้าต่างนี้แสดงรายการปลั๊กอินที่ติดตั้งทั้งหมด มีช่องทำเครื่องหมายทางด้านขวาของชื่อปลั๊กอินแต่ละชื่อ การสลับช่องทำเครื่องหมายนั้นเปิด / ปิดใช้งานปลั๊กอิน

• ที่เก็บปลั๊กอินออนไลน์ IntelliJ มีอยู่ที่นี่ ในการเพิ่ม / ลบที่เก็บปลั๊กอินให้คลิกที่ปุ่มเรียกดูที่เก็บและมันจะเป็นวิธีที่จำเป็น

• นอกจากนี้ยังอนุญาตให้ติดตั้งปลั๊กอินออฟไลน์ สำหรับสิ่งนี้ให้ดาวน์โหลดปลั๊กอินและเลือกติดตั้งปลั๊กอินจากปุ่มดิสก์และไปที่เส้นทางการดาวน์โหลด

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

ทำงานกับการตั้งค่า

ส่วนนี้ให้เคล็ดลับสำคัญบางประการในการจัดการการตั้งค่า ช่วยให้คุณสามารถนำเข้าส่งออกและแบ่งปันการตั้งค่า IntelliJ

การตั้งค่าการส่งออก

อนุญาตให้ส่งออกการตั้งค่าปัจจุบันเป็นไฟล์ jar

• ไปที่ไฟล์→ส่งออกการตั้งค่า

• หน้าต่างการตั้งค่าการส่งออกจะแสดงรายการการตั้งค่าที่พร้อมใช้งานที่เกี่ยวข้องกับ UI, ดีบักเกอร์, SDK พร้อมกับอื่น ๆ

• มีช่องทำเครื่องหมายสำหรับการเลือก เมื่อเลือกเสร็จแล้วให้คลิกที่ปุ่ม OK เพื่อบันทึกการตั้งค่าบนดิสก์ภายในเครื่อง

นำเข้าการตั้งค่า

อนุญาตให้นำเข้าการตั้งค่าที่เก็บไว้ในไฟล์ jar

• ไปที่ไฟล์→นำเข้าการตั้งค่า
• เลือกโถการตั้งค่าโดยการนำทางโครงสร้างโฟลเดอร์
• คลิกที่ปุ่ม OK

ตั้งค่าการแชร์

IntelliJ IDEA ช่วยให้คุณแบ่งปันการตั้งค่า IDE ของคุณระหว่างอินสแตนซ์ต่างๆ สิ่งนี้มีประโยชน์อย่างยิ่งเมื่อคุณต้องการใช้การตั้งค่าเดียวกันภายในทีมหรือองค์กร ข้อกำหนดเบื้องต้นสำหรับสิ่งนี้คือการเปิดใช้งานSettings Repositoryเสียบเข้าไป. มีการติดตั้งและเปิดใช้งานตามค่าเริ่มต้น

เพื่อให้แน่ใจว่าสถานะ -

• ไปที่ไฟล์→การตั้งค่า→ปลั๊กอิน

• ค้นหาปลั๊กอินที่เก็บการตั้งค่าการตั้งค่า

เราสามารถจัดเก็บการตั้งค่าปัจจุบันบน GitHub / Bitbucket และนำไปใช้กับอินสแตนซ์อื่น ๆ ในการจัดเก็บการตั้งค่าปัจจุบัน -

• ไปที่ File → Settings Repository

• พิมพ์ URL ที่เก็บ Git ในกล่องโต้ตอบ URL ต้นน้ำ

• คลิกที่ปุ่ม Overwrite remote

• หากต้องการใช้การตั้งค่าเดียวกันกับอินสแตนซ์อื่น ๆ ให้คลิกที่ปุ่มเขียนทับในเครื่อง

การกำหนดค่า JVM Options และ Platform Properties

เราสามารถกำหนดค่าตัวเลือก JVM ได้โดยไปที่ไฟล์ Help → Edit Custom VM Optionsเมนู. ต่อไปนี้เป็นตัวเลือก JVM ที่สำคัญบางประการที่เราสามารถตั้งค่าได้

• –server - อนุญาตให้เลือก Java HotSpot Server VM

• -Xms<size>- ตั้งค่าขนาดฮีป Java เริ่มต้น ค่าเริ่มต้นคือ 128 MB

• -Xmx<size>- ตั้งค่าขนาดฮีป Java สูงสุด ค่าเริ่มต้นคือ 750 MB

• -Xss<size> - ตั้งค่าขนาดสแต็กเธรด Java

• –XX - อนุญาตให้ตั้งค่าอัลกอริทึม GC และคุณสมบัติอื่น ๆ

ถึงเวลาแล้วที่เราจะได้สัมผัสกับ IntelliJ โดยตรง ในบทนี้เราจะสร้าง Java Project แรกของเรา เราจะเขียนและดำเนินการแบบดั้งเดิมHello Worldโปรแกรม. บทนี้จะอธิบายการคอมไพล์และการรันแอ็พพลิเคชัน Java

สร้างโครงการ

สำหรับสิ่งที่เกี่ยวข้องกับการพัฒนานักพัฒนาจะต้องสร้างโครงการใหม่ด้วย IntelliJ ให้เราทำตามขั้นตอนเหล่านี้เพื่อสร้างโครงการ -

• เปิด IntelliJ

• ไปที่ File → New → Project เมนู.

• เลือกโครงการ Java และ SDK ที่เหมาะสมแล้วคลิกปุ่มถัดไป

• หากคุณต้องการสร้างคลาส Java ด้วยวิธีการหลักจากนั้นเลือกสร้างโครงการจากกล่องกาเครื่องหมายเทมเพลต

• เลือกแอพบรรทัดคำสั่งจากกล่องโต้ตอบที่แสดงด้านล่างและดำเนินการต่อ

• ป้อนชื่อโปรเจ็กต์และตำแหน่งไดเร็กทอรี

• คลิกที่ปุ่มเสร็จสิ้น

สร้างแพ็คเกจ

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

• ไปที่มุมมองของโครงการ

• คลิกขวาที่โครงการเลือกไฟล์ New->Module ตัวเลือก

• หน้าต่างโมดูลใหม่จะคล้ายกับโครงการใหม่ เลือกตัวเลือก Java และ SDK ที่เหมาะสมแล้วคลิกปุ่มถัดไป

• ป้อนชื่อโมดูล

• คลิกที่ปุ่มเสร็จสิ้น

สร้างคลาส Java

ในส่วนนี้เราจะเรียนรู้วิธีการสร้างคลาส Java คลาส Java สามารถสร้างได้ภายใต้โมดูล Java ทำตามขั้นตอนเหล่านี้เพื่อสร้างโมดูล -

• ไปที่มุมมองโครงการ

• ขยายโครงการและเลือกไฟล์ src ไดเร็กทอรีจากโมดูล

• คลิกขวาที่มัน เลือกไฟล์New->Java ตัวเลือกคลาส

• ป้อนชื่อชั้นเรียนในกล่องโต้ตอบและคลิกที่ปุ่มตกลง

• มันจะเปิดหน้าต่าง Editor พร้อมกับการประกาศคลาส

รัน Java Application

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

• ให้เราเขียนโค้ดง่ายๆซึ่งจะพิมพ์ข้อความบนคอนโซล ป้อนรหัสต่อไปนี้ในหน้าต่างตัวแก้ไข -

public class HelloWorld { 
   public static void main(String[] args) { 
      System.out.println("Hello, World !!!"); 
   } 
}

• ไปที่เมนู Run และเลือกตัวเลือก Run

• เลือกชื่อคลาสและคลิกที่เรียกใช้

• หากไม่มีข้อผิดพลาดในการคอมไพล์ระบบจะแสดงเอาต์พุตที่ด้านล่างของหน้าต่าง

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

การทำความเข้าใจโครงการ

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

การทำความเข้าใจโมดูล

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

นอกจากนี้เรายังสามารถนำเข้าโมดูลที่มีอยู่ ทำตามขั้นตอนเหล่านี้เพื่อนำเข้าโมดูลที่มีอยู่ -

• ไปที่ไฟล์→โครงสร้างโครงการ
• เลือกโมดูลและคลิกที่ไอคอนบวก
• จะแสดงตัวเลือกในการนำเข้าโมดูล

การทำความเข้าใจโฟลเดอร์

Content rootคือโฟลเดอร์ที่มีไฟล์ทั้งหมดที่ประกอบเป็นโมดูลของคุณ โมดูลสามารถมีโฟลเดอร์เนื้อหาได้มากกว่าหนึ่งโฟลเดอร์ โฟลเดอร์แบ่งออกเป็นประเภทต่อไปนี้ -

• Sources - ด้วยการกำหนดหมวดหมู่นี้ให้กับโฟลเดอร์เราสั่งให้ IntelliJ ทราบว่าสิ่งนี้และโฟลเดอร์ย่อยมีซอร์สโค้ด java และควรรวบรวมเป็นส่วนหนึ่งของกระบวนการคอมไพล์

• Tests- ด้วยการกำหนดหมวดหมู่นี้ให้กับโฟลเดอร์เราสั่งให้ IntelliJ เป็นตำแหน่งสำหรับการทดสอบหน่วย โฟลเดอร์นี้สามารถเข้าถึงคลาสจากโฟลเดอร์ Sources

• Resources- แสดงถึงไฟล์ทรัพยากรต่างๆที่ใช้ในโครงการเช่นรูปภาพ XML และไฟล์คุณสมบัติ ในระหว่างขั้นตอนการคอมไพล์เนื้อหาของโฟลเดอร์นี้จะถูกคัดลอกไปยังโฟลเดอร์เอาต์พุต

• Excluded- เนื้อหาจากโฟลเดอร์ที่แยกออกจะไม่ถูกทำดัชนีโดย IntelliJ ซึ่งหมายความว่า IntelliJ จะไม่ให้คำแนะนำการเติมโค้ดและคำแนะนำอื่น ๆ ตัวอย่างเช่นไดเร็กทอรีเอาต์พุตและไดเร็กทอรีเป้าหมายถูกแยกออกโดยค่าเริ่มต้น

• Test resources - สิ่งนี้คล้ายกับทรัพยากรและใช้สำหรับการทดสอบหน่วย

การทำความเข้าใจไลบรารี

ห้องสมุดคือการรวบรวมคลาสต่างๆ ไลบรารีช่วยให้สามารถใช้รหัสซ้ำได้ ใน Java ไลบรารีสามารถอยู่ใน ZIP, Jar หรือเพียงแค่โฟลเดอร์ เราสามารถกำหนดไลบรารีได้สามระดับ ระดับ ได้แก่ - ระดับโลกโครงการและระดับโมดูล

• Global level - แชร์โดยทุกโครงการ

• Project level - แชร์โดยโมดูลทั้งหมดของโครงการ

• Module level - แชร์โดยคลาสของโมดูลเหล่านั้น

การทำความเข้าใจ Facets

Facets เป็นส่วนขยายของโมดูล พวกเขาเพิ่มการสนับสนุนให้กับกรอบและเทคโนโลยี เมื่อมีการเพิ่ม facet ในโมดูล IntelliJ จะระบุว่าจะเพิ่มการสนับสนุน ตัวอย่างเช่นคำแนะนำและความช่วยเหลือในตัวแก้ไขเครื่องมือใหม่ในแถบหน้าต่างการดาวน์โหลดการพึ่งพาและอื่น ๆ คุณสามารถเพิ่มแง่มุมจากไฟล์File → Project Structure หน้าต่างดังภาพด้านล่าง -

สิ่งประดิษฐ์

Artifacts คือผลลัพธ์ของโปรเจ็กต์ อาจเป็นไฟล์ JAR ธรรมดาแอปพลิเคชัน Java EE หรือแอปพลิเคชัน Java EJB หากเราใช้เครื่องมือสร้างภายนอกเช่น Gradle หรือ Maven IntelliJ จะเพิ่มสิ่งประดิษฐ์ให้โดยอัตโนมัติ สามารถสร้างอาร์ติแฟกต์ได้โดยไปที่ไฟล์File → Project Structure ดังแสดงด้านล่าง -

การนำเข้าโครงการที่มีอยู่

ในส่วนนี้เราจะเข้าใจวิธีการนำเข้าโครงการที่มีอยู่ เราสามารถนำเข้าโครงการได้สองวิธี -

• นำเข้าจากแหล่งที่มีอยู่
• นำเข้าจากโมเดลการสร้าง

ปัจจุบันรองรับ Gradle และ Maven build tools เพื่อนำเข้าโครงการ -

• ไปที่ไฟล์→ใหม่→โปรเจ็กต์จากแหล่งที่มีอยู่
• เลือกไดเร็กทอรีของโปรเจ็กต์ที่มีอยู่, pom.xml ของ Maven หรือบิลด์สคริปต์ของ Gradle
• คลิกที่ปุ่ม OK

รูปแบบโครงการ

IntelliJ รองรับรูปแบบโครงการสองประเภทหนึ่งคือ directory-based และอื่น ๆ คือ file-based. ขอแนะนำให้ใช้รูปแบบตามไดเร็กทอรีใหม่กว่า ตามค่าเริ่มต้น IntelliJ จะสร้างรูปแบบโครงการตามไดเรกทอรี คุณสามารถเลือกรูปแบบโครงการขณะสร้างโครงการใหม่ ในหน้าต่างโครงการใหม่เพียงคลิกที่การตั้งค่าเพิ่มเติมตามที่แสดงในภาพด้านล่าง -

รูปแบบโครงการตามไดเรกทอรี

รูปแบบนี้ช่วยสร้างโฟลเดอร์ไอเดียในโปรเจ็กต์ของคุณและเก็บไฟล์คอนฟิกูเรชันทั้งหมดไว้ในโฟลเดอร์นั้น การตั้งค่าจะถูกจัดกลุ่มไว้ในไฟล์ xml ตัวอย่างเช่นมันจะสร้างmisc.xml, modules.xml, workspace.xmlและอื่น ๆ ภาพหน้าจอต่อไปนี้จะช่วยให้คุณเข้าใจวิธีการทำงาน -

รูปแบบโครงการตามไฟล์

มันจะสร้างไฟล์โครงการสองไฟล์ด้วย ..ipr และ wprนามสกุล. ไฟล์ ipr จะมีการตั้งค่าเฉพาะโปรเจ็กต์และไฟล์ wpr จะมีการตั้งค่าเฉพาะพื้นที่ทำงาน

ในการแปลงโปรเจ็กต์ที่ใช้ไฟล์เป็นโปรเจ็กต์แบบไดเร็กทอรีให้ไปที่ไฟล์ File → Save as a Directory-Based format.

รูปแบบโครงการตามไดเรกทอรีเทียบกับไฟล์

เมื่อเทียบกับรูปแบบโครงการที่ใช้ไฟล์รูปแบบโครงการตามไดเรกทอรีจะจัดเก็บการตั้งค่าในโฟลเดอร์แยกต่างหากที่มีชื่อที่มีความหมาย ความแตกต่างอื่น ๆ ได้แก่ -

• การตั้งค่าที่เกี่ยวข้องจัดเก็บไว้ในไฟล์เดียวทำให้ง่ายต่อการจัดการในรูปแบบโครงการตามไดเรกทอรี

• ถ้าโฟลเดอร์มีโฟลเดอร์ย่อยไอเดีย IntelliJ จะจดจำโปรเจ็กต์นั้น ด้วยเหตุนี้คุณจึงไม่ได้เลือกโปรเจ็กต์ ipr อย่างชัดเจน

• รูปแบบโครงการตามไดเรกทอรีจะแบ่งการตั้งค่าออกเป็นไฟล์หลาย ๆ ไฟล์ดังนั้นจึงง่ายกว่าในการเลือกประเภทการตั้งค่าที่ต้องการเพื่อจัดเก็บในระบบควบคุมเวอร์ชัน

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

องค์ประกอบภาพของบรรณาธิการ

IntelliJ มีข้อกำหนดมากมายที่รวมถึงองค์ประกอบภาพที่ออกแบบมาเพื่อช่วยนักพัฒนาในการสำรวจและทำความเข้าใจสถานะที่แท้จริงของการเข้ารหัส

ตอนนี้เรามาดูข้อกำหนดต่างๆกัน -

พื้นที่รางน้ำ

พื้นที่รางน้ำของบรรณาธิการอยู่ทางด้านซ้ายของ IDE ดังที่แสดงในภาพต่อไปนี้ -

ป้ายกำกับ

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

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

• คุณสามารถเห็นสัญลักษณ์บวกขนาดเล็กที่บรรทัดหมายเลข 6 นี่คือฟังก์ชันการพับโค้ด หากคุณคลิกที่ไอคอนนั้นไอคอนนั้นจะคลี่ออก การพับโค้ดสามารถทำได้ในระดับวิธีการวงและระดับบล็อกอื่น ๆ

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

แถบสถานะ

ที่ด้านล่างของหน้าต่าง Editor จะมีแถบสถานะซึ่งจะแสดงข้อมูลเกี่ยวกับไฟล์ปัจจุบันและสถานะของโปรเจ็กต์

• ในภาพแรก 16: 1 แทนหมายเลขบรรทัดปัจจุบันและหมายเลขคอลัมน์ตามลำดับ

• ถัดไปคือตัวคั่นบรรทัดสำหรับ UNIX และ mac OS คือ \ n และสำหรับ windows ก็คือ \ r

• UTF-8 แสดงถึงการเข้ารหัสไฟล์

• ถัดไปคือ lockไอคอน. เราสามารถสลับแอตทริบิวต์อ่านอย่างเดียวของไฟล์ได้โดยคลิกที่มัน

• ตอนท้ายมีสัญลักษณ์รูปหน้าคน ช่วยให้จัดการระดับการตรวจสอบรหัส

  • เมื่อเราพิมพ์โค้ดใน Editor IntelliJ จะตรวจสอบโค้ด on the flyและแสดงคำใบ้ / ข้อเสนอแนะ เราสามารถตัดสินใจระดับการตรวจสอบได้จากที่นี่ ตัวอย่างเช่นเราสามารถปิดใช้งานได้อย่างสมบูรณ์หรืออนุญาตให้ตรวจสอบเฉพาะไวยากรณ์เป็นต้น

  • นอกจากนี้เรายังสามารถเปิดใช้งานโหมดประหยัดพลังงานได้จากที่นี่ซึ่งจะปิดใช้งานการวิเคราะห์โค้ดพื้นหลังและงานพื้นหลังอื่น ๆ

• แถบสถานะยังแสดงข้อมูลเกี่ยวกับการดำเนินการโครงการ ตัวอย่างเช่นภาพที่สองแสดงข้อมูลเกี่ยวกับการรวบรวมโครงการ

รอยขีดข่วน

IntelliJ มีตัวแก้ไขชั่วคราว คุณสามารถสร้างข้อความหรือโค้ดโดยไม่ต้องแก้ไขโครงสร้างโครงการปัจจุบัน มีไฟล์ชั่วคราวสองประเภท -

Scratch ไฟล์

พวกเขาใช้งานได้ทำงานได้และสามารถแก้ไขข้อบกพร่องได้ ในการสร้างไฟล์เริ่มต้น -

• ไปที่ File → New → Scratch ไฟล์.

• เลือกภาษาที่คุณต้องการ

• มันจะสร้างไฟล์ในโฟลเดอร์ IntelliJ-Installation-Directory \ config \ scratch

ขูดบัฟเฟอร์

ใช้สำหรับสร้างข้อความเท่านั้น ในการสร้างบัฟเฟอร์รอยขีดข่วน -

• กด Ctrl + Shift + A หรือคลิกที่ไอคอน Search Everywhere

• มันจะปรากฏขึ้นกล่องโต้ตอบ

• ป้อนข้อความบัฟเฟอร์รอยขีดข่วนใหม่ในช่องนั้นแล้วกด Enter

• มันจะเปิดบัฟเฟอร์รอยขีดข่วนในหน้าต่างตัวแก้ไข

เช่นเดียวกับไฟล์ Scratch scratch buffers ยังถูกเก็บไว้ในโฟลเดอร์ IntelliJ-Installation-Directory \ config \ scratch

แถบเลื่อน

แถบเลื่อนเน้นคำเตือน / ข้อความแสดงข้อผิดพลาด / เครื่องหมายสิ่งที่ต้องทำจากรหัส ตัวอย่างเช่นไม่เคยใช้เมธอด sayHello () และ sayGoodBye () ดังนั้นแถบเลื่อนจะแสดงเครื่องหมายสีเหลืองสำหรับพวกเขา

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

การกระทำของบรรณาธิการ

ในส่วนนี้เราจะพูดถึงการดำเนินการแก้ไขใน IntelliJ

ค้นหาและแทนที่

ในการค้นหาข้อความในไฟล์ปัจจุบัน -

• ไปที่ไฟล์ในหน้าต่าง Editor แล้วกด Ctrl + F

• มันจะแสดงกล่องข้อความพิมพ์ข้อความที่จะค้นหาในนั้น

• คุณสามารถระบุตัวเลือกต่างๆได้ที่นี่ - การจับคู่แบบตรงตามตัวพิมพ์เล็กและใหญ่การจับคู่แบบตรงทั้งหมดนิพจน์ทั่วไปและอื่น ๆ

คุณสามารถดำเนินการค้นหาในระดับที่ละเอียดมาก ตัวอย่างเช่นการค้นหาสามารถทำได้ในระดับโครงการโมดูลหรือไดเร็กทอรี -

• กด Ctrl+Shift+F คีย์ผสม

• หน้าต่างใหม่จะปรากฏขึ้น จากที่นี่คุณสามารถเลือกระดับที่เหมาะสมได้

ในการดำเนินการแทนที่ในไฟล์ปัจจุบัน -

• กด Ctrl+R คีย์ผสม

• กล่องโต้ตอบจะปรากฏขึ้นให้ป้อนข้อความที่จะแทนที่ที่นี่

• การดำเนินการนี้ช่วยให้คุณสามารถแทนที่การแข่งขันเดี่ยวการจับคู่ทั้งหมดหรือข้ามการแข่งขันปัจจุบัน

ในการดำเนินการแทนที่ในระดับละเอียด -

• กด Shift+Ctrl+R คีย์ผสม

• จะช่วยให้คุณสามารถแทนที่ข้อความในโครงการโมดูลไดเรกทอรีและขอบเขตอื่น ๆ

โหมดการเลือกคอลัมน์

ในการเปิดใช้งานการเลือกโหมดคอลัมน์ให้กดปุ่ม Altขณะเลือกข้อความ หากต้องการเปิดใช้งานโหมดการเลือกคอลัมน์แบบถาวรให้เลือกEdit → Column selection mode.

ประวัติคลิปบอร์ด

เมื่อเราคัดลอกข้อความใด ๆ มันจะไปที่ประวัติคลิปบอร์ด IntelliJ เก็บรักษาประวัติคลิปบอร์ด หากต้องการดูประวัตินี้ให้กดCtrl+Shift+Vคีย์ผสม คุณสามารถเลือกเนื้อหาที่จะวางจากหน้าต่างนี้

การกรอกรหัส

IntelliJ ตรวจสอบไฟล์ code on the flyและให้รหัสที่สมบูรณ์ ตัวอย่างเช่นเมื่อฉันพิมพ์คำsay - มันแนะนำ sayHello() และ sayGoodBye() วิธีการ

การเติมโค้ดจะแนะนำแอตทริบิวต์คลาสและเมธอดคลาสขณะทำงานกับคลาสอ็อบเจ็กต์

กำลังสร้างรหัส

IntelliJ มีวิธีการสร้างโค้ดที่เป็นประโยชน์เช่น constructor, getter, setter, toString () method, override method และอื่น ๆ ทำตามขั้นตอนเหล่านี้เพื่อคลิกขวาในหน้าต่างตัวแก้ไข

• เลือกไฟล์ Generate ตัวเลือก

• จะแสดงรายการวิธีการที่สามารถสร้างรหัสได้

การตรวจสอบรหัส

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

boolean flag = true; 
if (flag == true) { 
   System.out.println("Value of flag is true"); 
} else { 
   System.out.println("Value of flag is false"); 
}

IntelliJ ระบุสิ่งนี้และแนะนำให้ลบบล็อกโค้ดนี้

การเปรียบเทียบไฟล์และโฟลเดอร์

ทำตามขั้นตอนเหล่านี้เพื่อเปรียบเทียบไฟล์และโฟลเดอร์ -

• ถือ Ctrl คีย์และเลือกไฟล์ที่จะเปรียบเทียบจากมุมมองของโครงการ

• คลิกขวาที่ไฟล์แล้วเลือกไฟล์ Compare Files ตัวเลือก

• จะเปิดหน้าต่างเปรียบเทียบที่มีการเน้นการเปลี่ยนแปลง

คุณยังสามารถใช้การเปลี่ยนแปลงจากไฟล์หนึ่งไปยังอีกไฟล์หนึ่งได้ หากสังเกตดูจะมีเครื่องหมายลูกศรสองอันที่เน้นด้วยสีแดง คลิกเพื่อใช้การเปลี่ยนแปลงจากไฟล์อื่น กดCtrl+Z เพื่อเลิกทำการเปลี่ยนแปลง

ในทำนองเดียวกันหากต้องการเปรียบเทียบโฟลเดอร์ให้เลือกโฟลเดอร์จากมุมมองของโครงการแทนไฟล์

การขอความช่วยเหลือ

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

เอกสารแบบอินไลน์

ตามชื่อที่แนะนำ IntelliJ สามารถเข้าถึงเอกสารโดยแยกออกจากรหัส หากคุณให้ Java Docs สำหรับโค้ดของคุณ IntelliJ สามารถแสดงความช่วยเหลือเกี่ยวกับเรื่องนี้ได้ ในการเข้าถึงเอกสารแบบอินไลน์ให้โฮเวอร์คลิกที่ชื่อวิธีการแล้วกดปุ่มCtrl+Q คีย์ผสม

การดูคำจำกัดความ

หากต้องการดูคำจำกัดความให้วางเมาส์เหนือชื่อเมธอดแล้วกดปุ่ม Ctrl+Shift+I คีย์ผสม

แสดงการใช้งาน

หากต้องการดูวิธีการใช้งานให้คลิกที่การประกาศ / นิยามวิธีการแล้วกดปุ่ม Alt+Ctrl+F7 คีย์ผสม

ดูพารามิเตอร์

หากต้องการดูพารามิเตอร์วิธีการพิมพ์ชื่อเมธอดแล้วกด Ctrl+P คีย์ผสม

รหัสผ้าสำลี

Linting เป็นกระบวนการที่เครื่องมือ lint วิเคราะห์ซอร์สโค้ดและรายงานปัญหาที่อาจเกิดขึ้นที่เกี่ยวข้องกับมาตรฐานการเข้ารหัส ช่วยในการปรับปรุงคุณภาพโค้ด IntelliJ รองรับปลั๊กอิน SonarLint ซึ่งจะทับรหัส

เกี่ยวกับ SonarLint

เมื่อคุณติดตั้งและเปิดใช้งานปลั๊กอิน SonarLint มันจะเริ่มวิเคราะห์โค้ดโดยอัตโนมัติเมื่อคุณเปิดไฟล์ในหน้าต่างตัวแก้ไข จะรายงานปัญหาในแผง SonarLint เราจะพูดคุยเพิ่มเติมเกี่ยวกับเรื่องนี้ในส่วนนี้

SonarLint รองรับภาษาโปรแกรมยอดนิยมเช่น Java, JavaScript, PHP และ Python

การติดตั้ง

ทำตามขั้นตอนเหล่านี้เพื่อติดตั้ง SonarLint -

• ดาวน์โหลด SonarLint จากที่นี่

• Go to File → Settings → Select plugins.

• Click on the Install plugin from disk button.

• Follow on-screen installation to complete the installation procedure.

Code Analysis

Once the plug-in is installed and enabled, it will start analyzing code on the fly. It will report issues in the SonarLint panel. Follow these steps to view issues of the current file −

• Click on the Current file tab.

• It will report issues like unused local variables, unused class attributes, message logging and so on.

• To know more about issue, click on issue from SolarLint panel.

• In the right side of the window, it will show its severity as Major, Minor and so on.

Do One Time Code Analysis

If you are not comfortable with on-the-fly code analysis, then you can disable it and perform one time code analysis once you are ready with code. Follow these steps to disable on-the-fly code analysis −

• Go to File → Settings → Other Setting → SonarLint General Settings

• Uncheck Automatically Trigger Analysis checkbox from the settings tab.

• Click on Apply followed by Ok button.

In this chapter, we will learn about Code Refactoring and how it works in IntelliJ. Code refactoring is restructuring of code without changing its functionality and usability. Code refactoring can be done to improve code readability, performance or to remove unused/duplicate functionality. IntelliJ provides great support for code refactoring. This chapter discusses various code refactoring actions.

Rename

Rename actions can be used to rename methods, its parameters, class attributes, local variables and so on. Let us create the following class in IntelliJ.

public class Employee {
   private String name;
   private String address;
   private int age;
   public Employee() {
      this("Jarvis", "Palo Alto", 35);
   }
   public Employee(String name, String address, int age) {
      this.name = name;
      this.address = address;
      this.age = age;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getAddress() {
      return address;
   }
   public void setAddress(String address) {
      this.address = address;
   }
   public int getAge() {
      return age;
   }
   public void setAge(int age) {
      this.age = age;
   }
   
   @Override
   public String toString() {
      return "Employee{" +
      "name='" + name + '\'' +
      ", address='" + address + '\'' +
      ", age=" + age +
      '}';
   }
   public static void main(String args[]) {
      Employee e = new Employee();
      System.out.println(e);
   }
}

Now, let us rename Employee class to Person. This action will do modifications in constructors and the main() method −

• Select Employee word

• Go to Refactor → Rename and rename it with Person.

Replace Code Duplicates

This is one of the powerful refactoring actions. IntelliJ identifies code duplicates and replaces it with appropriate code. Let us introduce code duplication and refactor it. Type the following code in the Editor −

public class Employee {
   private String name;
   private String address;
   private int age;
   public Employee() {
      this("Jarvis", "Palo Alto", 35);
   }
   public Employee(String name, String address, int age) {
      this.name = name;
      this.address = address;
      this.age = age;
   }
   public void setData(String name, String address,  int age) {
      this.name = name;
      this.address = address;
      this.age = age;
   }
   public void showEmployeeDetail() {
      System.out.println("Name = " + name + ", Address = " + address + ", Age = " + age);
   }
   public static void main(String args[]) {
      Employee e = new Employee();
      e.showEmployeeDetail();
   }
}

In this example, Employee(String name, String address, int age) constructor and public void setData(String name, String address, int age) method are exactly identical. After refactoring, the Employee(String name, String address, int age) constructor gets modified as follows −

public Employee(String name, String address, int age) {
 setData(name, address, age);
}

To replace the duplicates −

• Go to Refactor → Find and Replace Code Duplicates.

• Select refactor scope and follow on-screen steps to complete action.

Copy Refactoring

In this section, we will understand how to copy one class to another. Let us copy Employee class to Person class. We can copy it to the existing module or a new one. IntelliJ will do the required changes depending on it. Follow these steps to perform copy refactoring −

• Go to Refactor → Copy, it will open the dialog box.

• Enter new name and destination package.

• Click on the OK button and it will do the needful.

Move Refactoring

Move refactoring is similar to copy but instead of making another copy it moves the code to a different package or make it as inner class of another class.

Follow these steps to perform move refactoring −

• Go to, Refactor → Move.

• A new window will appear.

• Select one of the options according to your choice and click on Refactor.

Safe Delete

The Safe Delete action will delete object only when it is not referenced anywhere in the project. The target for this option can be class, interface, method, field or parameter.

Let us see this in action. Type the following code in Editor −

public class HelloWorld {
   static void sayHello() {
      System.out.println("Hello, World !!!");
   }
   public static void main(String[] args) {
      sayHello();
   }
}

Follow these steps to perform the safe delete action −

• Select the sayHello() method.

• Right-click on it and select the Refactor → Safe Delete option.

• As the sayHello() method is being used it will show an error as in the following screenshot −

Change Signature

The action modifies method signature. It can change the method name, its parameters, types, return values and so on. Let us take a method from the above example and change its signature.

Follow these steps to perform the Change Signature action −

• Select method.

• Right-click on it and select the Refactor → Change signature action

• A new window will appear wherein you can perform the above actions.

• At the bottom of the window, it shows the preview of new signature.

Type Migration

The Type Migration changes the type of the symbol. This symbol can be a method parameter or class attribute. Let us consider the following method before performing the required action −

static void sayHello(String name) {
   System.out.println(name);
}

Follow these steps to perform type migration −

• Select the “String” data type.

• Right-click on it and select Refactor → Type migration.

• Enter the required data type in the given text box.

• Choose scope and click on the Refactor button.

IntelliJ provides multiple ways to create configuration. This chapter discusses the options to create temporary, permanent configuration. It also discusses method to share configuration among other users.

Create Temporary Configuration

Temporary configuration is created when you run or debug Java class or test case. Consider the following steps to understand how this works −

• Create a Java class.
• Right-click on it and select the Run option.
• After the first Run, temporary configuration is added to the run menu.

Create Permanent Configuration

Temporary configuration can be converted to permanent configuration by saving it with IntelliJ. To save configuration, click on the Save Configuration option from the Run menu −

You can also modify the existing configuration by editing it.

Create New Configuration

In this section, we will understand how to create new configuration. Follow these steps to create new configuration −

• Navigate to the Run → Edit Configuration.

• Click on the Plus button to add new configuration.

• Select Application from the dropdown list.

• It will create un-named configuration.

• Configure it according to your requirements and click on the OK button.

• This saved configuration will be accessible from the Run menu along with other configurations.

Sharing the Configuration

Follow these steps to share configuration with others −

• Navigate to the Run → Edit Configuration.

• Select configuration from the left pane and click on the Share checkbox.

• It will store configuration on disk.

If directory based format is used, it will save configuration in separate file under runConfiguration folder. Otherwise, it will store configuration in the .ipr file.

Run Configuration

To run project with specific configuration −

• Select configuration from the Run menu.

• Run the project as shown in the following screenshot −

IntelliJ provides a way to build and package Java package. It supports external build tools like Maven and Gradle. This chapter discusses about these build tools.

Creating Maven Project

Follow these steps to create a Maven project −

• Navigate to File → Project.

• Select Maven option and click on Next button.

• In the new project window enter tutorialspoint.com as GroupId and HelloWorld as ArtifactId.

• In the New window, it will open the pom.xml file.

• We need to add properties to this file; the final pom.xml file should look like this −

<?xml version = "1.0" encoding = "UTF-8"?>
<project xmlns = "http://maven.apache.org/POM/4.0.0"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0  
      http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoing</groupId>
   <artifactId>HelloWorld</artifactId>
   <version>1.0-SNAPSHOT</version>
   <properties>
      <maven.compiler.source>1.7</maven.compiler.source>
      <maven.compiler.target>1.7</maven.compiler.target>
   </properties>
</project>

Now, let us create a Java class inside the src/main/java directory of the Maven project. Follow these steps to create the class −

• Navigate to the src/main/java directory.

• Right click on it and select New → Java Class.

Follow these steps to compile this class using Maven −

• ไปที่ Run → Edit Configuration

• คลิกที่ไอคอนบวกสีเขียวและเลือกตัวเลือก Maven จากเมนูแบบเลื่อนลง

• ป้อนชื่อโปรเจ็กต์เป็น Maven-Package

• จัดเตรียมแพ็คเกจเป็นบรรทัดคำสั่ง

• คลิกที่ปุ่ม OK

• ไปที่ Run และเลือกไฟล์ Maven-Package ตัวเลือก

• มันจะเริ่มสร้างแพ็คเกจ เมื่อสร้างแพ็คเกจสำเร็จคุณจะเห็นผลลัพธ์ต่อไปนี้ -

สร้างโครงการ Gradle

ในส่วนนี้เราจะเรียนรู้วิธีสร้างโครงการ Gradle -

• นำทางไปยัง File → Project และเลือก Gradle

• คลิกที่ปุ่มถัดไป

• ในหน้าต่างโปรเจ็กต์ใหม่ให้ป้อน tutorialspoint เป็น GroupId และ HelloWorld เป็น ArtifactId

• คลิกที่ปุ่มถัดไปตรวจสอบรายละเอียดโครงการและคลิกที่ปุ่มเสร็จสิ้น

• ทำตามคำแนะนำบนหน้าจอเพื่อทำกระบวนการให้เสร็จสิ้น

• เปิด buildl.gradle ไฟล์และเขียนงาน Hello ดังที่แสดงในภาพหน้าจอด้านบน

• ในการคอมไพล์งานนี้ให้ไปที่ไฟล์ Run → Build-Gradle ตัวเลือก

การทดสอบหน่วยมีบทบาทสำคัญในการพัฒนาซอฟต์แวร์ IntelliJ รองรับกรอบการทดสอบหน่วยต่างๆเช่น JUnit, TestNG, Spock และอื่น ๆ อีกมากมาย ในบทนี้เราจะใช้ JUnit3

สร้างแบบทดสอบหน่วย

ในส่วนนี้เราจะเรียนรู้วิธีสร้างแบบทดสอบหน่วย ทำตามขั้นตอนเหล่านี้เพื่อสร้างการทดสอบ -

• เลือกไฟล์ Navigate → Test ตัวเลือก

• กล่องโต้ตอบจะปรากฏขึ้นซึ่งคุณต้องเลือก Create New Test.

• ทำตามคำแนะนำบนหน้าจอเพื่อดำเนินการต่อ -

• ให้รายละเอียดเกี่ยวกับการทดสอบเช่นไลบรารีการทดสอบรายละเอียดคลาส setUp วิธีการฉีกขาดและอื่น ๆ

• คลิกที่ปุ่ม OK เพื่อดำเนินการต่อ

• จะมีการสร้างคลาสทดสอบ ในขั้นต้นอาจล้มเหลวในการแก้ไขสัญลักษณ์บางอย่าง นำทางเคอร์เซอร์ไปที่บรรทัดข้อผิดพลาดมันจะแสดงสัญลักษณ์คำใบ้

• เลือกตัวเลือกที่เหมาะสมจากเมนูแบบเลื่อนลง เราได้เลือกไฟล์Add library ‘junit.jar!’ to classpath ตัวเลือก -

คุณสามารถเพิ่มตรรกะในการทดสอบแต่ละครั้งตามความต้องการทางธุรกิจของคุณ ฉันเก็บมันไว้ว่างเปล่าเพื่อความเรียบง่าย

เรียกใช้การทดสอบหน่วย

ทำตามขั้นตอนเหล่านี้เพื่อเรียกใช้การทดสอบหน่วย -

• เลือกคลาสทดสอบหน่วยจากหน้าต่างตัวแก้ไข

• ไปที่เมนู Run และเลือกตัวเลือก Run

• ผลลัพธ์ต่อไปนี้จะถูกสร้างขึ้น

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

จุดพัก

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

จุดพักแสดงโดยใช้สัญลักษณ์วงกลมสีแดง พิจารณาจุดพักที่กำหนดไว้ที่บรรทัดที่ 3

พิจารณาขั้นตอนต่อไปนี้เพื่อทำความเข้าใจเพิ่มเติมเกี่ยวกับวิธีการทำงานของเบรกพอยต์ -

• คลิกขวาที่สัญลักษณ์วงกลมสีแดง

• เลือกไฟล์ More ตัวเลือก.

• หากต้องการลบเบรกพอยต์เพียงคลิกที่สัญลักษณ์เดียวกัน

ทำตามขั้นตอนเหล่านี้เพื่อเริ่มการดีบักเกอร์ -

• ไปที่เมนู Run
• เลือกตัวเลือก Debug

ก้าวเข้าสู่

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

ตัวอย่างเช่นเมื่อการทำงานของโปรแกรมมาถึงบรรทัดที่ 9 และหากเราเลือกขั้นตอนในการดำเนินการก็จะหยุดการดำเนินการในแต่ละบรรทัดใน sayGoodBye() ฟังก์ชัน

ก้าวออกมา

การดำเนินการ Step out เป็นการย้อนกลับของ Step in action ตัวอย่างเช่นหากคุณดำเนินการขั้นตอนออกจากสถานการณ์ข้างต้นดีบักเกอร์จะกลับมาจากไฟล์sayGoodBye() วิธีการและเริ่มดำเนินการที่บรรทัดที่ 10

ก้าวข้าม

Step over action จะไม่เข้าสู่ฟังก์ชันแทน แต่จะข้ามไปที่โค้ดบรรทัดถัดไป ตัวอย่างเช่นหากคุณอยู่ที่บรรทัดที่ 9 และดำเนินการตามขั้นตอนมากกว่าการกระทำมันจะย้ายการดำเนินการไปยังบรรทัดที่ 10

โปรแกรมดำเนินการต่อ

การดำเนินการ Resume Program จะดำเนินการโปรแกรมต่อไปโดยละเว้นจุดพักทั้งหมด

หยุดการกระทำ

การดำเนินการ Stop ช่วยหยุดการดีบักเกอร์

ก้าวเข้าสู่

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

ตอนนี้ให้เราสร้างคลาส Java ด้วยโค้ดบรรทัดต่อไปนี้ -

public class HelloWorld {
   public static void main(String[] args) {
      allFunctions();
   }
   static void allFunctions() {
      System.out.println(function1() + " " + function2() + " " + function3());
   }
   static String function1() {
      return "function1";
   }
   static String function2() {
      return "function2";
   }
   static String function3() {
      return "function3";
   }
}

ในโค้ดด้านบน allFunctions()เรียกอีก 3 ฟังก์ชั่น ให้เรากำหนดจุดพักที่ฟังก์ชันนี้ ทำตามขั้นตอนเหล่านี้เพื่อดำเนินการอย่างชาญฉลาดใน -

• ไปวิ่ง
• เลือกขั้นตอนที่ชาญฉลาดเป็น
• เลือกฟังก์ชันลูกที่จะไป

การตรวจสอบตัวแปร

ในระหว่างการดีบัก IntelliJ จะแสดงค่าของตัวแปรในหน้าต่างตัวแก้ไขเอง นอกจากนี้เรายังสามารถดูข้อมูลเดียวกันได้ในหน้าต่าง Debug

ประเมินการแสดงออก

ประเมินการแสดงออกทำให้สามารถประเมินการแสดงออกได้ทันที ทำตามขั้นตอนเหล่านี้เพื่อดำเนินการนี้ -

• เริ่มแอปพลิเคชันในดีบักเกอร์

• นำทางไปยัง Run->Evaluate นิพจน์.

• ใส่นิพจน์ ในตัวอย่างด้านล่างค่าปัจจุบันของตัวแปร 'i' คือ 0; ดังนั้นนิพจน์ 'i> 100' จะประเมินเป็นเท็จ

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

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

บทนำ

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

สิทธิประโยชน์

• อินเทอร์เฟซภาพสำหรับแอปพลิเคชัน Java ภายในและระยะไกลที่รันบน JVM

• การตรวจสอบการใช้หน่วยความจำของแอปพลิเคชันและพฤติกรรมรันไทม์ของแอปพลิเคชัน

• การตรวจสอบเธรดแอปพลิเคชัน

• การวิเคราะห์การจัดสรรหน่วยความจำไปยังแอปพลิเคชันต่างๆ

• ถังขยะ - มีประโยชน์มากในกรณีที่มีการหยุดชะงักและสภาพการแข่งขัน

• กองทิ้ง - มีประโยชน์มากในการวิเคราะห์การจัดสรรหน่วยความจำฮีป

การกำหนดค่า

ในส่วนนี้เราจะเรียนรู้ขั้นตอนในการกำหนดค่า VisualVM ขั้นตอนมีดังนี้ -

• ดาวน์โหลดได้จากที่นี่

• แตกไฟล์ zip

• ไปที่ไฟล์ etc / visualvm.conf และเพิ่มบรรทัดต่อไปนี้ในไฟล์นี้ -

visualvm_jdkhome=<path of JDK>

• หาก JDK ของคุณติดตั้งในไฟล์ C:\Program Files\Java\jdk-9.0.1 ไดเรกทอรีควรมีลักษณะดังนี้ -

visualvm_jdkhome="C:\Program Files\Java\jdk-9.0.1"

การตรวจสอบแอปพลิเคชัน

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

• ดับเบิลคลิกที่ไฟล์ visualvm.exe
• เลือกแอปพลิเคชันจากบานหน้าต่างด้านซ้าย
• เลือกแท็บจอภาพ

คุณจะถูกนำไปที่หน้าต่างที่คุณจะได้รับรายละเอียดเกี่ยวกับ CPU, Heap, Classes และ threads หากต้องการเจาะจงกับการใช้งานให้วางเมาส์เหนือกราฟใด ๆ เราสามารถดูการใช้งาน Heap ได้ในภาพหน้าจอด้านบน

ข้อมูลเชิงลึกเกี่ยวกับเธรด

แอ็พพลิเคชัน Java สามารถมีเธรดการเรียกใช้งานได้หลายเธรด หากต้องการทราบข้อมูลเพิ่มเติมเกี่ยวกับเธรดให้เลือกแท็บเธรดของแอปพลิเคชันเฉพาะ มันจะให้สถิติต่างๆเกี่ยวกับเธรดเช่นจำนวนเธรดสดและเธรดดีมอน สถานะของเธรดที่แตกต่างกันคือ Running, Sleeping, Waiting, Park และ Monitor

แอปพลิเคชันการสุ่มตัวอย่าง

VisualVM รองรับ CPU การสุ่มตัวอย่างหน่วยความจำและการตรวจจับการรั่วไหลของหน่วยความจำ ในการใช้ตัวอย่างเลือกแอปพลิเคชันและเลือกแท็บตัวอย่าง -

การสุ่มตัวอย่าง CPU

สำหรับการสุ่มตัวอย่าง CPU ให้คลิกที่ปุ่ม CPU ตามที่แสดงในภาพหน้าจอต่อไปนี้ -

โปรไฟล์หน่วยความจำ

สำหรับการสร้างโปรไฟล์หน่วยความจำคลิกที่ปุ่มหน่วยความจำดังที่แสดงในภาพหน้าจอต่อไปนี้ -

หน่วยความจำรั่ว

การรั่วไหลของหน่วยความจำเกิดขึ้นเมื่อแอปพลิเคชันกำลังทำงานค่อยๆเติมฮีปด้วยอ็อบเจ็กต์ที่โปรแกรมไม่ได้ลบโดยอัตโนมัติ

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

แอปพลิเคชันโปรไฟล์

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

โปรไฟล์ CPU

ในการทำโปรไฟล์ CPU ให้คลิกที่ปุ่ม CPU ตามที่แสดงในภาพหน้าจอด้านล่าง -

โปรไฟล์หน่วยความจำ

ในการทำโปรไฟล์ CPU ให้คลิกที่ปุ่ม CPU ตามที่แสดงในภาพหน้าจอด้านล่าง -

IntelliJ รองรับระบบควบคุมเวอร์ชันต่างๆเช่น Git, Subversion, Mercurial, CVS, GitHub และ TFS คุณสามารถดำเนินการที่เกี่ยวข้องกับการควบคุมเวอร์ชันได้จาก IDE เอง

ในบทนี้เราจะพูดถึง Git และ Subversion (ต่อไปนี้จะเรียกว่า SVN) เราถือว่าผู้อ่านคุ้นเคยกับเครื่องมือ Git และ SVN และคำศัพท์ของมัน

Git

ในส่วนนี้เราจะเรียนรู้วิธีการทำงานกับ Git

โคลน

ในการโคลนที่เก็บ Git ที่มีอยู่ -

• ไปที่ File-> New-> Project จาก Version Control-> Git

• ป้อน URL ที่เก็บไดเร็กทอรีหลักและชื่อไดเร็กทอรี

• คลิกที่ปุ่มโคลนเพื่อดำเนินการต่อ

• เมื่อดำเนินการตามขั้นตอนข้างต้นสำเร็จที่เก็บจะถูกโคลน

ติดตามการเปลี่ยนแปลง

Git จะติดตามการเปลี่ยนแปลงที่คุณทำในที่เก็บ ให้เราแก้ไขไฟล์ใด ๆ จากที่เก็บและเปรียบเทียบกับที่เก็บ

• ไปที่ VCS → Git →เปรียบเทียบกับเวอร์ชันที่เก็บล่าสุด

• ขั้นตอนข้างต้นจะเปิดหน้าต่าง diff

• คุณจะเห็นว่ามีบรรทัดใหม่ทางด้านขวาพร้อมสีพื้นหลังสีเขียว

• Git แสดงเป็นสีเขียวเมื่อเราได้เพิ่มเนื้อหาใหม่ หากเราลบเนื้อหาใด ๆ ออกจะแสดงเป็นสีแดง

เปลี่ยนกลับการเปลี่ยนแปลงในเครื่อง

ทำตามขั้นตอนเหล่านี้เพื่อยกเลิกการเปลี่ยนแปลงภายในเครื่อง -

• ไปที่ไฟล์ VCS → Git → Revert ตัวเลือก

• ระบบจะขอการยืนยันและลบการเปลี่ยนแปลงของคุณ

เพิ่มไฟล์ลงในที่เก็บ

ในการเพิ่มไฟล์ลงในที่เก็บไปที่ VCS → Git → Add option. การดำเนินการนี้คล้ายกับไฟล์git add หนังบู๊.

ยอมรับการเปลี่ยนแปลง

การดำเนินการ Commit จะสร้างการคอมมิตในเครื่อง มันคล้ายกับไฟล์git commitหนังบู๊. เพื่อดำเนินการกระทำ -

• ไปที่ไฟล์ VCS → Git → Commit File ตัวเลือก

• เลือกไฟล์ที่จะคอมมิต

• ป้อนข้อความกระทำและคลิกที่ปุ่ม Commit

พุชการเปลี่ยนแปลงไปยังที่เก็บระยะไกล

การดำเนินการพุชจะส่งการเปลี่ยนแปลงในเครื่องไปยังที่เก็บระยะไกล เพื่อผลักดันการเปลี่ยนแปลง -

• ไปที่ไฟล์ VCS → Git → Push ตัวเลือก

• หน้าต่างจะปรากฏขึ้น ที่นี่คุณสามารถเห็น comitts ที่จะผลักดัน

• ยืนยันการกระทำและคลิกที่ปุ่ม Push เพื่อเผยแพร่การเปลี่ยนแปลงของคุณ

ดูประวัติหรือบันทึก

หากต้องการแสดงประวัติให้ไปที่ไฟล์ VCS → Git → Show history option. การดำเนินการนี้คล้ายกับไฟล์git logคำสั่ง จะแสดงประวัติดังนี้ -

รับข้อมูลอัปเดต

ทำตามขั้นตอนเหล่านี้เพื่อดึงข้อมูลอัพเดตจากที่เก็บ -

• ไปที่ไฟล์ VCS → Git → Pull ตัวเลือก

• เลือกตัวเลือกตามความต้องการของคุณ

• คลิกที่ปุ่มดึง

เพิ่มโครงการที่มีอยู่ใน Git

ในการเพิ่มโครงการที่มีอยู่ภายใต้ Git -

• นำทางไปยัง VCS → Import into Version Control → Create Git ที่เก็บ

• เลือกโครงการโดยการเรียกดูไดเรกทอรี

• คลิกที่ปุ่ม OK

การโค่นล้ม

ในส่วนนี้เราจะเข้าใจว่า Subversion ทำงานอย่างไรใน IntelliJ ให้เราพิจารณาการกระทำที่สำคัญสองสามประการเพื่อทำความเข้าใจสิ่งนี้

เช็คเอาท์

ในการชำระเงินที่เก็บ SVN -

• นำทางไปยัง File → New → Project from Version Control → Subversion.

• ป้อน URL ที่เก็บ

• คลิกที่ OK ปุ่ม.

ติดตามการเปลี่ยนแปลง

SVN จะติดตามการเปลี่ยนแปลงที่คุณทำในที่เก็บ ให้เราแก้ไขไฟล์ใด ๆ จากที่เก็บและเปรียบเทียบกับที่เก็บ -

• ไปที่ VCS-> Subversion-> เปรียบเทียบกับเวอร์ชันที่เก็บล่าสุด

• คุณจะเห็นว่ามีบรรทัดใหม่ทางด้านขวาพร้อมสีพื้นหลังสีเขียว

• SVN แสดงด้วยพื้นหลังสีเขียวเพื่อระบุการเพิ่มเนื้อหาใหม่ หากเราลบเนื้อหาใด ๆ เนื้อหานั้นจะแสดงเป็นสีแดง

เปลี่ยนกลับการเปลี่ยนแปลงในเครื่อง

ทำตามขั้นตอนเหล่านี้เพื่อเปลี่ยนกลับการเปลี่ยนแปลงในเครื่องที่คุณทำ -

• ไปที่ไฟล์ VCS → Subversion → Revert ตัวเลือก

• ระบบจะขอการยืนยันและลบการเปลี่ยนแปลงของคุณ

ยอมรับการเปลี่ยนแปลงที่เก็บระยะไกล

ทำตามขั้นตอนเหล่านี้เพื่อยอมรับการเปลี่ยนแปลงในที่เก็บระยะไกล -

• นำทางไปยัง VCS → Subversion → Commit Files ตัวเลือก

• หน้าต่างใหม่จะปรากฏขึ้น ที่นี่คุณสามารถดูไฟล์ที่จะเชื่อมต่อกับที่เก็บข้อมูลระยะไกล

• ตรวจสอบไฟล์และคลิกที่ปุ่ม Commit เพื่อเผยแพร่การเปลี่ยนแปลงของคุณ

ดูประวัติหรือบันทึก

หากต้องการแสดงประวัติให้ไปที่ไฟล์ VCS → Subverion → Show historyตัวเลือก ตัวเลือกนี้คล้ายกับไฟล์svn logคำสั่ง จะแสดงประวัติดังนี้ -

อัปเดตการดำเนินการ

ในการดึงข้อมูลการเปลี่ยนแปลงล่าสุดไปที่ VCS → Subversion → Update File/Update Folder ตัวเลือก

เพิ่มโครงการที่มีอยู่ในการโค่นล้ม

ทำตามขั้นตอนเหล่านี้เพื่อเพิ่มโครงการที่มีอยู่ภายใต้ SVN -

• นำทางไปยัง VCS → Import into Version Control → Import into Subverion.

• ป้อน URL ที่เก็บและคลิกที่ปุ่มนำเข้า -

IntelliJ มีเครื่องมือฐานข้อมูลที่ช่วยให้คุณสามารถดำเนินการที่เกี่ยวข้องกับฐานข้อมูลจาก IDE เอง รองรับฐานข้อมูลหลักทั้งหมดเช่น MySQL, Oracle, Postgress, SQL server และอื่น ๆ อีกมากมาย ในบทนี้เราจะพูดถึงวิธีที่ IntelliJ รองรับฐานข้อมูล MySQL

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

สร้างฐานข้อมูล

เริ่มต้นด้วยเราจะสร้างฐานข้อมูล - test_db. ดำเนินการคำสั่งต่อไปนี้ในพรอมต์คำสั่ง -

เชื่อมต่อกับฐานข้อมูล

ทำตามขั้นตอนเหล่านี้เพื่อเชื่อมต่อกับฐานข้อมูล -

• นำทางไปยัง View → Tool Windows → Database.

• คลิกที่ไอคอนบวกสีเขียวและเลือกแหล่งข้อมูล→ MySQL

• ป้อนที่อยู่โฮสต์และคลิกที่ปุ่มทดสอบการเชื่อมต่อ

• หากทุกอย่างเป็นไปด้วยดีก็จะแสดงว่าประสบความสำเร็จดังที่แสดงในภาพด้านบน

• คลิกที่ปุ่ม OK เพื่อบันทึกการเชื่อมต่อ

สร้างตาราง

ทำตามขั้นตอนเหล่านี้เพื่อสร้างตารางใหม่ -

• คลิกขวาที่บานหน้าต่างฐานข้อมูลและเลือกสคีมา

• เลือกไฟล์ New → Table ตัวเลือก

• หน้าต่างใหม่จะปรากฏขึ้น กำหนดตารางด้วยคอลัมน์ประเภทและอื่น ๆ

• คลิกที่ปุ่มดำเนินการ

• คลิกที่ปุ่มดำเนินการ

แทรกข้อมูล

ทำตามขั้นตอนเหล่านี้เพื่อแทรกข้อมูล -

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

ดึงข้อมูล

ในการดึงข้อมูลให้ดับเบิลคลิกที่ student_table จากบานหน้าต่างฐานข้อมูล มันจะแสดงข้อมูลตารางในหน้าต่างใหม่

เพื่อให้แน่ใจว่าข้อมูลถูกแทรกลงในตารางให้เปิดพรอมต์คำสั่งและดำเนินการคำสั่งต่อไปนี้ -

NetBeans เป็น Java IDE ยอดนิยมอีกตัว หากคุณเป็นผู้ใช้ NetBeans ในปัจจุบันและต้องการย้ายจากไปยัง IntelliJ นี่จะเป็นจุดเริ่มต้นที่ดี

บทนี้กล่าวถึงการนำเข้าโครงการ NetBeans ใน IntelliJ คำศัพท์ที่เทียบเท่ากับ NetBeans ทางลัดยอดนิยมและคำถามที่พบบ่อย

นำเข้าโครงการ NetBeans

ในส่วนนี้เราจะเรียนรู้วิธีการนำเข้าโครงการ NetBeans ทำตามขั้นตอนเหล่านี้เพื่อนำเข้าโครงการ -

• ไปที่ไฟล์→ใหม่→โปรเจ็กต์จากแหล่งที่มาที่มีอยู่

• เลือกไดเรกทอรีโครงการ NetBeans ของคุณ

• เมื่อวิซาร์ดนำเข้าโครงการเปิดขึ้นให้เลือกตัวเลือกสร้างโครงการจากแหล่งที่มาที่มีอยู่

• ทำตามคำแนะนำบนหน้าจอเพื่อดำเนินการต่อ

คำศัพท์ IntelliJ vsNetBeans

ตารางต่อไปนี้เปรียบเทียบคำศัพท์ของ IntelliJ และ NetBeans -

IntelliJ	NetBeans
โมดูล	โครงการ
ห้องสมุดส่วนกลาง	ห้องสมุดส่วนกลาง
ไลบรารีโมดูล	ไลบรารีโครงการ
การพึ่งพาโมดูล	การพึ่งพาโครงการ
SDK โมดูล	SDK เฉพาะโครงการ

ทางลัดยอดนิยม

IntelliJ เป็น IDE ที่เน้นแป้นพิมพ์ มีทางลัดสำหรับการดำเนินการส่วนใหญ่ ตารางต่อไปนี้แสดงรายการทางลัดที่สำคัญบางประการ -

หนังบู๊	ทางลัด
รันโปรแกรม Java	ctrl + shift + F10
จัดระเบียบการนำเข้า	ctrl + alt + o
System.out.println ()	พิมพ์ sout แล้วกด ctrl + j
ลบบรรทัดปัจจุบัน	ctrl + y
ค้นหา	ctrl + shift + f
สร้าง getter และ setter	alt + แทรก
รหัสรูปแบบ	ctrl + alt + l
แสดงความคิดเห็นรหัส	ctrl + /
ไปที่บรรทัด	ctrl + g
ไปที่การประกาศ	ctrl + b
เปลี่ยนชื่อ	กะ + F6
ย้ายเส้น	ctrl + shift + ขึ้น / ลง

ทางลัดดีบักเกอร์

ตารางต่อไปนี้แสดงรายการช็อตคัทดีบั๊กที่สำคัญบางอย่าง -

การแก้ไขข้อบกพร่อง	ทางลัด
ดีบักโปรแกรม	Shift + F9
เลือกการกำหนดค่าและแก้ไขข้อบกพร่อง	Shift + Alt + F9
ก้าวข้าม	F8
ก้าวเข้าสู่	F7
ก้าวเข้าสู่	Shift + F7
ก้าวออกมา	Shift + F8
บังคับให้ก้าวข้าม	Shift + Alt + F8
บังคับให้ก้าวเข้าสู่	Shift + Alt + F7
โปรแกรมดำเนินการต่อ	F9
ประเมินการแสดงออก	Alt + F8
สลับจุดพัก	Ctrl + F8
ดูจุดพัก	Ctrl + Shift + F8

คำถามที่พบบ่อยและคำแนะนำ

ในส่วนนี้เราจะพูดถึงคำถามและคำแนะนำที่มีการตอบบ่อย คำถามที่พบบ่อยและเคล็ดลับมีดังนี้ -

ฉันสามารถใช้การผูกคีย์ NetBeans ใน IntelliJ IDEA ได้หรือไม่

• ไปที่ไฟล์→การตั้งค่าและเลือกคีย์แมป

• เลือก NetBeans จากกล่องดรอปดาวน์

ประวัติศาสตร์ท้องถิ่นใน IntelliJ IDEA แตกต่างจากใน NetBeans หรือไม่

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

ฉันสามารถเปิดใช้งาน 'compile on save' ใน IntelliJ IDEA ได้หรือไม่?

• ไปที่ File → Settings → Build, Execution, Deployment → Compiler
• เลือกตัวเลือกสร้างโครงการโดยอัตโนมัติ
• คลิกที่ปุ่ม OK

ฉันสามารถใช้ปลั๊กอิน NetBeans ใน IntelliJ IDEA ได้หรือไม่

ไม่คุณไม่สามารถ.

เป็นไปได้หรือไม่ที่จะสร้างแอปพลิเคชัน NetBeans RCP ด้วย IntelliJ IDEA

มันเป็นไปได้; อย่างไรก็ตามคุณจะไม่ได้รับการสนับสนุนแบบเดียวกับที่คุณได้รับจาก NetBeans (วิซาร์ดการทำงานของเมนู ฯลฯ ) ดูรายละเอียดเพิ่มเติมได้ที่นี่

Eclipse เป็น Java IDE ยอดนิยมอีกตัวหนึ่ง หากคุณเป็นผู้ใช้ปัจจุบันของ Eclipse และต้องการย้ายจากมันไปยัง IntelliJ นี่เป็นจุดเริ่มต้นที่ดี

บทนี้กล่าวถึงวิธีการนำเข้าโปรเจ็กต์ Eclipse ใน IntelliJ คำศัพท์ที่เทียบเท่ากับ Eclipse ทางลัดยอดนิยมและคำถามที่พบบ่อย

นำเข้าโครงการที่มีอยู่

ในส่วนนี้เราจะพูดถึงวิธีการนำเข้าโครงการที่มีอยู่ ทำตามขั้นตอนเหล่านี้เพื่อนำเข้าโครงการ -

• ไปที่ไฟล์→ใหม่→โปรเจ็กต์จากแหล่งที่มาที่มีอยู่

• เลือกไดเรกทอรีโครงการ NetBeans ของคุณ

• เมื่อวิซาร์ดนำเข้าโครงการเปิดขึ้นให้เลือกตัวเลือกสร้างโครงการจากแหล่งที่มาที่มีอยู่

• ทำตามคำแนะนำบนหน้าจอเพื่อดำเนินการต่อ

คำศัพท์ IntelliJ vsEclipse

ตารางต่อไปนี้เปรียบเทียบคำศัพท์ของ IntelliJ และ NetBeans -

IntelliJ	คราส
โครงการ	พื้นที่ทำงาน
โมดูล	โครงการ
แง่มุม	แง่มุม
ห้องสมุด	ห้องสมุด
SDK	JRE
ตัวแปรเส้นทาง	ตัวแปร Classpath

ทางลัดยอดนิยม

IntelliJ เป็น IDE ที่เน้นแป้นพิมพ์ มีทางลัดสำหรับการดำเนินการส่วนใหญ่ ตารางต่อไปนี้แสดงรายการทางลัดยอดนิยมบางส่วน -

หนังบู๊	ทางลัด
เรียกใช้โปรแกรม java	ctrl + shift + F10
จัดระเบียบการนำเข้า	ctrl + alt + o
System.out.println ()	พิมพ์ sout และกด ctrj + j
ลบบรรทัดปัจจุบัน	ctrl + y
ค้นหา	ctrl + shift + f
สร้าง getter และ setter	alt + แทรก
รหัสรูปแบบ	ctrl + alt + l
แสดงความคิดเห็นรหัส	ctrl + /
ไปที่บรรทัด	ctrl + g
ไปที่การประกาศ	ctrl + b
เปลี่ยนชื่อ	กะ + F6
ย้ายเส้น	ctrl + shift + ขึ้น / ลง

ทางลัดดีบักเกอร์

ตารางต่อไปนี้แสดงรายการทางลัดดีบักเกอร์ที่ใช้กันทั่วไป -

การแก้ไขข้อบกพร่อง	ทางลัด
ดีบักโปรแกรม	Shift + F9
เลือกการกำหนดค่าและแก้ไขข้อบกพร่อง	Shift + Alt + F9
ก้าวข้าม	F8
ก้าวเข้าสู่	F7
ก้าวเข้าสู่	Shift + F7
ก้าวออกมา	Shift + F8
บังคับให้ก้าวข้าม	Shift + Alt + F8
บังคับให้ก้าวเข้าสู่	Shift + Alt + F7
โปรแกรมดำเนินการต่อ	F9
ประเมินการแสดงออก	Alt + F8
สลับจุดพัก	Ctrl + F8
ดูจุดพัก	Ctrl + Shift + F8

คำถามที่พบบ่อยและคำแนะนำ

ในส่วนนี้เราจะเห็นคำถามและเคล็ดลับที่ตอบบ่อย คำถามที่พบบ่อยและเคล็ดลับมีดังนี้ -

ใช้ Eclipse Compiler

ในขณะที่ Eclipse ใช้คอมไพเลอร์ของตัวเอง IntelliJ IDEA ใช้คอมไพเลอร์ javac ที่มาพร้อมกับโปรเจ็กต์ JDK หากคุณต้องการใช้คอมไพเลอร์ Eclipse -

• นำทางไปยัง File → Settings → Build, Execution, Deployment → Compiler → Java Compiler.

• เลือกคอมไพเลอร์ที่ต้องการจากดรอปดาวน์คอมไพเลอร์ผู้ใช้

คีย์แมป Eclipse

สำหรับผู้ใช้ Eclipse ที่ไม่ต้องการเรียนรู้ทางลัดใหม่ IntelliJ IDEA จัดเตรียมคีย์แมป Eclipse ที่เลียนแบบทางลัดอย่างใกล้ชิด -

• ไปที่ไฟล์→การตั้งค่า→ตัวเลือกคีย์แมป
• เลือก Eclipse จากเมนูแบบเลื่อนลงของ Keymap

การจัดรูปแบบรหัส

ในการนำเข้าการตั้งค่าฟอร์แมตเตอร์ Eclipse ของคุณ -

• นำทางไปยัง File → Settings → Editor → Code Style → Java.

• เลือกไฟล์ Eclipse XML ข้อมูลส่วนตัว.

การทำงานกับเครื่องมือสร้าง

เช่นเดียวกับ Eclipse IntelliJ ไม่มีรูปแบบภาพสำหรับการแก้ไขไฟล์คอนฟิกูเรชัน Maven / Gradle

เมื่อคุณนำเข้า / สร้างโครงการ Maven / Gradle ของคุณแล้วคุณมีอิสระที่จะแก้ไขไฟล์ pom.xml / build.gradle โดยตรงในโปรแกรมแก้ไขข้อความ