Судовой журнал путешествия к острову Ява. День 008.
Казалось, что всё будет
не так легко как казалось.
Оказалось, что не казалось…
(один недоумевающий человек)
И опять я бегу вперёд паровоза. По правде говоря, не удостоив и косого взгляда упрощённую версию игры, я сразу взялся за полную версию. И всё опять пошло вкривь и вкось. Почему так? Внимательно взглянув на свои предыдущие "топтания по дорожкам", я понял, что на самом деле, несколько раз открутил и закрутил винтик, там, где собирают и разбирают часы.
Ну что ж выйдем на свободную полянку и потренируемся.
Для начала, наметим сами тропки и пройдемся по ним простыми переменными.
package arraytrans;
public class ArrayTrans{
public static void main(String[] args) {
int a=2, b=3, c=4;
SecondClass second = new SecondClass();
second.SecondClass(a, b);
ThirdClass third = new ThirdClass();
System.out.println("Итого: "+third.ThirdClass(c));
}
}
class SecondClass{
static int b;
public void SecondClass(int a, int b){
this.b=a+b;
}
}
class ThirdClass extends SecondClass{
int ThirdClass(int c){
c=b+c;
return c;
}
}
На вид довольно просто. В Главном методе создаём представителей двух соседних классов, и с их помощью раскидываем переменные. Во втором классе принимаем две первые переменные и складываем их. В третьем классе, одну переменную принимаем из Главного метода, а вторую наследуем от второго класса. Складываем и возвращаем в главный метод.
И ещё. Во втором классе переменная b принимает цифровое значение в методе, а наследуется из класса, будучи без значения (числа). Для того чтобы переменная b имела своё значение и для класса, объявляем её static.
Но нас интересуют не просто переменные, а массивы. Вот что у нас вытанцовывается.
package arraytrans;
public class ArrayTrans {
public static void main(String[] args) {
int firstarr[] = {1, 2, 3};
int secondarr[] = {2, 3, 4};
int thirdarr[];
int a = 5;
SecondClass second = new SecondClass();
second.SecondClass(firstarr, a);
ThirdClass third = new ThirdClass();
thirdarr = third.ThirdClass(secondarr);
System.out.println("Числа массива: "+thirdarr[0]+" + "+thirdarr[1]+" + "+thirdarr[2]);
}
}
class SecondClass{
static int firstarr[]=new int[3];
public void SecondClass(int []firstarr, int a){
for (int n=0; n<3; n++){this.firstarr[n] = firstarr[n] + a;}
}
}
class ThirdClass extends SecondClass{
int[] ThirdClass(int []secondarr){
int thirdarr[] = new int[3];
for (int n=0; n<3; n++){thirdarr[n] = firstarr[n] + secondarr[n];}
return thirdarr;
}
}
Тут собственно обратить внимание стоит лишь на то, как метод принимает массив и как он его возвращает (я имею в виду фонетику). А так тоже самое.
Ну вот размялись, и теперь прыжок!
package foxhunt;
import java.util.Arrays;
import java.util.Scanner;
class FoxHunt {
public static void main(String[] args) {
int vol;
boolean allcatch;
double field[] = new double[2];
double snatch[] = new double[2];
System.out.println("Введите через пробел длину и ширину игрового поля");
Scanner inputfl = new Scanner(System.in);
for (int n=0; n<2; n++){ // Make the field.
field[n] = inputfl.nextInt();
}
System.out.println("Введите количество лис");
Scanner inputfx = new Scanner(System.in);
vol = inputfx.nextInt(); // Fox value.
FoxGenerator fg = new FoxGenerator();
fg.FoxGenerator (field, vol);
allcatch = false;
ActionClass hunt = new ActionClass(); // Make the second class object;
start: do{ // Hunting cycle.
System.out.println(" ");
System.out.println("\nВведите через пробел координаты x и y:");
Scanner input = new Scanner(System.in);
for (int n=0; n<2; n++){ //Getting snacth coordinates.
snatch[n] = input.nextDouble();
}
if (snatch[0]>field[0]||snatch[1]>field[1]) { // Do we find the field?
System.out.println("Тут лисы не водятся");
continue start;
}
allcatch = hunt.ActionClass(snatch, vol);
}while (allcatch == false);
System.out.println("Все лисы изловлены");
}
}
class FoxGenerator{
static double fox[][];
void FoxGenerator (double [] field, int vol){
this.fox = new double[3][vol];
int a=0; here: while (a
Ну вот! Программка с более дружелюбной моськой. Что тут у нас?
Три класса.
В первом классе сидит главный метод, в котором задаются все переменные. Туда же возвращаются и вычисленные данные.
Второй класс используется лишь один раз для разгона заданного количества лис, по заданному же полю. После этой процедуры, Второй класс передаёт по наследству поле с лисами Третьему классу.
Третий класс используется много раз. В нём собственно содержится весь механизм ловли. В Главный метод он возвращает логическую переменную, которая символизирует наличие лис на поле.
Единичные переменные разделились на две группы - рабочие, и служащие.
Рабочая переменная по сути одна, это буква n. Используется как рабочая лошадка во всех циклах.
Служащие переменные, получают хоть сокращенное, но всё же интуитивно понятное имя. Vol locvol - соответственно первоначальное и текущее количество лис. Stat - переменная которая используется для счёта оставшихся лис на основании их статуса.
Из того, на что стоит обратить внимание, думаю это объявление массива static double fox[][]; во Втором классе. Так как заранее мы не знаем, количества лис, то мы размечаем массив в методе - this.fox = new double[3][vol]; Там же его и заполняем. А в классе лишь объявляем его, что вполне достаточно для передачи по наследству.
Ну, вот и всё.
А, нет, не всё =)
В ходе изнурительных тренировок на лисьих тропках родилась ещё одна игрушка. Довольно простая по своим правилам, но для тренировок вполне подходящая. Вот она.
package labyrinth;
import java.util.Scanner;
class Labyrinth{
public static void main(String[] args) {
int fin = 0, a, b=0;
SecondClass second = new SecondClass();
System.out.print("Итак, мы в лабиринте. ");
here: while (fin>=0){ //Working cycle.
System.out.println("Перед нами три двери, выбери одну и иди.");
Scanner input = new Scanner(System.in);
a = input.nextInt();
if (a!=1&&a!=2&&a!=3&&a!=101011001) { // Numb of doors only 1, 2 or 3.
System.out.println("Тут только три двери, попробуй ещё раз.");
continue here;
}
if (a==101011001){System.out.println("Emergency exit"); breack;}
fin = second.SecondClass(a);
if (fin<0){break;} // "-1" is out of labyrinth.
System.out.println("Ты находишься на "+fin+" уровне");
b++;
if (b==20) { // In case of too impress.
System.out.println("Для экстренного выходя из лабиринта наберите: 101011001");
b = 0;
}
}
System.out.println("Ты вышел из лабиринта");
}
}
class SecondClass {
int doors[] = new int[3];
int a = 0, b = 0;
int SecondClass(int x) {
sec: do { // Placing doors cycle.
for (a=0; a<3; a++) {
doors[a] = (int)Math.round(Math.random()*2+1);
}
if (doors[0]==doors[1]||doors[0]==doors[2]||doors[1]==doors[2]){a=a-2; continue sec;}
else {a=5;} // Outdouble checking.
} while (a<4);
if (x == doors[0]){
System.out.println("Это хорошая дверь, идешь на верх");
b--;
}
if (x == doors[1]){
System.out.println("Это нейтральная дверь, остаёшься на месте");
}
if (x == doors[2]){
System.out.println("Это плохая дверь, идёшь вниз");
b++;
}
return b;
}
}
Что в этой программе можно особо отметить. Тут нет ни одной тропки, которой не встречалось бы в лисах. Но тут есть одни интересный приём. Логический смысл программы состоит в том, что шанс выхода из лабиринта составляет ровно 50%. Ну то есть остальные 50% за остование в лабиринте навсегда. Человек с рациональным складом ума, просто прервет нафиг выполнение программы и всё. Но как быть иррациональным людям!? Для них и предусмотрен экстренный выход, силами самой программы.
Вот теперь всё.
Вы таки будете смеяться, но опять не всё. В ходе тестирования лабиринт показал занимательную особенность. Если вместо номера двери набрать, что-нибудь вроде "Go to hell with your *** labyrinth!" Программа обидевшись, завершается. Во избежание подобных недоразумений в Яве существует способ ловли нестандартных выражений: try{...} catch(...){...}.
Вот как это выглядит на примере нашего лабиринта.
package labyrinth;
import java.util.InputMismatchException;
import java.util.Scanner;
class Labyrinth{
public static void main(String[] args){
int fin = 0, a, b=0;
SecondClass second = new SecondClass();
System.out.print("Итак, мы в лабиринте. ");
here: while (fin>=0){ //Working cycle.
System.out.println("\nПеред нами три двери, выбери одну и иди.");
try{Scanner input = new Scanner(System.in);
a = input.nextInt();
if (a!=1&&a!=2&&a!=3&&a!=101011001) { // Numb of doors only 1, 2 or 3.
System.out.println("Тут только три двери, попробуй ещё раз.");
continue here;
}
if (a==101011001){System.out.println("Emergency exit"); break;}
fin = second.SecondClass(a);
if (fin<0){break;} // "-1" is out of labyrinth.
System.out.println("Ты находишься на "+fin+" уровне");
b++;
if (b==20) { // In case of too impress.
System.out.println("\nДля экстренного выходя из лабиринта наберите: 101011001");
b = 0;
}
}
catch(InputMismatchException e){
System.out.println("Такой двери нет");
}
}
System.out.println("Ты вышел из лабиринта");
}
}
class SecondClass {
int doors[] = new int[3];
int a = 0, b = 0;
int SecondClass(int x) {
sec: do { // Placing doors cycle.
for (a=0; a<3; a++) {
doors[a] = (int)Math.round(Math.random()*2+1);
}
if (doors[0]==doors[1]||doors[0]==doors[2]||doors[1]==doors[2]){a=a-2; continue sec;}
else {a=5;} // Outdouble checking.
} while (a<4);
if (x == doors[0]){
System.out.println("Это хорошая дверь, идешь на верх");
b--;
}
if (x == doors[1]){
System.out.println("Это нейтральная дверь, остаёшься на месте");
}
if (x == doors[2]){
System.out.println("Это плохая дверь, идёшь вниз");
b++;
}
return b;
}
}
Сходу возникает вопрос, это что за "InputMismatchException e" внутри catch()? Отвечаем. Так уж повелось, что ловцу исключений (а всё, что не является числом, для нашей программы является исключением) необходимо указать что именно ему ловить. Образцы как водится, лежат в библиотеке java.util, от туда мы и вытаскиваем InputMismatchException. Переменная "e" тут для сохраниения наших инсинуаций, ну так, может пригодится когда...
И ещё, Вы наверняка заметили внутри "Сообщений" вот такую "\n" штуку. Она служит для вставки пустой строки в череде других сообщений. Так удобнее отделять циклы друг от друга.
Вот теперь, наверное, всё.