Руководство по возможностям java версий 8-14

Методы класса 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;

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


С этим читают