<<Предыдущий урок Список уроков Следующий урок>>
Методы в Java
Методы в Java — это законченная последовательность действий (инструкций), направленных на решение отдельной задачи. По сути, это функции (они же процедуры, подпрограммы) более ранних, не ООП языков. Только эти функции являются членами классов и для различия с обычными функциями, согласно терминологии объектно-ориентированного программирования, называются методами.
Методы определяются всегда внутри классов:
public class Main { public static void foo() { // Тело метода } }
foo -
это метод, который мы определили в классе Main, давайте его рассмотрим.
public
– тип доступа (метод может вызываться из другого класса). Существуют и другие типы доступа, к примеру private (метод доступен только внутри класса) и protected (о нем мы будем говорить позже).static
означает что метод статический, он принадлежит классу Main, а не конкретному экземпляру класса Main. Мы можем вызвать этот метод из другого класса так:Main.foo()
.void
значит, что этот метод не возвращает значение. Методы могут возвращать значение в Java и оно должно быть определено при объявлении метода. Однако, вы можете использоватьreturn
просто для выхода из метода.- Этот метод не получает никаких аргументов, но методы java могут получать аргументы, как мы увидим далее на примерах.
Если тип возвращаемого значения не void, в теле метода должен быть хотя бы один оператор
return выражение;
где тип выражения должен совпадать с типом возвращаемого значения. Этот оператор возвращает результат вычисления выражения в точку вызова метода.
Если тип возвращаемого значения – void, возврат из метода выполняется либо после выполнения последнего оператора тела метода, либо в результате выполнения оператора
return;
(таких операторов в теле метода может быть несколько).
Пример объявления метода, возвращающего значение типа int – сумму двух своих параметров типа int:
int sum(int a, int b){ int x; x = a + b; return x; }
При вызове метода, например, sum(5, 3), параметры 5 и 3 передаются в метод, как значения соответственно a и b, и оператор вызова метода sum(5, 3)– заменяется значением, возвращаемым методом (8).
В отличие от языка C, в котором тип параметра, задаваемого при вызове, приводится к типу параметра в объявлении функции, тип задаваемого параметра в Java должен строго соответствовать типу параметра в объявлении метода, поэтому вызов метода sum(1.5, 8) приведет к ошибке при компиляции программы.
Не статические методы
Не статические методы в Java используются чаще, чем статические методы. Эти методы могут принадлежать любому объекту, экземпляру класса, а не всему классу.
Не статические методы могут получать доступ и изменять поля объекта.
public class Student { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } }
Вызов методов требует экземпляра класса Student
.
Student s = new Student(); s.setName("Danielle"); String name = s.getName(); Student.setName("Bob"); // Не будет работать! Student.getName(); // Не будет работать!
Перегруженные методы
В языке Java в пределах одного класса можно определить два или более методов, которые совместно используют одно и то же имя, но имеют разное количество параметров. Когда это имеет место, методы называют перегруженными, а о процессе говорят как о перегрузке метода (method overloading).
Когда метод вызывается, то по количеству параметров и/или их типам среда выполнения Java определяет, какую именно версию перегруженного метода надо вызывать (тип возвращаемого значения во внимание не принимается, хотя, в принципе, он тоже может отличаться у разных версий перегруженных методов).
Например, метод
double sum(double a, double b) { double x; x = a + b; return x; }
вместе с объявленным ранее методом int sum(int a, int b)составляют пару перегруженных методов и при вызове sum(5, 8) будет вызван первый метод, а при вызове sum(5.0, 8.0) будет вызван второй метод.
По умолчанию метод, как и переменная, доступен только классам в том же пакете (наборе классов), что и исходный класс. Если перед возвращаемым типом задан модификатор доступа public, то метод является глобальным и доступен любым объектам, а модификатор private означает, что метод доступен в том классе, в котором он был объявлен, т.е. метод инкапсулирован в данном классе.
Переопределение методов
Кроме перегрузки существует также замещение, или переопределение методов (англ. overriding). Замещение происходит, когда класс потомок (подкласс) определяет некоторый метод, который уже есть в родительском классе(суперклассе), таким образом новый метод заменяет метод суперкласса. У нового метода подкласса должны быть те же параметры или сигнатура, тип возвращаемого результата, что и у метода родительского класса.
public class Thought { public void message() { System.out.println("Я себя чувствую как стрекоза, попавшая в параллельную вселенную."); } } public class Advice extends Thought { @Override // Аннотация @Override с Java 5 является необязательной, но весьма полезной public void message() { System.out.println("Внимание: Даты в календаре ближе, чем кажутся."); } }
Класс Thought
представляет собой суперкласс и обеспечивает вызов метода message()
. Подкласс, называемый Advice
, наследует каждый метод класса Thought
. Однако, класс Advice
переопределяет метод message()
, замещая функционал, описанный в классе Thought
.
В Java, когда подкласс содержит метод, переопределяющий метод суперкласса, то он может помимо своего метода вызывать и метод суперкласса при помощи ключевого слова super.
Например, нижеследующий вариант выводит оба сообщения при вызове метода подкласса:
public class Advice extends Thought { @Override public void message() { System.out.println("Внимание: Даты в календаре ближе, чем кажутся."); super.message(); // Вызов версии метода родительского класса } }
Существуют методы, которые подкласс не может переопределять. Например, в Java метод, объявленный с ключевым словом final
, не может быть переопределён. Методы, объявленные как private
или static
не могут быть переопределены, поскольку это соответствует неявному использованию final
.
Резюме
- Каждый java-метод должен быть внутри класса
- Статические методы принадлежат классу, а не статические методы принадлежат объектам, экземплярам класса
- В пределах одного класса может быть два и более методов с одинаковыми именами, но разным набором параметров (перегрузка метода)
- Класс-потомок может обеспечивать свою реализацию метода, уже реализованного в одном из родительских классов (переопределение метода)
Упражнение
Написать метод printFullName
класса Student, который выводит полное ФИО студента.
Выполните упражнение, прежде чем перейти к следующему уроку.
class Student {
private String FName, SName, TName;
Student(String F, String S, String T) {
FName = F;
SName = S;
TName = T;
}
public void PrintFullName() {
System.out.println(FName+” “+SName+” “+TName);
}
}
public class Main {
public static void main(String[] args) {
Student S = new Student(“Ivanov”, “Ivan”, “Ivanovich”);
S.PrintFullName();
}
}
public class Main {
public static class Student {
private String famyli;
private String name;
private String otchestvo;
private String setFIO() {
String fio = (famyli + ” ” + name + ” ” + otchestvo);
System.out.println(fio);
return fio;
}
public void setFamyli(String famyli) {
this.famyli = famyli;
}
public void setName(String name) {
this.name = name;
}
public void setOtchestvo(String otchestvo) {
this.otchestvo = otchestvo;
}
}
public static void main(String[] args) {
Student s = new Student();
s.setFamyli(“фамилия”);
s.setName(“имя”);
s.setOtchestvo(“отчество”);
s.setFIO();
}
}
public class Student {
public static void printFullName() {
String f = “Фамилия”;
String i = “Имя”;
String o = “Отчество”;
System.out.println(f+” “+i+” “+o);
}
}
И в Main классе вызываем этот метод:
Student.printFullName();
Я конечно не эксперт, но зачем коды такие длинные писать?
public class Student {
private String Name = "Максим", SurName = "Бурко", Batya = "Олегович";
public static void main(String[] agrs) {
Student s = new Student();
s.printFullName();
}
void printFullName () {
System.out.println(SurName + " " + Name + " " + Batya);
}
}
package com.example.proekt_uchebniy;
public class PrivetMir {
public static void main(String[] args) {
printFullName();
}
public static class Student{
public String name,famil,otchestvo;
public void setName(String name){
this.name = name;
}
public void setFamil(String famil){
this.famil = famil;
}
public void setOtchestvo(String otchestvo){
this.otchestvo = otchestvo;
}
public String getName(){
return name;
}
public String getFamil(){
return famil;
}
public String getOtchestvo(){
return otchestvo;
}
}
public static void printFullName(){
Student student1 = new Student();
student1.setName(“Vladislav”);
student1.setFamil(“Nikonov”);
student1.setOtchestvo(“Alekseevich”);
String name = student1.getName();
String famil = student1.getFamil();
String otchestvo = student1.getOtchestvo();
System.out.print(“Hello! I am ” + famil +” ” + name +” “+ otchestvo + ” , and i am student!”);
}
}
public class MyJavaClass {
public static class Student {
String name;
String surname;
String patronymic;
}
public static void main(String[] args) {
System.out.println(printFullName());
}
public static String printFullName() {
Student d2 = new Student();
d2.name = “Alex”;
d2.surname = “Shikura”;
d2.patronymic = “Uriyovic”;
return(d2.name + ” ” + d2.surname + ” ” + d2.patronymic);
}
}
Не совсем понял задание. Интересно было бы узнать, правильна ли такая реализация.
public class Student {
String fio;
String fio2;
String fio3;
String fio4;
public void printFullName(){
System.out.println(“ФИО Студента: ” + fio);
System.out.println(“ФИО Студента: ” + fio2);
System.out.println(“ФИО Студента: ” + fio3);
System.out.println(“ФИО Студента: ” + fio4);
}
public static void main (String args []) {
Student Stu = new Student();
Stu.fio = “Иванов Иван Иванович”;
Stu.fio2 = “Павлов Анатолий Анатольевич”;
Stu.fio3 = “Поджог Сараев Рулонов”;
Stu.fio4 = “Рулон Обоев Поджогов”;
Stu.printFullName();
}
}
Вариант покороче:
public class Main {
public static void main(String[] args) {
Student a = new Student();
System.out.println(a.printFullName("dfsf","sadasd","asdasd")); //вводим три параметра: Фамилию Имя Отчество
}
}
public class Student{
public String printFullName(String family, String name, String soname) {
return "Фамилия Имя Отчество: " + (family + " " + name + " " + soname);
}
}
Я сделал вот так:
public class Student{
public String name, soname, family;
public String printFullName(){
return "Фамилия Имя Отчество: " + (family + " " + name +" "+ soname);
}
}
public class Main {
public static void main(String[] args) {
Student a = new Student();
a.name = "Константин"; //Вводится Имя
a.soname = "Константинович"; //Вводится отчество
a.family = "Головенков"; //Вводится Фамилия
System.out.println(a.printFullName());
}
}
class Student {
private String firstName;
private String lastName;
public Student(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public void printFullName(){
System.out.print(firstName+” “);
System.out.println(lastName);}
}
public class Main {
public static void main(String[] args) {
Student[] students = new Student[] {
new Student(“Morgan”, “Freeman”),
new Student(“Brad”, “Pitt”),
new Student(“Kevin”, “Spacey”),
};
for (Student s : students) {
s.printFullName();}
}}
Создал классы: Main, Student, Surname, Name, Middle_name.
Класс Main (Выводи полное ФИО):
public class Main {
public static void main(String[] args) {
Student a = new Student();
a.printFullName();
}
}
Класс Student, метод printFullName (объединяет классы Surname, Name, Middle_name):
public class Student {
public void printFullName(){
Surname a = new Surname();
a.setsurname(“Kataev”);
String surname = a.getsurname();
System.out.println(surname);
Name b = new Name();
b.setname(“Aleksandr”);
String name = b.getname();
System.out.println(name);
Middle_name c = new Middle_name();
c.setmiddle_name(“Vladislavovich”);
String middle_name = c.getmiddle_name();
System.out.println(middle_name);
}
}
Класс Surname:
public class Surname {
public String surname;
public String getsurname(){
return surname;
}
public void setsurname (String surname){
this.surname = surname;
}
}
Класс Name:
public class Name {
public String name;
public String getname(){
return name;
}
public void setname (String name){
this.name = name;
}
}
Класс Middle_name:
public class Middle_name {
private String middle_name;
public String getmiddle_name() {
return middle_name;
}
public void setmiddle_name(String middle_name) {
this.middle_name = middle_name;
}
}
Я так написал. Чувствую, что задание вроде не реализованной на 100%, но я понял его так..
public class Program
{
public static void main(String[] args) {
printFullName(“FirstName”, “Name”, “LastName”);
}
public static void printFullName(String a, String b, String c){
System.out.println(a + ” ” + b + ” ” + c);
}
}
Я сделал таким путьом…
Может не совсем верно… Подскажите.
public class Main {
public static void main(String args[]){
Student fio;
fio = new Student ();
fio.name = “Андрей”;
fio.famili = “Фамилия”;
fio.ot = “Васильевич”;
System.out.print (fio.name);
System.out.print (” “);
System.out.print(fio.ot);
System.out.print (” “);
System.out.println(fio.famili);
}
}
Благодарствую за подсказки ребят выше, испробовал 2 способа изменения ФИО в Student:
1. Обращение к приватным переменным fam\name\sur через сеттеры.
2. Обращение напрямую к публичным переменным fam2\name2\sur2
public class Student {
private String fam;
private String name;
private String sur;
String fam2;
String name2;
String sur2;
public void setFam(String a){
this.fam = a;
}
public void setName(String a){
this.name = a;
}
public void setSur(String a){
this.sur = a;
}
public void printFullName(){
System.out.println(fam);
System.out.println(name);
System.out.println(sur);
}
public void printFullName2(){
System.out.println(fam2);
System.out.println(name2);
System.out.println(sur2);
}
}
public class Main {
public static void main(String[] args){
Student s = new Student();
s.setFam("Онищенко");
s.setName("Игорь");
s.setSur("Сергеевич");
s.fam2 = "Иванов";
s.name2 = "Иван";
s.sur2 = "Иванович";
s.printFullName();
s.printFullName2();
}
}
public class student {
public String printFullName(){
String FullName = (famil+” “+name+” “+otch);
return FullName;
}
private String name;
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
private String famil;
public String getFamil(){
return famil;
}
public void setFamil(String famil){
this.famil = famil;
}
private String otch;
public String getOtch(){
return otch;
}
public void setOtch(String otch){
this.otch = otch;
}
}
public class main {
public static void main(String[] args){
student s = new student();
s.setName(“Igor”);
s.setFamil(“Rymarev”);
s.setOtch(“Igorevich”);
String fio = s.printFullName();
System.out.println(fio);
}
}
Я не понял почему программа начала выполнять метод main? Где вызов этого метода?
Метод main является точкой входа в java-программу и вызывается виртуальной машиной
Всё нормально излагается. Больше читайте и больше пишите
class test {
public static void main(String args[]) {
String name1 = “Jack”;
String name2 = “Daniel”;
String fullname = fname(name1, name2);
System.out.println(fullname);
}
private static String fname(String n1, String n2) {
n1 = n1 + ” ” + n2;
return n1;
}
}
Разобрался только посмотрев другой урок про методы:(
public class Student {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Зачем здесь (private String name;) указано private ? Вроде бы без него все работает.
Что ж язык изложения стал такой сложный. Материал бы лучше усваивался, еслибы язык изложения был более человечный. Слишком много терминов, о которых не говорилось в предыдущих уроках. И это очень усложняет понимание.
public class Student {
private static String name;
private static String lastname;
private static String family;
public static void FOQ(){
System.out.print(name + ” “);
System.out.print(lastname + ” “);
System.out.print(family);
}
public static void setFOQ(String n,String ln, String fn){
name = n;
lastname = ln;
family = fn;
public class Student {
private String firstName;
private String lastName;
public static void main(String[] args) {
Student c = new Student();
c.setFirstName(“Ivan”);
c.setLastName(“Grigoriev”);
c.printFullName();
}
public void setFirstName(String name){
firstName = name;
}
public void setLastName(String name){
lastName = name;
}
public void printFullName(){
String fullName;
fullName = firstName + ” ” + lastName;
System.out.println(fullName);
}
}
Получилось, только такое:
public class Student {
String name;
String surname;
String patronomic;
public void printFullName(){
System.out.println(“name: ” + name);
System.out.println(“surname ” + surname);
System.out.println(“patronomic” + patronomic);
} /* определил метод */
public static void main (String args[]){
Student S2 = new Student();
S2.name = “JOOORA”;
S2.surname = “KURZAAAAANOOOV”;
S2.patronomic = “VACHESLAVOVICH”;
S2.printFullName();
}
}
Т.е. в связке с методом печатающим ФИО требуется метод, устанавливающий Фамилию и Отчество по аналогии с назначением имени и потом метод, который “цепляет” эти параметры и выводит их?