ჯავის პროგრამის გამოყენება Google Drive მონაცემთა ბაზაზე: 8 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:19

ოდესმე გსურდათ ისეთი პროგრამის შექმნა, რომელიც მუშაობს დინამიურ მონაცემთა ბაზაზე, რომელთან მუშაობაც ადვილია, საშუალებას აძლევს არატექნიკურ მცოდნე მომხმარებლებს შეიტანონ მონაცემები და არ ამოწურონ კომპანიის რესურსები? კარგი, მაშინ მე მაქვს გამოსავალი თქვენთვის. დღეს ჩვენ შევქმნით პროგრამას, რომელიც მუშაობს Google Drive- ზე (კარგად, კონკრეტულად Google Sheets) და შეიძლება გამოყენებულ იქნას სხვადასხვა მიზნით. მიუხედავად იმისა, რომ ეს სახელმძღვანელო ფოკუსირდება ღონისძიებაზე დაფუძნებული აპლიკაციის შექმნაზე, რომელიც აჩვენებს კოლეჯის კამპუსში მომხდარი მოვლენების ჩამონათვალს, ეს პროექტი მარტივად შეიძლება ხელახლა დაიწეროს, რომ ფუნქციონირებდეს მრავალნაირად, იქნება ეს გამომთვლელი აპლიკაცია იმ აპლიკაციისთვის, რომელიც მონიტორინგს უწევს აქციები პროდუქტებისთვის. მე დავურთე ჩემი განაცხადის ასლი, თუ გსურთ ნახოთ რას გავაკეთებთ. გახსენით zip ფაილი და გაუშვით JAR მასში. ახლა კი, ყოველგვარი გატაცების გარეშე, დავიწყოთ!

ნაბიჯი 1: რაც დაგჭირდებათ

ამ პროექტის დასაწყებად დაგჭირდებათ შემდეგი რესურსები:

• ნეტბები

  მე გირჩევ Java EE გადმოტვირთვას, რადგან ის უზრუნველყოფს სერვერის მხარდაჭერას, მაგრამ თუ არ გინდა არასაჭირო ფაილები ან დამატებითი ადგილი დისკზე, Java SE ასევე იმუშავებს. Netbeans იქნება როგორც IDE ჩვენი პროგრამის კოდირებისა და შედგენისთვის

• ჯუსუპი

  მე ეს ჩავრთე ინსტრუქციებში, რომ გადმოწეროთ. ეს არის HTML ანალიზატორი, რომელიც საშუალებას მოგვცემს გამოვიღოთ ინფორმაცია გამოქვეყნებული ცხრილიდან

• Java SDK (V8)

  ჩამოტვირთეთ ნებისმიერი ფაილი, რომელიც შეესაბამება თქვენს სისტემას. თუ თქვენ უკვე გაქვთ Java SDK წინა ვერსიაში, გირჩევთ განახლებას. ჩემი ზოგიერთი ფუნქცია იყენებს ლამბდას ახალ გამონათქვამებს, რომლებიც შექმნილია v8– ში და კოდი შეიძლება არ იმუშაოს მათ გარეშე, რასაც აკეთებთ

• ვიზუალური სტუდია (სურვილისამებრ)

  სრულიად სურვილისამებრ. მიუხედავად იმისა, რომ NetBeans საოცრად მუშაობს ჩვენი აპლიკაციის შედგენისა და შეფუთვისთვის, მე არ ვარ განვითარების სტუდიის დიდი გულშემატკივარი. მე მირჩევნია კოდირება VS– ში, რადგან მას აქვს უფრო ლამაზი ინტერფეისი. თუ ეს არ მოგწონთ, ინტერნეტში უამრავი სხვა IDE არსებობს, ასე რომ იპოვეთ ის, რაც მოგწონთ საუკეთესოდ

• საწყისი კოდი

  მე ჩავრთე საწყისი წყარო ამის რესურსებში და ასევე გამოვაქვეყნე GitHub– ში. ამაში მე მაქვს მთავარი ფაილი (მოვლენა), რომელიც უზრუნველყოფს სტრუქტურას იმ ფაილისთვის, რომელიც რეალურად მართავს აპს, ასევე EventTester, რომელიც იყენებს JavaFX პროგრამის GUI შესაქმნელად. თუ გსურთ მიიღოთ სრული გამოცდილება, არ გირჩევთ კოპირებასა და ჩასმას. მიიღეთ დრო და წაიკითხეთ ეს

სხვები:

ჯავის ძირითადი ცოდნა. სასარგებლო იქნება ჯავის ცოდნა, როგორიცაა ფუნქციების წერა, ობიექტების შექმნა და ა

ნაბიჯი 2: შექმენით თქვენი მონაცემთა ბაზა

პროექტის დასაწყებად, ჩვენ ჯერ უნდა შევიდეთ Google Drive– ში და შევქმნათ ფურცელი, რომელსაც ჩვენ ვიყენებთ ჩვენი პროგრამის გასაშვებად. გადადით drive.google.com– ზე და დააწკაპუნეთ „ახალი“ხატზე ზედა მარცხენა კუთხეში და აირჩიეთ „ფურცლები“ამის ქვეშ.

მას შემდეგ, რაც თქვენი ფურცელი ჩაიტვირთება, განაგრძეთ და დაარქვით მას ადვილად ცნობადი. ამის შემდეგ, გააგრძელეთ და შეავსეთ ზედა სტრიქონი თქვენი მონაცემების სახელებით, როგორიცაა საგნები, რომლებსაც თითოეულ სვეტში დააყენებთ. ჩემს მაგალითს რომ გადავხედე, მე ზედა ეტიკეტი მივაწერე ისეთებს, როგორიცაა "მოვლენის სახელი", "თარიღი" და ა.

ამის შემდეგ, დაიწყეთ თქვენი ცხრილის შევსება იმ მონაცემებით, რომელთა შევსებაც გსურთ. დაიმახსოვრეთ თქვენი ყველა მონაცემის ფორმატირება ისე, რომ კოდს შეეძლოს მასთან მუშაობა შეცდომების დაშვების გარეშე. მაგალითად, თუ თქვენ აპირებთ თარიღების გამოყენებას თქვენს კოდში, ფრთხილად იყავით თითოეული თარიღის ერთნაირად ფორმატირებაში, წინააღმდეგ შემთხვევაში კოდი ვერ შეძლებს მის გაანალიზებას.

თქვენი მონაცემების შეტანის შემდეგ გამოაქვეყნეთ ცხრილი, გადადით "ფაილი" -> "ინტერნეტში გამოქვეყნებაზე". აქედან, თქვენ გსურთ აირჩიოთ მთელი დოკუმენტი და დარწმუნდეთ, რომ ის გამოქვეყნებულია როგორც HTML ფაილი, ამ გზით ჩვენი აპლიკაცია შეძლებს მონაცემების სწორად დახაზვას. თქვენი ცხრილის გამოქვეყნების შემდეგ, დარწმუნდით, რომ მიაქციეთ ყურადღება მის მიერ მოწოდებულ ბმულს. ეს მოგვიანებით დაგჭირდებათ აპლიკაციაში.

ნაბიჯი 3: NetBeans– ის დაყენება

ახლა, როდესაც ჩვენ გვაქვს ჩვენი ცხრილი, დროა შევქმნათ NetBeans, რათა დავიწყოთ კოდირება. მას შემდეგ რაც ჩამოტვირთავთ და დააინსტალირებთ NetBeans და თქვენი Java SDK, გააგრძელეთ და შექმენით ახალი პროექტი. ტიპის არჩევისას შეარჩიეთ "ჯავის" კატეგორია და "ჯავა პროგრამის" პროექტი. შეარჩიეთ როგორიც გსურთ რომ იყოს თქვენი პროექტი შეარჩიეთ ჩამრთველი "გამოიყენეთ ბიბლიოთეკების შესანახად გამოყოფილი საქაღალდე", ასევე "მთავარი კლასის შექმნის" გარდა. ამის შემდეგ, NetBeans– მა უნდა შექმნას პროექტისა და პროექტის დირექტორია, რომ დავიწყოთ მუშაობა, ისევე როგორც სურათზე.

სანამ დავიწყებთ კოდირებას, ჩვენ ასევე უნდა დავრწმუნდეთ, რომ NetBeans– ს აქვს JSoup ბიბლიოთეკა, რომელიც დაგჭირდებათ ჩვენი ცხრილების გასაანალიზებლად. NetBeans– ში დააწკაპუნეთ მარჯვენა ღილაკით „ბიბლიოთეკების“ხატულაზე თქვენი პროექტის დირექტორიაში. ამომხტარი მენიუს ქვეშ აირჩიეთ ღილაკი.jar ფაილის დასამატებლად. ახლა, გადადით იქ, სადაც განათავსებთ თქვენს jsoup ჩამოტვირთვას (სავარაუდოდ თქვენი ჩამოტვირთვების საქაღალდე, თუ სხვაგან არ გაქვთ მითითებული). აირჩიეთ ეს ფაილი და დაამატეთ ბიბლიოთეკა. თუ გააფართოვებთ ბიბლიოთეკების საქაღალდეს NetBeans– ში, თქვენ ახლა უნდა ნახოთ jsoup.jar ამ სფეროში. ამის გაკეთების შემდეგ, ჩვენ შეგვიძლია დავიწყოთ ჩვენი აპლიკაციის კოდირება.

ნაბიჯი 4: ჩვენი ძირითადი კლასის კოდირება

ასე რომ, ჩვენი პროგრამის კოდირების პირველი ნაბიჯი არის თქვენი ძირითადი კლასის შექმნა. თქვენი ძირითადი კლასი იქნება იქ, სადაც ჩვენ ვქმნით ჩვენს ობიექტებს, გვექნება JSoup– თან ურთიერთქმედების მეთოდები და სხვა. დავუშვათ, რომ ყველას, ვინც ამას კითხულობს, აქვს კოდირების გამოცდილება, გააგრძელეთ და გამოიყენეთ შემდეგი იმპორტი:

იმპორტი java.util. კოლექციები;

იმპორტი java.util. List;

იმპორტი java.util. ArrayList;

იმპორტი java.util. Date;

იმპორტი java.util.stream. Stream;

იმპორტი java.util.stream. კოლექტორები;

java.text. SimpleDateFormat იმპორტი;

java.text. ParseException იმპორტი;

იმპორტი org.jsoup. Jsoup;

იმპორტი org.jsoup.nodes. Document;

იმპორტი org.jsoup.nodes. Element;

იმპორტი org.jsoup.select. ელემენტები;

იმპორტი javafx.beans.property. SimpleStringProperty;

ეს შეიძლება ბევრი ჩანდეს და თქვენი პროექტიდან გამომდინარე, ყველაფერი შეიძლება არ იყოს საჭირო. როგორც ჩვენ ვაგრძელებთ კოდს, NetBeans შეგატყობინებთ თუ გაქვთ გამოუყენებელი იმპორტი, ასე რომ ჩვენ ყოველთვის შეგვიძლია მათი წაშლა მოგვიანებით. თუმცა, ეს არის ის, რაც ჩვენ ახლა გვჭირდება.

მას შემდეგ რაც მივიღეთ ჩვენი იმპორტის განცხადებები, მოდით წავიდეთ წინ და გამოვაცხადოთ ჩვენი კლასი. თუ თქვენ გეგმავთ თარიღების ან რაიმე არა-ძირითადი ობიექტის გამოყენებას თქვენი კლასის სპეციფიკური ობიექტის შემუშავებისას, გირჩევთ დაამატოთ „იმპლემენტი შესადარებელი“თქვენს კლასის დეკლარაციას. ეს საშუალებას მოგცემთ შეადაროთ ობიექტები, რაც საშუალებას მოგცემთ დაალაგოთ ClassObjects სია მოგვიანებით. ამის გაკეთების შემდეგ, გააგრძელეთ და გამოაცხადეთ ყველა ის ცვლადი, რაც დაგჭირდებათ. ყველა საჯარო სტრიქონისთვის, რომელსაც თქვენ შექმნით, თქვენ ასევე უნდა შექმნათ SimpleStringProperty მისთვის. ეს არის JavaFX ობიექტები, რომლებიც საშუალებას მოგვცემს ვიმუშაოთ ჩვენი ძირითადი კლასის ობიექტებთან შემდგომში.

ახლა, განაგრძეთ და განაცხადეთ, რომ წვდებით ფუნქციებს. რაც შეეხება თქვენს ძირითად ცვლადებს, თქვენ შეგიძლიათ დაასახელოთ თქვენი ფუნქციები რასაც აირჩევთ. თუმცა, თქვენთვის SSP წვდომის ფუნქციებისათვის, თქვენ უნდა გამოიყენოთ ფორმატი getFunctionNameHere (). ეს იმიტომ ხდება, რომ მოგვიანებით ჩვენ გამოვიყენებთ JavaFX– ს ამ ფუნქციებთან დასაკავშირებლად და ის ფუნქციები, რომელსაც ჩვენ გამოვიყენებთ, მოითხოვს, რომ დავიწყოთ ჩვენი SSP ფუნქციები get– ით. თქვენ შეგიძლიათ ნახოთ მაგალითი ზემოთ.

თქვენი წვდომის ყველა ცვლადის განსაზღვრის შემდეგ, გააგრძელეთ და განსაზღვრეთ ნებისმიერი სხვა ფუნქცია, რომელიც შეიძლება დაგჭირდეთ. ეს არის ძალიან მომხმარებლისთვის სპეციფიკური, რადგან ფუნქციები, რომლებიც გჭირდებათ, განსხვავდება პროექტიდან პროექტამდე. თუ თქვენ გჭირდებათ რაიმე შთაგონება, შეამოწმეთ ჩემი Javadoc ან რეალური კოდი და ნახეთ ზოგიერთი ფუნქცია, რაც მე გავაკეთე. მაგალითად, მე შევქმენი დახარისხების ფუნქცია, რომელიც ალაგებს სიას თარიღის მიხედვით, ასევე ფუნქციებს, რომლებიც აბრუნებენ მხოლოდ მოვლენებს საზოგადოების ჯგუფური სტატუსებით და სხვა. მიუხედავად იმისა, რომ კარგია, რომ ეს სტატიკური იყოს ისე, რომ თქვენ შეძლოთ ტესტირების ჩატარება, მე გირჩევთ არ გქონდეთ რაიმე სტატიკური მეთოდი დებაგირების დასრულებისთანავე, რათა თავიდან ავიცილოთ შეცდომები, როდესაც ჩვენ მივაღწევთ პროექტის შემდეგ საფეხურს.

ნაბიჯი 5: ჩვენი შექმნის () მეთოდის განსაზღვრა

ახლა მოდის ალბათ კოდის ყველაზე მნიშვნელოვანი ნაწილი, სადაც ჩვენ ვაპირებთ განვსაზღვროთ ჩვენი create () მეთოდი, რომელიც არის ის, რაც რეალურად შევა ჩვენს ვებ გვერდზე და მოგვაწვდის მონაცემებს. მნიშვნელოვანია აღინიშნოს, რომ თქვენ უნდა დაამატოთ ისლების გამონაკლისი ხაზი თქვენს მეთოდის დეკლარაციაში, ასე რომ ჩვენ არ უნდა დავწეროთ try ბლოკები ჩვენს კოდში. დასაწყებად, გააგრძელეთ და გამოაცხადეთ თქვენი ობიექტის ცარიელი სია. ჩემს შემთხვევაში, ასე გამოიყურებოდა

ღონისძიების მოვლენები = ახალი ArrayList ()).

ახლა, წადი და იპოვე ის URL, რომელიც ადრე დააკოპირე გამოქვეყნებულ ცხრილში. გამოაცხადეთ ეს ბმული სტრიქონად Java- ში და დაარქვით მას როგორც გინდათ. ახლა, წადი და გამოაცხადე ახალი Jsoup დოკუმენტი. ამის გაკეთება შეგიძლიათ ახალი დოკუმენტის ობიექტის შექმნით, როგორიცაა

დოკუმენტის დოკუმენტი = ახალი დოკუმენტი ();

ახლა, გააგრძელეთ და დააყენეთ თქვენი დოკუმენტი, რომ დაუკავშირდეს ჩვენს URL- ს და მიიღოთ მონაცემები. ამისათვის სცადეთ:

დოკუმენტი doc = Jsoup.connect (url).get ();

ახლა ჩვენ უნდა მივიღოთ ჩვენი დოკუმენტის ძირითადი ნაწილი, სადაც ინახება რეალური მონაცემები.

სიმებიანი სხეული = doc.body (). ტექსტი ();

ახლა ჩვენ უნდა დავიწყოთ მონაცემების ამოღება სხეულიდან. ვინაიდან ჩვენი მონაცემები არის ცხრილში (ვინაიდან ის იყო ცხრილი), ჩვენ გვჭირდება ცხრილის ამოღება სხეულიდან. Მოდი ვცადოთ

ელემენტის ცხრილი = doc.select ("მაგიდა"). მიიღეთ (0);

ეს ირჩევს პირველ ცხრილს. ამ შემთხვევაში, მხოლოდ ერთია. ახლა, აკრიფეთ

ელემენტების რიგები = table.select ("tr");

ეს გვაძლევს ყველა ცხრილს აღნიშნულ ცხრილში.

ასე რომ, ახლა, ჩვენი ყველა მონაცემი ამ რიგების ცვლადშია. ეს კარგია და ყველაფერი, მაგრამ ამ კლასის შიგნით ამ ფუნქციის დაწერის მთელი აზრი იმაში მდგომარეობს, რომ ჩვენ შეგვიძლია შევქმნათ საგნები მისგან. ასე რომ, სანამ ამის დაბრუნებას შევძლებთ, ჩვენ უნდა შევქმნათ სია ჩვენი რიგებიდან. ამისათვის ჩვენ შეგვიძლია გამოვიყენოთ for loop. უნდა აღვნიშნო, რომ ამან მცირედი გამოცდა და შეცდომები დამჭირდა, რომ გამოვსულიყავი. მივხვდი, რომ რიგებიდან ამოღებისას, ჩვენი ზოგიერთი მონაცემი არ არის გამოსადეგი ამ სიტუაციისთვის, რადგან ის შეიცავს ისეთებს, როგორიცაა ინდივიდუალური ფურცლის სახელი, პირველი სტრიქონი ჩვენი მონაცემების იდეებით და ა.შ. საბოლოოდ, მე დავაყენე საწყისი შეყვანის ნომერი for მარყუჟისთვის 2, ასე რომ ის გვერდს აუვლის ამ ელემენტებს და შეუძლია შექმნას ჩვენი ერთეულები. საბოლოო ჯამში, მე შევიმუშავე სახე კოდით

for (int i = 2; i <rows.size (); i ++) {

ელემენტის რიგი = რიგები. მიიღეთ (i);

ელემენტები cols = row.select ("td");

ახლა, ობიექტის შესაქმნელად, გააკეთე მსგავსი რამ

ობიექტის სახელი = ახალი ობიექტი (cols.get (0).text ());

არსებითად, cols.get (0) მიიღებს მონაცემებს სტრიქონიდან (i) სვეტიდან (0) და გადააქცევს მას სტრიქონად, რომელიც შემდეგ შეიძლება გადაეცეს ობიექტის კონსტრუქტორს.

თქვენი კონსტრუქციის დაყენების შემდეგ დაამატეთ ის ჩვენს მიერ ადრე შექმნილ სიაში list.add (), როგორიცაა

events.dd (სახელი);

ახლა დახურეთ თქვენი მარყუჟი და დარეკეთ ნებისმიერი ფუნქცია, რომელიც შეიძლება დაგჭირდეთ. მაგალითად, მე დავრეკე ჩემი დახარისხების ფუნქცია, რომ მოვლენები თარიღის მიხედვით დალაგდეს. ამის შემდეგ დააბრუნეთ თქვენი სია და შემდეგ დაასრულეთ ეს განყოფილება!

ნაბიჯი 6: ჩვენი აპლიკაციის კოდირება

შექმენით ახალი ფაილი და დაასახელეთ ის, რასაც აირჩევთ. თქვენ დაგჭირდებათ შემდეგი იმპორტი:

იმპორტი java.util. List;

იმპორტი java.util. ArrayList;

იმპორტი java.util. Date;

იმპორტი javafx.geometry. Pos;

იმპორტი javafx.scene.layout. HBox;

იმპორტი javafx.application. Application;

იმპორტი javafx.collections.transformation. FilteredList;

იმპორტი javafx.scene.text. Font; იმპორტი javafx.scene.control.*;

იმპორტი javafx.collections. FXCollections;

იმპორტი javafx.collections. ObservableList;

იმპორტი javafx.geometry. Insets;

იმპორტი javafx.scene. Group;

იმპორტი javafx.scene. Scene;

იმპორტი javafx.scene.control. Label;

იმპორტი javafx.scene.control.cell. PropertyValueFactory;

იმპორტი javafx.scene.layout. VBox;

იმპორტი javafx.stage. Stage;

მე ვიცი, რომ ეს შეიძლება ბევრი ჩანდეს, მაგრამ დამიჯერეთ, ისინი აუცილებელია ჩვენთვის, რომ შევქმნათ ჩვენი აპლიკაცია. წადი და გამოაცხადე შენი კლასი და დარწმუნდი, რომ ის გააგრძელებს განაცხადს, რადგან ეს არის პროექტის აუცილებელი კომპონენტი. დასაწყისში, გამოაცხადეთ ახალი ცვლადის მაგალითი, რომელიც არის თქვენი ობიექტის TableView, როგორიცაა

პირადი TableView მაგიდა = ახალი TableView ();

ასევე, გამოაცხადეთ ძირითადი მეთოდი, რომელსაც ჩვენ გამოვიყენებთ აპლიკაციის გასაშვებად. არსებითად, ის უნდა გამოიყურებოდეს სურათის ზედა ნაწილში.

ახლა ჩვენ უნდა შევქმნათ ჩვენი დაწყების მეთოდი. დარწმუნდით, რომ ის აგდებს გამონაკლისს, რადგან ჩვენ მოვუწოდებთ create () მეთოდს ჩვენი ყოფილი კლასიდან. შექმენით ახალი მოვლენა ცარიელი პარამეტრებით, უბრალოდ ასე რომ ჩვენ შეგვიძლია დავუძახოთ შექმნის მეთოდი. განსაზღვრეთ ახალი სია და დააყენეთ იგი შექმნის () შედეგის ტოლი. ახლა შექმენით ახალი ObservableList, რომელიც გამოყენებული იქნება ჩვენი ცხრილის შესავსებად ჩვენი მონაცემებით. განსაზღვრეთ ასე:

ObservableList მონაცემები = FXCollections.observableArrayList ();

ახლა შექმენით ახალი სცენა:

სცენის სცენა = ახალი სცენა (ახალი ჯგუფი ());

დააყენეთ სათაური, სიგანე, სიმაღლე და სხვა ყველაფერი, რაც გჭირდებათ თქვენთვის, რაც თქვენთვის მუშაობს. თქვენ შეგიძლიათ ნახოთ ჩემი ღირებულებები სურათზე ზედა. ახლა ჩვენ შეგვიძლია დავიწყოთ ჩვენი მაგიდის გაშლა. ყველა იმ ინფორმაციისთვის, რომლის ჩვენებაც გსურთ, შექმენით TableColumn, მაგალითად:

TableColumn eventCol = ახალი TableColumn ("მოვლენის სახელი"); eventCol.setMinWidth (100); eventCol.setCellValueFactory (ახალი PropertyValueFactory ("სახელი"));

"SName" პარამეტრი უნდა იყოს შევსებული როგორიც არ უნდა იყოს თქვენი SSP წვდომის ფუნქციები, ასე რომ მას შეუძლია მიიღოს მნიშვნელობები, რომლებიც გჭირდებათ მოცემული ობიექტებისთვის. გააკეთეთ იმდენი სვეტი, რამდენიც გჭირდებათ, შემდეგ დაამატეთ ისინი ცხრილში

FilteredList flEvent = ახალი FilteredList (მონაცემები, p -> ჭეშმარიტი);

table.setItems (flEvent);

table.getColumns (). addAll (eventCol, statCol, groupCol, datingCol, descCol, locationCol);

თუ გსურთ დაამატოთ საძიებო ზოლი, როგორც მე გავაკეთე, შეამოწმეთ კოდი ინფორმაციისთვის, თუ როგორ უნდა შექმნათ არჩევანის ყუთი და textField, რაც თქვენს მომხმარებელს საშუალებას მისცემს გაფილტროს ცხრილი კონკრეტული მნიშვნელობებით. თუ თქვენ გადაწყვიტეთ ამის გაკეთება, თქვენ ასევე უნდა გააკეთოთ hBox, რომ შეიცავდეს მათ

HBox hBox = ახალი HBox (არჩევანი Box, textField);

hBox.setAlignment (პოზი. ცენტრი);

თქვენ ასევე უნდა დაამატოთ hBox ქვემოთ.addAll () მეთოდით.

წინააღმდეგ შემთხვევაში, უბრალოდ შექმენით ახალი vBox ჩვენი მონაცემების შესანარჩუნებლად

საბოლოო VBox vbox = ახალი VBox ();

vbox.getChildren (). addAll (ეტიკეტი, ცხრილი);

((ჯგუფი) სცენა.getRoot ()). GetChildren (). AddAll (vbox);

ეტაპი. დადგენა სცენა (სცენა); ეტაპი. ჩვენება ();

ახლა შეადგინეთ თქვენი კოდი და გაუშვით და ნახეთ მუშაობს თუ არა. გამოიყენეთ NetBeans შეცდომების მოსაძებნად, რომლებიც გამოჩნდება ეკრანის მარჯვენა მხარეს წითელი ზოლების სახით. გააგრძელეთ ეს მანამ, სანამ შეცდომები აღარ გექნებათ და პროექტი არ ამოქმედდება.

თქვენი კოდირების დასრულების შემდეგ, მე გირჩევთ შექმნათ თქვენი კოდის Javadoc, რათა ხალხმა ნახოს რას აკეთებს თქვენი კოდი. ამისათვის, ეკრანის ზედა ნაწილში "გაშვების" ღილაკის ქვეშ, უბრალოდ დააჭირეთ "გენერირება Javadoc". თქვენ შეგიძლიათ იპოვოთ ჩემი Javadoc– ის ასლი პირველ გვერდზე zip ფაილის შიგნით და აირჩიოთ index.html ფაილი.

ნაბიჯი 7: ჩვენი ჯარის ფაილის შედგენა და შეფუთვა

მას შემდეგ რაც საკმარისად გაასწორეთ და წარმატებით გაუშვით, შეგიძლიათ საბოლოოდ შეადგინოთ ეს JAR ფაილში, რომელიც შემდეგ გამოქვეყნდება, რათა სხვებმა შეძლონ ამ პროგრამული უზრუნველყოფის გაშვება NetBeans ან Jsoup საჭიროების გარეშე.

თქვენი აპლიკაციის შედგენამდე დარწმუნდით, რომ ყველაფერი დასრულებულია. თუ გსურთ დაამატოთ დოკუმენტაცია და შექმნათ JavaDoc, გააგრძელეთ ეს. თუ თქვენ გაქვთ რაიმე ბრძანება System.out, რომელიც იბეჭდება თქვენს კონსოლზე, წაშალეთ ისინი. არსებითად, დარწმუნდით, რომ თქვენს აპს არ აქვს არასასურველი ბრძანებები და ფუნქციები და რომ მას აქვს ყველაფერი, რაც უნდა იყოს შეფუთული.

ამის შემდეგ, დააწკაპუნეთ მარჯვენა ღილაკით პროექტის სახელზე NetBeans– ში. ის უნდა გამოჩნდეს მენიუში. დააჭირეთ თვისებებს (მენიუს ბოლოში), შემდეგ დააჭირეთ "შეფუთვას" ახალი მენიუს მარცხენა მხარეს. ახლა დარწმუნდით, რომ ყველა ჩამრთველი მონიშნულია. თქვენი ეკრანი უნდა გამოიყურებოდეს ზემოთ.

ამის გაკეთების შემდეგ, კიდევ ერთხელ დააწკაპუნეთ მარჯვენა ღილაკით თქვენს პროექტზე NetBeans– ში. ამ ეტაპზე, დააჭირეთ ღილაკს "გაწმინდე და ააშენე" და NetBeans დაიწყებს თქვენი ბიბლიოთეკების და ფაილების აღებას და სამუშაო JAR ფაილში შედგენას. თუ ყველაფერი კარგად მიდის, თქვენ უნდა ნახოთ შეტყობინება კონსოლში რამდენიმე წუთის შემდეგ, რომელიც გეუბნებათ, რომ თქვენი JAR დასრულებულია შედგენა და ფაილის ახლა გაშვება შესაძლებელია. გაუშვით ეს აპლიკაცია და დარწმუნდით, რომ ყველაფერი მუშაობს. თუ არა, შეცვალეთ და განაახლეთ პროცესი, სანამ შეცდომები არ დამუშავდება.

ნაბიჯი 8: გილოცავთ

გილოცავთ! თუ თქვენ ზუსტად მიჰყევით ყველა ინსტრუქციას და კარგად დაშიფრეთ ყველაფერი, მაშინ თქვენ უნდა გქონდეთ თქვენი საკუთარი სამუშაო პროგრამა. ყველაზე მაგარი ის არის, რომ ახლა, როდესაც თქვენ ან ვინმე სხვას, ვისაც აქვს წვდომა თქვენს ცხრილებზე, შეასწორებს მონაცემებს, თქვენს აპს შეეძლება შეცვალოს და მოახდინოს რეაგირება ახალ მონაცემებზე. აქ არის სწრაფი ვიდეო, თუ როგორ აღმოჩნდა ჩემი.

თუ თქვენ ეძებთ გაუმჯობესებისა და მშენებლობის გზებს, გირჩევთ შეამოწმოთ JavaFX– ის ზოგიერთი უფრო მოწინავე ფუნქცია, როგორიცაა FancyText ან FancyButton, რომელსაც შეუძლია დაამატოთ უფრო მაღალი დონის გრაფიკა თქვენს აპლიკაციაში. წარმატებებს გისურვებთ და დატოვეთ კომენტარი, თუ გჭირდებათ დახმარება ან შეამჩნევთ შეცდომას ჩემს კოდში!