Java: быстрый старт. Т.В. Гурьянова

Введение в Java: быстрый старт

Т.В. Гурьянова

Книга в разных форматах доступна по ссылке: https://drive.google.com/folderview?id=0B4icNOfw8DwUc25MbHJjQ0lTQVk&usp=sharing

Предисловие

Основу данного учебного пособия составили программы из книги по Java 2 П.Ноутона и Г.Шильтда [1], а также теория и задания 30-часового курса по основам Java, который читался Т.В. Гурьяновой школьникам 6-8 классов «Юни-центра XXI» ФПМИ БГУ в 2014/2015 учебном году.

Первая простая программа

Теперь, когда объектно-ориентированные основы языка Java были обсуждены, посмотрим на некоторые реальные программы. Начнем с компиляции и выполнения короткой программы, представленной ниже. Как вы увидите, она включает немного больше работы, чем можно было бы представить.

/* Это простая Jаvа-программа.

Назовите этот файл “Example.java” . */

class Example {

// Программа начинается с вызова main().

public static void main(String[ ] args) {

System.out.println (“Это простая Jаvа-программа.”); }}

После выполнения программы на экран выводится строка:

Это простая Jаvа-программа.

Рассмотрим поближе каждую часть программы.

/* Это простая Jаvа-программа. Назовите этот файл “Example.java”. */

Это комментарий. Как и большинство других языков программирования, Java позволяет вводить замечания в исходный программный файл. Содержимое комментария игнорируется компилятором. Комментарий описывает и объясняет работу программы всем, кто читает исходный код. Такой тип комментария называют многострочным комментарием. Этот тип комментария должен начинаться символами /* и заканчиваться */. Все символы, находящиеся между этими парами, игнорируются компилятором.

Следующая строка кода программы:

class Example {

Эта строка использует ключевое слово class для объявления, что определен новый класс.


Полное определение класса, включающее все его члены, размещается между открывающей ({) и закрывающей (}) фигурными скобками. Использование фигурных скобок в Java аналогично способу их использования в С и С++ (begin и end в Паскале).

Следующая строка в программе — однострочный комментарий:

// Программа начинается с вызова main( ).

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

Следующая строка кода:

public static void main(String[ ] args) {  — строка заголовка метода (функции) main ( ). Как подсказывает предшествующий комментарий, отсюда начнется выполнение программы. Все приложения Java начинают выполнение с вызова main ( ). (Точно так же, как в C/C++.)

Итак, main ( ) — это метод, вызываемый, когда Jаvа-приложение начинает выполняться. Имейте в виду, что Java чувствителен к регистру. Таким образом, Main отличается от main.

Следующая строка кода (заметим, она находится внутри main ( ):

System.out.println (“Это простая Jаvа-программа.”) ;

выводит на экран строку “Это простая Jаvа-программа.”,

Вот еще один пример программы: мы определяем целочисленную переменную num, затем увеличиваем ее значение вдвоер результаты выводим на экран (в консоль):

//отладку сделал Борис Комаров, 5 класс

public class Example2 {

public static void main(String[] args) {

int num;

num=100;

System.out.println(“Znachenie num: “ +num );

num = num * 2;

System.out.println(“Znachenie num: “ +num );

}

}

Оператор if

Формат if:

if (condition) statement;

Здесь condition представляет собой логическое выражение. Если оно истинно (true), то statement исполняется. Если condition ложно (false), то statement пропускается.

Пример программы, иллюстрирующей оператор if:

//отладку сделал Илья Бохон, 7 класс

public class IfSample {

public static void main(String[] args) {

int x, y;

x=10;

y=20;

if(x < y) System.out.println(“x menshe chem y”);

x = x * 2;

if(x == y) System.out.println(“x ravno y”);

x = x * 2;

if(x > y) System.out.println(“x bolshe chem y”);

// следующий оператор не выводит свое сообщение

if(x == y) System.out.println(“vy nichego ne uvidite”);

}

}

Вывод, генерируемый этой программой:

х x menshe chem у

х ravno у

х bolshe chem у

Обратите внимание на строку:

int х, у;

В ней объявлены две переменные, х и y, разделенные запятой.

Сокращенный if

Ниже показана программа, которая демонстрирует условную операцию. Она используется для получения абсолютного значения переменной.

//отладку сделала Анастасия Станкевич, 8 класс

public class ExampleIf2 {

public static void main(String[] args) {

int i, k;

i = 10;

k = i < 0 ? -i: i; //получить абсолютное значение i

System.out.print(“Абсолютное значение “);

System.out.println(i + “ равно” + k);

i = -10;

k = i < 0 ? -i: i; //получить абсолютное значение i

System.out.print(“Абсолютное значение “);

System.out.println(i + “ равно” + k);

}

}

Вывод, генерируемый программой:

Абсолютное значение 10 равно 10

Абсолютное значение -10 равно 10

Пояснение.

Строка

k = i < 0 ? -i: i;

аналогична выполнению двух строк:

if (i < 0) k=-i;

if (i >= 0) k=i;

Цикл for

Формат цикла for:

for (initialization; condition; iteration) statement;

Логическое выражение condition проверяет эту переменную. Если результат проверки — истина (true), цикл for продолжает итерации, если — ложь (false), цикл завершается. Выражение iteration определяет, как переменная цикла изменяется на каждом шаге выполнения цикла.

Пример программы, иллюстрирующей цикл for:

//отладку сделал Роман Климаков, 6 класс

public class ForTest {

public static void main(String[] args) {

int x;

for(x = 0; x<10; x = x+1)

System.out.println(“Значение x: “ + x);

}

}

Программа генерирует следующий вывод:: ..

Значение х: 0

Значение х: 1

Если вы знакомы с С/С++, то знаете, что на этих языках запятая — это оператор, который можно использовать в любом правильном выражении. В Java, однако, дело обстоит не так. В Java запятая — это разделитель, который применяется только в цикле for:

/* Два разделенных запятыми оператора в итерационной части

выполняются каждый раз, когда цикл повторяется.*/

//отладку сделал Егор Безмен

public class CiklFor {

public static void main(String[] args) {

int a , b;

for(a=1, b=4; a<b; a++, b—) {

System.out.println(“a = “ + a);

System.out.println(“b = “ +b);

}

}

}

Программа генерирует следующий вывод:

а = 1

b = 4

а = 2

b = 3

Оператор switch

Модифицируйте программу, введя номер месяца с клавиатуры:

//отладку сделал Иван Королев, 7 класс

public class SwitchSample {

public static void main(String[] args) {

int month = 13;

String season;

switch (month){

case 2:

case 1:

case 13:

season =”Зима”;

break;

case 5:

case 4:

case 12:

season =”Весна”;

break;

case 9:

case 7:

case 8:

season =”Лето”;

break;

case 3:

case 44:

case 6:

season =”Осень”;

break;

default:

season = “Непонятный месяц”;}

System.out.println(“ это “ + season + “.”);}}

Оператор switch может быть вложенным:

switch(count) {

case 1:

switch(target){ // вложенный switch

case 0:

System.out.println (“target равен нулю”) ;

break;

case 1: // нет конфликтов с внешним switch

System.out.println(“target равен единице”);

break;

}

break;

case 2:

Оператор цикла while

while(условие) {

// тело цикла

}

//отладку сделал Егор Безмен

public class _While {

public static void main(String[] args) {

int n=10;

while (n>0){

System.out.println(“тик “ + n);

n—;

}

}

}

Программа при выполнении “тикнет” ровно десять раз:

тик 10

тик 9

тик 8

тик 1

Цикл do while

Цикл do while особенно полезен, когда вы обрабатываете выбор из меню, потому что обычно требуется, чтобы тело цикла меню выполнялось по крайней мере один раз. Рассмотрим следующую программу, которая реализует очень простую справочную систему для Jаvа-операторов выбора и повторения (полужирным шрифтом выделен консольный ввод символа):

//Пример программы-викторины, написанной Даниилом Селиным, 6 класс

public class viktorina {

public static void main(String[] args)

//операторы, выделенные полужирным обеспечивают консольный ввод символа

throws java.io.IOException {

char x,r,tmp;

int y = 0;

do{

System.out.println(“Гаттерия  — это:”);

System.out.println(“1. бабочка огромных размеров”);

System.out.println(“2. Мелкий крокодил”);

System.out.println(“3. единственная рептилия, у которой есть третий глаз на темени”);

x = (char) System.in.read();

tmp= (char) System.in.read();

// это считывание в tmp необходимо, поскольку завершение консольный ввод завершается

// нажатием клавиши Enter, что, в свою очередь, воспринимается, как ввод символа

if (x == ‘3’) {System.out.println(“Вы правы плюс очко”);

y = y + 1;}

if (x != ‘3’) System.out.println(“Вы не правы “);

}

while(x<’1’||x>’3’);

do{

System.out.println(“Сколько обычно весит сама крупная рептилия — кожистая черепаха:”);

System.out.println(“1.до 700 кг “);

System.out.println(“2. до 1000 кг “);

System.out.println(“3. до 2000 кг “);

x = (char) System.in.read();

tmp=(char) System.in.read();

if (x == ‘1’) {System.out.println(“Вы правы плюс очко”);

y = y + 1;}

if (x != ‘3’) System.out.println(“Вы не правы “);

}

while(x<’1’||x>’3’);

do{

System.out.println(“Самый крупный динозавр (длинна до 36 м и вес до 88 тонн):”);

System.out.println(“1. диплодок “);

System.out.println(“2. сейсмозавр “);

System.out.println(“3. бронтозавр”);

x = (char) System.in.read();

if (x == ‘2’) {System.out.println(“Вы правы плюс очко”);

y = y + 1;}

if (x != ‘3’) System.out.println(“Вы не правы “);

}

while(x<’1’||x>’3’);

System.out.println(“Вы получили “+y+” очко”);

}

}

Упражнения

1. Поменяйте между собой значения двух переменных a и b:

(a) воспользовавшись третьей переменной r для временного хранения значений;

(b) не используя других переменных.

2. Найдите сумму членов арифметической прогрессии a, a+d, a+2*d,… , a+n*d

по заданным значениям a, d, n

3. Вычислите расстояние между двумя точками с координатами X1, Y1 и X2, Y2.

4. Переменная X содержит трехзначное целое число. Поместите в переменную

S сумму цифр этого числа.

5. Возведите число А в пятую степень, в шестнадцатую степень.

6. Введите число. Напечатайте 1, если число четное, и 0, если число нечетное.

7. Ввести два числа и напечатать сначала меньшее, затем большее.

8. Решить предыдущую задачу, использовав только один оператор вывода.

9. Ввести три числа. Выбрать и напечатать наибольшее из них.

10. Напишите программу, которая вводит целые числа с клавиатуры и складывает их, пока не будет введено число 0.

11. Введите с клавиатуры n чисел и определите их среднее арифметическое.

12. Сосчитайте, сколько шестизначных чисел имеют одинаковые суммы трех первых и трех последних цифр.

13. Составьте программу, печатающую квадраты всех натуральных чисел от 0 до заданного натурального n.

14. Разбейте заданное число на два слагаемых всеми различными способами. Способы, отличающиеся лишь порядком слагаемых, разными не считать!

15. Распечатайте квадраты чисел от 1 до n, используя из арифметических операций лишь сложение.

16. Вычислите произведение чисел от n до m, где n<m; n, m — натуральные числа, пользуясь циклом for.

17. Напишите программу, которая находит и печатает все совершенные числа от 2 до x. Совершенное число — это число, равное сумме всех своих делителей, включая единицу, но исключая само число. (Например, 28=1+2+4+7+14, 6=1+2+3- совершенные числа

18. Вычислите сумму чисел от 1 до n, возведенных в степень m.

19. Введите число и определите, простое оно или составное. Распечатайте первую сотню простых чисел.

Один из вариантов выполнения 1 (а) упражнения (программа написана Егором Безменом):

public class Upr_1 {

public static void main(String[] args) {

int a=5;

int b=10;

int r;

System.out.println(“a=”+a);

System.out.println(“b=”+b);

r=a;

a=b;

b=r;

System.out.println(“Меняем величины переменных”);

System.out.println(“a=”+a);

System.out.println(“b=”+b);

}

}

Один из вариантов выполнения 2 упражнения (программа написана Анастасией Станкевич):

import java.io.IOException;

public class Program2 {

public static void main(String[] args) throws IOException {

int a, d, n, i, k;

System.out.println(“Введите 3 числа”);

a=(int)System.in.read();//Чтобы вы зря не радовались — эта строка не работает

d=(int)System.in.read();//И эта

n=(int)System.in.read();//И эта тоже. Да. Вы попали.

for(i=0; i<n; i++)

{

k=a+d*i;

System.out.println(a+”+”+d+”*”+i+”=”+k);

}

}

}

Массивы

Следующая программа создает трехмерный массив Зх4х5, затем заполняет каждый элемент произведением его индексов и отображает эти значения на экран.

// Демонстрирует трехмерный массив.

//отладку сделал Никита Капитанов, 9 класс:

public class Example {

public static void main(String[] args) {

int theeD[][][] = new int[3][4][5];

int i, j, k;

for(i=0; i<3; i++)

for( j=0; j<4; j++)

for( k=0; k<5; k++)

theeD[i][j][k] = i *j * k;

for( i=0; i<3; i++){

for( j=0; j<4; j++){

for( k=0; k<5; k++)

System.out.print(theeD[i][j][k] + “ “);

System.out.println();

}

System.out.println();

}

}

Упражнение. Напишите программу, в которой элементы 2-мерного массива вводятся с клавиатуры (консольный ввод), а затем выводятся на экран:

for(i=0; i<4; i++){

for(j=0; j<4; j++)

Sytem.out.print(m[i] [j] + “ “);

System.out.println( );}

Упражнение. Вставьте код в java-проект, допишите его, чтобы получить следующую таблицу:

0 0 0 0

0 1 2 3

0 2 4 6

0 3 6 9

// Демонстрирует двумерный массив.

//отладку сделала Анастасия Станкевич:

public class Example2 {

public static void main(String[] args) {

int m[][]= new int [4][4];

int i, j;

for(i=0; i<4; i++)

for(j=0;j<4; j++)

m[i][j]=i*j;

for(i=0; i<4; i++){

for(j=0;j<4; j++)

System.out.print(m[i][j]+”.0 “);

System.out.println();

}

}

}

Упражнения

1. Подсчитайте произведение элементов массива.

2. Вычислите значения функции Y=X*X для X=2,4,6,8,… ,28 и разместите их в одномерном массиве Y.

3. Измените порядок следования значений элементов массива на обратный.

4. “Сожмите”’ числовой массив, выбросив из него отрицательные числа. (Сдвиньте все элементы массива после удаления отрицательных чисел, пустые места в конце массива заполните нулями.)

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

6. Задан массив и некоторое число. Найти, на каком месте расположено число в массиве.

7. В массиве целых чисел найдите самую длинную неубывающую последовательность.

8. Поверните квадратный (количество строк равно количеству столбцов) массив

на 90, 180, 270 градусов по часовой стрелке. (В этой задаче требуется не положить все цифры “на бок” или поставить на голову, а передвинуть элементы в указанном порядке.)

9. Выясните, есть ли одинаковые числа:

(a) в одномерном массиве;

(b) в двумерном массиве;

10. Подсчитайте количество уникальных (неповторяющихся) чисел в массиве.

11. В массиве содержатся числа 0, 1, 2 и ничего кроме них. Упорядочить массив по неубыванию.

12. Взяв за основу предыдущую задачу, упорядочить массив по убыванию. Можно менять местами лишь соседние элементы.

13. Задан массив чисел. Заменить каждое число суммой предыдущих:

(a) включая заменяемое

(b) исключая заменяемое.

Введение в классы

Вот пример описания класса — нового типа, описанного пользователем, в нашем примере — класс Box состоит из трех переменных типа double (width, height, depth). При инициализации переменной вновь созданного типа-класса вызывается конструктор с таким же именем, как и класс (new Box()).

//отладку сделал Антон Силебин, 9 класс

public class Box{

double width;

double height;

double depth;

}

public class BoxDemo {

public static void main(String[] args) {

//выделяется место в памяти под переменную mybox типа Box:

Box mybox = new Box();

mybox.width = 10;

mybox.height = 20;

mybox.depth = 15;

double vol;

vol = mybox.width*mybox.height*mybox.depth;

System.out.println(“Obyem raven “ + vol);

}

}

Каждый объект имеет свои собственные копии переменных экземпляра. Если вы имеете два Bох-объекта (объявление класса Box, хранящих характеристики прямоугольного параллелепипеда, см. ниже), каждый из них обладает своей собственной копией depth (длина основания), width (ширина основания) и height (высота). Важно понять, что изменения переменных экземпляра одного объекта не имеют никакого влияния на переменные экземпляра другого.

Следующая программа объявляет два Bох-объекта:

//отладку сделал Егор Кресик

import java.util.Scanner;

class Box {

int width;

int height;

int depth;

};

class BoxDemo2{

public static void main(String[] args)

throws java.io.IOException{

Box mybox1 = new Box();

Box mybox2 = new Box();

double vol;

Scanner in = new Scanner(System.in);

System.out.println(“Напишите параметры первого параллелепипеда”);

// присвоить значения переменным экземпляра объекта mуbох1 класса Box (водятся с клавиатуры):

mybox1.width = in.nextInt();

mybox1.height = in.nextInt();

mybox1.depth = in.nextInt();

System.out.println(“Теперь второго”);

mybox2.width = in.nextInt();

mybox2.height = in.nextInt();

mybox2.depth = in.nextInt();

// вычислить объем первого параллелепипеда:

vol = mybox1.width * mybox1.height * mybox1.depth;

System.out.println(“Объем равен “ + vol);

vol = mybox2.width * mybox2.height * mybox2.depth;

System.out.println(“Объем равен “ + vol);

}

}

Для объявления объектов myboxl и mybox2 типа Вoх использовались строки вида:

Bох mybox1= new Bох();

Bох mуbох2 = new Bох();

Оператор Bох mybox = new Bох(); комбинирует два шага:

Вох mybox; // объявить ссылку на объект

mуbох = new Bох(); // распределить память для Вох-объекта

Давайте теперь вычисление объема параллелепипеда (mybox2.width * mybox2.height * mybox2.depth) сделаем функцией, описанной в самом классе Box:

// Эта программа включает метод внутрь класса Вох.

class Вох {

double width;

double height;

double depth;

// вычислить и вывести на экран объем параллелепипеда:

void volume () {

System.out.print (“Объем равен “);

System.out.println(width * height * depth);

class ВохDеmоЗ {

public static void main(String args[]) {

Bох mуbох1 = new Bох();

Bох mуbох2 = new Bох();

// присвоить значения переменным экземпляра rnуbох1

mybox1.width = 10;

mybox1.height = 20;

mybox1.depth = 15;

// присвоить другие значения переменным экземпляра rnуЬох2

mybox2.width = 3;

mybox2.height = 6;

mybox2.depth = 8;

// показать объем первого параллелепипеда:

mybox1.volume();

// показать объем второго параллелепипеда:

mybox2.volume();

}}

Перегрузка конструкторов

Опишем класс Box следующим образом:

class Вох {

double width;

double height;

double depth;

// Это новый вид конструктора класса Вох (с параметрами!):

Box(double w, double h, double d) {

width = w;

height = h;

depth = d;}

double volume(){return width * height * depth};

Здесь конструктор Вох() имеет три параметра. Это означает, что все объявления Вoх-объектов должны переслать в конструктор Вох() три аргумента. Например, объявление в этом случае

Box mуbох2 = new Box(3,6,8);

будет равнозначным выполнению нескольких строчек из предыдущей программы:

Bох mуbох2 = new Bох();

mybox2.width = 3;

mybox2.height = 6;

mybox2.depth = 8;

что экономит время и упрощает запись.

Но!

Например, следующий оператор Вох оb = new Вох(); в новом варианте описания объекта Box будет недопустим: Вох () требует трех параметров, и его вызов без них — ошибка.

Это поднимает несколько важных вопросов. Что, если вы просто хотели построить трехмерный блок и не знаете (не хотите знать), каковы его размеры? А можно ли сократить запись, если вы хотите инициапизировать куб: тогда достаточно задать лишь одно значение, и оно будет использоваться для всех трех размеров.

Все эти проблемы решаются с помощью перегрузки конструктора Вох().

// Класс Bох: три конструктора для разных способов инициализации размеров блока.

class Bох {

double width;

double height;

double depth;

// конструктор для инициализации всех размеров

Bох(dоublе w, double h, double d) {

width = w;

height = h;

depth = d;

// конструктор для инициализации без указания размеров

// по ряду причин удобно использовать -l для указания блока с незаданными значениями размеров

Bох () {

width = -1;

height = -1;

depth = -1;

// конструктор для создания куба

Box(doub1e 1еn) {

width = height = depth = len;

// вычислить и возвратить объем

double volume() {return width * height * depth;}

с1аss OverloadCons {

public static void rnain(String args[]) {

// создать блоки, используя различные конструкторы

Bох mуbох1 new bох(10, 20, 15);

Bох mуbох2 = new bох();

Bох mуcube new bох(7);

double vol;

// получить объем первого блока

vol = myboxl.volume();

Sуstem.оut.рrintln(“Объем mуbох1 равен” + vol);

// получить объем второго блока

vo1 = mybox2.vo1ume();

Sуstem.оut.рriпtln(“Объем mуbох2 равен” + vo1);

// получить объем куба

vo1 = mycube.vo1ume();

Sуstеm.оut.рriпt1n(“Объем mусubе равен” + vo1);

}}

Рекурсия

Java поддерживает рекурсию. Рекурсия — это процесс определения чего-то в терминах самого себя. Что касается Jаvа-программирования, то рекурсия — это атрибут, который позволяет методу вызвать самого себя. Такой метод называют рекурсивным.

Классический при мер рекурсии — вычисление факториала числа. Факториал числа N есть произведение всех целых чисел между 1 и N. Например, факториал 3 равен lx2x3 или 6. Ниже показано, как факториал может быть вычислен при помощи рекурсивного метода:

// Простой пример рекурсии

//Отладка сделана Иваном Гужевым и Алексеем Гусаром

class Factorial {

int fact(int n){

int result;

if (n==1)return 1;

result=fact(n-1)*n;

return result;}

}

public class Recursion {

public static void main(String[] args) {

Factorial f = new Factorial();

System.out.println(“факториал 3 =”+ f.fact(3));

System.out.println(“факториал 4 =”+ f.fact(4));

System.out.println(“факториал 5 =”+ f.fact(5));

}}

Вывод этой программы:

Факториал 3 равен 6

Факториал 4 равен 24

Факториал 5 равен 120

Упражнение. Вычислите n! без использования рекурсии.

Вот один из вариантов выполнения этого упражнения (сделал Егор Кресик, 9 класс):

public class Recursion {

public static void main(String[] args) {

int a,b,s;

a=9;

b=1;

s=1;

for(b = 1; b<=a; s = s*b, b++);

System.out.println(s);

}

}

Передача аргументов

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

Второй способ — передача аргумента по ссылке. В этом методе ссылка на параметр (а не его значение) передается параметру. Внутри подпрограммы она используется, чтобы обратиться к фактическому параметру, указанному в вызове. Это означает, что изменения параметра будут влиять на аргумент, использованный для вызова подпрограммы. Java использует оба метода, в зависимости от того, что передается во время вызова подпрограмме. Когда методу передается простой тип, он передается по значению. Таким образом, то, что происходит с параметром, который принимает аргумент, никак не влияет на сам аргумент (Т. е. аргумент при этом не изменяется).

Рассмотрим следующую программу:

// Простые типы передаются по значению.

class Test (

void meth(int i, int j) {

i *= 2;

j /= 2;

class CallByValue {

public static void main(String args[]) (.

Test оb = new Test();

int а = 15, b = 20;

System.out.println(“a и b перед вызовом: “ + а + “ “ + b);

ob.meth(a, b);

System.out.print1n(“a и b после вызова: “ + а + “ “ + b);

Вывод этой программы:

а и b перед вызовом: 15 20

а и b после вызова: 15 20

Как видите, операции, которые происходят внутри meth (), никак не влияют на значения a и b, используемые в вызове (их значения здесь не изменялись до 30 и 10, хотя метод meth() И выполнил соответствующие вычисления над своими параметрами).

Когда вы передаете методу объект, ситуация драматически изменяется, потому что объекты передаются по ссылке. Имейте в виду, что при создании переменной типа “класс”, вы создаете только ссылку на объект. Таким образом, когда вы передаете эту ссылку методу, принимающий ее параметр будет ссылаться на тот же самый объект, что и аргумент. Это и означает, что объекты передаются методам по ссылке. Все изменения объекта внутри метода затрагивают объект, используемый как аргумент. Например, рассмотрим следующую программу:

// Объекты передаются по ссылке.

class Test {

int а, b;

Test (int i, int j) {

а = i

b = j;

// передать объект

void meth(Test о) {

o.а *= 2;

о.b /= 2;

class CallByRef {

public static void main(String args[]) {

Test оb = new Test(15, 20);

System.out.println(“ob.a и оb.b перед вызовом: “ + оb.а + “ “ + оb.b);

ob.meth(ob);

System.out.println(“ob.a и оb.b после вызова: “ + оb.а + “ “ + оb.b);

Эта про грамма генерирует следующий вывод:

оb.а и оb.b перед вызовом: 15 20

оb.a и оb.b после вызова: 30 10

Не трудно заметить, что в этом случае действия внутри meth() воздействовали на объект, используемый как аргумент.

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

Замечание. Простые типы передаются методу по значению, а объекты — по ссылке.

Возврат объектов

Метод может возвращать любой тип данных, включая типы классов, которые вы создаете. Например, в следующей программе метод incrByTen() возвращает объект, в котором значение а на десять больше, чем в вызывающем объекте.

// Возврат объекта

сlаss Test

int а;

Test (int i) (

а = i;

Test incrByTen() {

Test temp = new Test(a+l0);

return temp;

class RetOb {

public static void main(String args[]) (

Test оb1 = new Test(2);

Test оb2;

оb2 = ob1.incrByTen();

System.out.println(“obl.a: “ + оb1.а);

System.out.println(“ob2.a: “ + оb2.а);

ob2 = оb2. inсrВуТеn () ;

System.out.println(“ob2.a после повторного увеличения: “ + оb2.а);

Вывод, сгенерированный этой программой:

оb1.а: 2

оb2.а: 12

оb2.а после повторного увеличения: 22

Каждый раз, когда incrByTen() вызывается, создается новый объект, и ссылка на него возвращается вызывающей подпрограмме.

Пример программы, считывающий строки текста из консоли

//Отладку выполнил Бохон Илья, 7 класс :

import java.io.BufferedReader;

import java.io.InputStreamReader;

public class example {

public static void main(String[] args)

throws java.io.IOException {

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String str[] = new String[100];

System.out.println(“ВведиТе строки текста.”);

System.out.println(“Введите ‘stop’ для завершения.”);

for (int i=0; i<100; i++) {

str[i] = br.readLine();

if(str[i].equals(“stop”)) break;

}

System.out.println(“\n Boт ваши строки:”);

for(int i=0; i<100; i++) {

if(str[i].equals(“stop”)) break;

System.out.println(str[i]);

}

}

}

Чтение данных из текстового файла

Программа выполняющая чтение из текстового файла text.txt (должен находиться в основной папке проекта)

//программу отладил Егор Кресик

import java.io.*;

class ShowFile {

public static void main(String args[])

throws IOException{

int i;

FileInputStream fin;

try {

fin = new FileInputStream(“text.txt”);

}

catch(FileNotFoundException е) {

System.out.print(“ФаЙл не найден”);

return;}

catch(ArrayIndexOutOfBoundsException е){

return;}

do{

i = fin.read () ;

if(i != -1) System.out.print( (char) i);

}while (i != -1);

fin.close();

}}

Работаем со строками

//Отладку выполнил Бохон Илья

class example{

public static void main(String args[]){

char с[] = {‘J’,’а’, ‘v’, ‘а’};

String s = new String(с);

String s2 = new String(s);

System.out.println(s);

System.out.println(s2);

}

}

package proj;

class example{

public static void main(String args[]) {

byte ascii[] = {65, 66, 67, 68, 69, 70 };

String sl = new String(ascii);

System.out.println(sl);

String s2 = new String(ascii, 2, 3);

System.out.println(s2);

}

}

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

Система Swing

Отсюда скачиваем ПО: https://netbeans.org/downloads/

Вводный урок (Лабораторная 1) можно найти тут:

https://www.youtube.com/watch?v=2IZebtJuh3s

Попробуем, опираясь на то, что было рассказано выше, преобразовать строку в число

String str = new String(jTextField1.getText());

int n=str.length();

char str_mass[]= str.toCharArray(); // преобразуем строку в массив символов

int a,b=0;

for(int i=0;i<=n+1;i++) {

a=str_mass[i]-48;

b=b*10+a;

System.out.print(“i=”+i+’\t’+”b=”+b+” a=”+a+’\t’+”n=”+n+’\n’);

Лабороторная 2

Сложение двух чисел по щелчку кнопки. Программа считывает значение переменных из двух

текстовых полей и выводит их сумму в элемент управления Swing “метка” (jLabel).

String str1 = jTextField1.getText();

String str2 = jTextField2.getText();

int n1=str1.length();

int n2=str2.length();

char str_mass1[]= str1.toCharArray();

char str_mass2[]= str2.toCharArray();

int a1,a2,b1=0;

int b2=0;

for(int i=0;i<n1;i++) {

a1=str_mass1[i]-48;

b1=b1*10+a1;

}

System.out.print(“b1= “+b1);

for(int i=0;i<n2;i++) {

a2=str_mass2[i]-48;

b2=b2*10+a2;

}

int sum=b1+b2;

System.out.print(sum);

jLabel1.setText(“сумма числел = “ + sum);

Как правильно преобразовать строку в число Опубликовано в java.lang

http://javist.ru/category/java-lang/):

byte b = Byte.parseByte(“123”);

short s = Short.parseShort(“123”);

int i = Integer.parseInt(“123”);

long l = Long.parseLong(“123”);

float f = Float.parseFloat(“123.4”);

double d = Double.parseDouble(“123.4e10”);

Видео по выполнению этой лабораторной находится тут:

https://www.youtube.com/watch?v=11ozSJc0Wvg

https://www.youtube.com/watch?v=4E6wgAwQcrM

В итоге выпоненная лабораторная должна содержать примерно такой код:

String str1 = jTextField1.getText();

String str2 = jTextField2.getText();

double a = Double.parseDouble(str1);

double b = Double.parseDouble(str2);

double sum=a+b;

jLabel1.setText(“Сумма чисел равна“+sum);

jPanel1.add(jLabel1);

Лабороторная 3. Заготовка к игре “Крестики нолики”

1. Cоздаем новый проект.

2. Перетаскиваем на форму 10 кнопок Button1,…, Button9. Стираем на них подписи, делаем нужный размер.

9 кнопок располагаем по три в ряд, десятую — отдельно — при нажатиии на нее ход будет передаваться компьютеру.

Таким образом мы формируем поле для игры в крестики-нолики.

Для простоты считаем, что первым ходит человек, в качестве “фишек” выбираем “крестики”. Компьютер будет

всегда делать ответный ход и играть “ноликами”, причем будет перебирать все пустые “клетки поля”

(в нашем случае кнопки 1-9) и ставить “нолики” в первое свободное.

3. В обработчик щелчка кнопок 1-9 (двойной клик на кнопку) вставляем код:

jButton1.setText(“X”);

jButton9.setText(“X”);

4. В обработчик щелчка кнопки 10

вставляем код:

if ((jButton1.getText()!=”X”)&&(jButton1.getText()!=”O”)) jButton1.setText(“O”);

else if ((jButton2.getText()!=”X”)&&(jButton2.getText()!=”O”)) jButton2.setText(“O”);

else if ((jButton3.getText()!=”X”)&&(jButton3.getText()!=”O”)) jButton3.setText(“O”);

else if ((jButton4.getText()!=”X”)&&(jButton4.getText()!=”O”)) jButton4.setText(“O”);

else if ((jButton5.getText()!=”X”)&&(jButton5.getText()!=”O”)) jButton5.setText(“O”);

else if ((jButton6.getText()!=”X”)&&(jButton6.getText()!=”O”)) jButton6.setText(“O”);

else if ((jButton7.getText()!=”X”)&&(jButton7.getText()!=”O”)) jButton7.setText(“O”);

else if ((jButton8.getText()!=”X”)&&(jButton8.getText()!=”O”)) jButton8.setText(“O”);

else if ((jButton9.getText()!=”X”)&&(jButton9.getText()!=”O”)) jButton9.setText(“O”);

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

5. Убираем кнопку 10 (передающую ход компьютеру), при этом автомотически уничтожается код описанный в п.4.

6. Вводим глобальную меременную int cnt, с помощью которой будем считать ходы: на четном ходе ставится “X”,

на нечетном — “О”. Для этого сразу после названия главного класса

public class NewJFrame extends javax.swing.JFrame {

прописываем:

int cnt=0;

7. В обработчик щелчка кнопок 1-9 (двойной клик на кнопку) изменяем код:

if (cnt%2==0)jButton1.setText(“X”);

else jButton1.setText(“O”);

cnt=cnt+1;

if (cnt%2==0)jButton9.setText(“X”);

else jButton9.setText(“O”);

cnt=cnt+1;

8. Тестируем приложение с напарником, думаем, как написать игру человек-компьютер, используя некоторую стратегию. Пробуем реализовать.

Видео по выполнению этой лабораторной находится тут:

https://www.youtube.com/watch?v=0yZ3ilIjR5E&feature=youtu.be

Чтобы определить выигрышную позицию, при нажатии, например, кнопки “Ход компьютера” перед тем, как компьютер поставит “О”, можно проверить, не выиграл ли человек. Так проверяем, не стоят ли крестики в горизонтальном среднем ряду:

if ((jButton3.getText()==”X”)&&(jButton4.getText()==”X”)&&(jButton5.getText()==”X”)) jLabel1.setText(“You win”);

Если же выигрышная комбинация образовалась после хода компьютера, то на поле выведим надпись “Oops…” Для этоко после кода, приведенного в п.4 добавим проверку (сейчас проверяем, не стоят ли нолики в горизонтальном среднем ряду ):

if ((jButton3.getText()==”O”)&&(jButton4.getText()==”O”)&&(jButton5.getText()==”O”)) jLabel1.setText(“Oops…”);

После того, как вы полностью отладили программу для игры 3×3, можете увеличить размерность до 4×4,… Можете также добавть кнопку “New game”, при нажатии на которую надписи на всех игровых кнопках стираются:

jButton1.setText(“ ”);

jButton9.setText(“ ”);

Можете посмотреть также вариант игры, описанный в [2].

О средах разработки

Программисты обычно   работают   с   инструментом,   который   называется   интегрированная   среда   разработки   IDE   (Integrated   Development  Environment).  Программы  можно  писать, компилировать  и   запускать  прямо  в  этой  среде.  В  IDE  также  есть  такая  штука, как   Справка,  содержащая  все  элементы  языка,  которая  упрощает  поиск  и   исправление  ошибок  в  программах.  Про то, откуда можно скачать  IDE NetBeans, мы уже говорили. IDE  Eclipse  можно  загрузить  с  веб-­сайта  www.eclipse.org. Из загрузок различных версий http://www.eclipse.org/downloads/ можно выбрать, например, Eclipse IDE for Java EE Developers.

Создадим заготовку к калькулятору в IDE Eclipse или NetBeans, без использования графического редактора виджетов.

Видео по выполнению этой лабоаторной находится тут: http://youtu.be/x-Wtnuguv6k

import javax.swing.*;

import java.awt.FlowLayout;

public class SimpleCalculator {

public static void main(String[] args) {

// Создаём панель

JPanel windowContent= new JPanel();

// Задаём менеджер отображения для этой панели

FlowLayout fl = new FlowLayout();

windowContent.setLayout(fl);

// Создаём компоненты в памяти

JLabel label1 = new JLabel(«Number 1:»);

JTextField field1 = new JTextField(10);

JLabel label2 = new JLabel(«Number 2:»);

JTextField field2 = new JTextField(10);

JLabel label3 = new JLabel(«Sum:»);

JTextField result = new JTextField(10);

JButton go = new JButton(«Add»);

// Добавляем компоненты на панель

windowContent.add(label1);

windowContent.add(field1);

windowContent.add(label2);

windowContent.add(field2);

windowContent.add(label3);

windowContent.add(result);

windowContent.add(go);

// Создаём фрейм и задаём для него панель

JFrame frame = new JFrame(«My First Calculator»);

frame.setContentPane(windowContent);

// задаём и размер и делаем фрейм видимым

frame.setSize(400,100);

frame.setVisible(true);

}

}

Скомпилируйте  и  запустите  эту  программу.

Swing устарел для написания графических програм для интернет приложений. Создатели Java придумали платформу JavaFX, специально для этих целей: http://www.oracle.com/technetwork/java/javase/overview/javafx-overview-2158620.html

Платформа JavaFX

Лабораторная

В основе выполнения этой лабораторной работы мы взяли однин из видео-уроков

Oracle Learning Library: (https://vk.com/computersciencescollege?w=wall-86363774_72)

1. Создайте в NetBeans новый проект: JavaFX\Приложение (Application) Java FX.

2. Запустите его: увидите кнопку с надпистью «Say: Hello world» при каждом нажатии на которую в консоль будет выводится надпись «Hello world». Сделайте так, чтобы окощко для игры было обсолютно пустое: уберите кнопку и прочее, закомментировав соответствующие строки кода.

После чего подпишите форму, например, «Game1» внеся изменения в строке кода: primaryStage.setTitle(«Game1»);

Проверьте, что получилось.

3. Измените размеры окна. Для этого введите две переменные (ширину высоту окна-сцены). Прописываем сразу после строки public void start(Stage primaryStage) {

final static int WIDTH=800; //задаем размеры окна игры (ширину)

final static int HEIGHTS=600; //задаем размеры окна игры (высоту)

И меняем соответсвующую строку, создающую сцену-окно в коде на:

Scene scene = new Scene(root, WIDTH, HEIGHTS);

4. Создайте изображение-заставку к игре. Для этого связыжите переменную, хранящую изображение с файлом Bgr.png, который Вами должен быть к этому времени уже нарисован и помещен в ту же папку, в которой находится главный файл проекта с кодом:

final Image BACKGROUNG_IMAGE = new Image(JavaFXGame1.class.getResource(«Bgr.png»).toString());

final ImageView background = new ImageView(BACKGROUNG_IMAGE);

final Group root= new Group(background);

Ваш файл с кодом на этом этапе должен выглядеть примерно так:

package javafxgame1;

import javafx.application.Application;

import javafx.scene.Group;

import javafx.scene.Scene;

import javafx.scene.image.Image;

import javafx.scene.image.ImageView;

import javafx.stage.Stage;

public class JavaFXGame1 extends Application { // в видео этот класс назван FXGame!!!

final static int WIDTH=800; //задаем размеры окна игры (ширину)

final static int HEIGHTS=600; //задаем размеры окна игры (высоту)

@Override

public void start(Stage primaryStage) {

//+++++++++++++++++++++++++++++++++++++++++++++++

//создаем изображение-заставку к игре

//+++++++++++++++++++++++++++++++++++++++++++++++

//связываем переменную, хранящую изображение с файлом Bgr.png, который нарисован заранее

//и помещен в ту же папку, в которой находится этог файл с кодом

final Image BACKGROUNG_IMAGE = new Image(JavaFXGame1.class.getResource(«Bgr.png»).toString());

//делаем возможным отобразить этот рисунок на нашей форме

final ImageView background = new ImageView(BACKGROUNG_IMAGE);

//группируем его для отображения на сцене

final Group root= new Group(background);//

Scene scene = new Scene(root, WIDTH, HEIGHTS);//задаем сцену с определенными размерами и заставкой

//+++++++++++++++++++++++++++++++++++++++++++++++

primaryStage.setTitle(«Game1»); //подписываем форму

primaryStage.setScene(scene);

primaryStage.show();

}

/**

* @param args the command line arguments

*/

public static void main(String[] args) {

launch(args);

}

}

5. Аналогичным образом добавляем на сцену три дерева и птичку, используем при этом различные функции маштабирования изображений и применения к ним спецэффектов. Код должен получиться примерно такой:

package javafxgame1;

import javafx.application.Application;

import javafx.scene.Group;

import javafx.scene.Scene;

import javafx.scene.effect.BoxBlur;

import javafx.scene.effect.DropShadow;

import javafx.scene.image.Image;

import javafx.scene.image.ImageView;

import javafx.stage.Stage;

public class JavaFXGame1 extends Application { // в видео этот класс назван FXGame!!!

final static int WIDTH=800; //задаем размеры окна игры (ширину)

final static int HEIGHTS=600; //задаем размеры окна игры (высоту)

@Override

public void start(Stage primaryStage) {

final Image BACKGROUNG_IMAGE = new Image(JavaFXGame1.class.getResource(«Bgr.png»).toString());

final Image TREE_1_IMAGE = new Image(JavaFXGame1.class.getResource(«tree1.png»).toString());

final Image TREE_2_IMAGE = new Image(JavaFXGame1.class.getResource(«tree2.png»).toString());

final Image TREE_3_IMAGE = new Image(JavaFXGame1.class.getResource(«tree3.png»).toString());

final Image BIRD_1_IMAGE = new Image(JavaFXGame1.class.getResource(«bird1.png»).toString());

final Image BIRD_2_IMAGE = new Image(JavaFXGame1.class.getResource(«bird2.png»).toString());

final ImageView tree1 = new ImageView(TREE_1_IMAGE);

tree1.scaleXProperty().set(0.5);//уменьшаем размеры деревьев в 2 раза,

tree1.scaleYProperty().set(0.5);//умножая высоту и ширину на 0.5

tree1.setTranslateX(-110);

tree1.setTranslateY(-150);

final ImageView tree2 = new ImageView(TREE_2_IMAGE);

tree2.scaleXProperty().set(0.5);

tree2.scaleYProperty().set(0.5);

tree2.setTranslateX(150);

tree2.setTranslateY(-120);

final ImageView tree3 = new ImageView(TREE_3_IMAGE);

tree3.scaleXProperty().set(0.5);

tree3.scaleYProperty().set(0.5);

tree3.setTranslateX(300);

tree3.setTranslateY(-30);

final Group foreground= new Group(tree1,tree2,tree3);

foreground.setEffect(new DropShadow());//Применяем к заднему фону эффект DropShadow

final ImageView bird1 = new ImageView(BIRD_1_IMAGE);

final ImageView bird2 = new ImageView(BIRD_2_IMAGE);

bird1.scaleXProperty().set(0.1);//уменьшаем размеры птицы в 10 раз,

bird1.scaleYProperty().set(0.1);//умножая высоту и ширину на 0.1

bird1.setTranslateX(-610);

bird1.setTranslateY(-580);

final Group bird = new Group(bird1);

final ImageView background = new ImageView(BACKGROUNG_IMAGE);

background.setEffect(new BoxBlur()); //Применяем к заднему фону эффект BoxBlur(),

background.setOpacity(0.5); // делаем его, в конечном итоге бледным и размытым.

final Group root= new Group(background,bird,foreground);

Scene scene = new Scene(root, WIDTH, HEIGHTS);//задаем сцену с определенными размерами и заставкой

//+++++++++++++++++++++++++++++++++++++++++++++++

primaryStage.setTitle(«Game1»); //подписываем форму

primaryStage.setScene(scene);

primaryStage.show();

}

/**

* @param args the command line arguments

*/

public static void main(String[] args) {

launch(args);

}

}

Окончательный вариант этой игры (подготовила Анастасия Станкевич, 8 класс) можно скачать отсюда: https://drive.google.com/folderview?id=0B4icNOfw8DwUfkh4eldWOThqdy1QbGhKSFJieTFOcnVQNndXaXhLckxsVXdQbDNWeGhucnM&usp=sharing

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

Ключевое слово this

Ключевое  слово this полезно, когда  нужно  сослаться  на  экземпляр класса внутри объекта этого класса.

Рассмотрим следующий пример:

class Fish {

int currentDepth ;

Fish(int currentDepth){

this.currentDepth = currentDepth;

}

}

Здесь  идентификатор this   помогает  избежать   конфликта  имён,  например this.currentDepth   ссылается   на   атрибут   класса   currentDepth,   в  то   время   как   currentDepth  ссылается   на   значение   аргумента  конструктора.  Другими   словами,   экземпляр   класса  Fish  указывает на самого  себя  с  помощью  слова  this.

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

Массивы

Предположим,  программа  должна  сохранить  имена  четырёх  игрoков.   Вместо  того,  чтобы  объявлять  четыре  переменные  типа String,  можно   объявить массив,  который  содержит  четыре  элемента  типа  String. Массивы  обозначаются  с помощью  квадратных  скобок,  помещённых   после  типа  данных  или после  имени  переменной:

String [] players;

или

String players[];

Эти  инструкции  сообщают  компилятору  Java,  что вы  планируете   сохранить  несколько  строк  в  массиве  players.   Каждый  элемент  массива имеет  свой  индекс, начиная с нуля.

String players[] = new String [4];

players[0] = «David»;

players[1] = «Daniel»;

players[2] = «Anna»;

players[3] = «Gregory»;

Неободимо знать размер массива, иначе массивы  не  могут  быть   использованы (а исползуется,

например, ArrayList).

 У каждого массива есть атрибут  length,  который  “помнит”  количество элементов в  массиве,  и  вы всегда  можете  узнать,  как  много  элементов   у  вас  есть:

int totalPlayers = players.length;

Если  во  время  инициализации  массива, вы знаете  значения  всех   элементов,  которые будут в нём  храниться,  то  Java  позволяет  создать   такой  массив  в  одну  строку:

String [] players = {«David», «Daniel», «Anna», «Gregory»};

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

String theWinner = players[1];

System.out.println(«Поздравляем, « + theWinner + «!»);

Этот  код  выведет на  экран следующее:

Поздравляем, Daniel!

Наследование

Подкласс — версия суперкласса (superclass), который наследует все переменные и методы суперкласса, плюс, прибавляет свои уникальные элементы.

//отладку сделал Егор Кресик
//Главный класс (superclass) — class A

class A {

int i, j;

void showij() {

System.out.println(“i и j:”+i+” “+ j);

}

}

//Класс B — подкласс — наследник класса А

class B extends A {

int k;

void showk() {

System.out.println(“k: “+ k);

}

void sum() {

System.out.println(“i+j+k:” + (i+j+k));

}

}

class SimpleInheritance{

public static void main(String[] args) {

A superOb = new A();

B subOb = new B();

superOb.i = 10;

superOb.j = 20;

System.out.println(“Содержимое superOb: “);

superOb.showij();

System.out.println();

subOb.i = 6;

subOb.j = 7;

subOb.k = 8;

System.out.println(“Содержимое of subOb: “);

subOb.showij();

subOb.showk();

System.out.println(“Сумма i, j, и k в subOb:”);

subOb.sum();

}

}

class bo{

double width ;

double height;

double depth;

double volume(){

return width*height*depth;

}

}

Попробуем с помощью наследования переописать описанный ранее класс Box:

class Box {

double width;

double height;

double depth;

Box(Box ob) {

width = ob.width;

height = ob.height;

depth = ob.depth;

}

Box(double w , double h , double d){

width = w;

height = h;

depth = d;

}

Box( ){

width =-1;

height=-1;

depth =-1 ;

}

Box (double len){

width = height = depth = len;

}

double volume () {

return width * height * depth;

}

class BoxWeight extends Box {

double weight;

BoxWeight(double w, double h, double d, double m) {

width =w;

height = h;

depth = d ;

weight = m;

}

}

class DemoBoxWeight {

public void main(String[] args) {

BoxWeight mybox1 = new BoxWeight(10, 20, 15, 34.3);

BoxWeight mybox2 = new BoxWeight (2, 3, 4, 0.076);

double vol;

vol = mybox1.volume ();

System.out.println(“Объёь mybox равен”+ vol);

System.out.println(“Вес mybox1 равен” +mybox1.weight);

System.out.println();

vol = mybox2.volume();

System.out.println(“Объём mybox2 равен” + vol);

System.out.println (“Вес mybox равен” + mybox2.weight);

}

}

}

Вот еще пример (отладку сделал Анастасия Станкевич, 8 класс)

class BB extends bo{

double weight;

BB(double w, double h, double d, double m){

width = w;

height = h;

depth = d;

weight = m;

}

double density(){ // плотность

double plotnost=weight/width*height*depth;

return plotnost;

}}

public class toucan {

public static void main(String[] args) {

BB putehestvo = new BB(13, 44, 44, 68.83);

BB romany = new BB(0.1, 78, 78, 45.45);

double volly;

double dens;

volly=putehestvo.volume();

dens=putehestvo.density();

System.out.println(“Объём кирпича 1 равен “+volly);

System.out.println(“Вес кирпича 1 равен “+putehestvo.weight);

System.out.println(“Плотность кирпича 1 равен “+dens);

System.out.println();

volly = romany.volume();

dens=romany.density();

System.out.println(“Объём кирпича 2 равен “+volly);

System.out.println(“Вес кирпича 2 равен “+romany.weight);

System.out.println(“Плотность кирпича 2 равен “+dens);

}

}

Вот три программы из проекта, демонстрирующего работу с JFrame (выполнен Даниилом Селиным, 6 класс).

Упражнение. Соберите эти три программы в одном проекте и запустите на выполнение.

//Test_1.java:

public class Test_1 {

public static void main(String[] args) {

test t = new test();

t.setSize(400,200);

t.setVisible(true);

}

}

//test.java:

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.*;

public class test extends JFrame{

JButton b1,b2,b3;

JLabel l1;

JTextField t1,t2;

tery te = new tery();

Tests t = new Tests(“Save”);

String save;

public test(){

setLayout(new FlowLayout());

b1 = new JButton(“New File!”);

b2 = new JButton(“Open File!”);

b3 = new JButton(“Save File!”);

l1 = new JLabel(“”);

t1 = new JTextField(20);

add(b1);

add(b2);

add(b3);

add(t1);

add(l1);

b1.addActionListener(te);

b2.addActionListener(te);

b3.addActionListener(te);

}

public class tery implements ActionListener{

public void actionPerformed(ActionEvent e) {

if(e.getSource() == b1){

l1.setText(null);

t1.setText(null);

}

if(e.getSource() == b2){

}

if(e.getSource() == b3){

t.setSize(400,100);

t.setVisible(true);

save = t1.getText();

}

}

}

}

// Tests.java

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.Formatter;

import javax.swing.*;

public class Tests extends JFrame{

static Formatter x;

String d;

JTextField t4;

JButton b4;

lou l = new lou();

public Tests(String s){

super(s);

setLayout(new FlowLayout());

b4 = new JButton(“Готово!”);

t4 = new JTextField(10);

add(t4);

add(b4);

Апплеты

Пример (видео тут: http://youtu.be/cDcXhZKA2ts )

 Создайте класс HelloApplet в Eclipse. Затем  в окне “Run” выберите “Java Applet” .

Вот текст программы: 

public class HelloApplet extends java.applet.Applet{

public void paint(java.awt.Graphics graphics) {

graphics.drawString(«Hello world!», 90, 60);

}

}

Если использовать Swing, то наследоваться нужно от класса JApplet:

class TicTacToe extends javax.swing.JApplet {

}

Java-­апплеты   AWT используют в расчете на пользователей имеющих не самые последние модели компьютеров.

Чтобы протестировать этот апплет в веб-­браузере, создайте файл Hello.html в той же папке, где находится ваш апплет. Для этого в notepad’е наберите текст:

<HTML>

<BODY>

Here is my first applet:<P>

<APPLET code=”HelloApplet.class” width=200 height=100>

</APPLET>

</BODY>

</HTML>

и откройте его с помощью веб-браузера.

Вот исходники проекта одного из постых апплетов, подготовил который Владимир Полотнюк (7 класс):

https://drive.google.com/folderview?id=0B4icNOfw8DwUdHJqRmY5YUYxcjA&usp=sharing

В отличие от обычных программ Java, апплетам не нужен метод   main(), потому что веб-­ браузер сам скачает и запустит их, как только встретит на страничке тег <applet>. Также браузер будет посылать сигналы апплетам, когда будут происходить важные события, например запуск апплета, перерисовка апплета, и так далее. Чтобы убедиться, что апплет реагирует на эти события, вы должны написать специальные методы обратного вызова

(“callback methods”): init(), start(), paint(), stop(), и destroy().

init() вызывается только один раз, таким образом, этот метод играет роль конструктора в обычных классах Java.

start() вызовется сразу после init(). Он также вызывается, когда пользователь возвращается на данную страницу  после «путешествия» по другим

paint() — вызовется когда нужно показать или обновить окно апплета после каких-­либо действий на экране. Например, апплет перекрывается каким-­то другим окном и браузеру нужно его перерисовать.

• stop() вызовется, когда пользователь покидает веб-­страничку, содержащую апплет.

• destroy() – вызовется, когда браузер уничтожает апплет. Вам придется писать текст программы в этом методе только, если апплет использует некоторые внешние ресурсы.

Литература

1. П.Ноутон, Г.Шилдт. Java 2. Наиболее полное руководство. БХВ-Петербург, 2006

2. Яков Файн. Программирование на Java для детей, родителей, дедушек и бабушек.

3. Официальный  учебник  по  Java:  http://download.oracle.com/javase/tutorial/java/index.html

 

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

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

методические материалы по информатике