В этом практическом занятии (лабораторной работе) вы улучшите свои навыки программирования на Java, изучив методы и основы объектно-ориентированного программирования (ООП). Эти концепции являются важными для написания хорошо структурированного, повторно используемого и эффективного кода. Мы рассмотрим следующие аспекты:
Создание и использование методов для организации кода и обеспечения его повторного использования.
Понимание основных идей, лежащих в основе классов и объектов.
Реализация простого класса, включающего методы и атрибуты.
По завершении этого практического занятия вы сможете писать программы на Java, которые используют методы для разбиения сложных задач на более мелкие и управляемые части. Вы также получите представление о том, как работает объектно-ориентированное программирование в Java, что является важным навыком для создания более крупных и сложных приложений. Если эти концепции кажутся сложными вначале, не беспокойтесь — мы рассмотрим их пошагово, и к концу практического занятия вы оцените, как эти идеи способствуют созданию более организованного и мощного кода.
Давайте начнем!
Это Guided Lab, который предоставляет пошаговые инструкции, чтобы помочь вам учиться и практиковаться. Внимательно следуйте инструкциям, чтобы выполнить каждый шаг и получить практический опыт. Исторические данные показывают, что это лабораторная работа уровня начальный с процентом завершения 88%. Он получил 98% положительных отзывов от учащихся.
Понимание и создание методов (Methods)
Методы (Methods) — это, по сути, небольшие программы внутри вашей основной программы. Они помогают вам организовать код, улучшить его читаемость и обеспечить повторное использование кода без необходимости многократно писать один и тот же код. Рассматривайте методы как специализированные инструменты в наборе инструментов — каждый предназначен для определенной цели.
Начните с открытия файла MethodDemo.java в WebIDE. Вы должны увидеть следующий стартовый код:
public class MethodDemo {
public static void main(String[] args) {
System.out.println("Welcome to the Method Demo!");
// TODO: Call methods here
// TODO: Вызовите методы здесь
}
// TODO: Add methods here
// TODO: Добавьте методы здесь
}
Это фундаментальная структура нашей Java-программы. Метод main является точкой входа, с которой начинается выполнение нашей программы.
Теперь давайте создадим наш первый метод. Мы создадим простой метод, который выводит приветствие. Добавьте этот метод вне и после метода main, на уровне класса:
public class MethodDemo {
public static void main(String[] args) {
System.out.println("Welcome to the Method Demo!");
// TODO: Call methods here
// TODO: Вызовите методы здесь
}
// Add the new method here, outside and after the main method
// Добавьте новый метод здесь, вне и после метода main
public static void printGreeting(String name) {
System.out.println("Hello, " + name + "! Welcome to Java methods.");
}
}
Давайте разберем, что это значит:
public: Это ключевое слово указывает, что метод может быть доступен из других классов.
static: Это означает, что метод принадлежит самому классу, а не конкретному экземпляру класса. Мы углубимся в эту концепцию позже; пока что думайте об этом как о требовании для методов, которые мы хотим использовать без создания объекта.
void: Это означает, что наш метод не возвращает никакого значения. Он выполняет действие — вывод приветствия — но не возвращает никаких данных.
printGreeting: Это имя, которое мы присвоили нашему методу. Мы будем использовать это имя для вызова метода.
(String name): Это параметр — часть данных, которую принимает наш метод. Он ожидает String (строку), которую мы назвали name. Когда мы вызываем этот метод, нам нужно будет предоставить значение для этого параметра.
Отлично! Теперь, когда мы создали метод, давайте его используем. Внутри метода main замените комментарий // TODO: Call methods here на:
printGreeting("Alice");
Эта строка вызывает наш метод printGreeting и передает ему имя "Alice" в качестве аргумента. Аргумент предоставляет конкретный ввод, необходимый методу для выполнения своего действия.
Сохраните файл и давайте скомпилируем и запустим программу. В терминале внизу вашей WebIDE введите следующие команды:
Первая команда компилирует наш Java-файл, преобразуя его в байт-код, который может понять виртуальная машина Java (Java Virtual Machine). Вторая команда запускает скомпилированную программу. Вы должны увидеть вывод, подобный этому:
Welcome to the Method Demo!
Hello, Alice! Welcome to Java methods.
Превосходно! Вы только что создали и использовали свой первый Java-метод. Давайте вызовем его снова с другим именем. Добавьте эту строку в метод main сразу после первого вызова printGreeting:
printGreeting("Bob");
Сохраните, скомпилируйте и запустите программу снова. Теперь вы должны увидеть:
Welcome to the Method Demo!
Hello, Alice! Welcome to Java methods.
Hello, Bob! Welcome to Java methods.
Заметили, как мы можем повторно использовать наш метод с разными входными данными? Это значительное преимущество использования методов.
Теперь давайте создадим метод, который возвращает значение. Добавьте этот метод в свой класс под методом printGreeting:
public static int sumNumbers(int a, int b) {
return a + b;
}
Этот метод принимает два целых числа, складывает их вместе и возвращает результат. Обратите внимание, что вместо void мы используем int, чтобы указать, что этот метод возвращает целочисленное значение.
Давайте используем этот новый метод в нашем методе main. Добавьте эти строки в конец метода main:
int result = sumNumbers(5, 7);
System.out.println("The sum of 5 and 7 is: " + result);
Здесь мы вызываем наш метод sumNumbers, предоставляя значения 5 и 7 в качестве аргументов. Возвращаемое значение метода затем сохраняется в переменной с именем result. После сохранения возвращаемого значения мы выводим значение в консоль.
Сохраните, скомпилируйте и запустите программу еще раз. Теперь вы должны увидеть дополнительный вывод:
The sum of 5 and 7 is: 12
Поздравляем! Вы создали и использовали свои первые Java-методы. Вы увидели, как методы могут выполнять действия (например, отображать приветствия) и предоставлять возвращаемые значения (например, сумму двух чисел). Методы позволяют структурировать код на более мелкие, многократно используемые части, что упрощает понимание и поддержку ваших программ.
Введение в классы и объекты
Теперь, когда мы освоили методы, давайте сделаем шаг в объектно-ориентированное программирование, создав простой класс. В объектно-ориентированном программировании мы используем классы в качестве чертежей для создания объектов. Представьте класс как шаблон для печенья, а объекты - как печенье, которое вы делаете с его помощью.
Откройте файл Car.java и начнем создавать наш класс. Сначала мы определим класс и добавим некоторые атрибуты:
public class Car {
// Attributes
private String make;
private String model;
private int year;
}
Эти атрибуты (также называемые полями или свойствами) определяют, какие характеристики будут у каждого объекта Car. Каждая машина будет иметь марку, модель и год выпуска.
Ключевое слово private означает, что эти атрибуты могут быть доступны только изнутри самого класса. Это пример инкапсуляции - концепции, которая помогает защитить целостность данных в наших объектах.
Теперь давайте добавим конструктор в наш класс. Конструктор - это специальный метод, который автоматически вызывается, когда мы создаем новый объект. Он в основном используется для инициализации атрибутов объекта. Добавьте этот конструктор в класс Car:
// Constructor
public Car(String make, String model, int year) {
this.make = make;
this.model = model;
this.year = year;
}
Этот конструктор принимает три параметра и использует их для установки значений наших атрибутов. Ключевое слово this используется для обращения к атрибутам текущего объекта - это помогает различать атрибут объекта и параметр, переданный в конструктор, когда их имена совпадают.
Далее, давайте добавим метод в наш класс, который будет отображать информацию о машине. Добавьте этот метод в класс Car:
Этот метод не принимает никаких параметров и не возвращает никакого значения. Он просто выводит информацию о машине на консоль.
Отлично! Мы создали класс Car. Теперь откройте файл CarDemo.java и добавьте следующий код:
public class CarDemo {
public static void main(String[] args) {
// We'll add code here in the next step
}
}
Это устанавливает базовую структуру для нашей демонстрационной программы.
Теперь давайте создадим несколько объектов Car и используем их. Добавьте этот код внутри метода main:
Car myCar = new Car("Toyota", "Corolla", 2022);
myCar.displayInfo();
Car friendsCar = new Car("Honda", "Civic", 2023);
friendsCar.displayInfo();
Здесь мы создаем два объекта Car. Ключевое слово new используется для создания нового объекта, и мы вызываем конструктор, который мы определили ранее, чтобы установить марку, модель и год. Затем мы вызываем метод displayInfo для каждого объекта Car, чтобы отобразить их свойства.
Перед тем, как мы скомпилируем и запустим нашу программу, важно отметить, что мы работаем с несколькими Java-файлами (Car.java и CarDemo.java). При компиляции нескольких файлов, которые имеют зависимости, нам нужно компилировать их вместе. Также убедитесь, что файлы CarDemo.java и Car.java находятся в одной и той же директории, в противном случае вам нужно будет импортировать класс Car в начале файла CarDemo.java, как показано ниже.
Если файлы CarDemo.java и Car.java находятся в разных директориях, вам может потребоваться добавить оператор импорта в начале файла CarDemo.java:
import packagename.Car; // Replace 'packagename' with the actual package name if applicable
Теперь давайте скомпилируем и запустим программу CarDemo:
Первая команда компилирует оба наших Java-файла вместе, убеждаясь, что все зависимости разрешены. Вторая команда запускает наш класс CarDemo.
Вы должны увидеть вывод, похожий на следующий:
Car Information:
Make: Toyota
Model: Corolla
Year: 2022
Car Information:
Make: Honda
Model: Civic
Year: 2023
Поздравляем! Вы только что создали свой первый класс на Java и использовали его для создания объектов. Это основа объектно-ориентированного программирования в Java. Вы определили чертеж (класс Car) и использовали его для создания конкретных экземпляров (объекты Car). Каждый объект имеет свою уникальную набор атрибутов, но они все имеют общую структуру и поведение, определенные классом.
Расширение функциональности класса с помощью дополнительных методов
Теперь, когда у нас есть базовое понимание классов и объектов, давайте улучшим наш класс Car, добавив больше методов, чтобы повысить его функциональность. Мы добавим методы, которые представляют действия, которые может выполнять автомобиль, и свойства, о которых мы можем хотеть узнать.
Откройте файл Car.java. Давайте добавим метод, который представляет ускорение автомобиля. Добавьте этот метод в класс Car:
public void accelerate() {
System.out.println("The " + make + " " + model + " is accelerating.");
}
Этот метод не изменяет никаких атрибутов автомобиля; он просто выводит сообщение о том, что автомобиль ускоряется.
Теперь давайте добавим метод для торможения. Добавьте этот метод в класс Car:
public void brake() {
System.out.println("The " + make + " " + model + " is braking.");
}
Этот метод также просто выводит сообщение о действии автомобиля, как и предыдущий метод accelerate.
Далее, давайте добавим метод, который предоставляет информацию о автомобиле. Добавьте этот метод:
public String getMakeAndModel() {
return make + " " + model;
}
Этот метод объединяет марку и модель в одну строку и возвращает ее. Обратите внимание, что тип возвращаемого значения - String, а не void, так как этот метод предоставляет нам информацию.
Наконец, давайте добавим метод, который определяет, является ли автомобиль антикварным. Во многих местах автомобиль считается антикварным, если ему более 25 лет. Добавьте этот метод:
public boolean isAntique() {
int currentYear = java.time.Year.now().getValue();
return (currentYear - year) > 25;
}
Этот метод использует встроенный класс Year в Java, чтобы получить текущий год. Затем он вычисляет возраст автомобиля и возвращает true, если он старше 25 лет, и false в противном случае.
После добавления этих дополнительных методов в наш класс Car, давайте обновим файл CarDemo.java, чтобы использовать их. Откройте CarDemo.java и замените его содержимое на:
public class CarDemo {
public static void main(String[] args) {
Car myCar = new Car("Toyota", "Corolla", 2022);
Car classicCar = new Car("Ford", "Mustang", 1965);
myCar.displayInfo();
myCar.accelerate();
myCar.brake();
System.out.println(classicCar.getMakeAndModel() + " is an antique: " + classicCar.isAntique());
Car[] carArray = {myCar, classicCar};
for (Car car : carArray) {
System.out.println(car.getMakeAndModel() + " is an antique: " + car.isAntique());
}
}
}
Этот новый метод main выполняет несколько задач:
Он создает два объекта Car: современный автомобиль и классический автомобиль.
Он вызывает наши недавно добавленные методы accelerate и brake для объекта современного автомобиля.
Он использует методы getMakeAndModel и isAntique для объекта классического автомобиля.
Он создает массив объектов Car и использует цикл for-each для перебора их, демонстрируя, как мы можем работать с коллекциями объектов.
Сохраните оба файла, затем скомпилируйте и запустите программу CarDemo:
Car Information:
Make: Toyota
Model: Corolla
Year: 2022
The Toyota Corolla is accelerating.
The Toyota Corolla is braking.
Ford Mustang is an antique: true
Toyota Corolla is an antique: false
Ford Mustang is an antique: true
Поздравляем! Вы значительно расширили класс Car и создали более сложную программу, используя объекты. Это демонстрирует, как объектно-ориентированное программирование можно использовать для моделирования реальных концепций в коде. Каждый объект автомобиля теперь имеет свои собственные данные (марка, модель, год) и действия (ускорение, торможение и т.д.), как и настоящие автомобили.
Мы добавили методы в наш класс Car, которые представляют действия (accelerate() и brake()). Хотя эти методы не изменяют состояние автомобиля в нашей текущей реализации, в более сложной программе они могли бы изменять атрибуты, такие как скорость или уровень топлива.
Мы добавили метод getMakeAndModel(), который объединяет две части информации в одну строку. Это распространенная практика в объектно-ориентированном программировании - создание методов, которые обеспечивают удобный доступ к данным объекта.
Метод isAntique() показывает, как данные объекта (год выпуска автомобиля) могут быть объединены с внешней информацией (текущим годом), чтобы получить новую информацию об объекте.
В нашем классе CarDemo мы показали, как создавать и использовать несколько объектов, как вызывать различные методы для этих объектов и как перебирать массив объектов.
Этот пример демонстрирует мощь объектно-ориентированного программирования. Мы создали класс Car, который инкапсулирует как данные (марка, модель, год), так и поведение (ускорение, торможение, определение антикварности). Каждый объект Car, который мы создаем, независим и имеет свой собственный уникальный набор данных, но они все следуют одному и тому же набору действий, определенных классом.
Резюме
В этом практическом занятии (лабораторной работе) мы совершили значительный прогресс в изучении программирования на Java. Мы рассмотрели некоторые базовые, но важные концепции, которые являются основой для написания более сложных и организованных Java-программ. Давайте обобщим то, что мы узнали:
Методы:
Мы создали и использовали методы для структурирования кода и повышения его повторного использования.
Мы изучили, как методы могут принимать параметры и возвращать значения, что позволяет нам разбивать сложные задачи на более мелкие и управляемые подзадачи.
Методы помогают нам уменьшить повторение кода и сделать наши программы легче для понимания и поддержки.
Классы и объекты:
Мы познакомились с концепцией классов как с чертежами для создания объектов.
Мы создали класс Car с атрибутами (марка, модель, год выпуска) и методами (отображение информации, ускорение, торможение и т.д.).
Мы научились создавать объекты (экземпляры класса) и вызывать методы для этих объектов.
Объектно-ориентированное программирование:
Мы увидели, как объектно-ориентированное программирование позволяет нам моделировать реальные концепции в нашем коде.
Мы инкапсулировали данные (атрибуты) и поведение (методы) в нашем классе Car.
Мы создали несколько объектов Car, показав, что каждый объект имеет свой собственный набор данных, но использует одни и те же действия, определенные классом.
Расширение функциональности класса:
Мы расширили класс Car более сложными методами, в том числе методом, который использует встроенные инструменты для работы с датами в Java, чтобы определить, является ли автомобиль антикварным.
Мы увидели, как методы могут взаимодействовать с данными объекта и внешней информацией, чтобы получать новую информацию.
Работа с несколькими объектами:
Мы создали массив объектов Car, показав, как работать с коллекциями объектов в наших программах.
Эти концепции являются основой программирования на Java и необходимы для создания более крупных и сложных приложений. По мере продолжения изучения Java вы будете многократно использовать эти концепции.
Помните, что овладение программированием требует постоянной практики. Вот несколько идей, которые помогут вам расширить свои знания:
Попробуйте добавить больше атрибутов в класс Car, например, color (цвет) или mileage (пробег).
Создайте методы, которые изменяют эти атрибуты, например, paint(String newColor) (покрасить в новый цвет) или drive(int miles) (пройти определенное количество миль).
Создайте класс Garage (гараж), который может хранить несколько объектов Car. Добавьте методы для добавления автомобилей в гараж, удаления автомобилей и отображения всех автомобилей в гараже.
Пробуйте создавать классы для других типов объектов, таких как Book (книга) или Student (студент).
Продолжайте писать код, продолжайте исследовать, и, что самое главное, продолжайте получать удовольствие! Вы идете по верному пути к тому, чтобы стать опытным программистом на Java.
