Содержание
Методы класса Java.lang.Integer
Метод | Модификатор и Тип | Описание |
---|---|---|
bitCount(int i) | static int | Возвращает количество однобитовых двоичных данных в двоичном коде дополнения, представляющего указанное значение типа int. |
byteValue() | byte | Возвращает значение этого целого числа в байтах. |
compare(int x, int y) | static int | Сравнивает два значения int численно. |
compareTo(Integer anotherInteger) | int | Численно сравнивает два объекта Integer. |
decode(String nm) | static Integer | Декодирует строку в целое число. |
doubleValue() | double | Возвращает значение этого Integer как double. |
equals(Object obj) | boolean | Сравнивает этот объект с указанным объектом. |
floatValue() | float | Возвращает значение этого целого числа как число с плавающей точкой. |
getInteger(String nm) | static Integer | Determines the integer value of the system property with the specified name. |
hashCode() | int | Возвращает хеш-код для этого Integer. |
intValue() | int | Возвращает значение этого целого числа в виде целого числа. |
longValue() | long | Возвращает значение этого Integer как long. |
lowestOneBit(int i) | static Int | Возвращает значение типа int, содержащее не более одного бита, в позиции младшего бита («самого правого») в указанном intvalue. |
reverse(int i) | static Int | Возвращает значение, полученное путем изменения порядка битов в двоичном представлении дополнения до двух указанных значений int. |
reverseBytes(int i) | static Int | Возвращает значение, полученное путем изменения порядка следования байтов в представлении дополнения до двух указанных значений int. |
shortValue() | short | Возвращает значение этого целого числа в виде short. |
toString() | String | Возвращает объект String, представляющий значение этого целого числа. |
toString(int i) | static String | Возвращает объект String, представляющий указанное целое число. |
valueOf(int i) | static Integer | Возвращает экземпляр Integer, представляющий указанное значение типа int. |
valueOf(String s) | static Integer | Возвращает объект Integer, содержащий значение указанной строки. |
Объекты как параметры методов
Последнее обновление: 19.04.2018
Объекты классов, как и данные примитивных типов, могут передаваться в методы. Однако в данном случае есть одна особенность — при передаче объектов в качестве значения передается копия ссылки на область в памяти, где расположен этот объект. Рассмотрим небольшой пример. Пусть у нас есть следующий класс Person:
public class Program{ public static void main(String[] args) { Person kate = new Person("Kate"); System.out.println(kate.getName()); // Kate changeName(kate); System.out.println(kate.getName()); // Alice } static void changeName(Person p){ p.setName("Alice"); } } class Person{ private String name; Person(String name){ this.name = name; } public void setName(String name){ this.name = name; } public String getName(){ return this.name; } }
Здесь в метод changeName передается объект Person, у которого изменяется имя. Так как в метод будет передаваться копия ссылки на область памяти, в которой находится объект Person, то переменная kate и параметр p метода changeName будут указывать на один и тот же объект в памяти. Поэтому после выполнения метода у объекта kate, который передается в метод, будет изменено имя с «Kate» на «Alice».
От этого случая следует отличать другой случай:
public class Program{ public static void main(String[] args) { Person kate = new Person("Kate"); System.out.println(kate.getName()); // Kate changePerson(kate); System.out.println(kate.getName()); // Kate - изменения не произошло // kate хранит ссылку на старый объект } static void changePerson(Person p){ p = new Person("Alice"); // p указывает на новый объект p.setName("Ann"); } static void changeName(Person p){ p.setName("Alice"); } } class Person{ private String name; Person(String name){ this.name = name; } public void setName(String name){ this.name = name; } public String getName(){ return this.name; } }
В метод changePerson также передается копия ссылки на объект Person. Однако в самом методе мы изменяем не отдельные значения объекта, а пересоздаем объект с помощью конструктора и оператора new. В результате в памяти будет выделено новое место для нового объекта Person, и ссылка на этот объект будет привоена параметру p:
static void changePerson(Person p){ p = new Person("Alice"); // p указывает на новый объект p.setName("Ann"); // изменяется новый объект }
То есть после создания нового объекта Person параметр p и переменная kate в методе main будут хранить ссылки на разные объекты. Переменная kate, которая передавалась в метод, продолжит хранить ссылку на старый объект в памяти. Поэтому ее значение не меняется.
НазадВперед
Примеры
package Edureka; import java.io.*; import java.util.*; public class javaIntegerExamples{ public static void main(String args[]) { int value = 161; // Get the binary equivalent System.out.println("Binary equivalent:"+Integer.toBinaryString(value)); System.out.println("Bit Count:"+Integer.bitCount(value)); //example for byteValue() int Value1=123; Integer a = new Integer(Value1); System.out.println("Byte Value is "+a.byteValue()); //compare two integer values System.out.println(Integer.compare(20, 20)); System.out.println(Integer.compare(20, 19)); System.out.println(Integer.compare(20, 22)); //compare two integers Integer value2 = new Integer(50); System.out.println(value2.compareTo(50)); System.out.println(value2.compareTo(49)); System.out.println(value2.compareTo(51)); //decode the string System.out.println(Integer.decode("0124")); //base8 System.out.println(Integer.decode("0x124")); //base16 } }
Обычный внутренний класс
Внутренний класс определяется в области действия внешнего класса.
Чтобы создать объект внутреннего класса, должен существовать объект внешнего класса.
Внутренний и внешний класс имеют доступ ко всем членам класса друг друга (даже ).
Следующий пример демонстрирует объявление обычного внутреннего класса:
Внутри метода внешнего класса, объект внутреннего класса создается как обычно:
Если мы создаем объект внутреннего класса не в методах внешнего класса или в статических методах внешнего класса, необходимо использовать объект внешнего класса:
или
Если необходимо получить ссылку на внутренний класс во внутреннем классе, используем слово :
Если необходимо получить ссылку на объект внешнего класса, запишите имя внешнего класса, за которым следует точка, а затем ключевое слово :
Обычный внутренний класс является таким же членом внешнего класса, как и переменные и методы. Следующие модификаторы могут быть применены к обычному внутреннему классу:
- – но преобразует его во вложенный класс
Если метод описан как (явно либо неявно), то JVM гарантирует, что результаты вычисления выражений с и в пределах метода будут одинаковыми на всех платформах. Модификатор для класса и интерфейса указывает на то, что все методы класса/интерфейса будут .
Ключевое слово static
При создании объектов каждый объект получает свой отдельный набор переменных экземпляров. Если же нужно сделать какую-то переменную общей для всех экземпляров, то используется ключевое слово static .
Пример:
Goblin.java
Java
class Goblin { static int idCounter = 0; int id;
Goblin() { idCounter++; id = idCounter; } }
1 2 3 4 5 6 7 8 9 |
classGoblin{ staticintidCounter=; intid; Goblin(){ idCounter++; id=idCounter; } } |
В таком классе Goblin переменная idCounter одна, общая для всех экземпляров. Для всех экземпляров этого класса значение этой переменной будет всегда одно и то же, благодаря чему каждый экземпляр класса будет получать в поле id уникальное значение, большее значения поля id предыдущего экземпляра. Переменная idCounter называется статическим свойством/полем или переменной класса и относится к классу, а не к его экземплярам.
Обратиться к статическому свойству можно либо через имя класса, либо через имя экземпляра, однако рекомендуется всегда обращаться к статическим свойствам через имя класса, чтобы подчеркнуть, что оно относится именно к классу:
Java
System.out.println(«idCounter=» + Goblin.idCounter); // предпочтительно Goblin goblin = new Goblin(); System.out.println(«idCounter=» + Goblin.idCounter); // предпочтительно System.out.println(«idCounter=» + goblin.idCounter);
1 2 3 4 |
System.out.println(«idCounter=»+Goblin.idCounter);// предпочтительно Goblin goblin=newGoblin(); System.out.println(«idCounter=»+Goblin.idCounter);// предпочтительно System.out.println(«idCounter=»+goblin.idCounter); |
Статическое свойство может тоже иметь модификаторы private , protected или public.
Модификатор static можно применить к методу, тогда он будет статическим и его можно будет вызывать через имя класса:
Java
static int getIdCounter() { return idCounter; }
1 2 3 |
staticintgetIdCounter(){ returnidCounter; } |
Пример вызова:
Java
int x = Goblin.getIdCounter();
1 | intx=Goblin.getIdCounter(); |
Статические методы можно вызывать и через имя экземпляра, но рекомендуется всегда вызывать их через имя класса, так как они относятся именно классу.
К статическим методам и свойствам можно обратиться даже тогда, когда ещё нет ни одного экземпляра класса.
Запомните:
- Методы экземпляров могут обращаться к переменным экземпляров (нестатическим свойствам/полям) и методам экземпляров напрямую.
- Методы экземпляров могут обращаться к переменным класса (статическим полям) и методам класса (статическим методам) напрямую.
- Методы классов могут обращаться к методам класса (статическим методам) и переменным класса (статическим свойствам/полям) напрямую.
- Методы классов не могут напрямую обращаться к переменным экземпляров (нестатическим свойствам/полям) и методам экземпляров, и они не могут использовать ключевое слово this , так как для них нет экземпляра класса. Они должны использовать ссылку на какой-нибудь экземпляр.
Объявление полей
Пример объявления полей:
Java
class Goblin { private int money; double health; protected int diamonds = 10; public String name; }
1 2 3 4 5 6 |
classGoblin{ privateintmoney; doublehealth; protectedintdiamonds=10; publicStringname; } |
В этом примере мы объявили четыре поля:
- поле money с типом int ;
- поле health с типом double ;
- поле diamonds с типом int;
- поле name с типом String.
Каждый экземпляр класса Goblin будет иметь своё значение полей money , health , diamonds и name.
В самом начале объявления поля указывается модификатор доступа к полю ( private , protected или public ), либо не указывается, и тогда используется доступ по умолчанию package-private. Затем указывается, если нужно, ключевое слово static (будет объяснено позже), а также, если нужно, ключевое слово final (будет объяснено позже). Затем и имя. Затем поле может сразу инициализироваться начальным значением, например как поле diamonds инициализируется числом 10 в нашем примере.
Модификатор доступа, static и final могут располагаться в любом порядке, но согласно соглашению о кодировании принят именно такой порядок, который описан в статье.
Поле money объявлено с модификатором доступа private, и оно будет доступно только внутри этого класса.
Поле health объявлено без модификаторов доступа, и для него будет использоваться уровень доступа package-private (поле будет доступно только внутри своего пакета).
Поле diamonds объявлено с модификатором доступа protected, и оно будет доступно в этом пакете, этом классе и классах наследниках от этого класса (как объявлять наследников будет объяснено позже).
Поле name объявлено с модификатором доступа public, и оно будет доступно во всех классах всех пакетов.
Модификатор | Класс | Пакет | Дочерний класс | Все классы |
---|---|---|---|---|
Есть | Есть | Есть | Есть | |
Есть | Есть | Есть | Нет | |
без модификатора | Есть | Есть | Нет | Нет |
Есть | Нет | Нет | Нет |
Имя поля следует давать в соответствии с .
Обращаться к полю внутри класса, которому оно принадлежит можно просто по имени поля:
Goblin.java
Java
class Goblin { int ammo = 10; //..
другие поля класса // метод стрельбы public void fire() { // уменьшаем количество пуль. // Обратите внимание, что к полю класса // обращаемся просто по имени ammo —;. // ..
остальной код }
// … остальной код }
// … другие методы }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
classGoblin{
intammo=10;
//..
другие поля класса
// метод стрельбы
publicvoidfire(){
// уменьшаем количество пуль.
// Обратите внимание, что к полю класса
// обращаемся просто по имени
ammo—;
// … остальной код
}
// ..
другие методы
}
Из других классов обращение к полю класса происходит через точку, например:
Java
// Создаём объект GoblinObj Goblin goblinObj = new Goblin();
// Обращение к полю ammo goblinObj.ammo ++;
1 2 3 4 5 |
// Создаём объект GoblinObj Goblin goblinObj=newGoblin(); // Обращение к полю ammo goblinObj.ammo++; |
Имейте в виду, что прямое обращение к полю другого класса является плохим стилем, поскольку оно нарушает принципы ООП. Все обращения должны происходить к методам, которые уже сами меняют значения полей в соответствии с заложенной в них логике.
Также рекомендуется давать всем полям класса самый минимальный из возможных уровней доступа, что означает, что большинство полей класса должны иметь уровень доступа private. Остальные уровни доступа должны даваться отдельным переменным только в том случае, если это действительно нужно.
При объявлении полей можно в одной инструкции объявить несколько полей с одинаковым типом и одинаковыми модификаторами, но согласно соглашению о кодировании так делать не стоит:
Java
// Так делать НЕ рекомендуется int x, y, z; // Объявляем три переменные: x, y, z
1 2 |
// Так делать НЕ рекомендуется intx,y,z;// Объявляем три переменные: x, y, z |
Структура программы
Последнее обновление: 12.04.2018
Основным строительным блоком программы на языке Java являются инструкции (statement). Каждая инструкция выполняет некоторое действие, например, вызовы методов, объявление переменных и присвоение им значений. После завершения инструкции в Java ставится точка с запятой (;). Данный знак указывает компилятору на конец инструкции. Например:
System.out.println("Hello Java!");
Данная строка представляет вызов метода , который выводит на консоль строку «Hello Java!». В данном случае вызов метода является инструкцией и поэтому завершается точкой с запятой.
Кроме отдельных инструкций распространенной конструкцией является блок кода. Блок кода содержит набор инструкций, он заключается в фигурные скобки, а инструкции помещаются между открывающей и закрывающей фигурными скобками:
{ System.out.println("Hello!"); System.out.println("Welcome to Java!"); }
В этом блоке кода две инструкции, которые выводят на консоль определенную строку.
Выполнение программы. Метод main
Java является объектно-ориентированным языком, поэтому всю программу можно представить как набор взаимодействующих между собой классов и объектов. В первой главе при создании первого приложения программа была определена следующим образом:
public class Program{ public static void main (String args[]){ System.out.println("Hello Java!"); } }
То есть основу нашей программы составляет класс Program. При определении класса вначале идет модификатор доступа public, который указывает, что данный класс будет доступен всем, то есть мы сможем его запустить из командной строки. Далее идет ключевое слово class, а затем название класса. После названия класса идет блок кода, в котором расположено содержимое класса.
Входной точкой в программу на языке Java является метод main, который определен в классе Program. Именно с него начинается выполнение программы. Он обязательно должен присутствовать в программе. При этом его заголовок может быть только таким:
public static void main (String args[])
При запуске приложения виртуальная машина Java ищет в главном классе программы метод main с подобным заголовком, и после его обнаружения запускает его.
Вначале заголовка метода идет модификатор , который указывает, что метод будет доступен извне. Слово указывает, что метод main — статический, а слово — что он не возвращает никакого значения. Далее в скобках у нас идут параметры метода — — это массив args, который хранит значения типа String, то есть строки. При запуске программы через этот массив мы можем передать в программу различные данные.
После заголовка метода идет его блок, который содержит набор выполняемых инструкций.
Комментарии
Код программы может содержать комментарии. Комментарии позволяют понять смысл программы, что делают те или иные ее части. При компиляции комментарии игнорируются и не оказывают никакого влияния на работу приложения и на его размер.
В Java есть два типа комментариев: однострочный и многострочный. Однострочный комментарий размещается на одной строке после двойного слеша //. А многострочный комментарий заключается между символами /* текст комментария */. Он может размещаться на нескольких строках. Например:
/* многострочный комментарий Объявление нового класса, который содержит код программы */ public class Program{ // начало объявления класса Program // определение метода main public static void main (String args[]){ // объявление нового метода System.out.println("Hello Java!"); // вывод строки на консоль } // конец объявления нового метода } // конец объявления класса Program
НазадВперед
Ключевое слово final
Это больше относится к наследованию, которое будет рассмотрено в более поздних статьях. Здесь я опишу лишь в общих чертах.
Ключевое слово final может быть применено к локальной переменной, переменной экземпляра или параметру. Оно означает, что значение переменной не будет меняться после инициализации. Если попытаться изменить значение такой переменной, то будет ошибка компиляции.
Goblin.java
Java
class Goblin { final String name;
public Goblin (String name) { this.name = name; // Инициализируем переменную final. }
public void someMethod1(final String secondName) { final String thirdName = «Third»; // Переменные с final менять после инициализации нельзя! this.name = secondName; //Нельзя! Ошибка компиляции. secondName = «3»; // Нельзя! Ошибка компиляции. thirdName = «4»; // Нельзя! Ошибка компиляции. } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
classGoblin{ finalStringname; publicGoblin(Stringname){ this.name=name;// Инициализируем переменную final. } publicvoidsomeMethod1(finalStringsecondName){ finalStringthirdName=»Third»; // Переменные с final менять после инициализации нельзя! this.name=secondName;//Нельзя! Ошибка компиляции. secondName=»3″;// Нельзя! Ошибка компиляции. thirdName=»4″;// Нельзя! Ошибка компиляции. } } |
Переменные final не инициализируются значением по умолчанию. Им обязательно должно быть присвоено какое-нибудь значение, иначе возникнет ошибка компиляции.
Ключевое слово final может применяться к методу, тогда этот метод нельзя переопределять в классах-потомках для методов экземпляров и нельзя скрывать (hide) в классах потомках для случая статических методов (наследование и переопределение метода будет описано в статье про наследование):
Goblin.java
Java
class Goblin {
// Этот метод нельзя переопределять в потомках. public final void myFinalMethod1() { }
// Этот метод нельзя скрывать в потомках. public static final void myFinalMethod2() { } }
1 2 3 4 5 6 7 8 9 10 |
classGoblin{ // Этот метод нельзя переопределять в потомках. publicfinalvoidmyFinalMethod1(){ } // Этот метод нельзя скрывать в потомках. publicstaticfinalvoidmyFinalMethod2(){ } } |
Можно применить final ко всему классу, что означает, что у класса не может быть потомков, то есть будет нельзя наследоваться от этого класса.
Goblin.java
Java
final class Goblin { }
1 2 |
finalclassGoblin{ } |
Модификатор static , применённый совместно с final, к свойствам класса используется для объявления констант. Такое свойство не может быть изменено после инициализации, и оно обязательно должно быть проинициализировано.
Компилятор подставляет реальное значение констант во все места программы, где они используются. Если значение константы пришлось в последствии поменять, то нужно перекомпилировать все классы, которые её используют, так как иначе там останется старое значение.
Пример объявления константы:
Java
static final double PI = 3.141592653589793;
1 | staticfinaldoublePI=3.141592653589793; |
Согласно имена констант записываются прописными буквами, а между словами ставится символ подчёркивания.
С этим читают