สามารถอ่านรหัสได้ แต่ต้องดิ้นรนอย่างมากที่จะเขียนมัน [ปิด]

ฉันมีการสอบการเขียนโปรแกรมครั้งแรกของฉันเมื่อเร็ว ๆ นี้ ... และฉันก็ทำได้ดีมาก ไม่ได้ยอดเยี่ยมเลย ฉันมีโทษตัวเองนอกเวลาเรียนเท่านั้นฉันไม่ได้ทำอะไรเลย

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

ฉันอ่านหนังสือได้พอสมควรแล้ว (ทำประมาณ 5-6 ชั่วโมงสำหรับเดือนที่ผ่านมา) ในแต่ละวัน ... แต่เมื่อเปิด IDE ของฉันฉันมักจะรู้สึกว่ามันถึงเวลาแล้วที่จะลดระดับลง โดยเฉพาะอย่างยิ่งเพราะฉันมีความรู้เกี่ยวกับโหนด, รายการ, arraylist, อินเตอร์เฟสและอื่น ๆ แต่นอกเหนือจากการอ่านบนหน้าเว็บที่เกี่ยวกับมัน ฉันสามารถชี้ให้เห็นทุกอย่างที่เกิดขึ้นในโปรแกรมเพื่อให้คำอธิบายประกอบโค้ดตัวอย่างฉันคิดว่าดี แต่การเขียนโค้ดของตัวเองเป็นอีกเรื่องหนึ่ง ..

คุณเรียนรู้วิธีการเขียนโปรแกรมโดยการเขียนโปรแกรม

แต่คุณต้องเริ่มต้นเล็ก ๆ

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

จากนั้นเริ่มสร้าง ...

public class HelloWorld {
    static String test = "This is a test";

    public static void main(String[] args) {
        System.out.println(test);
    }
}

แล้ว ...

public class HelloClass {
    String test;

    public void setTest(String str)
    {
        test = str;
    }  

    public String getTest()
    {
        return test;
    }
}

public class HelloWorld {
    HelloClass myHelloInstance;

    public static void main(String[] args) {
        myHelloInstance = new HelloClass();
        myHelloInstance.SetTest("Hello World.")
        String myResult = myHelloInstance.getTest();
        System.out.println(myResult);
    }
}  

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

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

คุณกำลังเรียนรู้เกี่ยวกับ ...

1. เครื่องมือที่คุณใช้ในการเขียนรหัส สภาพแวดล้อมการพัฒนาของคุณผู้แก้ไขผู้ดีบักคอมไพเลอร์ของคุณ มีคู่มือและไฟล์ช่วยเหลือสำหรับเครื่องมือเหล่านี้ตรวจสอบพวกเขา ยิ่งคุณรู้จักเครื่องมือมากเท่าไหร่ก็ยิ่งสร้างรหัสได้ง่ายขึ้นเท่านั้น
2. ไวยากรณ์ของภาษาการเขียนโปรแกรมภายใต้การศึกษาจากโพสต์ของคุณดูเหมือนว่าคุณจะมุ่งเน้นที่นี่และคุณต้อง
3. ทักษะการออกแบบวิธีการแก้ปัญหา วิธีการรวมโค้ดที่มีประโยชน์และบำรุงรักษาได้ นี่คือกล้ามเนื้อที่คุณต้องสร้างขึ้น เช่นเดียวกับโปสเตอร์อื่น ๆ ที่ชี้ให้เห็นคุณเรียนรู้ด้วยการทำ

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

ฉันขอแนะนำให้คุณทำสิ่งที่ท้าทาย ดูที่ต่อไปนี้เป็นการออกกำลังกาย

http://en.wikipedia.org/wiki/Eight_queens_puzzle

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

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

นี่คือกลยุทธ์ในการลอง ...

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

2. เมื่อคุณแทงที่ขั้นตอนที่ 1 แล้วให้วางสองควีนไว้บนนั้นเพื่อให้ปลอดภัย

3. ในที่สุดให้ไปวางมากกว่า 2 ควีนบนกระดานเพื่อให้พวกเขาปลอดภัย

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

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

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

อาจเป็นแหล่งที่มากับคุณ

คำนำด่วน

เรียนรู้โดยการทำ: ความรู้และความรู้

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

และวิธีเดียวที่จะเข้าถึงส่วนที่สองคือฝึกฝน นั่งลงเปิดตัวแก้ไขข้อความบรรทัดคำสั่งและลงไปที่มัน

การเขียนโปรแกรมขนาดเล็ก

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

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

หนังสือ

ในขณะที่คุณตั้งค่าบน Java และถ้าคุณต้องการหนังสือ Java ที่เหมาะสมฉันแนะนำ:

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

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

กระบวนการเรียนของคุณ

เวิร์กโฟลว์พื้นฐาน

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

1. อ่านและศึกษา
   1. อ่านแบบฝึกหัด
   2. ทำให้แน่ใจว่าคุณเข้าใจพวกเขา
2. รหัส
   1. ปิดหนังสือ
   2. นั่งหน้าคอมพิวเตอร์ด้วยโปรแกรมแก้ไขรหัสและบรรทัดคำสั่ง
   3. พยายามเขียนโปรแกรมด้วยตัวเอง

ในกรณีที่ล้มเหลว

หากคุณล้มเหลวและรู้สึกว่าคุณจำเป็นต้องอ่านหนังสือความล้มเหลวของคุณน่าจะเป็น:

• (เป็นไปได้มากที่สุด) ที่คุณไม่เข้าใจวิธีแก้ปัญหา
• (มีโอกาสน้อยกว่า) ที่คุณลืมว่าโซลูชันมีลักษณะเป็นอย่างไร: ไวยากรณ์, การใช้ API, ...

สาเหตุแรกน่าจะเป็นสิ่งที่คุณเผชิญบ่อยที่สุด อันที่สองคือประวัติย่อ ทั้งสองได้รับการแก้ไขด้วยการฝึกซ้ำ

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

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

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

ในกรณีที่ประสบความสำเร็จ: ก้าวต่อไป!

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

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

มันเป็นแค่การเรียนรู้ - การเปรียบเทียบ

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

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

โปรดทราบว่านี่เป็นปัญหาที่พบได้บ่อยในวิชาคณิตศาสตร์ แต่ในความคิดของฉันคุณจะเห็นมันในหลาย ๆ สาขาที่มีตรรกะที่จำเป็นต้องใช้: การเรียนรู้ไวยากรณ์ภาษาไวยากรณ์ฟิสิกส์ ฯลฯ ... และมันไม่ได้ลงไปถึงความสามารถ "ธรรมชาติ" เพื่อทำความเข้าใจกับสิ่งเหล่านี้: มันลงมาสู่การฝึกฝน (ไม่ว่าจะเป็นในพื้นที่นั้นหรือในที่อื่น ๆ ที่ทำให้แต่ละคนเข้าใจแนวคิดในสาขานี้ได้ง่ายขึ้น)

ไม่มีเหตุผลที่คุณเรียนรู้ที่จะเขียนโค้ดไม่ได้ คุณแค่พยายามต่อไปจนกว่าจะถึง "อาอา!" / เดี๋ยวยูเรก้า จากนั้นไปยังปัญหาถัดไปที่ยากขึ้น

สิ่งเหล่านี้อาจช่วยได้เช่นกัน (ในภายหลัง):

• เรียนรู้การเขียนโปรแกรมย้อนหลังหรือ "ดังนั้นฉันจึงล้มเหลวในการทดสอบ FizzBuzz ตอนนี้อะไร?"
• /software/151229/im-having-trouble-learning/151242#151242

ฉันรู้ว่านี่ไม่ใช่คำตอบที่คุณต้องการได้ยิน แต่: เขียนโค้ดเพิ่มเติม!

ตัดรหัสที่คุณเข้าใจให้ชัดเจนยิ่งขึ้น บ่อยครั้งที่มันช่วยให้ฉัน "แปล" เป็นภาษาอังกฤษปกติ

อย่ากลัวที่จะระดมความคิดของคุณสำหรับการเขียนโค้ดก่อน (เช่น "ฉันต้องการประกาศตัวแปรที่นี่ย้ำผ่านส่วนนี้และอื่น ๆ ") และจากนั้นค้นหาชิ้นส่วนเหล่านี้ทีละชิ้น

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

แค่เชื่อว่ายิ่งคุณเขียนและอ่านรหัสได้มากเท่าไหร่ก็ยิ่งสมเหตุสมผลเท่านั้น

อย่างที่คนอื่น ๆ พูดมานี่เป็นกรณีที่คุณต้องฝึกฝนฝึกฝนฝึกฝน

เขียนโปรแกรมเล็ก ๆ จำนวนหนึ่งที่แก้ปัญหาเดียวเท่านั้น

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

• สร้าง 1,000 หมายเลขสุ่มและแทรกลงในคอลเล็กชัน (คิวรายการ ฯลฯ ) จัดเรียงคอลเลกชันโดยไม่ต้องใช้วิธีการใด ๆ ที่จัดเรียงไว้สำหรับคุณ
• แสดง 10 คนที่คุณรู้จัก อันดับแรกเรียงลำดับชื่อตามชื่อและแสดง จากนั้นเรียงลำดับชื่อตามนามสกุลและแสดง จากนั้นให้ลองเรียงลำดับตามรูปแบบ "สุดท้ายก่อน" (เช่น Smith, Andrew จะอยู่ก่อน Smith, Jessica)
• ค้นหาหมายเลขเฉพาะทั้งหมดระหว่าง 1 ถึง 100
• (มรดก) ทำให้ระดับ Polygon GetAreaและให้มันฟังก์ชั่น ตอนนี้ให้คลาสสามเหลี่ยมและสี่เหลี่ยมผืนผ้าได้รับสืบทอดมาจากรูปหลายเหลี่ยมและตรวจสอบให้แน่ใจว่าพวกเขาใช้ GetArea ทำสิ่งนี้ต่อไปเพื่อรูปหลายเหลี่ยมเรียงลำดับที่สูงขึ้น (รูปห้าเหลี่ยมหกเหลี่ยมเป็นต้น)
• ลองเลือกสิ่งต่าง ๆ จากการแลกเปลี่ยนรหัสสแต็คกอล์ฟ *

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

ตัวอย่างโค้ดกอล์ฟที่สนุก:

• อำนาจของ 4 ไม่ต้องกังวลเกี่ยวกับการแก้ด้วย regex (มันค่อนข้างยากอย่างที่คุณเห็นคำตอบ) แต่แทนที่จะแก้คำถามที่ว่า "กำหนดสตริง s, ความยาวของมันหารด้วย 4 กำลังหรือไม่" คุณสามารถถ่ายภาพได้เช่นกัน: ความยาวของสตริงหารด้วย 4 หรือไม่? หารด้วย 6 หรือไม่? มันสำคัญหรือเปล่า (มันยากสำหรับสายยาวดังนั้นลองทำดูถ้าคุณกล้า!)?
• สตริง รับสตริง s, ส่งออกสตริงย่อยที่เป็นไปได้ทั้งหมด
• นับเป็น Word อันนี้อาจเป็นเรื่องยากขึ้นอยู่กับว่าคุณอยู่ในการศึกษาการเขียนโปรแกรมของคุณ มีบางสิ่งที่ทำให้มันง่ายมาก (เช่นคอลเล็กชันเชื่อมโยง) แต่ถ้าคุณไม่รู้สิ่งเหล่านั้นมันอาจเป็นเรื่องยาก
• หากชื่อฟังดูเป็นความลับคุณก็แค่เพิกเฉยต่อคำถาม อย่างที่ฉันพูดรหัสกอล์ฟสำหรับโปรแกรมเมอร์ที่มีประสบการณ์ เพียงแค่มุ่งเน้นไปที่ปัญหาที่เรียบง่ายและพยายามหาคำตอบง่ายๆ

โครงสร้างพื้นฐานของการแก้ปัญหา:

สิ่งเหล่านี้มากมายทำให้คุณมีความคิดที่ดีว่าฟังก์ชันควรมีลักษณะอย่างไร ให้ X ทำ Y และผลลัพธ์ควรเป็น Z:

void foo()
{
    // Set up X here

    // Do Y here

    // Display Z here
}

เพื่อวัตถุประสงค์ในการเรียนรู้พื้นฐานและทำความคุ้นเคยกับภาษาเทมเพลตข้างต้นก็เพียงพอแล้ว แม่แบบเชิงวัตถุเพิ่มเติมจะเป็น:

Z foo(input X)
{
    Z result;
    // Do Y to X
    return result;
}

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

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

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

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

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

คำถามนี้มีคำตอบที่ดีอยู่แล้ว แต่มีความคิดเล็กน้อยที่ฉันยังไม่เคยเห็น

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

อย่างที่คนอื่นพูดคุณไม่สามารถเรียนรู้การเขียนโปรแกรมเพียงแค่อ่านจากโปรแกรม

เริ่มต้นเล็ก ๆ มองหาการสอนแบบจาวาและทำทุกยูนิตทีละอัน และเมื่อคุณมั่นใจพอเลือกโครงการขนาดเล็กเพื่อทดสอบทักษะของคุณบางทีอาจเป็นเกมง่ายๆที่คุณรู้ดีซึ่งไม่ต้องการการโต้ตอบกับ GUI มากเกินไป เมื่อคุณตัดสินใจแล้วอย่าเพิ่งเปิด Eclipse และจ้องที่ 'หน้าว่าง' สร้างกระดานเรื่องราว คุณไม่จำเป็นต้องวาดไดอะแกรม UML อย่างละเอียดแค่คิดว่าจะแก้ปัญหาบางประการของโปรแกรมได้อย่างไร - เนื้อเรื่องหรือการโต้แย้งของคุณแผ่ออกไปอย่างไร และเมื่อเขียนรหัสให้เริ่มด้วยร่างคร่าวๆ ฉันมักจะเขียนความคิดเห็นจำนวนมากอธิบายว่าโปรแกรมควรทำอย่างไรในลำดับใดแล้วเริ่มกรอกรหัสโปรแกรมจริง

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

หากคุณมีแรงบันดาลใจสั้น ๆProject Eulerก็มีแบบฝึกหัดคณิตศาสตร์ / การเขียนโปรแกรมที่มีความยากเพิ่มมากขึ้น พวกเขาให้เป้าหมายที่ชัดเจนและท้าทายเพื่อให้บรรลุและควรช่วยให้คุณได้รับโปรแกรมการออกแบบที่สะดวกสบายมากขึ้น

แค่คิดว่าฉันจะพูดสอดในหัวข้อนี้เพราะมันกระทบกับบ้าน

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

ฉันยังควรเพิ่มว่าคุณเพียงแค่ should't เริ่มเขียนโปรแกรมสุ่มสี่สุ่มห้า ทำโครงการด้วยตัวคุณเอง คุณต้องการทิศทางที่จะทำให้คุณรู้ว่าคุณต้องการทำอะไร คุณจะประหลาดใจเมื่อเห็นว่าคุณเรียนรู้ได้เร็วแค่ไหน หากคุณเพิ่งเปิด IDE และเริ่มทำตัวอย่าง Hello World ง่ายๆความรู้สึกที่ลดทอนความรู้สึกจะคืบคลานคุณอย่างรวดเร็ว ค้นหาสิ่งที่มีความลึกเล็กน้อยและก่อนที่คุณจะรู้ว่าคุณกำลังจะขยาย