>> FRED Widjaja ყველა უფლება.
Hi, ყველას.
დიდი მადლობა, მივესალმები გაწევრიანების მე ამ სემინარზე.
ასე რომ, დღეს ჩვენ ვაპირებთ უნდა ლაპარაკი როგორ უნდა განვითარდეს apps for Android,
და განსაკუთრებით, ჩვენ ვაპირებთ გამოყენებით Android Studio მიზნით
განვავითაროთ ჩვენი apps.
>> ისე, როგორც თქვენ ყველამ იცით.
Android იყენებს ჯავა, და ამიტომ ჩვენ გადის მოკლე შესავალი
ჯავის თავად.
ასე რომ, მე ვიცი, ბევრ თქვენგანს მხოლოდ გამოცდილება პროგრამირების C. ასე
რომ მთლიანად ჯარიმა, და ეს იმიტომ, Java, ძალიან
მსგავსი C, პატარა განსხვავებები.
>> ასე რომ სახის Java არიან ფიქსირებული რაოდენობის bytes.
ასე რომ, C, ჩვენ გვაქვს shorts და მიისწრაფვის, და ისინი
განსხვავდება რაოდენობის ბიტი მანქანა მანქანა.
ჯავაში, ეს უკვე როგორც სტანდარტი.
ასე bytes რვა ბიტი, shorts 16 ბიტი, და ასე შემდეგ და ასე შემდეგ.
ჩვენ ასევე გვაქვს სიმბოლო, booleans, და ასევე მოძრავი და ორადგილიანი.
ასე რომ გზა, თქვენ პროგრამა Java, ეს ძალიან ჰგავს.
ასე მაგალითად, ჩვენ გვაქვს მარყუჟების და ხოლო მარყუჟების,
და თუ სხვაგან და განცხადებები, ზუსტად ისევე, როგორც თქვენ ამას გავაკეთებთ C.
>> ყველა უფლება, ასე რომ სპეციალური რამ შესახებ Java არის ის, რომ ობიექტზე ორიენტირებული.
ახლა, რა ობიექტები?
ასე რომ, თუ გადავხედავთ რამ თქვენს გარშემო, თქვენ
შეამჩნია, რომ ყველა რეალური სამყაროს ობიექტი აქვს ორი საერთო მახასიათებლები.
და ის არის, რომ მათ აქვთ სახელმწიფო და მათ აქვთ გარკვეული ქმედებები.
>> ასე მაგალითად, ძაღლი ექნება სახელმწიფოს, რომელიც
არის სახელი, ფერი, ჯიშის, შესაძლოა, თუ ძაღლი მშიერი თუ არა.
და ზოგიერთ ქცევას, რომ ძაღლები არ ექნება იქნება ყეფა, ან wagging კუდი,
ან მიღება დაადასტურა.
ამიტომ ჩვენ შეიძლება ასევე გამოიყენოს ეს inanimate ობიექტები.
ასე მაგალითად, მანქანები, მათ აქვთ მოდელი, წელი, მაქსიმალური სიჩქარე,
და ასე შემდეგ და ასე შემდეგ.
და მათ აქვთ გარკვეული ქცევა.
მაგალითად, დაჩქარება, ან დამუხრუჭების, ან აპირებს საპირისპირო.
>> ასე Java ობიექტების მცდელობა მოდელზე ამ მქონე სფეროებში და მეთოდები.
ასე სფეროებში აცხადებს, რომ ჯავის ობიექტი შეიძლება ჰქონდეს,
ხოლო მეთოდი წარმოადგენს ქცევა, რომელიც ჯავის ობიექტი იქნებოდა.
ამიტომ როდესაც ვამბობ მეთოდები და სფეროებში, მე ნამდვილად
უბრალოდ ნიშნავს ცვლადები და ფუნქციები.
ისინი ზუსტად იგივე, გარდა რომ ისინი ვრცელდება გარკვეული ობიექტი.
>> OK, ასე მოძრავი კლასების.
Java კლასებს მოსწონს მალე ობიექტი.
ისინი გითხრათ, თუ რა მეთოდებით მას, რა სფეროებში, მას აქვს,
და კიდევ, ჩვენ გვაქვს რაღაც მოუწოდა ხელმისაწვდომობის მოდიფიკატორები, რომელიც
ჩვენ კიდევ, ხოლო.
ასე, რომ განაცხადოს Java კლასი, ის ძალიან მსგავსი სინტაქსი რომ C struct.
>> აქ ჩვენ ვიწყებთ off ერთად საჯარო კლასის მანქანა, და მაშინ ჩვენ გვაქვს ღია გაუწიოს და შემდეგ
გარკვეული რაოდენობის სფეროებში, გსურთ ობიექტი აქვს.
და მერე აქ ჩვენ გვაქვს გარკვეული მეთოდები, და ჩვენ ასევე გვაქვს ობიექტი მშენებელი.
ახლა რა ეს ობიექტი მშენებელი არ არის ეს ეუბნება ობიექტი,
OK, მე მინდა ვრთავ ამ ობიექტის გარკვეული სფეროებში.
>> ასე რომ, ჩვენ გვინდა, რომ ყველა მანქანა აქვს მოდელი და წელი.
ამიტომ ჩვენ გვაქვს მშენებელი მხოლოდ კონკრეტულად
მოდელი და წელი, და ეს იქნებოდა მითითებული მოდელი ველი
გარკვეული ღირებულება, და წლის სფეროში, ასევე.
>> ახლა ხელმისაწვდომობის მოდიფიკატორები იყო საუბარი.
აქ ჩვენ გვაქვს საჯარო და კერძო ხელმისაწვდომობის მოდიფიკატორები.
ასე რომ თქვენ შეგიძლიათ წარმოიდგინოთ, რომ ეს RWX თქვენი საიტები.
ასე რომ, ისინი საშუალებას გარკვეული ხალხი წავიკითხე, და ჰქონდეს
ამ სფეროში და მეთოდები.
>> ასე რომ, თუ მე ვიტყვი, რომ მოდელი და წელს და სიჩქარე არის კერძო,
ეს ნიშნავს, რომ სხვა ობიექტები არ შეუძლია მცდელობა, რათა შეამოწმონ ამ ობიექტის სფეროებში
არსებობს კერძო.
მაგრამ, როცა მე მითითებული ხელმისაწვდომობა მოდიფიკატორის უნდა იყოს საჯარო,
ახლა, რაც იმას ნიშნავს, რომ სხვა ობიექტები არის თავისუფალი, რათა შეამოწმონ და კი
გამოიყენება მეთოდები, რომლებიც განსაზღვრულია აქ.
>> ასე რომ ეს არის ძირითადი მანქანის ობიექტი, რომ მაქვს.
ჩვენ გვაქვს დააჩქაროს, შესვენება და getSpeed ​​მეთოდები.
ამ ეტაპზე, ყველას ნათელი on Java ობიექტების და როგორ უნდა გამოვაცხადოთ?
მაგარი, ყველა უფლება.
ასე რომ, თუ გსურთ გამოიყენოთ Java ობიექტის პროგრამა თავისთავად,
მაშინ ჩვენ შეგვიძლია გამოვიყენოთ ეს ახალი მანქანის მშენებელი.
ასე რომ, აქ ჩვენ ვამბობთ, გვინდა განვაცხადოთ, ახალი ობიექტი, რომელიც ტიპის მანქანა.
და აქ ის გამოყენებით მოდელი და წელი,
რომელიც ჩვენ განსაზღვრულ ეს ობიექტი უფლება აქ.
>> ასე რომ, ეს არის კიდევ ერთი წინააღმდეგი, თუ თქვენ შეამჩნევთ.
ეს კლასი მთავარი პროგრამა თავისთავად.
და ჩვენ გვაქვს ამ PSVM, ან საზოგადოებრივი სტატიკური ბათილად მთავარი, ფუნქცია,
და მისი ამოსავალი წერტილი თქვენს პროგრამაში,
მსგავსი მთავარ ფუნქცია თქვენი C პროგრამა.
აქ, ჩვენ შეუძლია და გამოიყენოს ობიექტი ფუნქციები
გამოყენებით dot და შემდეგ ფუნქციის სახელი notation.
და ჩვენ კი დააკონკრეტა, გარკვეული არგუმენტები ან პარამეტრების
ეს ფუნქცია.
>> OK, ასე რომ, ახლა მოძრავი მემკვიდრეობა.
ასე რეალური სამყაროს ობიექტების შეუძლია ერთნაირი მახასიათებლები.
ასე მაგალითად, არსებობს სხვადასხვა ტიპის ველოსიპედებით.
მაგალითად, მთის ველოსიპედით, ქალაქის ველოსიპედი, ან ტანდემი ველოსიპედი.
ასე რომ მათ ამ საერთო დამახასიათებელი მიმდინარეობს ველოსიპედით.
>> და ასე ველოსიპედი შეიძლება ჰქონდეს ორ საბურავს და ისინი შეიძლება ჰქონდეს handlebar, შესაძლოა,
კუდი მსუბუქი ან რამე მაგდაგვარს.
ასე Java გვაძლევს ამ ძალა წარმოადგენს ობიექტები
რომ აქვს გარკვეული საერთო მახასიათებლები გზით მემკვიდრეობა.
ახლა, რა მემკვიდრეობა აკეთებს, ის გადის ობიექტის სფეროებში და მეთოდები
წლის ბავშვი ობიექტი.
>> ასე მაგალითად, თუ მე გაქვთ მანქანა, და მას აქვს
სახელმწიფო, რომელსაც ოთხი დისკები და ერთი საჭე,
მაშინ ჩვენ შეგვიძლია გავლა, რათა გარკვეული სხვადასხვა სახის მანქანები.
მაგალითად, ჩვენ გვაქვს სედანი, სპორტ-კარი, და ჯიპი.
ახლა, ამ სამ განსხვავებულ სახის მანქანები მაინც
აქვს ოთხივე საბურავს და ერთი საჭე, მაგრამ მერე
შეიძლება ჰქონდეს გარკვეული განსაკუთრებული მახასიათებლები,
როგორიცაა, რომელსაც ხუთივე რაოდენობა და ამისთვის სედანი, მაგალითად.
>> ასე რომ, რათა გამოიყენონ ეს მემკვიდრეობა ფუნქცია, ჩვენ ვიყენებთ ამ ვრცელდება სიტყვით.
ასე მახსოვს, უკან მანქანა წინააღმდეგი, რომ მე განისაზღვრება წინასწარ.
ახლა მე განსაზღვროს სედანი ობიექტი.
ასე რომ, ეს Sedan ობიექტი იქნებოდა იგივე სფეროებში და ფუნქციები, ან მეთოდები,
რომ Car ექნება.
მაგრამ შემდეგ, აქ მე დააკონკრეტა გარკვეული დამატებითი ფუნქციები,
მაგალითად, კომპლექტი მგზავრთა რაოდენობა
და მიიღეთ რაოდენობის მგზავრი.
>> აქ, თქვენ ასევე შეამჩნია რომ ჩვენ შეიძლება override მეთოდები,
და ეს ნიშნავს, რომ ჩვენ მხოლოდ შეცვლის ქცევა
სხვაგვარად მოქმედებას გარკვეულ შემთხვევებში.
ასე, მაგალითად, მინდა მითითებული მაქს სიჩქარე ჩვენი მანქანა.
და გავაკეთოთ, რომ, მე შეამოწმოს თუ არა ეს სიჩქარე წავიდოდა მეტი მაქსიმალური სიჩქარე.
და თუ ეს არ მოხდა, მაშინ მოვუწოდებ სუპერ კლასი "დააჩქაროს მეთოდი.
ასე რომ, ეს არის super.accelerate () ზარები სუპერ კლასი "დააჩქაროს მეთოდი.
>> და ბოლოს, ჩვენ ვაპირებთ ვისაუბროთ ინტერფეისები.
ასე ინტერფეისი გზა გამოვლენა მხოლოდ გარკვეული მეთოდები გარე სამყაროსთან.
ამიტომ ისინი, როგორიცაა მაგიდა შინაარსი, და თქვენ
შეიძლება ვიფიქროთ, რომ ისინი, როგორც როგორიცაა C header ფაილი, მხოლოდ
მსგავსი მეთოდები ცარიელი ორგანოების, და ისინი დააკონკრეტა, თუ რა ობიექტი ან კლასი
აქვს, ან რა მეთოდებით ობიექტის ან კლასი აქვს.
>> ასე მაგალითად, თუ მე აქვს ველოსიპედის ინტერფეისი,
და მას აქვს სამი სხვადასხვა მეთოდები, და აქ თუ მე განახორციელოს ამ ინტერფეისი,
მაშინ ეს იმას ნიშნავს, რომ ეს ველოსიპედი რომ უნდა განახორციელოს იმავე სამ
მეთოდები, რომ მე განსაზღვრული ინტერფეისი.
>> ამ ეტაპზე, რაიმე სხვა კითხვები?
ყველა უფლება, ზემოთ.
ასე რომ ეს იყო ძალიან მოკლე და სწრაფი ი Java.
არსებობს გზა მეტი ფუნქციები და თემები Java, რომ თქვენ შეგიძლიათ რეალურად გაიაროს.
მაგალითად, არსებობს გენერიკების, არსებობს მონაცემთა ტიპები,
იქ კი enums და პერსონალი.
ასე რომ, თუ გსურთ შეიტყოთ უფრო მეტი ამის შესახებ, აღნიშნულ ბმულებს,
და ისინი ყველაფერს გასწავლით მეტი მათ შესახებ.
>> OK, ასე რომ, მოდით გადაადგილება, რათა ფაქტობრივი ხორცი სემინარი,
და ეს არის რეალურად Android პროგრამირების.
ასე რომ, სანამ ჩვენ რეალურად მისაღებად პროგრამირების,
მინდა ვისაუბროთ ზოგიერთ jargon.
ასე აქტივობა Android- ის გზა ამბობდა
ეს ერთ ეკრანზე განაცხადი.
>> ასე, მაგალითად, თუ თქვენ გაქვთ Gmail app, ჩვენ გვაქვს view ელ საქმიანობაში.
და მაშინ, თუ თქვენ დააჭირეთ გარკვეული ელ, რომელიც
გამოჩნდება კიდევ ერთი საქმიანობა, სადაც ეს ხედი ელ საქმიანობაში.
და მაშინ ჩვენ ასევე გვაქვს შეადგენს საქმიანობა, ან რედაქტირების გაგზავნა საქმიანობაში.
და ასე საქმიანობა ზოგადად მხოლოდ ერთ ეკრანზე
ფარგლებში განაცხადის თავად.
>> ახლა, შეხედულებები კომპონენტი, რომელიც up ეკრანზე, ან საქმიანობაში თავად.
ასე ისინი გარკვეული რამ თქვენს ეკრანზე.
ასე მაგალითად, ეს შეიძლება იყოს ტექსტური ველი, ეს შეიძლება იყოს label,
ეს შეიძლება იყოს ამოწმებს ყუთში.
ასე რომ ბევრი სხვადასხვა ტიპის რაოდენობა.
ახლა ჩვენ გვაქვს განცდა, და ეს გაგზავნა
რომ გადაეცემა სხვა საქმიანობას.
და ისინი არ შეიცავენ ინფორმაციას იმის შესახებ, რა გსურთ ამ საქმიანობაში, რათა შესრულდეს.
საბოლოოდ, ჩვენ გვაქვს მანიფესტი ფაილი, და რომ
XML ფაილი, რომელიც თქვენი ტელეფონი ყველა ინფორმაციას თქვენი app.
ასე რომ, ეს მოიცავს ვერსია, და საქმიანობა, რომელიც თქვენ შეიძლება ჰქონდეს.
>> OK, მოდით დავიწყოთ.
ამიტომ, ჩვენ ვაპირებთ, რომ იყოს გამოყენებით Android Studio.
ასე რომ, თუ თქვენ ბიჭები გვყავს ეს უკვე დაყენებული, შეგიძლიათ დაიცვას გასწვრივ.
ჩვენ შევეცდებით და დაიწყოს ნულიდან.
და ამიტომ მე ვაპირებ ცდილობენ და შევქმნათ ახალი პროექტი.
და მე ვაპირებ მოვუწოდო ჩემი პროექტი Android 101.
და აქ ჩვენ დააყენა სახელი პროექტის განაცხადის სახელი სფეროში.
>> კომპანია Domain, თქვენ არ ნამდვილად უნდა ფიქრი, რომ.
ეს არის, თუ რამდენად Android განსაზღვრავს თქვენი განაცხადი.
ასე რომ თქვენ გაქვთ დომენი, შეგიძლიათ ჩაწეროთ თქვენი დომენი შიგნით არსებობს.
მაგრამ თუ არა, თქვენ შეგიძლიათ გრძნობენ უფასო აკრიფოთ არაფერი გსურთ.
ასე რომ აქ მე უბრალოდ აკრიფოთ frederickw.com.
>> და მაშინ, საბოლოოდ, მე აირჩიოს, სადაც მინდა შესანახად ჩემი პროექტი.
და მე ვაპირებ უბრალოდ აირჩიეთ ჩემი კომპიუტერი.
ასე მომხმარებელი, Frederick Widjaja და Desktop.
OK.
შემდეგ დააჭირეთ შემდეგი.
აქ, მე ვაპირებ აირჩიოს მინიმალური API მხარდაჭერა.
ასე რომ, ამ შემთხვევაში, მე აპირებს აირჩიოს API 15.
და ეს ჯარიმა, თუ რეალურად მხოლოდ აირჩიეთ 4.4, რომელიც არის უკანასკნელი API.
ან 5, ფაქტობრივად.
მაგრამ მაშინ უბრალოდ უნდა ფიქრი რომელიც ტელეფონები თქვენ ნამდვილად მხარდამჭერი,
და რომელიც ტელეფონები თქვენ გათვლილი.
დაწკაპეთ შემდეგი.
>> OK, ასე მივალთ ამ ეკრანზე, და ჩვენ უბრალოდ
აპირებთ გამოიყენოთ შექმნა საქმიანობის მეშვეობით.
ამიტომ, მე ვაპირებ დააწკაპუნეთ ცარიელი საქმიანობა და მაშინ შემდეგი.
ჩვენ ვაპირებთ ეძახით მთავარი საქმიანობა, მე ვფიქრობ, რომ ეს ჯარიმა.
უბრალოდ ვაპირებ მოვუწოდო მას, პრეს Finish უფლება აქ.
დაველოდოთ მას ჩატვირთვა, და იქ წასვლა.
>> ასე რომ აქ ჩვენ შეამჩნია სამი სხვადასხვა საქაღალდეებში.
ჩვენ გვაქვს ცხადი ფოლდერი რომელიც შეიცავს ჩვენი მანიფესტი.
თუ თქვენ გახსნას, ჩვენ დავინახავთ, ჩვენი პაკეტი.
ან როგორ Android განსაზღვრავს თქვენი განცხადება
და მაშინ ჩვენ გვაქვს ამ განაცხადის tag, რომელიც
შეიცავს ტიტული ჩვენი განცხადება ისევე როგორც ხატი განაცხადი.
>> ჩვენ შეგვიძლია რეალურად აწარმოებს ამ განაცხადის სწორი.
რატომ არ ვცდილობთ, და ამის გაკეთება?
მე ვაპირებ გამოიყენოთ Genymotion.
თუ თქვენ მოუტანა საკუთარ ტელეფონზე, თქვენ შეგიძლიათ ბმული it up და გაუშვით, თუ გსურთ.
მაგრამ მე უბრალოდ აპირებს გამოიყენოს emulator, და მე ვაპირებ დაიწყება.
Ooh.
მე ვფიქრობ, რომ ის, აპირებს, ხოლო,
ასე რომ, მე ვფიქრობ, რომ ჩვენ უბრალოდ პირდაპირ შევიდა აეხსნა მეტი ამის შესახებ.
ასე რომ, აქ ჩვენ გვაქვს Java დირექტორია, ან სადაც თქვენი წყარო შეიცავდა.
აქ ჩვენ გვაქვს ძირითად საქმიანობას თავად.
თქვენ ხედავთ, რომ ეს ვრცელდება საქმიანობაში კლასის.
ასე რომ, ჩვენი ძირითადი საქმიანობა არის ეკრანზე რომელიც იქნება ჩვენი განცხადება.
და მერე აქ შევნიშნავთ, რომ ნომერი ფუნქციები ავტომატურად გენერირებული ჩვენთვის.
ჩვენ გვაქვს onCreate ფუნქცია, და რომ დაერქმევა whenever--
სტუდენტი: თქვენ ძალაუნებურად მიღების ტექსტში დიდი?
FRED Widjaja: OK, დარწმუნებული ვარ.
ვეცდები და ფონტის ზომის გაზრდა.
ვფიქრობ, რომ უნდა იყოს კარგი.
რომ კარგი?
>> სტუდენტი: უბრალოდ ცოტა უმაღლესი, როგორიცაა 20 ან რამე.
>> FRED Widjaja: 20?
OK.
OK, ყველა უფლება.
ასე რომ აქ გვაქვს onCreate მეთოდი, რომელიც
ეწოდოს, როდესაც ჩვენი საქმიანობა შექმნილია [? ნახოთ?].
ჩვენ გვაქვს onCreateOptionsMenu, და ჩვენ
ვხედავთ, რომ იქ ფაქტიურად სამოქმედო ბარი, და მაშინ
ჩვენ შეგვიძლია დავამატოთ გარკვეული მენიუს ელემენტი მას.
და მერე აქ გვაქვს onOptionsItemSelected.
ასე რომ, ეს არის, როგორიც ღონისძიება მსმენელი, ასე როდესაც ვარიანტი ჩვენი სამოქმედო ბარი
დააწკაპებთ, ეს ფუნქცია დაერქმევა,
და ეს იქნება მიღებული, გარკვეული ნივთი, რომელიც დააწკაპებთ.
>> OK, მე ვაპირებ ვხედავ რომ არ მუშაობს კარგად.
მოდით, ვცადოთ და დაიწყოს.
Oh ძვირფასო.
OK.
ეს არის შემაშფოთებელი.
OK, ასე მაინც.
აქ ჩვენ გვაქვს განლაგება ჩვენი საქმიანობა თავისთავად.
ეს არის ჩვენი მთავარი ამოცანა, და აქ ჩვენ შეამჩნია, რომ არსებობს სამოქმედო ბარი.
და მაშინ ჩვენ გვაქვს ამ Hello მსოფლიო label, და ჩვენ შეგვიძლია რეალურად
შეცვალონ ტექსტი უფლება აქ.
თუ თქვენ წავიდეთ და გადახვევა ქვემოთ Hello World,
ჩვენ შეგვიძლია შევცვალოთ ის რაც ჩვენ გვინდა.
მაგალითად, ეს შეიძლება იყოს, Hi არსებობს.
მივესალმებით.
და იქ წასვლა, იგი შეიცვლის.
Oh ძვირფასო.
ეს სტილი არ მუშაობს.
OK, რაც შემაშფოთებელია.
OK, მაინც, ჩვენ შეგვიძლია გადაადგილება გარეშე, რომ.
ასე რომ, მოდით, ვცადოთ და დაკავდით ნამდვილად ძირითადი პერსონალი.
ასე რომ აქ ჩვენ ვაპირებთ აქვს ეტიკეტების, და მაშინ ჩვენ
გვექნება ტექსტი view-- უკაცრავად, არ არის ტექსტი აზრით,
ჩვენ ვაპირებთ, რომ უნდა შეცვალონ ტექსტი.
და ეს არის კომპონენტი თქვენ ჩაწერეთ და პერსონალი.
ამიტომ ჩვენ გვაქვს მარტივი ტექსტის, და მაშინ ჩვენ უბრალოდ დაამატოთ ეს onto ჩვენი ინტერფეისი.
>> აქ, მინდა ასევე, გარკვეული ზღვარი ყველაზე ასე, რომ იგი გამოიყურება გავალამაზოთ.
ასე რომ, ჩვენ ვაპირებთ წასვლა თვისებები და შემდეგ ზედა ზღვარი,
ჩვენ ვაპირებთ, რომ დაამატოთ 20 DPS.
ასე რომ, ახლა, DPS მხოლოდ ერთეული ზომის Android,
და ისინი დგანან for სიმჭიდროვე დამოუკიდებელი pixels.
ასე რომ, როგორც მოგეხსენებათ, Android, არსებობს სხვადასხვა სახის ეკრანებზე
და შემდეგ მათ აქვთ სხვადასხვა ეკრანზე სიმკვრივეების.
ასე რომ, აქ ის უბრალოდ იქნება სიმჭიდროვე დამოუკიდებელი pixel,
ასე რომ, ეს იქნება იგივე მთელი ეკრანებზე.
>> აპირებს გააგრძელოს ეს შეცვალონ ტექსტი და მაშინ მე ასევე აპირებს დაამატოთ ღილაკს.
და ის აპირებს ვთქვა OK.
20 DPS.
OK.
ასე რომ, ახლა ჩვენ გვაქვს სამი სხვადასხვა კომპონენტები.
და გზა ჩვენ შეგვიძლია ეხება ეს ჩვენი ძირითადი საქმიანობა კლასის
არის ამ მეთოდით მოუწოდა findViewByID.
ამიტომ, მე ვაპირებ, რომ განსაზღვროს გარკვეულ სფეროებში.
ასე გვაქვს TextView, ასე ვთქვათ helloText.
და მაშინ, თუ თქვენ იყენებთ Android Studio, თქვენ შეგიძლიათ გამოიყენოთ მალსახმობი ალტერნატიული,
შევა.
და დააჭირეთ იმპორტი კლასი ავტომატურად იმპორტი შესაბამისი კლასი
რომ ჩვენ გვჭირდება.
და მერე აქ მე ვაპირებ დაამატოთ ID, რომ ამ TextView და ეძახით text_hello.
ახლა, რომ ჩვენ არ განისაზღვრება ID ამ TextView,
ჩვენ შეგვიძლია გამოვიყენოთ ეს ეხება TextView, რომ ჩვენ უბრალოდ განსაზღვრული.
ასე helloText ტოლია TextView findViewByID,
და მაშინ ჩვენ დააკონკრეტა ID, რომ ჩვენ გვინდა, რომელიც r.ID.text_hello.
>> ასე რომ, ეს ძალიან ჰგავს JavaScript და jQuery, სადაც შეგვიძლია რეალურად მხოლოდ
ეხება გარკვეული ელემენტები განლაგება მხოლოდ
გამოყენებით ID, რომ ჩვენ არ კონკრეტდება.
ასე რომ, ზოგადად, რათა შეამოწმონ გარკვეული ობიექტის ან გარკვეულ სფეროში
ჩვენს განლაგება, თქვენ ვაპირებთ აქვს გამოიყენოს ეს findViewByID მეთოდი.
და მაშინ ჩვენ ვაპირებთ გავაკეთოთ იგივე რამ ორი ელემენტია.
აქ, მე ვაპირებ დაამატეთ ID text_name.
დიახ.
ისევე, როგორც ეს ერთი.
Button_ok.
>> ახლა რა მინდა ამ გავაკეთოთ არის როდესაც ჩვენ დააჭირეთ OK ღილაკს,
და ჩვენ inputted გარკვეული სახელი შევიდა ველში,
შემდეგ ის აპირებს განაახლოთ ეტიკეტების ვთქვა, hi, სახელი, მისასალმებელია.
ასე რომ, უკან ჩვენი მთავარი საქმიანობაში კლასის, ჩვენ
ასევე აპირებს ცდილობენ და მიმართოს იმ ელემენტებს, ჩვენ უნდა მოვძებნოთ.
>> ამიტომ ჩვენ გვაქვს EditText nameText.
Oops.
შესვლის და ალტერნატიული, იმპორტი კლასის.
და შემდეგ ასევე OK ღილაკს.
ანალოგიურად, ჩვენ ვაპირებთ გავაკეთოთ იგივე აქ.
nameText ტოლია EditText findViewByID, r.ID.text_name.
და შემდეგ OK ღილაკს.
findViewByID, r.ID და შემდეგ button_ok.
>> OK, ასე რომ, ახლა გვაქვს სამივე ელემენტები, რომ ჩვენ გვინდა ეხება.
ასე რომ, ახლა მე ვაპირებ ანიჭებენ on დააწკაპუნეთ მსმენელი ჩვენი ღილაკს
მოვუსმინოთ შესახებ დაწკაპუნებით.
იმისათვის, რომ ჩვენ უბრალოდ გამოიყენოთ setOnClickListener ღონისძიება.
ახლა, აქ, ის ამბობდა, რომ ჩვენ გვჭირდება დააკონკრეტა, setOnClickListener,
და შეგიძლიათ გააკეთოთ, რომ უბრალოდ მქონე ახალი onClickListener, და დააჭირეთ Enter.
>> და მაშინ თქვენ ეს ანონიმური კლასი, ან ანონიმური ობიექტი.
და ჩვენ ასევე გვაქვს ამ onClick მეთოდი, და ეს, ძირითადად,
რასაც ის აპირებს ეწოდოს როდესაც ჩვენი ღილაკს დააწკაპებთ.
>> ასე რომ, აქ, მინდა მიიღოს სახელი, რომ იყო შეყვანის ველში პირველი ასე
სიმებიანი სახელი უტოლდება nameText.getText ().
კიდევ ერთხელ, ეს მოსწონს Java სინტაქსი გულისხმობდა
ფუნქციები ფარგლებში ობიექტი.
ასე nameText.getText, და მაშინ ჩვენ გარდაქმნას მას სიმებიანი.
ახლა ჩვენ გვაქვს სახელი, რომ იყო შეტანის შესახებ.
>> და მაშინ ჩვენ ვაპირებთ გენერირება ახალი ტექსტი,
ასე რომ, ეს იქნება მოუწოდა hello.
მე ვაპირებ ვთქვა, hi, სახელი, მისასალმებელია.
და ბოლოს, გსურთ განაახლოთ helloText.
ასე გავაკეთოთ, რომ, ჩვენ უბრალოდ დარეკეთ helloText.setText (hello).
OK.
Oops.
>> მე ვაპირებ ცდილობენ და ხელახლა აწარმოებს Genymotion ერთი საბოლოო დრო და თუ მუშაობს.
თუ ეს არ მოხდა, ეს სრულიად ჯარიმა.
OK.
ამიტომ ვფიქრობ, ეს არ მუშაობს.
ფაქტობრივად, ნება მომეცით ცდილობენ და ამის გაკეთება.
შეიძლება იყოს ეს.
Genymotion.
OK.
ყველა უფლება.
დიახ, ეს მუშაობს.
OK.
რომ იყო საშიში.
OK.
მე არ ნიშნავს, რომ ამის გაკეთება.
OK, ასე გვაქვს ამ Android emulator.
მიადევნე თვალი ჩართოთ ეს off.
ასე რომ, ჩვენ გვაქვს ჩვენი Android emulator.
ამიტომ, ჩვენ ვაპირებთ, რომ ცდილობენ და აწარმოებს ამ app, რომელიც ჩვენ მივიღეთ.
უბრალოდ აპირებს დააწკაპუნეთ Play ღილაკს, და ის აპირებს ვთქვა, ელოდება ADB.
ოჰ, კაცი.
გადატვირთვა.
OK, მე ვფიქრობ, ეს მაინც არ მუშაობს.
OK, nevermind, მაშინ.
ეს იქნება ძალიან სამწუხაროა.
მაგრამ ასე ვთქვათ, რომ ჩვენ გვინდა შევქმნათ ახალი საქმიანობის,
და ჩვენ ვაპირებთ, რომ აქვს სურათს, რომ საქმიანობაში.
უნდა გავაკეთოთ, რომ, ჩვენ შეგვიძლია უბრალოდ დააჭირეთ ეს ფაილი, და მაშინ ახალი.
და მაშინ აქ ჩვენ შეგვიძლია შერჩევა აქტიურობა და შემდეგ ცარიელი საქმიანობაში.
აქ, ჩვენ ვაპირებთ, რომ მოვუწოდო იქნებ CatActivity.
>> OK, ასე რომ, ახლა საერთოდ ორი სხვა ფაილი.
ერთი ეწოდება activity_cat და სხვა
ეწოდება catActivity, რომელიც კლასში.
ასე ვთქვათ, რომ ჩვენ გვინდა დავამატოთ სურათს cat უფლება აქ.
ასე რომ, როდესაც თქვენ, რომ ჩვენ ვაპირებთ გამოიყენოს ImageView კლასის.
ჩვენ ვაპირებთ, რომ დაამატოთ ეს onto აქ.
და შემდეგ მითითებული ზღვარი უნდა იყოს 20 DP.
>> და ახლა ჩვენ ვაპირებთ, რათა იპოვოს იმიჯი cat ინტერნეტში.
ასე რომ, ვნახოთ.
კატა.
OK.
ვფიქრობ, ეს არის ჯარიმა.
OK.
ახლა ჩვენ გვაქვს ჩვენი იმიჯი.
ასე რომ, ჩვენ ვაპირებთ, რომ დაამატოთ იგი ჩვენი პროექტი.
ამისათვის მარჯვენა დაჭერით, და შემდეგ ჩვენ
შეიძლება რეალურად უბრალოდ გახსნა, წასვლა ჩამოტვირთვების, უკაცრავად, desktop.
ვაპირებ ცდილობენ და საპოვნელად.
კატა.
უფლება აქ.
მე ვაპირებ კოპირება ჩემს ფოლდერში.
ახლა, ის აპირებს მკითხავთ რამდენიმე ვარიანტი.
ახლა, მე უბრალოდ მინდა, რომ ეს იყოს Drawable საქაღალდეში,
და რომ იქნება ყველა სხვადასხვა ეკრანის რეზოლუცია.
გარდა ამისა, ჩვენ შეგვიძლია რეალურად მონიშნოს
რომელიც ეკრანზე რეზოლუცია თქვენ მინდა ამ სურათის იყოს.
ასე აპირებს შერჩევა Drawable საქაღალდეში, დააწკაპუნეთ OK.
უბრალოდ აპირებს დაარქვით cat.jpg.
>> OK, ასე რომ, ახლა კი დასძინა ჩვენი image.
ჩვენ ვაპირებთ, რომ უნდა გამოვიყენოთ ამ წყაროს სწორედ აქ,
და მაშინ ჩვენ შეგვიძლია გამოვიყენოთ ეს dot dot dot ღილაკს და აირჩიეთ კატა იმიჯი.
OK.
ასე რომ, ახლა მე მინდა, რომ მას ასეთი რომ ეს მხოლოდ უფლება ზომა.
ამიტომ, მე ვაპირებ აირჩიოთ ეს შეცვალოს ნახატის საზღვრები ვარიანტი სწორედ აქ,
და რომელიც ავტომატურად ადგენს მას უფლება ზომა.
OK.
ახლა, რეალურად დაიწყებს ამ საქმიანობის ჩვენი წინა საქმიანობის,
თქვენ აპირებთ უნდა გამოვიყენოთ რაღაც მოუწოდა განზრახვა.
ასე ვთქვათ, მე ვაპირებ რჩეულებში სხვა ღილაკს რომ იწყებს საქმიანობას.
მე ვაპირებ, რომ დაამატოთ ეს აქ, უფლება აქ.
და შემდეგ ის აპირებს აქვს ტექსტი გაააქტიუროთ იგი.
Oops.
OK.
>> ახლა, როგორ უნდა რეალურად გახსნა ახალი საქმიანობის ფარგლებში ამ აქტივობის შესახებ?
ასე იგივე გარიგება, როგორც ადრე.
ჩვენ უნდა დაამატოთ ID, რომ ამ ღილაკს, და მას button_activate.
და შემდეგ ჩვენი მთავარი ამოცანა, აპირებს აქვს ახალი Button activateButton.
და შემდეგ ასევე გამოიყენოთ findViewByID მეთოდი.
activateButton ტოლია Button findViewByID r.ID.button_activate.
>> OK.
და მაშინ ჩვენ ასევე ვაპირებთ რჩეულებში in onClickListener.
ახალი onClickListener.
და მაშინ ჩვენ ვაპირებთ გამოვიყენოთ ეს რამ მოუწოდა განზრახვა.
განზრახვა უდრის ახალი განზრახვა (ეს).
და შემდეგ სახელი საქმიანობა, რომელიც ჩვენ გვინდა, რომ გამოჩნდება.
ასე რომ აქ ამ, ჩვენ ვაპირებთ აქვს catActivity.class.
უკაცრავად.
ჩვენ ვაპირებთ, რომ უნდა დააკონკრეტა @ MainActivity.this.
ასე რომ, ახლა .ეს ქონება გულისხმობდა მიმდინარე ინსტანციის ობიექტი
თავად.
OK.
ამ ეტაპზე, რაიმე კითხვა?
ყველა კარგი?
ყველა უფლება.
>> და მაშინ, თუ გსურთ დაიწყება საქმიანობის, ეს საკმაოდ მარტივია.
ჩვენ უბრალოდ ვუწოდებთ startActivity მეთოდი.
და მაშინ ჩვენ გაივლის განზრახვა ობიექტი, რომელიც ჩვენ უბრალოდ განსაზღვრული.
სამწუხაროდ, ჩვენ ნამდვილად ვერ აჩვენებს, ამ.
მე იმ იმედით, რომ ჩვენ შეგვიძლია რეალურად აწარმოებს ამ და დავანახოთ, რომ ერთად სემინარი,
მაგრამ, სამწუხაროდ, არა.
ოჰ, კაცი.
მე ვერ ვხედავ.
Oh, ჩვენ ვაპირებთ, რომ ცდილობენ და კლავს ATB.exe.
OK.
გადატვირთვა.
არ მუშაობს?
ოჰ, OK.
ასე რომ, ახლა ის რეალურად შედგენა.
Oh.
სამწუხაროდ, არ არსებობს არ მოწყობილობები გაშვებული.
მოდით, ვცადოთ და გადატვირთვა ჩემი emulator.
Ah, იქ ჩვენ წავიდეთ.
აღმოჩნდა.
OK.
ამიტომ, მე ვაპირებ, რომ დაიწყოს ჩემი ოთახი ჩემს Android emulator.
და ჩვენ გვაქვს ყველაფერი რომ ჩვენ განსაზღვრული ახლა.
ამიტომ ჩვენ გვაქვს label, ტექსტი აზრით, ველში და შემდეგ ღილაკს.
ამიტომ, მე ვაპირებ შეყვანის ჩემი სახელი აქ,
და იქ წასვლა, ის შეიცვალა ტექსტი.
ასე რომ, თუ ჩვენ აკრიფოთ Foo, ეს აპირებს შეცვალოს Foo.
>> და თუ მე დააწკაპუნეთ გააქტიურება ღილაკს, რომელიც
ჩვენ უკავშირდება რეალურად დაიწყოს ახალი საქმიანობის, იმედია ეს იმუშავებს,
იქ ჩვენ წავიდეთ.
ის იწყებს ახალ საქმიანობაში.
დაბრუნდეს, ჩვენ შეგვიძლია დააჭირეთ თავში ღილაკს უფლება აქ.
თუ არა.
ოჰ, იქ ჩვენ წავიდეთ.
Oops.
რომ იყო ცუდი.
OK.
>> ასე რომ, ახლა რომ ჩვენ განვახორციელეთ ზოგიერთი ძირითადი პერსონალის Android,
ჩვენ შეგვიძლია ვცდილობთ და დაკავდით უფრო რთული პერსონალი.
ასე რომ, პირველი, მოდით ცდილობენ და გაივლის შეტყობინებები ერთი საქმიანობაში სხვა.
ასე ვთქვათ, ჩვენ გვინდა, რომ გაივლის სახელი ძირითადი საქმიანობის
კატა საქმიანობაში.
და სახელი იქნება მოძიებულია ამ nameText.
>> OK, ასე რომ, პირველ რიგში, ჩვენ ვაპირებთ ვიღებ სახელი უფლება აქ.
String სახელი შეადგენს nameText.getText (). toString ().
OK.
და მაშინ ჩვენ შეგვიძლია გამოვიყენოთ ეს საგანი მოუწოდა intent.putExtra (სახელი),
და მაშინ რეალურად ასევე სურს გასაღები ამ დამატებითი სფეროში.
>> ამიტომ, მე ვაპირებ განსაზღვროს ახალი გასაღები, ჩვენ მოვუწოდებთ მას EXTRA_NAME.
ამიტომ, მე ვაპირებ, რათა გამოიყენონ ეს გასაღები, CatActivity.EXTRA_NAME,
და შემდეგ გაივლის სახელი თავად.
>> OK, ასე რომ, ახლა ჩვენ შეგვიძლია რეალურად ვიღებ ამ ფარგლებში ახალი CatActivity.
უნდა გავაკეთოთ, რომ, ჩვენ უნდა გამოვიყენოთ განზრახვა ტოლია getIntent მეთოდი.
ასე რომ, ახლა ის აპირებს ვიღებ განზრახვა, რომ
იყო გამოყენებული, რათა დაუკავშირდეთ ამ ახალ საქმიანობაში.
ასე რომ, თუ გსურთ მიიღოთ სიმებიანი რომ ჩვენ რეალურად დააყენა შიგნით განზრახვა,
თქვენ შეგიძლიათ გამოიყენოთ intent.getStringExtra და შემდეგ გაივლის იგივე გასაღები,
>> OK, ასე რომ, ახლა ვთქვათ თქვენ გსურთ შეცვალოთ ამ სფეროში.
ამ ველის შეცვლა უფლება აქ.
და მოდით შრიფტი ზომა ამ სფეროში დიდი.
ასე ვთქვათ, მე მინდა, რომ ეს უნდა იყოს 20 DP.
OK.
და მე ვაპირებ დამატებას ID ამ TextView,
და მე ვაპირებ მოვუწოდო მას text_cat.
უკაცრავად.
>> და უკან CatActivity, იგივე გარიგება, როგორც ადრე.
ჩვენ ვაპირებთ, რომ განსაზღვროს გარკვეულ სფეროებში.
აქ ის იქნება TextView catText.
და შემდეგ catText ტოლია TextView findViewByID, r.ID.text_cat.
OK.
და შემდეგ უკან აქ, მე შექმნას აპირებს ტექსტი მარჯვენა
მას შემდეგ, რაც ჩვენ ვიღებ for ეს განზრახვა.
setText (სახელი).
>> OK, მოდით ცდილობენ რომ.
დააჭირეთ Play ღილაკს.
მე ვაპირებ გამოიყენოთ იგივე მოწყობილობის.
უკან აქ.
ასე ვთქვათ, მე არ შეყვანა თუ ჩვენ არ დააკონკრეტა ნებისმიერი სახელი,
ვნახოთ, რა მოხდება.
ასე რომ, ახლა იქ არაფერი ჩანს.
ასე რომ, ჩვენ დაბრუნდეს და input ჩვენი სახელი, ეს მხოლოდ თქმას Fred.
ასე რომ ჩვენ შეგვიძლია რეალურად გაივლის შეტყობინებები ერთი საქმიანობაში სხვა.
OK.
>> ასე რომ, არსებობს რამოდენიმე სხვა views რომ თქვენ შეგიძლიათ გამოიყენოთ Android.
ახლა ჩვენ გვაქვს პროგრესი ბარები, ჩვენ გვაქვს სიის ნახვა, ჩვენ გვაქვს გადავრთოთ ღილაკები,
და თუ თქვენ ნამდვილად სურდა შეიტყოთ უფრო მეტი რომ,
თქვენ შეგიძლიათ რეალურად ეწვევა ამ ვებ გვერდებზე.
ისინი შეიცავს ბევრ სხვადასხვა რესურსები.
ასე მაგალითად, API სახელმძღვანელოს უფლება აქ ფაქტიურად
გაძლევთ რამდენიმე კოდი მაგალითები გარკვეული ფუნქციების Android ბიბლიოთეკაში.
>> და რამდენიმე გაკვეთილები აღმოვაჩინე სასარგებლო როდესაც სწავლის შესახებ Android.
ეს ოფიციალური tutorial თავად, და ასევე ამ სხვა tutorial უფლება აქ.
და ბოლოს, თქვენ შეგიძლიათ რეალურად გამოყენება სხვადასხვა ბიბლიოთეკებში
თქვენი Android განაცხადი.
ახლა, ეს რეალურად ვრცელდება ფუნქციონალური თქვენი app
გარეშე ნამდვილად წერენ ბევრად კოდი.
Downside არის, რა თქმა უნდა, რომ თქვენ რეალურად
უნდა ვისწავლოთ ბიბლიოთეკების თავს.
>> ასე მაგალითად, თუ გინდათ გამოყენება Dropbox cloud ტექნოლოგია,
მაშინ შეგიძლიათ გამოიყენოთ Dropbox API.
მსგავსი Facebook API.
და შემდეგ იქ რეალურად რამდენიმე სხვადასხვა სხვა სხვადასხვა ბიბლიოთეკებში
რომელიც შეგიძლიათ გამოიყენოთ.
თუ თქვენ ცდილობთ მიიღოთ, ისევე, JSON გარკვეული ნახვა,
მაშინ მე ვფიქრობ, რომ Google JSON ბიბლიოთეკა იქნება საკმაოდ სასარგებლო.
ასე რომ, ახლა, რომელიც გარდაქმნის JSON ფორმატირებული ტექსტის Java ობიექტი,
და პირიქით.
>> და შემდეგ იქ Retrofit და პიკასო.
და რომ, თუ გსურთ გამოიყენოს ეს არის ის, თუ თქვენ იყენებთ დანარჩენი API.
და პიკასო, თუ თქვენ იყენებთ images თქვენი Android განაცხადი.
ყველა უფლება.
ძალიან დიდი მადლობა, და არ fun კოდირება.