Что такое полиморфизм в java
Перейти к содержимому

Что такое полиморфизм в java

  • автор:

Что такое полиморфизм в Java

Привет! Это статья об одном из принципов ООП — полиморфизм.

Что такое полиморфизм

Определение полиморфизма звучит устрашающе ��

Полиморфизм — это возможность применения одноименных методов с одинаковыми или различными наборами параметров в одном классе или в группе классов, связанных отношением наследования.

Слово «полиморфизм» может показаться сложным — но это не так. Нужно просто разбить данное определение на части и показать на примерах, что имеется в виду. Поверьте, уже в конце статьи данное определение полиморфизма покажется Вам понятным ��

Полиморфизм, если перевести, — это значит «много форм». Например, актер в театре может примерять на себя много ролей — или принимать «много форм».

Так же и наш код — благодаря полиморфизму он становится более гибким, чем в языках программирования, которые не используют принципы ООП.

Так о каких формах идет речь? Давайте сначала приведем примеры и покажем, как на практике проявляется полиморфизм, а потом снова вернемся к его определению.

Как проявляется полиморфизм

Дело в том, что если бы в Java не было принципа полиморфизма, компилятор бы интерпретировал это как ошибку:

Как видите, методы на картинке отличаются значениями, которые они принимают:

Однако, поскольку в Java используется принцип полиморфизма, компилятор не будет воспринимать это как ошибку, потому что такие методы будут считаться разными:

Называть методы одинаково — это очень удобно. Например, если у нас есть метод, который ищет корень квадратный из числа, гораздо легче запомнить одно название (например, sqrt()), чем по одному отдельному названию на этот же метод, написанный для каждого типа:

Как видите, мы не должны придумывать отдельное название для каждого метода — а главное их запоминать! Очень удобно.

Теперь Вы можете понять, почему часто этот принцип описывают фразой:

Один интерфейс — много методов

Это предполагает, что мы можем заполнить одно название (один интерфейс), по которому мы сможем обращаться к нескольким методам.

Перегрузка методов

То, что мы показывали выше — несколько методов с одним названием и разными параметрами — называется перегрузкой. Но это был пример перегрузки метода в одном классе. Но бывает еще один случай — переопределение методов родительского класса.

Переопределение методов родителя

Когда мы наследуем какой-либо класс, мы наследуем и все его методы. Но если нам хочется изменить какой-либо из методов, который мы наследуем, мы можем всего-навсего переопределить его. Мы не обязаны, например, создавать отдельный метод с похожим названием для наших нужд, а унаследованный метод будет «мертвым грузом» лежать в нашем классе.

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

Пример

Представим, что у нас есть такая структура:

Вверху иерархии классов стоит класс Animal. Его наследуют три класса — Cat, Dog и Cow.

У класса «Animal» есть метод «голос» (voice). Этот метод выводит на экран сообщение «Голос». Естественно, ни собака, ни кошка не говорят «Голос» �� Они гавкают и мяукают. Соответственно, Вам нужно задать другой метод для классов Cat, Dog и Cow — чтобы кошка мяукала, собака гавкала, а корова говорила «Муу».

Поэтому, в классах-наследниках мы переопределяем метод voice(), чтобы мы в консоли получали «Мяу», «Гав» и «Муу».

  • Обратите внимание: перед методом, который мы переопределяем, пишем «@Override«. Это дает понять компилятору, что мы хотим переопределить метод.

Так что же такое полиморфизм

Тем не менее, полиморфизм — это принцип. Все реальные примеры, которые мы приведодили выше — это только способы реализации полиморфизма.

Давайте снова посмотрим на определение, которое мы давали в начале статьи:

Полиморфизм — возможность применения одноименных методов с одинаковыми или различными наборами параметров в одном классе или в группе классов, связанных отношением наследования.

Выглядит понятнее, правда? Мы показали, как можно:

  • создавать «одноименные методы» в одном классе («перегрузка методов»)
  • или изменить поведение методов родительского класса («переопределение методов»).

Все это — проявления «повышенной гибкости» объектно-ориентированных языков благодаря полиморфизму.

Надеемся, наша статья была Вам полезна. Записаться на наши курсы по Java можно у нас на сайте.

  • ← Перечисления Enum в Java — Часть 1
  • Map в Java. Hashmap в Java →

Что такое полиморфизм в java

Формула: площадь треугольника: ½ * основания * высоту Формула: площадь круга: 3,14 * радиус * радиус 

��☕ Интересные задачи по Java для практики можно найти на нашем телеграм-канале «Библиотека задач по Java»

Типы полиморфизма

Два варианта реализации полиморфизма в Java:

  1. Overloading – перегрузка метода
  2. Overriding – переопределение метода

При перегрузке метода мы в одном классе создаем нескольких методов с одинаковым названием, но разным функционалом, например:

class Forms < public void shapearea()) < System.out.println("Площади фигур:"); >public void shapearea(int r) < System.out.println("Sкруга = "+3.14*r*r); >public void shapearea(double b, double h) < System.out.println("Sтреугольника ="+0.5*b*h); >public void shapearea(int l, int b) < System.out.println("Sпрямоугольника ="+l*b); >> class Main < public static void main(String[] args) < Forms xForms = new Forms(); xForms.shapearea(); xForms.shapearea(3); xForms.shapearea(2.5, 2.0); xForms.shapearea(4,7); >> 
Площади фигур: Sкруга = 28.26 Sтреугольника = 5 Sпрямоугольника = 28 

При п ереопределении название метода дочернего класса мы ставим такое же, как и уже объявленного метода родительского класса, например:

class Vehicles < // определение метода void drive()< System.out.println("Управлять транспортным средством");>> //создаем дочерний класс class Cars extends Vehicles < //определяем одноименный метод void drive()< System.out.println("Управлять автомобилем"); >public static void main(String args[]) < Cars model= new Cars(); //создание нового объекта model.drive(); //вызов переопределенного метода >> 
Управлять автомобилем 

Статический и динамический полиморфизм

При статическом варианте развития событий метод можно вызывать при компиляции кода, происходит это при помощи рассмотренной нами ранее концепции — перегрузки методов. Говоря проще, у них будет одинаковое название, но разная функциональная начинка (тип возвращаемых данных, свойств и т. д.). В таком случае Java позволяет пользователю свободно определять функциям идентичные названия, если они будут отличны по типу и параметрам, например:

public class Add < void sum(int x, int y) < int z = x + y; System.out.println(“Сумма двух чисел: ”+z); >void sum(int x, int y, int i) < int z = x + y + i; System.out.println(“Сумма трех чисел: ”+z); >public static void main(String[] args) < Add myAdd = new Add(); myAdd.sum(5, 11); myAdd.sum(1, 8, 11); >> 
Сумма двух чисел: 16 Сумма трех чисел: 20 

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

Создадим один родительский класс Звери и три подкласса: травоядные , плотоядные и всеядные . В этом случае классы-потомки расширили родителя и переопределили его метод eat() .

class Beast < void eat() < System.out.println("Животные питаются:"); >> class herbivorous extends Beast < void eat() < System.out.println("Травоядные едят растения"); >> class omnivorous extends Beast < void eat() < System.out.println("Всеядные едят растения и мясо"); >> class carnivorous extends Beast < void eat() < System.out.println("Хищники едят только мясо"); >> class main < public static void main(String args[]) < Beast X = new Beast(); Beast herb = new herbivorous(); Beast omni = new omnivorous(); Beast carn = new carnivorous(); X.eat(); herb.eat(); omni.eat(); carn.eat(); >> 
Животные питаются: Травоядные едят растения Всеядные едят растения и мясо Хищники едят мясо 

Преимущества и недостатки полиморфизма

  1. Предоставляет возможность повторного использования кода. Реализованные классы можно многократно использовать повторно. Кроме того, это экономит много времени разработчику, ведь при этом появляется возможность поменять что-то в программе, не трогая исходный код.
  2. Одна переменная может использоваться для хранения нескольких значений данных. Значение переменной в дочернем классе, наследуемой от родительского, может быть изменено без изменения родительской переменной.
  3. Легче отлаживать код, когда его не так много.

Помимо преимуществ, у рассматриваемой парадигмы есть еще и несколько недостатков:

  1. Полиморфизм не так просто реализовать на деле.
  2. Такой подход снижает читаемость кода.
  3. Может вызывать серьезные проблемы с производительностью в режиме реального времени.

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

Материалы по теме

  • ☕ Программирование на Java с нуля: инструкция к профессии Java-разработчика
  • ☕ Основы Java: выделяем 4 разных роли классов
  • ☕ Основы Java за 30 минут: самоучитель для начинающих

Что такое полиморфизм в Java?

Java — это язык объектно-ориентированного программирования (ООП), который особенно полезен, когда вам нужно реализовать хорошо структурированный код и повысить его повторное использование и ремонтопригодность. ООП использует четыре принципа для описания отношений между классами: наследование, инкапсуляция, абстракция и полиморфизм. В каждой Java-программе есть как минимум один класс. Поэтому очень важно понимать принципы ООП и то, как их использовать в своих приложениях. В этой статье рассматривается полиморфизм в его различных формах, как он соотносится с другими классами Java, а также варианты его использования и передовой опыт. Если у вас мало времени, воспользуйтесь приведенными ниже ссылками, чтобы найти именно то, что вы ищете:

Что такое полиморфизм в Java?

Полиморфизм, что буквально означает «разные формы», является одной из основных концепций ООП. Полиморфизм исследует, как создать и использовать два метода с одинаковыми именами для выполнения двух разных функций — например, добавить две функции с одинаковыми именами, но принимающие разные параметры. Например, давайте рассмотрим, как можно определить две функции с именем Multiply (). Один используется для вычисления произведения двух целых чисел, а другой — для вычисления произведения двух чисел типа double.
public class Main public static void main(String[] args) // using the first method
Multiplier.Multiply(3,5);
// using the second method
Multiplier.Multiply(3.5,5.1);
>
>

Когда код запущен, вывод выглядит следующим образом: Целочисленное умножение, результат = 15 двойное умножение, результат = 17,849999999999998 Вы заметите, что при вызове двух методов нет никакой разницы, кроме передаваемых параметров. Кроме того, обратите внимание, что выходные данные зависят от типа переданных параметров.

Различия между наследованием и полиморфизмом

Понятно, что разработчики иногда путают полиморфизм с другой ключевой концепцией ООП: наследованием. Однако эти два принципа существенно различаются. При наследовании класс, который называется дочерним классом, может наследовать методы и атрибуты другого класса (родительского класса). См. следующий пример:

class Shape // methods of Shape class
>
class Square extends Shape // methods of Shape class are not specified here but are automatically accessible to this Square class thanks to inheritance
// methods of Square class
>

При наследовании без полиморфизма дочерний класс наследует те же атрибуты и методы родительского класса без каких-либо модификаций их функциональности. При полиморфизме дочерний класс наследует атрибуты и методы, но предоставляет собственную реализацию (код) для этих методов. Наследование — это способ обеспечить возможность повторного использования кода, а полиморфизм — это способ динамического определения того, какая версия функции будет вызываться. Например, наследование позволяет использовать атрибуты и методы родительского класса. Напротив, полиморфизм позволяет дочернему классу определять свою версию функции с тем же именем, что и в родительском классе. В качестве альтернативы он позволяет реализовать функцию с одним и тем же именем несколькими различными способами и выбирает один из них для выполнения на основе количества и типов заданных параметров. Полиморфизм также используется для поддержки принципа «открыто-закрыто», который представляет собой букву «О» в аббревиатуре SOLID. В нем говорится, что код должен быть открыт для расширения и закрыт для модификации. Другими словами, когда вы пытаетесь добавить больше функциональности в свой код, вам не следует изменять существующие классы (закрытые для модификации). Вместо этого следует расширять функциональность за счет наследования и полиморфизма.

Полиморфизм против наследования: пример

Если у вас есть два типа автомобилей, например BMW и Mercedes, вы можете создать класс Car, а затем создать класс BMW и класс Mercedes, каждый из которых наследуется от класса Car. Это означает, что они наследуют его атрибуты и функции. При полиморфизме можно предположить, что Car (родительский класс) может быть BMW (дочерний класс) или Mercedes (дочерний класс). Следовательно, вы можете использовать родительский класс Car для ссылки на любой из двух типов автомобилей.
public class Car<>
Public class BMW extends Car <>
Public class Mercedes extends Car<>
Car myCar = new BMW();
//…some code…
myCar = new Mercedes();
//…some code…

В этом примере кода определяется переменная myCar типа Car и используется для хранения нового объекта — BMW. Затем он использовал ту же переменную для ссылки на Mercedes, что возможно, потому что они оба являются дочерними классами Car. Это простой пример повышения приведения, когда родительский класс ссылается на объект из дочернего класса. Используя восходящее преобразование, вы можете получить доступ к дочерней версии родительского класса. Это означает, что вы можете получить доступ к методам, которые были определены исключительно в родительском классе, но если метод с тем же именем указан в дочернем классе, вы можете получить доступ к этому. Восходящее преобразование полезно, когда вашему приложению необходимо определить, какую версию кода вызывать во время выполнения.

Типы и примеры полиморфизма в Java

  • Полиморфизм времени компиляции (статический полиморфизм)
  • Полиморфизм времени выполнения (динамический полиморфизм)

Полиморфизм времени компиляции

Этот тип полиморфизма, также называемый статическим полиморфизмом, достигается путем создания нескольких методов с одинаковыми именами в одном классе, но каждый из которых имеет разное количество параметров или параметров разных типов данных.

Обратите внимание, что в приведенном ниже примере три метода имеют одно и то же имя, но каждый из них принимает разное количество параметров или разные типы данных:

package com.hubspot;
class Multiplier static void Multiply(int a, int b)
System.out.println(«Integer Multiplication, Result double Multiplication, Result Three parameters, double Multiplication, Result ez-toc-section» > Полиморфизм времени выполнения

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

Вот пример:
package com.hupspot;
// Super Class
class Shape protected double length;
Shape(double length) this.length = length;
>
void area() >
>
// Child class
class Square extends Shape //constructor
Square(double side) super(side); // calling the super class constructor
>
//Overriding area() method
void area() System.out.println(«Square Area Circle Area ez-toc-section» > Варианты использования полиморфизма и лучшие практики

Одним из вариантов использования полиморфизма является использование одного имени метода для автоматического вызова правильного метода в зависимости от класса. Например, при использовании одного элемента хранилища для хранения нескольких типов в следующем примере реализуется Set типа Shape из предыдущего примера и сохраняются объекты из разных дочерних классов, таких как Circle s и Square s:
Set hs = new HashSet();
hs.add(circle1);
hs.add(circle2);
hs.add(square1);
hs.add(square2);
for(Shape hs_element : hs) hs_element.area();
>
Другой пример использования полиморфизма — замена условных операторов в вашем коде. Например, в приведенном ниже коде используется оператор switch в методе области, чтобы определить, какой код запускать при его вызове, на основе первого переданного ему параметра. Вы заметите, что он достигает того же результата, что и приведенный выше пример кода полиморфизма времени выполнения. Однако этот подход не так прост.

package org.hubspot;
// Super Class
class Shape enum Type SQUARE,
CIRCLE
>
protected double length;
Type shape_type;
Shape(Type shape, double length) this.length = length;
this.shape_type = shape;
>
double area() double area = 0;
switch (shape_type)
case SQUARE:
area = length * length;
break;
case CIRCLE:
area = 3.14*length * length;
break;
>
return area;
>
>
public class Main public static void main(String[] args) Shape Circle = new Shape(Shape.Type.CIRCLE, 10);
System.out.println(«Circle Area equals Square Area equals ez-toc-section» > Использование полиморфизма в Java

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

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

Наконец, полиморфизм очень полезен при разрешении методов, вызываемых либо во время выполнения, либо во время компиляции.

25. Java – Полиморфизм

Полиморфизм – способность объекта принимать множество различных форм. Наиболее распространенное использование полиморфизма в ООП происходит, когда ссылка на родительский класс используется для ссылки на объект дочернего класса. Постараемся разобраться с понятием полиморфизма в Java простыми словами, так сказать для чайников.

Любой объект в Java, который может пройти более одного теста IS-A считается полиморфным. В Java все объекты полиморфны, так как любой объект пройдёт тест IS-A для своего собственного типа и для класса Object.

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

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

Ссылочная переменная может обратиться к любому объекту своего объявленного типа или любому подтипу своего объявленного типа. Ссылочную переменную можно объявить как класс или тип интерфейса.

Пример 1

Рассмотрим пример наследования полиморфизм в Java.

public interface Vegetarian<> public class Animal<> public class Deer extends Animal implements Vegetarian<> 

Теперь класс Deer (Олень) считается полиморфным, так как он имеет множественное наследование. Следующие утверждения верны для примера выше:

  • A Deer IS-A Animal (олень — это животное);
  • A Deer IS-A Vegetarian (олень — это вегетарианец);
  • A Deer IS-A Deer (олень — это олень);
  • A Deer IS-A Object (олень — это объект).

Когда мы применяем факты ссылочной переменной к ссылке на объект Deer (Олень), следующие утверждения верны:

Пример 2

Deer d = new Deer(); Animal a = d; Vegetarian v = d; Object o = d; 

Все переменные (d, a, v, o) ссылаются к тому же объекту Deer (Олень).

Виртуальные методы

В этом разделе рассмотрим, как поведение переопределённых методов в Java позволяет воспользоваться преимуществами полиморфизма при оформлении классов.

Мы уже рассмотрели переопредение методов, где дочерний класс может переопределить метод своего «родителя». Переопределённый метод же скрыт в родительском классе и не вызван, пока дочерний класс не использует ключевое слово super во время переопределения метода.

Пример

/* File name : Employee.java */ public class Employee < private String name; private String address; private int number; public Employee(String name, String address, int number) < System.out.println("Собираем данные о работнике"); this.name = name; this.address = address; this.number = number; >public void mailCheck() < System.out.println("Отправляем чек " + this.name + " " + this.address); >public String toString() < return name + " " + address + " " + number; >public String getName() < return name; >public String getAddress() < return address; >public void setAddress(String newAddress) < address = newAddress; >public int getNumber() < return number; >> 

Теперь предположим, что мы наследуем класс Employee следующим образом:

/* File name : Salary.java */ public class Salary extends Employee < private double salary; // Годовая заработная плата public Salary(String name, String address, int number, double salary) < super(name, address, number); setSalary(salary); >public void mailCheck() < System.out.println("Внутри mailCheck класса Salary "); System.out.println("Отправляем чек " + getName() + " с зарплатой " + salary); >public double getSalary() < return salary; >public void setSalary(double newSalary) < if(newSalary >= 0.0) < salary = newSalary; >> public double computePay() < System.out.println("Вычисляем заработную плату для " + getName()); return salary/52; >> 

Теперь, внимательно изучите программу и попытайтесь предугадать её вывод:

/* File name : VirtualDemo.java */ public class VirtualDemo < public static void main(String [] args) < Salary s = new Salary("Олег Петров", "Минск, Беларусь", 3, 3600.00); Employee e = new Salary("Иван Иванов", "Москва, Россия", 2, 2400.00); System.out.println("Вызываем mailCheck, используя ссылку Salary --"); s.mailCheck(); System.out.println("Вызываем mailCheck, используя ссылку Employee --"); e.mailCheck(); >> 

После запуска программы будет выдан такой результат:

Собираем данные о работнике Собираем данные о работнике Вызываем mailCheck, используя ссылку Salary –– Внутри mailCheck класса Salary Отправляем чек Олег Петров с зарплатой 3600.0 Вызываем mailCheck, используя ссылку Employee –– Внутри mailCheck класса Salary Отправляем чек Иван Иванов с зарплатой 2400.0 

Итак, мы создали два объекта Salary. Один использует ссылку Salary, то есть s, а другой использует ссылку Employee, то есть e.

Во время вызова s.mailCheck(), компилятор видит mailCheck() в классе Salary во время компиляции, а JVM вызывает mailCheck() в классе Salary при запуске программы.

mailCheck() в e совсем другое, потому что e является ссылкой Employee. Когда компилятор видит e.mailCheck(), компилятор видит метод mailCheck() в классе Employee.

Во время компиляции был использован mailCheck() в Employee, чтобы проверить это утверждение. Однако во время запуска программы JVM вызывает mailCheck() в классе Salary.

Это поведение называется вызовом виртуальных методов, а эти методы называются виртуальными. Переопределённый метод вызывается во время запуска программы вне зависимости от того, какой тип данных был использован в исходном коде во время компиляции.

Оглавление

  • 1. Java – Самоучитель для начинающих
  • 2. Java – Обзор языка
  • 3. Java – Установка и настройка
  • 4. Java – Синтаксис
  • 5. Java – Классы и объекты
  • 6. Java – Конструкторы
  • 7. Java – Типы данных и литералы
  • 8. Java – Типы переменных
  • 9. Java – Модификаторы
  • 10. Java – Операторы
  • 11. Java – Циклы и операторы цикла
  • 11.1. Java – Цикл while
  • 11.2. Java – Цикл for
  • 11.3. Java – Улучшенный цикл for
  • 11.4. Java – Цикл do..while
  • 11.5. Java – Оператор break
  • 11.6. Java – Оператор continue
  • 12. Java – Операторы принятия решений
  • 12.1. Java – Оператор if
  • 12.2. Java – Оператор if..else
  • 12.3. Java – Вложенный оператор if
  • 12.4. Java – Оператор switch..case
  • 12.5. Java – Условный оператор (? 🙂
  • 13. Java – Числа
  • 13.1. Java – Методы byteValue(), shortValue(), intValue(), longValue(), floatValue(), doubleValue()
  • 13.2. Java – Метод compareTo()
  • 13.3. Java – Метод equals()
  • 13.4. Java – Метод valueOf()
  • 13.5. Java – Метод toString()
  • 13.6. Java – Метод parseInt()
  • 13.7. Java – Метод Math.abs()
  • 13.8. Java – Метод Math.ceil()
  • 13.9. Java – Метод Math.floor()
  • 13.10. Java – Метод Math.rint()
  • 13.11. Java – Метод Math.round()
  • 13.12. Java – Метод Math.min()
  • 13.13. Java – Метод Math.max()
  • 13.14. Java – Метод Math.exp()
  • 13.15. Java – Метод Math.log()
  • 13.16. Java – Метод Math.pow()
  • 13.17. Java – Метод Math.sqrt()
  • 13.18. Java – Метод Math.sin()
  • 13.19. Java – Метод Math.cos()
  • 13.20. Java – Метод Math.tan()
  • 13.21. Java – Метод Math.asin()
  • 13.22. Java – Метод Math.acos()
  • 13.23. Java – Метод Math.atan()
  • 13.24. Java – Метод Math.atan2()
  • 13.25. Java – Метод Math.toDegrees()
  • 13.26. Java – Метод Math.toRadians()
  • 13.27. Java – Метод Math.random()
  • 14. Java – Символы
  • 14.1. Java – Метод Character.isLetter()
  • 14.2. Java – Метод Character.isDigit()
  • 14.3. Java – Метод Character.isWhitespace()
  • 14.4. Java – Метод Character.isUpperCase()
  • 14.5. Java – Метод Character.isLowerCase()
  • 14.6. Java – Метод Character.toUpperCase()
  • 14.7. Java – Метод Character.toLowerCase()
  • 14.8. Java – Метод Character.toString()
  • 15. Java – Строки
  • 15.1. Java – Метод charAt()
  • 15.2. Java – Метод compareTo()
  • 15.3. Java – Метод compareToIgnoreCase()
  • 15.4. Java – Метод concat()
  • 15.5. Java – Метод contentEquals()
  • 15.6. Java – Метод copyValueOf()
  • 15.7. Java – Метод endsWith()
  • 15.8. Java – Метод equals()
  • 15.9. Java – Метод equalsIgnoreCase()
  • 15.10. Java – Метод getBytes()
  • 15.11. Java – Метод getChars()
  • 15.12. Java – Метод hashCode()
  • 15.13. Java – Метод indexOf()
  • 15.14. Java – Метод intern()
  • 15.15. Java – Метод lastIndexOf()
  • 15.16. Java – Метод length()
  • 15.17. Java – Метод matches()
  • 15.18. Java – Метод regionMatches()
  • 15.19. Java – Метод replace()
  • 15.20. Java – Метод replaceAll()
  • 15.21. Java – Метод replaceFirst()
  • 15.22. Java – Метод split()
  • 15.23. Java – Метод startsWith()
  • 15.24. Java – Метод subSequence()
  • 15.25. Java – Метод substring()
  • 15.26. Java – Метод toCharArray()
  • 15.27. Java – Метод toLowerCase()
  • 15.28. Java – Метод toString()
  • 15.29. Java – Метод toUpperCase()
  • 15.30. Java – Метод trim()
  • 15.31. Java – Метод valueOf()
  • 15.32. Java – Классы StringBuilder и StringBuffer
  • 15.32.1. Java – Метод append()
  • 15.32.2. Java – Метод reverse()
  • 15.32.3. Java – Метод delete()
  • 15.32.4. Java – Метод insert()
  • 15.32.5. Java – Метод replace()
  • 16. Java – Массивы
  • 17. Java – Дата и время
  • 18. Java – Регулярные выражения
  • 19. Java – Методы
  • 20. Java – Потоки ввода/вывода, файлы и каталоги
  • 20.1. Java – Класс ByteArrayInputStream
  • 20.2. Java – Класс DataInputStream
  • 20.3. Java – Класс ByteArrayOutputStream
  • 20.4. Java – Класс DataOutputStream
  • 20.5. Java – Класс File
  • 20.6. Java – Класс FileReader
  • 20.7. Java – Класс FileWriter
  • 21. Java – Исключения
  • 21.1. Java – Встроенные исключения
  • 22. Java – Вложенные и внутренние классы
  • 23. Java – Наследование
  • 24. Java – Переопределение
  • 25. Java – Полиморфизм
  • 26. Java – Абстракция
  • 27. Java – Инкапсуляция
  • 28. Java – Интерфейсы
  • 29. Java – Пакеты
  • 30. Java – Структуры данных
  • 30.1. Java – Интерфейс Enumeration
  • 30.2. Java – Класс BitSet
  • 30.3. Java – Класс Vector
  • 30.4. Java – Класс Stack
  • 30.5. Java – Класс Dictionary
  • 30.6. Java – Класс Hashtable
  • 30.7. Java – Класс Properties
  • 31. Java – Коллекции
  • 31.1. Java – Интерфейс Collection
  • 31.2. Java – Интерфейс List
  • 31.3. Java – Интерфейс Set
  • 31.4. Java – Интерфейс SortedSet
  • 31.5. Java – Интерфейс Map
  • 31.6. Java – Интерфейс Map.Entry
  • 31.7. Java – Интерфейс SortedMap
  • 31.8. Java – Класс LinkedList
  • 31.9. Java – Класс ArrayList
  • 31.10. Java – Класс HashSet
  • 31.11. Java – Класс LinkedHashSet
  • 31.12. Java – Класс TreeSet
  • 31.13. Java – Класс HashMap
  • 31.14. Java – Класс TreeMap
  • 31.15. Java – Класс WeakHashMap
  • 31.16. Java – Класс LinkedHashMap
  • 31.17. Java – Класс IdentityHashMap
  • 31.18. Java – Алгоритмы Collection
  • 31.19. Java – Iterator и ListIterator
  • 31.20. Java – Comparator
  • 32. Java – Дженерики
  • 33. Java – Сериализация
  • 34. Java – Сеть
  • 34.1. Java – Обработка URL
  • 35. Java – Отправка Email
  • 36. Java – Многопоточность
  • 36.1. Java – Синхронизация потоков
  • 36.2. Java – Межпоточная связь
  • 36.3. Java – Взаимная блокировка потоков
  • 36.4. Java – Управление потоками
  • 37. Java – Основы работы с апплетами
  • 38. Java – Javadoc

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *