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

Резюме

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

В тази глава видяхме как класовете изграждат библиотеки; първо начинът по кой­то група класове се пакетира в библиотека и второ начинът по който се управ­­лява достъпът до класовете.

Оценено е че програмен проект на C започва да се проваля някъде между 50K и 100K реда големина понеже C има едно общо “пространство на имената”, така че започват колизии, причиняващи проблеми с управлението на проекта. В Java клю­човата дума package, схемата за имената на пакетите и ключовата дума import позволяват пълен контрол на имената, така че въпросът за колизиите на име­ната лесно се заобикаля.

Има две причини да се управлява достъпът до членовете. Първата е да се дър­жи клиентът далеч от нещата, които не прябва да пипа; инструментите които са необ­ходими за вътрешните механизми на данновия тип, но не са част от ин­тер­фей­са използван от потребителя. Така че правенето на методи и полета private е в служба на потребителя, който с това знае кое му трябва и не се занимава с дру­гото. Това опростява и разбирането на класа.

Втората и по-важна причина е да се даде възможност на проектантът на би­блио­теката да промени вътрешностите без да се притеснява как това ще се от­ра­зи на приложните програми. Може да сте построили класа по един начин от­на­чало и после да сте открили, че реконструкция на кода ще даде много по-голя­ма скорост. Ако интерфейсът и реализацията са добре разделени и за­щи­те­ни, това може да се направи без да се кара потребителят да пренапише своя код.

Спецификаторите на достъпа в Java дават ценни възможности за управление на съз­дателя на класа. Потребителите на класа виждат точно какво да използват и как­во могат да игнорират. По-важното, по-нататък, е че може да се осигури не­за­висимост на потребителите от реализацията на класа. Ако знаете това като съз­дател на класове, може да променяте подлежащата реализация понеже е си­гурно, че това няма да засегне потребителите — те нямат достъп до тази част въоб­ще.

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

Public интерфейса на клас се вижда от потребителя, така че тази част е най-важ­но да се направи както трябва по време на анализа и проектирането. Даже и то­ва дава възможност за промени. Ако не стане интерфейсът изведнъж, може да до­бавите методи, само няма да махате — тъй като може клиентът да ги е из­полз­вал.

Упражнения

1. 
   Създайте клас с public, private, protected, и “приятелски” членове-данни и ме­тоди. Създайте обекти и вижте какви съобщения от компилатора ще по­лу­чи­те като се опитате да използвате всевъзможните членове. Помнете че кла­со­вете в една директория са част от “пакет по подразбиране”.
   
2. 
   Създайте клас с данни protected. Създайте друг клас в същия файл който ма­ни­пулира protected данните в първия клас.
   
3. 
   Създайте нова директория и редактирайте вашия CLASSPATH за да я вклю­чи­те. Копирайте P.class файла там и после сменете имената на файла, на P кла­са вътре и имената на методите. (Бихте могли да добавите оператори за из­веждане за да проследите работата.) Създайте друга програма в друга ди­рек­тория която използва вашия клас.
   
4. 
   Съъздайте следния файл в c05 директорията (предполага се че е на вашия CLASSPATH):
   

package C05;

class PackagedClass {

public PackagedClass() {

System.out.println(

"Creating a packaged class");

}

} ///:~

///: c05:foreign:Foreign.java

package C05.foreign;

import C05.*;

public class Foreign {

public static void main (String[] args) {

PackagedClass pc = new PackagedClass();

}

} ///:~

6: Многократно използване на класове

Една от най-привлекателните черти на Java е мно­го­крат­но­то използване на кода. Но за да бъде революционно, тряб­ва да можем много повече отколкото да копираме код и леко да го променяме.

Това последното е подходът в процедурните езици като C и то не работи много до­бре. Както всичко в Java, решението се върти около класовете. Пре-из­полз­ва­те кода чрез създаване на нови класове, но наместо да ги създавате изцяло на­но­во, използвате съществуващи класове които някой вече е създал и тествал.

Трикът е да се използва съществуващ код без да се пипа. В тази глава ще видите два начина да се стори това. Първият е съвсем праволинеен: Просто създавате обек­ти от съществуващ клас вътре в даден клас. Това се нарича композиция по­не­же новият клас е композиран от старите. Просто използвате функ­цио­нал­ност­та на кода, не формата му.

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

Оказва се, че повечето синтаксис и повезение са еднакви за композицията и на­сле­дяването (нищо чудно, понеже те са начини за добиване на нов тип от съ­ще­ству­ващ). В тази глава ще научите за тези механизми за повторно използване на код.

Каталог: Java
Java -> Лекция Изключения. Уравнение на КортевегДеВриз
Java -> Създаване на прозорци и аплети
Java -> Лекция 2 Типове данни. Класове и обекти. Числено интегриране
Java -> Национална академия по разработка на софтуер
Java -> Java за цифрово подписване на документи в уеб
Java -> Запознаване с JavaScript. Запознаване с Java Script
Java -> Програма за изчисляване на средна стойност

Изтегляне 13.53 Mb.

Сподели с приятели: