Книга е още в много ранна фаза на написване

Глави

Целта, тогава, е във всяка глава да се опише нова черта на езика или няколко близ­ки, свързани черти, без да се използуват такива, които са непознати до този мо­менти. По този начин може да бъде асимилиран материалът напълно при вся­ка стъпка, преди да се продължи нататък.

Ето кратко описание на главите в тази книга, което съответства на моя опит от се­минарите и упражненията:

Глава 1: Въведение в обектите

Тази глава е за всичко, което е предмет на обектно-ориентираното про­грамиране, вкл. основния въпрос “Що е обект?”, интерфейс и раз­ли­ките му с приложение, абстракция и капсулиране, съобщения и функ­ции, наследяване и композиция и важния за всичко поли­мор­фи­зъм. Също има въведение в създаването на обекти с конструктори, къ­де живее обектът, къде да ги сложим като са веднъж създадени и ма­ги­ческият “събирач на боклук” който почиства от обектите щом те ве­че не са нужни. И други неща се въвеждат, включително обработката на грешки с изключения, многонишковост за потребителски интер­фейси, които “не губят говор”, мрежи и Мрежата. Ще научите какво пра­ви Java специален, защо той бива толкова успешен и за обектно-ориен­тираните анализ и проектиране.

Глава 2: Всичко е обект

Тази глава ви довежда до точката, където ще може да напишете пър­ва­та си програма така че главата дава общ поглед върху основните не­ща, включително концепцията за “дръжка” (манипулатор, който по съ­щество е указател – б.пр.) към обект; как да се създаде обект; въ­ве­де­ние към първичните типове и масиви; обхват и как обектите биват раз­рушавани от боклучаря; как всичко във Java е нов даннов тип (class) и как да създавате маши собствени класове; функции, аргу­мен­ти и връщани стойности; видимост на имената и използуване на кла­со­ве зададени извън текущия файл; ключовата дума static; ко­мен­та­ри и вградена документация.

Тази глава започва с всичките оператори, които идват от C и C++. В до­бавка ще намерите общите клопки, превръщания, промоции и прио­ри­тет. Това е последвано от основните оператори за управление хода на програмата, които са общи за проктически всички езици за про­гра­ми­ране: избор с if-else; цикли с for и while; излизане от цикъл с break и continue както и етикетираните такива в Java (които заместват “лип­сващия goto” в Java); избор чрез switch. Въпреки че повечето такъв ма­териал има общи точки в C и C++ , има някои разлики. В добавка всич­ките примери ще са пълни Java примери така че по-добре ще усвои­те как изглежда Java.

Тази глава започва с въвеждането на конструктор, който гарантира пра­вилна инициализация. Дефиницията на конструктор води до кон­цеп­цията за презареждане на функции (бихме могли да искаме ня­кол­ко конструктора). Това е последвано от дискусия за разчистването (пре­ди излизане – б.пр.), което не винаги е толкова просто, колкото из­глежда. Нормално просто зарязвате обекта когато повече не е необ­хо­дим и като мине боклучаря, почиства всичко, освобождовойки па­мет­та. Тази част изследва боклучаря и някои негови особености, идио­син­карзии. Главата завършва с по-близък поглед към инициа­ли­за­ция­та: автоматична инициализация на членове, задаване на инициа­ли­за­ция, реда на инициализация, static инициализация и инициа­ли­за­ция на масиви.

Тази глава разглежда как се свързват заедно парчетата код и как някои ча­сти от библиотека са видими докато други са скрити. Тя започва с раз­глеждането на ключовите думи package и import, които по­зво­ляват опаковането на файлово ниво и позволяват създаването на би­блио­теки от класове. Въпросът с каталожните пътища и файловите име­на също е разгледан. Останалата част от главата разглежда клю­чо­ви­те думи public, private и protected, концепцията за “прия­телски” достъп и какво различните нива на достъп означават, кога­то са в различен контекст.

Концепцията за наследяване се споделя от практически всички OOP ези­ци. Това е начин да се вземе съществуващ клас и да се разшири не­го­вата функционалност (както и да се промени, темата на Глава 7). На­сле­дяването е често начин да се използува повторно код, като се оста­ви “базовия клас” същия и само се променят някои неща тук и там за по­стигане на целите. Наследяването обаче не е единствения начин да се получат нови класове от съществуващи такива. Може също да се вгра­ди един клас в друг чрез композиция. В тази глава ще научите за те­зи две техники на повторно използуване на кода в Java и как да ги из­ползувате.

Самички бихте могли да изразходвате девет месеца за откриване и раз­биране на полиморфизма, крайъгълен камък на OOP. Чрез малки, про­сти примери ще се научите как да създавате семейство типове чрез на­следяване и как да манипулирате обектите им чрез базовия клас. По­ли­морфизмът на Java позволява да се третират всички обекти от един тип генетично, което значи, че вашият код не зависи от спе­ци­фич­на за типа информация. Това прави програмите ви разширяеми, та­ка че произвеждането и управлението на програмните проекти е по-лес­но и управляемо. В добавка Java дава трети път да се устрои пов­тор­но използуване на кода чрез интерфейс, което е чиста абстракция на интерфейс на обект. Веднъж като сте станали наясно с поли­мор­физ­ма интерфейсите са лесни за разбиране. Тази глава също въвежда въ­трешни класове на Java 1.1.

Доста проста е всяка програма, която има фиксирано число обекти с известно време на живот. Изобщо, вашите програми ще създават най-различни обекти които ще бъдат ясни чак по времето, когато програмите работят. В добавка вие не бихте искали да знаете даже типа на обектите чак до пускането на програмата. За да решите общия проблем трябва да можете да създавате неограничено количество обекти, навсякъде, по всяко време. Тази глава дълбоко разглежда колекциите, които Java 2 доставя за да владеете обектите докато работите с тях: прости масиви и по-засукани колекции (структури от данни) като ArrayList и HashMap.

Основна философия в Java е, че лошо написан код не трябва да бъде пу­скан. Компилаторът хваща проблемите доколкото е възможно, но по­ня­кога проблемите – били те програмни грешки или естествени съ­стоя­ния, възникващи в някои случаи при изпълнение на програмата – мо­гат да бъдат хванати и обработени само по време на изпълнение. Java има exception handling да се разправя с всякакви проблеми, кои­то възникват, когато програмата работи. Тази глава разглежда как клю­човите думи try, catch, throw, throws и finally ра­бо­тят в Java; кога трябва да изхвърлите изключение и какво да пра­ви­те, когато го хванете. В добавка ще видите стандартните изключения в езика, как да създавате собствени, какво става с изключенията в кон­струк­торите и как се намира кодът, който да обработи изключенията.

Теоретично всяка програма прави три неща: вход, обработка и изход. Това предполага, че IO (вход/изход) е доста важна част от темата. В та­зи глава ще видите различни входно-изходни класове които Java има за четене на файлове, блокове памет и конзолата. Разликата меж­ду “стария” IO и “новия” Java 1.1 IO ще бъде показана. В добавка тук ще се покаже вземане на обект, неговия “streaming” (така че да може да бъде пратен на диск през мрежата) и реконструкцията му, което се пра­ви за вас от Java версия 1.1. Също се разглеждат компресираните би­блио­теки на Java 1.1, които се използуват в Java Archive файлов фор­мат (JAR).

Глава 11: Идентификация на типа по време на изпълнение

Идентификацията на типа по време на изпълнение в Java (RTTI) ви да­ва възможност да установите точния тип на обекта, ако само имате до­стъп до базовия тип. Нормално ще се стремите да не се занимавате с конкретни типове и ще оставите полиморфизмът (който е вграден в ези­ка) да върши това. Но понякога е много полезно да може да узна­ете конкретния тип на обекта. Често тази информация позволява да се на­правят някои специални операции по-ефективни. Тази глава обяс­ня­ва за какво е RTTI, как да се използва и как да се отървем от него, ко­га­то вече не е необходимо. В добавка се разглежда рефлексията - чер­та на Java 1.1.

Доколкото единствения начин да комуникирате с обектите в езика е чрез “handles,” концепцията за предаване на обект като параметър на функ­ция и връщането на обект като резултат от функция има инте­рес­ни продължения. Тази глава обяснява как да управлявате обекти ко­га­то влизате или излизате от функция и също показва класа String кой­то използува различен подход към проблема.

Java идва със “Swing” GUI библиотеката, която е множество от кла­со­ве, които поддържат създаването и управлението на прозорци по пре­но­сим начин; тези програми могат да бъдат както аплети, така и са­мо­стоя­телни програми. Тази глава е въведение в Swing създаване на апле­ти за World Wide Web. Важната “Java Beans” технология е въ­ве­де­на. Тя е от основно значение за създаване на Rapid-Application De­ve­lop­ment (RAD) инструменти за създаване на програми.

Java има възможност да изпълнява едновременно няколко подзадачи в рамките на една програма, наречени нишки. (Докато нямате няколко про­цесора във вашата инсталация само изглежда че се работят едно­вре­­менно.) Въпреки че могат да се използуват навсякъде, нишките са най-полезни например в случай, че искате да направите потребителски интер­фейс такъв, че да може да се натискат клавиши или въвеждат дан­ни докато се изпълнява някакъв друг конкретен процес. Тази глава по­глежда и към синтаксиса и семантиката на многонишковостта в Java.

Всички черти на Java и библиотеките сякаш се обединяват когато за­поч­нете да разработвате програми за работа в мрежи. Тази глава из­след­ва комуникациите по Мрежата и класовете, които езикът доставя за улеснение на тази работа. Тук също се разглежда как да се създаде Java аплет кайто да взаимодейства с common gateway interface (CGI) про­грама, показва как да се пишат CGI програми на C++, обхваща Java DataBase Connectivity (JDBC) и Remote Method Invocation (RMI) в Java 1.1.

Глава 16: Шаблони

Тази глава въвежда много важния и още не традиционен подход с “ша­блони”. Изучава се примерна еволюция на процеса на проек­ти­ра­не, започвайки от начално състояние и движейки се през логиката и при­движвнето на проекта до по-подходящи състояния на разработка. Ще видите начин, който разработката може да материализира с те­че­ние на времето.

Таза глава включва проекти, които са свързани с материала от цялата кни­га или по някаква друга причина не са могли да бъдат включени м по-ранните глави. Тези проекти са значително по-сложни от оста­на­ли­те примери в главите и често демонстрират допълнителни черти и тех­ни­ки на езика и библиотеките.

Има теми, които не могат да се включат в никоя глава. Те са засегнати в приложенията.

Приложение A:Използване на не-Java код

Една напълно преносима Java програма има сериозни недостатъци: ско­ростта и невъзможността да се използуват специфични за дадена плат­форма услуги. Когато платформата е известна, възможно е дра­ма­тич­но да се ускорят някои операции, като се направят native methods, кои­то са функции, написани на друг програмен език (в момента се под­държат само C/C++). Има и други пътища Java да поддържа не-Java код, включително CORBA. Това приложение прави достатъчно въ­веждане във въпроса, така че да може да се построят прости про­гра­ми, които взаимодействат с не-Java код.

Ако сте C++ програмист вие вече имате основната идея за обектно-ориен­тираното програмиране и несъмнено синтаксисът на Java ви е до­ста познат. Това има смисъл понеже Javaпроизлезе от C++. Има оба­че изненадващо много разлики между C++ и Java. Тези разлики са на­правени с намерение да се подобри езикът и ако ги разберете, вие ще знаете защо новият език е така успешен. Това приложение ви води през основните черти, които правят Java различен от C++.

Това приложение съдържа правила, които да ви помагат при разработ­ва­нето на проекти на ниско ниво и писането на код.

Това ще ви помогне да намерите причините за задръствания и да по­ви­­­шите скоростта на изпълнение на програмите си.

Тази глава описва операциите и подходите при освобождаването на па­метта, заета от вече ненужни обекти.

Списък на книги за Java които смятам, че биха били полезни.