Секреты программирования для Internet на Java

примитивных типов ни на что не указывают, а просто содержат в себе соответствующие данные, имеющие определенный фиксированный размер.

СОВЕТ Как вы можете видеть, ссылочные типы очень похожи на указатели, применяющиеся в С/С++. Однако есть и серьезные отличия. Во-первых, используя ссылочные типы, вы не можете получить доступ к фактическим адресам данных в памяти. А во-вторых, невозможность получить доступ к адресу в памяти в языке Java означает, что в этом языке полностью отсутствует арифметика указателей.

Примитивные типы

Сначала рассмотрим примитивные типы языка Java. С одним из этих типов - типом int - мы уже познакомились выше на конкретном примере. Всего в языке Java определено восемь примитивных типов, которые перечислены в табл. 2-4.

Первые шесть типов из перечисленных в таблице предназначены для хранения численных значений. С переменными этих типов вы можете использовать знаки операций +, -, *и /, предназначенные соответственно для сложения, вычитания, умножения и деления. Полностью синтаксис записи выражений, содержащих числовые значения, приведен в главе 4. По большей части правила этого синтаксиса аналогичны правилам языка С. Давайте рассмотрим подробнее булевский тип, который в явном виде отсутствует во многих других языках программирования. Вот как осуществляется присвоение значения булевской переменной.

Пример 2-6. Присвоение значения булевской переменной. boolean truth=true;

System.out.println(truth); boolean fallicy=false; System.out.println(fallicy); truth=(1==1); fallicy=(1==0); System.out.println(truth); System.out.println(fallicy);

Если мы поместим этот фрагмент кода в метод main из примера 2-1, то вывод программы будет иметь следующий вид:

true false true false

Как видите, булевским переменным можно присваивать результат операции сравнения. В языке Java знаки операций !, != и == работают с булевскими значениями так же, как одноименные операторы работают с целочисленными значениями в языке С. Полное описание синтаксиса и семантики для булевского типа, как и для остальных примитивных типов, вы найдете в главе 4.

www.books-shop.com

средство организации содержимого - данных и алгоритмов каждой программы. Но классы могут также использоваться и для определения новых типов. Переменные типов, определенных через классы, называются объектами, реализациями или экземплярами соответствующих классов.

Создание, или реализация, объекта осуществляется с помощью того же оператора new, а доступ к членам (составным частям) класса - с помощью оператора "точка" (.).

Пример 2-7b. Реализация объекта. public class RunMe {

public static void main(String ARGV[]) { MyType Mine=new MyType();

int i=Mine.myDataMember; Mine.myMethodMember();

}

}

Пример 2-7 иллюстрирует три основных вида действий, которые можно производить с объектом: создание объекта, доступ к членам-переменным объекта и доступ к членам-методам этого объекта. Последняя строчка кода в этом примере вызывает метод myMethodMember, который выводит на экран следующее:

I'm a member! myData=4

Поскольку тип myDataType является ссылочным типом, мы должны использовать оператор new. Этот оператор запрашивает у системы определенное количество памяти для хранения нашего объекта. Кроме того, мы можем определить, какие еще действия должны выполняться в момент реализации класса, определив так называемый конструктор (constructor). Вот как выглядит конструктор для типа myDataType, единственная функция которого - сообщить о том, что происходит реализация класса.

Пример 2-8a. Конструктор, сообщающий о реализации класса. public class MyType {

int myDataMember=0; public MyType() {

System.out.println("Instantiation in process!");}

}

Конструкторы можно использовать также для инициализации (присвоения начальных значений) членов-переменных данного класса. Вот пример конструктора, который присваивает переменной myDataMember целочисленное значение, переданное этому конструктору через аргумент.

Пример 2-8b. Конструктор, который инициализирует значение переменной, входящей в класс. public MyType(int val) {

System.out.println("setting myDataMember="+val); myDataMember=val;}

Теперь представим, что оба приведенных выше конструктора определены в нашем классе myDataType. Вот еще один фрагмент программы, в котором используются оба эти конструктора.

Пример 2-8c. Программа, использующая оба этих конструктора. public class RunMe {

public static void main(String ARGV[]) { MyType instance1=new MyType(); MyType instance2=new MyType(100);

}

}

Вывод этой программы будет иметь следующий вид:

Instantiation in progress! I'm a member! myDataType=4

setting myDataType=100 I'm a member!

www.books-shop.com

myDataType=100

Стандартные типы, определенные пользователем

Работая с определенными пользователем типами, вы должны помнить одну важную вещь: название этих типов совсем не подразумевает, что каждый пользователь должен сам определять для себя все типы, которые ему понадобятся. В состав JDK входят десятки готовых классов, которые вы можете использовать в своих программах. По сути дела изучение Java по большей части сводится к знакомству с этими предопределенными классами и изучению их свойств и применимости. Эти стандартные классы входят в интерфейс прикладного программирования

(Application Programming Interface, API). Подробнее мы будем говорить об API в главе 6.

Тип String

До сих пор мы говорили о примитивных типах и о типах, определенных пользователем. Теперь рассмотрим один особый тип, который представляет собой гибрид этих двух типов, - тип String (тип строковых переменных). В основе своей тип String является типом, определенным пользователем, так как он определяется как одноименный класс String, содержащий в себе методы и переменные. Но в то же время этот тип проявляет некоторые свойства примитивного типа, что выражается, в частности, в том, как осуществляется присвоение значений переменным этого типа.

String myString="Hello!";

Несмотря на то, что такой способ объявления и инициализации переменных типа String является не совсем законным с точки зрения синтаксиса типов, определенных пользователем, нельзя не признать, что для такого часто встречающегося в программировании объекта, как строки символов, этот способ является самым очевидным и удобным. Кроме того, для конкатенации (сложения) двух строк можно использовать знак операции +.

int muInt=4;

String anotherString=myString+"myInt is "+myInt;

После выполнения указанных действий значение переменной anotherString будет "Hello! myInt is 4". Однако поскольку anotherString является в то же самое время и объектом, мы можем вызывать методы - члены класса String. Так, чтобы вырезать первые пять символов строки anotherString, нужно написать следующее выражение:

String helloString=anotherString.substring(5);

Как видите, реализация переменных типа String не требует применения оператора new. С точки зрения практики программирования это очень удобно, поскольку строковые переменные используются очень часто. Однако, программируя на языке Java, вы всегда должны помнить о том, что тип String является особым - это единственный определенный пользователем тип, переменные которого могут объявляться и использоваться без применения оператора new.

Типы массива

Типы массива используются для определения массивов - упорядоченных наборов однотипных переменных. Вы можете определить массив над любым существующим в языке типом, включая типы, определенные пользователем. Кроме того, можно пользоваться массивами массивов или многомерными массивами (об этом см. в главе 4, "Синтаксис и семантика"). Коротко говоря, если мы можем создать переменную некоторого типа, значит, мы можем создать и массив переменных этого типа. Вместе с тем создание массивов в языке Java может показаться вам непривычным, так как оно требует применения оператора new.

Пример 2-9a. Выделение памяти для массива целых чисел myIntArray[]. int myIntArray[];

myIntArray=new int[3]; MyType myObjectArray[]; myObjectArray=new MyType[3];

Оператор new дает команду оболочке времени выполнения выделить необходимое количество памяти под массив. Как видно из этого примера, необязательно объявлять размер массива тогда же, когда вы создаете переменную-массив. После того как вы создали массив оператором new, доступ к этому массиву осуществляется точно так же, как в языках С или Паскаль.

Пример 2-9b. Присвоение значений элементам массива myIntArray[]. myIntArray[0]=0;

myIntArray[1]=1;

myIntArray[2]=2;

www.books-shop.com

myObjectArray[0]=new MyType(); myObjectArray[1]=new MyType(); myObjectArray[2]=new MyType(); myObjectArray[0].myDataMember=0; myObjectArray[1].myDataMember=1; myObjectArray[2].myDataMember=2;

Массивы в языке Java имеют три важных преимущества перед массивами в других языках. Вопервых, как вы только что видели, программисту необязательно указывать размер массива при его объявлении. Во-вторых, любой массив в языке Java является переменной - а это значит, что его можно передать как параметр методу и использовать в качестве значения, возвращаемого методом (подробнее об этом преимуществе мы будем говорить в следующем разделе, посвященном методам). И в-третьих, не составляет никакого труда узнать, каков размер данного массива в любой момент времени. Например, вот как определяется размер массива, который мы объявили выше.

Пример 2-9c. Получение длины массива. int len=myIntArray.length;

System.out.println("Length of myIntArray="+len);

Методы

Метод в языке Java представляет собой подпрограмму, аналогичную функциям языков С и Паскаль. Каждый метод имеет тип возвращаемого значения и может вызываться с передачей некоторых параметров.

Для простоты все методы, которые мы будем использовать в наших примерах, будут объявлены статическими (static). Модификатор static, как и другие модификаторы методов, влияет на то, как будет вести себя данный метод в объектно-ориентированной программе (подробнее об этом ниже).

Для начала давайте разберемся с синтаксисом объявления метода. Модификаторы, если они есть, предшествуют указанию типа возвращаемого значения, за которым следует имя метода и список параметров в круглых скобках. Следующее затем тело метода заключено в пару фигурных скобок:

<модификаторы_метода> тип_возвращаемого_значения имя_метода (<параметры)> { тело_метода

}

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

Ниже мы рассмотрим вопросы, связанные со значениями, возвращаемыми методами, и с передачей параметров методам. В конце раздела мы познакомимся с особым свойством языка Java, которое называется совмещением методов (method overloading), благодаря которому можно давать одно и то же имя нескольким методам, различающимся между собой списком принимаемых параметров.

Возвращаемые значения

С каждым методом должен быть соотнесен тип возвращаемого им значения. Тип void, который был приписан нашему методу main в примерах этой главы, является специальным способом указать системе, что данный метод не возвращает никакого значения. Методы, возвращаемый тип которых объявлен с помощью ключевого слова void, аналогичны процедурам языка Паскаль. Методы, у которых возвращаемое значение принадлежит к любому другому типу, кроме void, должны содержать в своем теле оператор return. Возвращаемое значение может принадлежать к любому из типов, о которых мы говорили в разделе "Переменные", - включая как примитивные типы, так и типы, определенные через класс. Ниже приведены примеры методов, не возвращающих никакого значения, и методов, возвращающих значение определенного типа.

Пример 2-10. Вызов методов. public class MethodExamples{ static void voidMethod() {

System.out.println("I am a void method");

www.books-shop.com

}

static int returnInt() { int i=4;

System.out.println("returning 4"); return i;}

static public final void main(String S[]) { System.out.println("Hello, methods!"); System.out.println("Calling a void method"); voidMethod();

int ans=returnInt(); System.out.print("method says -.-"); System.out.println(ans);

}

}

Как вы, вероятно, заметили, вызов методов в этом примере осуществлялся точно так же, как мы вызывали бы функции или процедуры в другом, не объектно-ориентированном языке. Это связано с тем, что в нашем примере статические методы вызывали другие статические методы, принадлежащие к тому же классу. То же самое верно и для тех случаев, когда нестатические (динамические) методы вызывают другие динамические методы. Однако когда динамические методы вызывают статические методы и, наоборот, когда возникает необходимость вызвать метод из другого класса, синтаксис вызова меняется. Об этих изменениях мы поговорим в следующем разделе.

Передача параметров

В качестве параметров в языке Java можно передавать переменные любого типа, включая типы, определенные через классы, и массивы переменных любого типа и размера. Однако переменные примитивных типов, передаваемые в качестве параметров, ведут себя иначе, чем переменные ссылочных типов в том же контексте. Сначала рассмотрим передачу переменных примитивных типов.

Все переменные примитивных типов передаются методам по значению (by value). Это означает, что в момент вызова метода делается копия переменной, передаваемой методу. Если метод будет изменять в своем теле значение переданной ему в качестве параметра переменной, то содержимое исходной переменной изменяться не будет, так как все действия будут производиться с ее копией. Проиллюстрируем это примером.

Пример 2-11. Передача в качестве параметров переменных примитивных типов. class ParameterExample {

static int addFour(int i) { i=i+4;

System.out.println("local copy of i="+i); return i;}

public final static void main(String S[]) { System.out.println("Hello, parameter passing!"); int i=10;

System.out.print("Original value of i="+i); int j=addFour(i); System.out.println("value of j="+j);

System.out.println("Current value of i="+i);

}

}

Вывод этой программы имеет следующий вид:

Hello, parameter passing! Original value of i=10 value of j=14

Current value of i=10

www.books-shop.com

Как видите, значение переменной i не изменилось, хотя метод addFour прибавил к значению своего параметра 4. Напротив, значения переменных ссылочного типа, переданных в качестве параметров, можно изменить в теле метода. Рассмотрим пример с массивом целых чисел.

Пример 2-12. Передача в качестве параметра переменной ссылочного типа. public class ReferenceParameterExample {

static void changeArray(int referenceVariable[]) { referenceVariable[2]=100;}

public static void main(String ARGV[]) { int anArray[]=new int[3]; anArray[2]=10; System.out.println("anArray[2]="); System.out.println(anArray[2]); changeArray(anArray); System.out.println(anArray[2]);}

}

Вывод программы выглядит так:

anArray[2]=

10

100

Когда мы передаем методу в качестве параметра переменную ссылочного типа, мы явным образом меняем то, на что указывает эта переменная, - в нашем случае массив целых чисел.

Строковые переменные и передача параметров

Несмотря на то, что тип String является определенным пользователем типом, он не ведет себя как ссылочный тип при передаче параметров. Переменные типа String в качестве параметров метода всегда передаются по значению, - то есть передав методу строковую переменную, вы в теле метода будете фактически работать с копией этой строковой переменной. Другими словами, изменение значения строковой переменной в теле метода не влияет на значение этой же переменной снаружи метода.

Совмещение методов

Вы наверняка сталкивались с необходимостью создавать две или несколько функций, выполняющих, по сути, одни и те же действия, но имеющих различные списки параметров. Язык Java дает в таких ситуациях более изящный выход из положения. В этом языке вы можете присвоить одно и то же имя нескольким методам, которые различаются списками своих параметров. Например, пусть у нас есть метод, предназначенный для сравнения двух целых чисел.

Пример 2-13a. Сравнение двух целых чисел.

public static String compareNums(int i, int j) { if (i==j) {

return "Numbers "+i+" and "+j+" are equal";} if (ij) {

return "Number "+i+" greater than "+j;} return "Number "+j+" greater than "+i;

}

Теперь представьте, что нам в программе понадобилось сравнить не два, а три целых числа. Конечно, можно было бы определить для этого новый метод с именем типа compareThreeNums. Но, к счастью, язык Java позволяет обойтись без умножения количества имен в программе.

Пример 2-13b. Совмещение метода с дополнительными параметрами. public static String compareNums(int i, int j, int k) {

String S=compareNums(i,j); S=S+"\n"; S=S+compareNums(i,k); return S;}

www.books-shop.com

Составляя каждый раз иной список параметров, мы таким образом можем определить любое количество методов с одним и тем же именем compareNums. Это становится особенно удобным в тех случаях, когда требуется произвести одно и то же действие над переменными разных типов. Как вы узнаете из главы 4, Java не позволяет передавать, к примеру, переменные типа double методу, параметры которого имеют тип int. Однако ничто не мешает нам прибегнуть к совмещению, определив еще один метод с тем же именем и со списком параметров типа double (или любого другого типа).

Пример 2-13c. Совмещение метода с параметрами другого типа.

public static String compareNums(double i, double j, double k)

{

if (i==j) {

return "Numbers "+i+" and "+j+" are equal";} if (i>j) {

return "Number "+i+" greater than "+j;} return "Number "+j+" greater than "+i;

}

Выгоды совмещения методов особенно очевидны для тех, кому приходится этими методами пользоваться: вместо того чтобы помнить несколько имен разных методов, можно ограничиться запоминанием только одного имени, общего для методов с разными параметрами. В обязанности компилятора входит выяснение того, какой именно метод требуется вызвать в каждом случае.

Пример 2-13d. Вызов совмещенных методов. public static void main(String ARGV[]) {

int a=3; int b=4; int c=5;

double d=3.3; double e=4.4; double f=5.5;

String S=compareNums(a,b); System.out.println(S); S=compareNums(a,b,c); System.out.println(S); S=compareNums(d,e,f); System.out.println(S);}

}

Классы

Теперь настало время заполнить некоторые пробелы в том, что вы уже знаете о классах. Как вы помните, наше знакомство с классами началось с того, что классы могут содержать в себе переменные и методы. В примерах, с которыми мы до сих пор имели дело, этого простейшего объяснения было вполне достаточно. Однако, с другой стороны, классы лежат в фундаменте объектно-ориентированных свойств языка Java, и теперь мы рассмотрим их с этой стороны.

Статические и динамические члены

Когда выше шла речь о переменных, мы видели, что с помощью классов можно определять новые типы. Теперь пора выяснить, что же означает модификатор static, который использовался в объявления методов в наших примерах. До сих пор мы использовали этот модификатор только при определении методов, поэтому сначала мы познакомимся с той стороной значения ключевого слова static, которая имеет прямое отношение к методам. Как вы увидите ниже, модификатор static может также использоваться с переменными, но при этом он имеет иное значение, нежели с методами.

Если в определении метода не использовать ключевое слов static, то этот метод будет по умолчанию динамическим (dynamic). Динамические методы и переменные всегда являются членами объектов, и доступ к ним осуществляется через переменную-объект. Напротив, статические методы не могут быть членами объектов. В табл. 2-5 указан синтаксис вызова динамических и статических методов.

Таблица 2-5. Синтаксис вызова динамических и статических методов

www.books-shop.com

Динамический никакого (по умолчанию) объект.имя метода (список параметров) Статический static имя класса.имя метода (список параметров)

Проиллюстрируем это примером.

Пример 2-14a. Определение статических и динамических методов. public class StaticVsDynamic {

int i=0;

public static void staticMethod(int j) { System.out.println("A static method"); System.out.println("j="+j);

}

// динамические методы

public void setInt(int k) { i=k;

System.out.println("setting i to "+k);

}

public int returnInt() { return i;}

}

Класс, определенный в этом примере, включает в себя один статический и один динамический метод. При этом статический метод не знает о существовании динамических членов класса setInt, returnInt и i. Вот как будет выглядеть первичный класс, иллюстрирующий различный синтаксис вызова статических и динамических методов.

Пример 2-14b. Вызов статических и динамических методов. public class RunMe {

public static void main(String S[]) { int i=0; StaticVsDynamic.staticMethod(10);

// чтобы вызвать статический метод, не обязательно создавать объект

StaticVsDynamic A=new StaticVsDynamic();

//прежде чем вызывать динамический метод, требуется реализовать

экземпляр

//объекта

A.setInt(20);

System.out.println("A.i = "+A.returnInt());

}

}

Модификатор static и метод main

Теперь вам должно быть понятно, почему модификатор static всегда присутствует в объявлении метода main. Дело в том, что, когда мы вводим команду "java primaryClass", оболочка времени выполнения языка Java загружает класс primaryClass в память в виде типа, а не в виде объекта. После этого оболочка просто вызывает метод main в виде "primaryClass.main (S)", где S - массив параметров командной строки.

Кроме того, модификатор static можно использовать при объявлении переменных. Синтаксис обращения к переменной похож на правила вызова функции:

<имя класса>.<имя переменной> Поскольку все методы и переменные должны принадлежать к какому-то классу, модификатор

static используется для указания на те методы и переменные, которые не играют роль части объекта. Это делает их в какой-то мере эквивалентными глобальным подпрограммам и переменным в каком-нибудь не объектно-ориентированном языке - за тем исключением, что мы все-таки должны знать имя класса, в котором они содержатся, чтобы получить к ним доступ.

Доступ к членам класса

Java позволяет контролировать доступ к методам и переменным, входящим в тот или иной класс. До сих пор все члены классов, которые мы объявляли, были общедоступными (public). Модификатор public указывает на то, что значение данной переменной можно изменять из любого места нашей программы. Однако существует возможность ограничить доступ к методам и переменным с помощью модификаторов, перечисленных в табл. 2-6.

www.books-shop.com