Естествено нововъведенията са много повече, но на този етап ще акцентирам върху четири от основните:

1. String като параметър на „switch“:

Вече е възможно да правите:

String str=...;
...
switch(str){
   case "...":
        ...
}

Мисля, че не е нужно да го коментирам подробно. Еквивалентно е на поредица от „if-else-if-else“ команди, при които във всеки „if“ се извиква оператор „equals“ на обекта от тип String.

2. Инстанции на обекти с тип по подразбиране:

Досега пишехме (а аз продължавам да пиша по навик) следното:

LinkedList<String> list = new LinkedList<String>();

Вече няма нужда да подавате типа на обектите в списъците от дясната страна. Тоест горното ще е еквивалентно на:

LinkedList<String> list = new LinkedList<>();

3. Няколко изключения в един catch блок:

Когато в един try блок могат да се генерират различни изключения ние пишехме по един catch блок за всяко, например:

try{
   ...
}
catch(ArrayOutOfBoundsException e){
   ...
}
catch(IOException e){
   ...
}

А сега можем да правим следното:

try{
   FileReader f = new FileReader("file.txt");
   ...
}
catch(ArrayOutOfBoundsException | IOException e){
   ...
}

4. Заделяне на ресурси за try блок:

На последно тук, но според мен първо по значение е заделянето на ресурси за try блок, които автоматично се освобождават при неговото затваряне. Разгледайте например това:

FileReader in = null;
try{
   in = new FileReader("file.txt");
   ...
}
catch(IOException e){
   ...
}
finally{
   try{
      if(in!=null) in.close()
   }
   catch(IOException e){
      ...
   }
}

Това, което се правеше във finally блока изглеждаше много „паразитно“ и не без основание. В новия си синтаксис в Java 7 можем да напишем много по-компактен код:

try(FileReader in = new FileReader("File.txt")){
   ...
}
catch(IOException e){
   ...
}

Така заделеният ресурс ще бъде затворен автоматично след излизане от try блока, независимо дали е генерирано изключение или не.

Приятно програмиране.

Примерно решение:

chatserver/Server.java:

package chatserver;
import java.io.IOException;
import java.io.DataOutputStream;
import java.net.Socket;
import java.util.ArrayList;
public class Server{
  private static int port = 1234;
  private static ArrayList<Socket> clients = new ArrayList<Socket>(10);
  public static void main(String[] args){
    ServerListener s = null;
    try{
      s = new ServerListener(port);
    }
    catch(IOException e){
      System.out.println("Не може да се отвори ServerSocket на порт: "+port);
      return;
    }
    while(true){
      try{
        Socket clientSocket = s.acceptConnection();
        clients.add(clientSocket);
        new ServerThread(clientSocket);
      }
      catch(IOException e){
        System.out.println("Неуспешно свързване на клиент...");
      }
    }
  }
  static void sendToAll(String message){
    synchronized(clients){
      for(int i=0; i<clients.size(); i++){
        try{
          DataOutputStream cos = new DataOutputStream(clients.get(i).getOutputStream());
          cos.writeUTF(message);
          cos.flush();
        }
        catch(IOException e){
          System.out.println("Не мога да изпратя съобщение...");
        }
      }
    }
  }
  static void removeClient(Socket c){
    synchronized(clients){
      System.out.println("Премахвам клиент "+c);
      clients.remove(clients.indexOf(c));
      try{
        c.close();
      }
      catch(IOException e){
        System.out.println("Не мога да затворя връзка с клиент");
      }
    }
  }
}

chatserver/ServerListener.java:

package chatserver;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerListener{
  private ServerSocket servSock;
  public ServerListener(int port) throws IOException{
    servSock = new ServerSocket(port);
    System.out.println("Сървърът е стартиран и слуша на порт: "+port);
  }
  public Socket acceptConnection() throws IOException{
    Socket s = this.servSock.accept();
    System.out.println("Нов клиент "+s.toString());
    return s;
  }
}

chatserver/ServerThread.java:

package chatserver;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
public class ServerThread extends Thread{
  private Socket sock;
  DataOutputStream os;
  public ServerThread(Socket sock){
    this.sock = sock;
    this.start();
  }
  public void run(){
    DataInputStream in;
    String message;
    try{
      in = new DataInputStream(this.sock.getInputStream());
      while(true){
        message = in.readUTF();
        if(message.equals("BYE")){
          break;
        }
        else{
          System.out.println(message);
          Server.sendToAll(message);
        }
      }
    }
    catch(IOException e){
      System.out.println("Проблем с предаване на данни до "+this.sock.toString());
    }
    finally{
      Server.removeClient(this.sock);
    }
  }
}

chatclient/Client.java:

package chatclient;
import java.util.Scanner;
import java.io.IOException;
public class Client{
  public static void main(String[] args){
    String host = "localhost";
    int port = 1234;
    String name = "Петър";
    Scanner keyboardIn = new Scanner(System.in);
    ClientThread c = new ClientThread(host, port);
    String messageOut;
    while(true){
      messageOut = keyboardIn.nextLine();
      if(messageOut.equalsIgnoreCase("exit")){
        c.sendMessage("BYE");
        c.interrupt();
        break;
      }
      else c.sendMessage(name+" каза: "+messageOut);
    }
    try{
      c.close();
      System.out.println("Успешен изход от системата");
    }
    catch(Exception e){
      System.out.println("Проблем при прекратяването на връзка");
    }
  }
}

chatclient/ClientThread.java:

package chatclient;
import java.net.Socket;
import java.io.DataOutputStream;
import java.io.DataInputStream;
import java.io.IOException;
public class ClientThread extends Thread{
  private Socket socket;
  private DataOutputStream out;
  private DataInputStream in;
  public ClientThread(String host, int port){
    try {
      this.socket = new Socket(host, port);
      System.out.println("Свързах се с "+socket);
      this.in = new DataInputStream(this.socket.getInputStream());
      this.out = new DataOutputStream(this.socket.getOutputStream());
      // Стартиране на нишката, която очаква получаване на съобщения
      this.start();
    }
    catch(IOException e){
      System.out.println("Не мога да се свържа със сървъра");
    }
  }
  public void run(){
    try{
      while(true){
        System.out.println(this.in.readUTF());
      }
    }
    catch(IOException e){
      System.out.println("Прекратяване на нишката поради невъзможност за четене");
      this.interrupt();
    }
  }
  void sendMessage(String message){
    try{
      this.out.writeUTF(message);
      this.out.flush();
    }
    catch(IOException e){
      System.out.println("Не мога да изпратя съобщението");
    }
  }
  void close() throws IOException{
    if(this.in!=null) in.close();
    if(this.out!=null) out.close();
    if(this.socket!=null) socket.close();
  }
}

Допълнителна задача: Реализирайте функционалност за предаване на лични съобщения между различни потребители. За целта запазете имената на клиентите и на сървъра и когато например някой клиент подаде съобщение от типа „/msg Petar abcdefg“, то на потребител с име „Petar“ ще бъде подадено съобщението „abcdefg“ (вместо да бъде разпратен целия String на всички).

Примерно решение:

package complexnum;
import java.lang.ArithmeticException;

public class ComplexNumber{
  private double re;
  private double im;
  public ComplexNumber(){
    this.re = 0;
    this.im = 0;
  }
  public ComplexNumber(ComplexNumber input) {
    this.re = input.getRe();
    this.im = input.getIm();
  }
  public ComplexNumber(double re, double im){
    this.re = re;
    this.im = im;
  }
  public double getRe(){
    return this.re;
  }
  public double getIm(){
    return this.im;
  }
  public void setRe(double re){
    this.re = re;
  }
  public void setIm(double im){
    this.im = im;
  }
  public String toString(){
    String result="";
    if (this.im==0){
      result += this.re;
    }
    else if (this.re==0){
      result += this.im+"i";
    }
    else if (this.im&gt0){
      result += this.re+"+"+this.im+"i";
    }
    else if (this.im<0){
      result += this.re+""+this.im+"i";
    }
    return result;
  }
  public void print(){
    System.out.println(this.toString());
  }
  public ComplexNumber getConjugate() {
    return new ComplexNumber(this.re, this.im * (-1));
  }
  public ComplexNumber add(ComplexNumber op) {
    ComplexNumber result = new ComplexNumber();
    result.setRe(this.re + op.getRe());
    result.setIm(this.im + op.getIm());
    return result;
  }

  public ComplexNumber substract(ComplexNumber op) {
    ComplexNumber result = new ComplexNumber();
    result.setRe(this.re - op.getRe());
    result.setIm(this.im - op.getIm());
    return result;
  }

  public ComplexNumber multiply(ComplexNumber op) {
    ComplexNumber result = new ComplexNumber();
    result.setRe(this.re * op.getRe() - this.im * op.getIm());
    result.setIm(this.re * op.getIm() + this.im * op.getRe());
    return result;
  }

  public ComplexNumber divide(ComplexNumber op) throws ArithmeticException {
    if(op.getRe()==0 && op.getIm()==0){
      throw new ArithmeticException("Division by zero");
    }
    ComplexNumber result = new ComplexNumber(this);
    result = result.multiply(op.getConjugate());
    double opNormSq = op.getRe()*op.getRe()+op.getIm()*op.getIm();
    result.setRe(result.getRe() / opNormSq);
    result.setIm(result.getIm() / opNormSq);
    return result;
  }
}

Задача 2. Напишете клас с main метод, в който прочитате израз от вида (a+bi)OP(c+di), където OP={*,/,+,-}, а {a,b,c,d} са цели числа. Като изход изведете резултата от извършената операция между две комплексни числа.

Примерен вход: (1-2i)-(-2+3i)
Очакван изход: 3.0-5.0i

Примерно решение:

package complexnum;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.Scanner;

public class program{
  public static void main(String[] args){
    Scanner keyboardIn = new Scanner(System.in);
    System.out.print("Въведете израз: ");
    String expression = keyboardIn.nextLine();
    Pattern p = Pattern.compile("^\\(([+-]?[0-9]+)?([+-]?[0-9]+i)?\\)([*/+-])\\(([+-]?[0-9]+)?([+-]?[0-9]+i)?\\)$");
    Matcher m = p.matcher(expression);
    if (m.find()){
      try{
        double a=0, b=0, c=0, d=0;
        if (m.group(1)!=null) a = Double.parseDouble(m.group(1));
        if (m.group(2)!=null) b = Double.parseDouble(m.group(2).substring(0,m.group(2).length()-1));
        if (m.group(4)!=null) c = Double.parseDouble(m.group(4));
        if (m.group(5)!=null) d = Double.parseDouble(m.group(5).substring(0,m.group(5).length()-1));

        ComplexNumber c1 = new ComplexNumber(a, b);
        ComplexNumber c2 = new ComplexNumber(c, d);
        switch(m.group(3)){
          case "*":
            (c1.multiply(c2)).print();
            break;
          case "/":
            (c1.divide(c2)).print();
            break;
          case "+":
            (c1.add(c2)).print();
            break;
          case "-":
            (c1.substract(c2)).print();
            break;
        }
      }
      catch(java.util.InputMismatchException e){
        e.printStackTrace();
      }
      catch(ArithmeticException e){
        System.out.println("Не може да делите на нула!");
      }
    }
  }
}

Server.java:

import java.io.PrintWriter;
import java.net.Socket;
import java.net.ServerSocket;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Scanner;

public class Server{
  public static void main(String args[]) {
    ServerSocket serverSocket = null;
    Socket connection = null;
    Scanner socketIn = null;
    PrintWriter socketOut = null;
    int port = 1234;

    // Безкраен цикъл - сървъра ще приема връзки
    // докато програмата не бъде спряна насилствено
    while(true){
      try {
        serverSocket = new ServerSocket(port);
        System.out.println("Сървъра очаква свързване...");
        connection = serverSocket.accept();
        System.out.println("Свърза се клиент:"
              +connection.getInetAddress().getHostName()
        );

        System.out.println("Подавам съобщение на клиента...");
        socketOut = new PrintWriter(connection.getOutputStream(), true);
        socketOut.println("Възможните команди са \"hi\" и \"exit\"");

        System.out.println("Сървъра очаква подаване на команда...");
        socketIn = new Scanner(new BufferedReader(
                          new InputStreamReader(connection.getInputStream()))
                       );

        String command = null;
        loop: do{
          socketOut.flush();
          command = socketIn.nextLine();
          switch(command){
            case "hi":
              System.out.println("Клиентът подаде команда \"hi\"");
              socketOut.println("OK");
              break;
            case "exit":
              System.out.println("Клиентът подаде команда \"exit\"");
              socketOut.println("OK");
              break loop;
            default:
              System.out.println("Получих непозната команда");
              socketOut.println("Не познавам тази команда");
              break;
          }
        }
        while(!command.equalsIgnoreCase("exit"));
        System.out.println("Затварям връзката с "
                             +connection.getInetAddress().getHostName()
                          );
      }
      catch(IOException e) {
        e.printStackTrace();
      }
      finally{
        try{
          if (socketIn!=null) socketIn.close();
          if (socketOut!=null) socketOut.close();
          if (connection!=null) connection.close();
          if (serverSocket!=null) serverSocket.close();
        }
        catch(IOException e){
          System.err.println("Не може да бъде затворен сокет");
        }
      }
    }
  }
}

Client.java:

import java.io.PrintWriter;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.net.Socket;
import java.io.IOException;
import java.net.ConnectException;

public class Client{
   public static void main(String args[]){
     Socket connection = null;
     Scanner socketIn = null;
     PrintWriter socketOut = null;
     Scanner keyboardIn = new Scanner(System.in);
     int port = 1234;
     String host = "localhost";

     try{
       System.out.println("Очаквам свързване със сървъра");
       try{
         connection = new Socket(host, port);
       }
       catch(ConnectException e){
         System.err.println("Не мога да осъществя връзка със сървъра");
         return;
       }
       System.out.println("Свързването със сървъра беше успешно!");

       System.out.println("Приемам първоначално съобщение от сървъра...");
       socketIn = new Scanner(new BufferedReader(
                         new InputStreamReader(connection.getInputStream()))
                      );
       System.out.println("Съобщението е: "+socketIn.nextLine());

       String command = null;
       socketOut = new PrintWriter(connection.getOutputStream(), true);
       do{
         socketOut.flush();
         System.out.print("Въведете команда: ");
         command = keyboardIn.nextLine();
         socketOut.println(command.toLowerCase());

         System.out.println("Изчакване на отговор от сървъра...");
         String answer = socketIn.nextLine();
         System.out.println("Сървърът отговори: "+answer);
       }
       while (!command.equalsIgnoreCase("exit"));
       System.out.println("Затваряне на връзката...");

     }
     catch(IOException e) {
       e.printStackTrace();
     }
     finally{
       try{
         if(socketIn!=null) socketIn.close();
         if(socketOut!=null) socketOut.close();
         if(connection!=null) connection.close();
       }
       catch(IOException e){
         System.err.println("Не може да се затвори сокета");
       }
     }
   }
}

„Ако два обекта са еднакви, то извикването на техните методи hashCode() трябва да връщат равни числа“ (1)

Ето един пример:

public class hashCodeExample{
   public static void main(String[] args){
      String s1 = "abcd";
      String s2 = "abcd";
      String s3 = "aBcd";
      System.out.println(s1+" has hash code: "+s1.hashCode());
      System.out.println(s2+" has hash code: "+s2.hashCode());
      System.out.println(s3+" has hash code: "+s3.hashCode());
   }
}

Резултатът ще бъде:

abcd has hash code: 2987074
abcd has hash code: 2987074
aBcd has hash code: 2956322

Виждате, че обектите, които са еднакви имат и еднакви хеш кодове. Това обаче не винаги ще бъде вярно, когато самите ние създаваме класове. Нека дадем следния пример:

public class hashCodeExample{
   public static void main(String[] args){
      Person p1 = new Person("Ivan", 23);
      Person p2 = new Person("Ivan", 23);
      Person p3 = new Person("Petar", 23);
      System.out.println(p1.name+" age "+p1.age+" hash code: "+p1.hashCode());
      System.out.println(p2.name+" age "+p2.age+" hash code: "+p2.hashCode());
      System.out.println(p3.name+" age "+p3.age+" hash code: "+p3.hashCode());
   }
}

class Person{
   public String name;
   public int age;
   public Person(String name, int age){
      this.name = name;
      this.age = age;
   }
}

Резултатът ще бъде:

Ivan age 23 hash code: 9555723
Ivan age 23 hash code: 8414877
Petar age 23 hash code: 15613422

Виждаме, че клас Person не отговаря на условието (1). Следователно ние трябва да се погрижим да предефинираме метод hashCode() така, че два еднакви обекта да връщат един и същи хеш код. Това може да стане например така:

public class hashCodeExample{
   public static void main(String[] args){
      Person p1 = new Person("Ivan", 23);
      Person p2 = new Person("Ivan", 23);
      Person p3 = new Person("Petar", 23);
      System.out.println(p1.name+" age "+p1.age+" hash code: "+p1.hashCode());
      System.out.println(p2.name+" age "+p2.age+" hash code: "+p2.hashCode());
      System.out.println(p3.name+" age "+p3.age+" hash code: "+p3.hashCode());
   }
}

class Person{
   public String name;
   public int age;
   public Person(String name, int age){
      this.name = name;
      this.age = age;
   }
   public int hashCode(){
      return (this.name.hashCode()+this.age);
   }
}

Резултатът вече ще е валиден:

Ivan age 23 hash code: 2291281
Ivan age 23 hash code: 2291281
Petar age 23 hash code: 77005191

Виждаме, че за да направим обектите си валидни, то елементарно трябва да предефинираме методът hashCode(). Въпросът, който остава е – проблем ли е ако ние не го правим? Всички програми в досегашните ни примери работеха напълно коректно и нямаха проблеми. Тогава защо ни е да предефинираме метод hashCode()? За да отговорим на този въпрос трябва да разгледаме два варианта:

1. Обектите са еднакви, но връщат различни хеш кодове: няма абсолютно никакъв проблем да работим с такива обекти, но ще такъв ще се появи тогава, когато ги добавяме към HashSet или HashMap (тези колекции ще разгледаме по-късно в следваща статия). Тези колекции използват функцията hashCode() и очакват правилото за нея да е спазено. Следователно резултатите в този случай стават непредвидими!;
2. Обектите са различни, но връщат еднакви хеш кодове: това принципно не е проблем – не нарушава дефиницията на hashCode(). Единственото негативно в този случай ще е, че HashSet и HьshMap ще работят по-бавно когато има много обекти с много повторения на хеш кода. Затова е добре хеш кодовете да са максимално различни при различните обекти.

С дотук казаното можем да заключим, че предефинирането на метод hashCode() е препоръчително за всеки клас. Освен това трябва да се стремим стойностите да са максимално различни. Последното впрочем е трудна задача в определени случаи. Дефинирането на добър hashCode() винаги е предизвикателство. В книгата „Thinking in Java“ се дава следната „рецепта“ – резултатът от функцията започва от числото 17 и за всяка променлива от класа го умножаваме по 37 и добавяме хеш кодът или стойността на променливата превърната в int (при примитивен тип данни) към него. Ето пример:

class Person{
  public String firstname;
  public String lastname;
  public int age;
  public Person(String firstname, String lastname, int age){
    this.firstname = firstname;
    this.lastname = lastname;
    this.age = age;
  }
  public int hashCode(){
    int result = 17;
    result = result*37 + this.firstname.hashCode();
    result = result*37 + this.lastname.hashCode();
    result = result*37 + this.age;
    return result;
  }
}

Ще забележите, че по този начин е възможно числата да станат отрицателни, защото прехвърлят размера на типа данни. Това не е проблем – хеш кодът може да е отрицателен. Спазването на горната рецепта е доказало практическата си ефективност. Препоръчва се такъв метод hashCode() да се предефинира във всеки клас.

Задача 2. Напишете абстрактен клас “равнинна фигура с три определящи параметри” (PlainFigure), който имплементира интерфейс Figure. Член променливи на класа са трите размерности на фигурата (d1, d2 и d3 от тип double) с права за достъп “public” и “final” (тоест те са константи, които ще бъдат инициализирани по-късно по време на изпълнение).

a) Напишете конструктор с подадени параметри, който подрежда входните параметри по големина и така с тях инициализира размерностите на фигурата (тоест d1 трябва да е с най-малка стойност, d2 със средна и d3 с най-голяма).

б) Реализирайте методите print (отпечатва размерностите в конзолата) и еquals (проверява дали размерностите на текущия обект и на подадения са равни).

в) Дефинирайте абстрактни методи “лице” (getArea() с връщана стойност от тип double) и “периметър” (getPerimeter() с връщана стойност от тип double).

Задача 3. Напишете клас “Триъгълник” (Triangle), който наследява класа PlainFigure, като за трите определящи параметъра се приемат страните на триъгълника.

а) Напишете конструктора (с подадени параметри) така, че ако трите подадени параметъра не могат да образуват триъгълник (условието за съществуване на триъгълник е страните да са с положителна дължина и да са изпълнени: d1+d2>d3, d2+d3>d1 и d1+d3>d2), то да бъде върнато изключение с име “TriangleException”.

б) Реализирайте метода getPerimeter() (периметърът на триъгълник е P=d1+d2+d3).

в) Реализирайте метода getArea() (лицето на триъгълник по Хереоновата формула е S = sqrt[p.(p-d1).(p-d2).(p-d3)], където p = P/2 е полупериметърът на триъгълника).

Задача 4. Реализирайте статичен метод в клас Triangle, който показва дали два триъгълника (обекти от клас Triangle подадени като входни параметри) са подобни (тоест коефициентите на пропорционалност на всяка двойка от страните на триъгълниците трябва да са равни).

Задача 5. Реализирайте класа на изключението TriangleException.

Забележка 1: Независимо кои две напълно решени задачи носят оценка среден (3). Всяка допълнително решена задача добавя една единица към оценката.

Забележка 2: Не си губете времето да правите get и set методи – размерностите са константи (т.е. set методи не могат да съществуват) и са с ниво на достъп public (т.е. get методи са безсмислени). Също така не пишете конструктори по подразбиране – в задачите това не се изисква.

Задача 2: Създайте клас „Картини”, който съдържа списък от обекти от клас „Картина”. Напишете необходимите конструктори (инициализират празен списък), get и set методи. Напишете метод за добавяне на картина към списъка (подава се обект „Картина” като входен параметър). Направете проверка за дублиране – ако такава картина вече има в списъка, то да се върне изключение или да се отпечата текст в конзолата. Напишете метод, който изтрива картина по подаден уникален номер.

Задача 3: Напишете метод за отпечатване на информацията за картините на даден автор (името му се подава като параметър, а ако се подаде празен низ да се отпечатва информацията за всички картини).

Задача 4: В клас „Картини” напишете метод, който намира най-скъпата или най-скъпите картини (ако са повече от една с равни цени) и отпечатва информация за тях на екрана. Напишете метод, който връща средната цена на картините от даден автор (името на автора се подава като параметър, като ако се подаде празен String, то да се върне средната цена на картините на всички автори).

Задача 5: Създайте main метод, който демонстрира функционалността на задачи от 1 до 4, като изписва меню на екрана, например:

1. Добави картина
2. Изтрий картина
3. Информация за картина
4. …
5. Изход

При избор на дадена опция потребителят да бъде прехвърлен в подменю, в което се извършва избраната операция, а след завършването й – да се връща обратно в главното меню.

Задача 2: Създайте клас „обикновен работник“, който наследява класа „работник на хонорар“, в който се добавя информация за броя часове, които работникът е изработил за текущата седмица. Направете конструктори по подразбиране (стандартно работниците работят 40 часа седмично) и чрез подадени параметри. Създайте необходимите get и set методи. Напишете метод, който връща седмичната заплата на работника. Всички часове до 40-тия се пресмятат умножени с коефициент 1.0, а наднормените часове се заплащат с коефициент 1.5. Предефинирайте методът за отпечатване на информацията за работника така, че да се отпечата на екрана и новата информация (седмичната му заплата). Направете проверки за валидност на данните – един работник НЕ може да работи повече от 84 часа седмично. Ако се опитате да създадете такъв, то трябва да се хвърли изключение.

Задача 3: Създайте клас „работник с възможност за нощна смяна“, който наследява класа „обикновен работник“ и добавя информация за броят дни, в които работникът е работил нощем. Направете конструктори по подразбиране (стандартно работниците не работят нощни смени) и чрез подадени параметри. Създайте необходимите get и set методи. Предефинирайте метода връщаш седмичната заплата така, че нощните смени да бъдат заплатени по коефициент 1.5 (счита се, че продължителността на една нощна смяна е 8 работни часа). Наднормените часове не могат да бъдат нощна смяна (т.е. не се умножават два пъти с коефициента). Направете проверки за валидност на данните – ако работник има поне една нощна смяна, то той вече не може да работи повече от 72 часа седмично, а броят на нощните му смени за седмица не може да е повече от 5.

Задача 4: Създайте клас „списък с работници“, в който се пазят списъци за работниците на хонорар, обикновените работници и работниците с възможност за нощна смяна. Направете конструктор по подразбиране, който инициализира празни списъци. Направете метод, който по подаден параметър един от трите типа работници го добавя в съответния списък. Трябва да се направи проверка дали служител с такъв уникален номер (id) вече съществува (ако да – да се „хвърли“ exception). Направете метод, който изтрива работник по подадена информация „уникален номер на служител“. Ако такъв работник не съществува – да се хвърли изключение. Направете метод, който по подаден параметър „уникален номер“ отпечатва информацията за работника. Ако той е „обикновен работник“ или „работник с възможност за нощна смяна“ да се отпечата и неговата текуща седмична заплата.
Направете метод за отпечатване на информацията за всички работници на хонорар.
Направете метод за отпечатване на информацията за всички обикновени работници.
Направете метод за отпечатване на информацията за всички работници с възможност за нощна смяна.
Направете метод за отпечатване на информацията на всички налични работници, като ги раздели по групи.
Направете метод, който намира средната седмична заплата на всички работници (тези, които са на хонорар не участват в изчисленията).

Задача 5: Демонстрирайте функционалността на създадените класове чрез написване на main метод.

class Point{
  final private double x;
  final private double y;
  public Point(){
    this.x = 0;
    this.y = 0;
  }
  public Point(double x, double y){
    this.x = x;
    this.y = y;
  }
  public double getX(){
    return this.x;
  }
  public double getY(){
    return this.y;
  }
  public String show(){
    return ("("+this.x+", "+this.y+")");
  }
  public static boolean equals(Point x, Point y){
    if( (x.getX()==y.getX()) && (x.getY() == y.getY()) ) return true;
    else return false;
  }
}

2. Да се създаде клас „множество” съдържащ списък от точки. Създайте член-методи за добавяне на точка към множеството, добавяне на множество точки към множеството, изтриване на точка от множеството и за отпечатване на екрана точките от множеството. Създайте необходимите изключения (в едно множество НЕ може да има дублиращи се точки; НЕ можем да изтрием точка, която не съществува в множеството). Създайте метод за отпечатване на координатите на множеството точки. Създайте статични методи за обединение, сечение и разлика на подадени две множества:

class AddPointException extends Exception{
  public AddPointException(Point x){
    super("The point "+x.show()+" is already in the set");
  }
  public AddPointException(String msg){
    super(msg);
  }
  public String toString(){
    return "The point is already in the set";
  }
}

class PointDoesNotExistsException extends Exception{
  public PointDoesNotExistsException(Point x){
    super("The point "+x.show()+" does not exists");
  }
  public PointDoesNotExistsException(String msg){
    super(msg);
  }
  public String toString(){
    return "The point does not exists";
  }
}

class Set{
  java.util.LinkedList<Point> list;
  public Set(){
    this.list = new java.util.LinkedList<Point>();
  }
  public boolean inSet(Point x){
    java.util.Iterator it = this.list.iterator();
    while(it.hasNext()){
      if(Point.equals((Point)it.next(), x)) return true;
    }
    return false;
  }
  public java.util.LinkedList<Point> getList(){
    return this.list;
  }
  public void addPoint(Point x) throws AddPointException{
    if(this.inSet(x)) throw new AddPointException(x);
    else this.list.addLast(x);
  }
  public void removePoint(Point x) throws PointDoesNotExistsException{
    boolean removed = false;
    for (int i=0; i<this.list.size(); i++){
      if (Point.equals(this.list.get(i),x)){
        this.list.remove(i);
        removed = true;
        break;
      }
    }
    if (!removed) throw new PointDoesNotExistsException(x);
  }
  public void print(){
    for (int i=0; i<this.list.size(); i++){
      System.out.println(""+(i+1)+". "+this.list.get(i).show());
    }
  }
  public void addSet(Set newlist){
    for(int i=0; i<newlist.getList().size(); i++){
      try{
        this.addPoint((Point)newlist.getList().get(i));
      }
      catch(AddPointException e){}
    }
  }
  public static Set union(Set x, Set y){
    Set result = new Set();
    result.addSet(x);
    result.addSet(y);
    return result;
  }
  public static Set intersect(Set x, Set y){
    Set result = new Set();
    firstset: for (int i=0; i<x.getList().size(); i++){
      for (int j=0; j<y.getList().size(); j++){
        if(Point.equals(x.getList().get(i),y.getList().get(j))){
          try{
            result.addPoint(x.getList().get(i));
            continue firstset;
          }
          catch (AddPointException e){
            System.err.println("Some bad logic error has occured???");
          }
        }
      }
    }
    return result;
  }
  public static Set complement(Set x, Set y){
    Set result = new Set();
    for (int i=0; i<x.getList().size(); i++){
      boolean found = false;
      for (int j=0; j<y.getList().size(); j++){
        if(Point.equals(x.getList().get(i),y.getList().get(j))){
          found = true;
          break;
        }
      }
      if (!found){
        try{
          result.addPoint(x.getList().get(i));
        }
        catch (AddPointException e){
          System.err.println("Some bad logic error has occured???");
        }
      }
    }
    return result;
  }
}

3. Демонстрирайте функционалността на създадените класове, чрез написване на главна програма с main метод:

public class mainprogram{
  public static void main(String[] args){
    Set points = new Set();
    // adding three points
    try{
      points.addPoint(new Point(2,3));
      points.addPoint(new Point(5,6));
      points.addPoint(new Point(-5,-6));
      System.out.println("Three points added successfully");
    }
    catch (AddPointException e){
      System.out.println(e.getMessage());
    }

    // Trying to add duplicate point
    try{
      points.addPoint(new Point(2,3));
      System.out.println("Another point added successfully");
    }
    catch (AddPointException e){
      System.out.println(e.getMessage());
    }

    // Removing point
    try{
      points.removePoint(new Point(5,6));
      System.out.println("Point (5,6) removed");
    }
    catch (PointDoesNotExistsException e){
      System.out.println(e.getMessage());
    }
    // Trying to remove non existing point
    try{
      points.removePoint(new Point(12,23));
      System.out.println("Point (12,23) removed");
    }
    catch (PointDoesNotExistsException e){
      System.out.println(e.getMessage());
    }

    // Otpechatvane na sashtestvuvashtite tochki v mnojestvoto
    System.out.println("\nFirst set points:");
    points.print();
    System.out.println();

    // Sazdavane na vtoro mnojestvo ot tri tochki
    Set points2 = new Set();
    try{
      points2.addPoint(new Point(2,3));
      points2.addPoint(new Point(-9,-9));
      points2.addPoint(new Point());
    }
    catch (AddPointException e){
      System.out.println(e.getMessage());
    }
    System.out.println("Second set points:");
    points2.print();
    System.out.println();

    // Obediniavane na mnojestvata
    System.out.println("Union:");
    Set up1p2 = Set.union(points, points2);
    up1p2.print();

    // Sechenie na mnojestvata
    System.out.println("\nIntersection:");
    Set ip1p2 = Set.intersect(points, points2);
    ip1p2.print();

    // Izvajdane na mnojestva
    System.out.println("\nComplement");
    Set cp1p2 = Set.complement(points, points2);
    cp1p2.print();
  }
}

а) Дефинирайте конструктор по подразбиране и такъв с параметри за задаване на дата.

б) Дефинирайте за него подходящите get и set методи.

в) Направете необходимите проверки за валидност на данните (ако не са валидни да се генерира изключение):

calException.java:

package example;
// Клас дефиниращ изключение "невалидна дата"
public class calException extends Exception{
  public calException(){
    super("Invalid date");
  }
  public calException(String msg){
    super(msg);
  }
  public String toString(){
    return "Invalid date";
  }
}

calendar.java:

package example;
public class calendar{
  private int day;
  private int month;
  private int year;
  // Конструктор по подразбиране
  // данните се четат от клавиатурата
  // възможно е s.nextInt() да хвърли InputMismatchException!
  public calendar() throws calException, java.util.InputMismatchException{
    java.util.Scanner s = new java.util.Scanner(System.in);
    System.out.print("Enter day: ");
    this.day = s.nextInt();
    System.out.print("Enter month: ");
    this.month = s.nextInt();
    System.out.print("Enter year: ");
    this.year = s.nextInt();
    if (this.validate(this.day, this.month, this.year)== false){
      throw new calException();
    }
  }
  // Конструктор с параметри за създаване на дата
  public calendar(int day, int month, int year) throws calException{
    if (this.validate(day, month, year) == false) throw new calException();
    else{
      this.day = day;
      this.month = month;
      this.year = year;
    }
  }
  // Метод за валидиране на дата (за вътрешно ползване на класа)
  private boolean validate(int day, int month, int year){
    if (day < 1) return false;
    if (month < 1 || month > 12) return false;
    switch(month){
      case 1: case 3: case 5: case 7: case 8: case 10: case 12:
        if(day > 31) return false;
        break;
      case 4: case 6: case 9: case 11:
        if(day > 30) return false;
        break;
      case 2:
        if (year%400==0 || (year%4==0 && year%100!=0)){
           if (day > 29) return false;
        }
        else{
          if (day > 28) return false;
        }
        break;
    }
    return true;
  }
  // get методи:
  public int getDay(){
    return this.day;
  }
  public int getMonth(){
    return this.month;
  }
  public int getYear(){
    return this.year;
  }
  // set методи:
  public void setDay(int day) throws calException{
    if (this.validate(day, this.month, this.year)==false) throw new calException();
    else this.day = day;
  }
  public void setMonth(int month) throws calException{
    if (this.validate(this.day, month, this.year)==false) throw new calException();
    else this.month = month;
  }
  public void setYear(int year) throws calException{
    if (this.validate(this.day, this.month, year)==false) throw new calException();
    else this.year = year;
  }
}

2. Дефинирайте клас, описващ студент като включите следните данни:

• Име;
• Факултетен номер;
• Дата на раждане – използвайте класа от зад.1;
• Среден успех.

а) Дефинирайте конструктор по подразбиране и с параметри за инициализиране на обекта.

б) Дефинирайте подходящите get и set методи.

в) Дефинирайте метод, който по зададен параметър текуща дата, връща възрастта на студента като брой навършени години.

г) Дефинирайте статичен метод, който сравнява двама студента по успех (връща -1, 0 или 1 в зависимост от това дали първият е с по-висок, равен или по-нисък успех от втория).

student.java:

package example;
public class student{
  private String name;
  private long fnum;
  private calendar birthdate;
  private double gpa;
  // Конструктор по подразбиране
  public student() throws calException, java.util.InputMismatchException{
    java.util.Scanner s = new java.util.Scanner(System.in);
    System.out.print("Enter name: ");
    name = s.nextLine();
    System.out.print("Enter fnum: ");
    fnum = s.nextLong();
    birthdate = new calendar();
    System.out.print("Enter GPA: ");
    gpa = s.nextDouble();
  }
  // Конструктор с подадени параметри
  public student(String name, int day, int month, int year, long fnum, double gpa)
    throws calException{
    this.name = name;
    this.fnum = fnum;
    this.gpa = gpa;
    birthdate = new calendar(day, month, year);
  }
  // Втори конструктор с подадени параметри
  public student(String name, long fnum, double gpa, calendar birthdate){
    this.name = name;
    this.fnum = fnum;
    this.gpa = gpa;
    this.birthdate = birthdate;
  }
  // Get методи
  public String getName(){
    return this.name;
  }
  public calendar getBirthdate(){
    return this.birthdate;
  }
  public double getGPA(){
    return this.gpa;
  }
  public long getFNum(){
    return this.fnum;
  }
  // Set методи
  void setName(String name){
    this.name = name;
  }
  void setFNum(long fnum){
    this.fnum = fnum;
  }
  void setBirthdate(calendar birthdate){
    this.birthdate = birthdate;
  }
  void setGPA(double GPA){
    this.gpa = gpa;
  }
  // Метод връщащ годините на студента спрямо подадена текуща дата
  public int showYears(calendar currentDate){
    if (currentDate.getMonth() > this.birthdate.getMonth()){
      return (currentDate.getYear() - this.birthdate.getYear());
    }
    else{
      if (currentDate.getMonth() < this.birthdate.getMonth()){
        return (currentDate.getYear() - this.birthdate.getYear() - 1);
      }
      else{
        if (currentDate.getDay() > this.birthdate.getDay()){
          return (currentDate.getYear() - this.birthdate.getYear());
        }
        else{
          return (currentDate.getYear() - this.birthdate.getYear() - 1);
        }
      }
    }
  }
  // Статичен метод сравняващ успеха на двама студенти
  public static int compare(student s1, student s2){
    if (s1.getGPA() > s2.getGPA()) return -1;
    else{
      if (s1.getGPA() > s2.getGPA()) return 1;
      else return 0;
    }
  }
}

3. Дефинирайте клас, описващ студентите от вашия поток, като включите:

• Списък от 100 студенти – използвайте класа от зад. 2 като информация за студентите включени в списъка;
• Поток номер;
• Специалност.

а) Дефинирайте конструктор по подразбиране и с параметри за инициализиране на обекта.

б) Дефинирайте подходящите get и set методи.

в) Дефинирайте метод, който добавя студент в потока. Обръщаме внимание, че факултетния номер на студент би следвало да бъде уникално число. Методът да връща true или false в зависимост дали добавянето е успешно.

г) Дефинирайте метод, който изтрива студент от потока по зададен параметър факултетен номер. Методът връща true или false в зависимост дали е изтрит или не.

д) Дефинирайте метод, който търси има ли студент по зададени като параметър факултетен номер и да връща обект от тип student.

е) Предефенирайте метода от д) така, че да работи и подаден параметър „име на студент“ (може да връща повече от един намерен студент).

ж) Дефинирайте метод, който намира студента с максимален успех от потока. Обръщаме внимание, че е възможно е да има повече от един студент с максимален успех.

potok.java:

package example;
public class potok{
  private static final int MAXSTUDENTS = 100;
  private student[] list;
  private int firstFreeSlot;
  private int potokN;
  private int specN;
  // Конструктор по подразбиране
  public potok() throws java.util.InputMismatchException{
    java.util.Scanner s = new java.util.Scanner(System.in);
    System.out.print("Enter group N: ");
    this.potokN = s.nextInt();
    System.out.print("Enter specialty N: ");
    this.specN = s.nextInt();
    this.list = new student[MAXSTUDENTS];
    this.firstFreeSlot = 0;
  }
  // Конструктор с подадени параметри
  public potok(int potokN, int specN){
    this.potokN = potokN;
    this.specN = specN;
    this.list = new student[MAXSTUDENTS];
    this.firstFreeSlot = 0;
  }
  // Get методи
  public int getPotokN(){
    return this.potokN;
  }
  public int getSpecN(){
    return this.specN;
  }
  public student getStudent(int i){
    return this.list[i];
  }
  // Set методи
  void setPotokN(int potokN){
    this.potokN = potokN;
  }
  void setSpecN(int specN){
    this.specN = specN;
  }
  // Метод добавящ студент в потока
  boolean addStudent(student s){
    if (this.firstFreeSlot == this.MAXSTUDENTS){
      System.err.println("Max students exceeded "+this.MAXSTUDENTS);
      return false;
    }
    // Търси за вече съществуващ студент
    for (int i=0; i < this.firstFreeSlot; i++){
      if (s.getFNum() == this.list[i].getFNum()){
        System.err.println("Student with fnum "+s.getFNum()+" already exists!");
        return false;
      }
    }
    // Добавя студент в първия наличен свободен слот
    this.list[this.firstFreeSlot] = s;
    this.firstFreeSlot++;
    return true;
  }
  // Метод изтриващ студент от потока
  boolean delStudent(long fnum){
    for (int i=0; i < this.firstFreeSlot; i++){
      if (fnum == this.list[i].getFNum()){
        if (i == firstFreeSlot - 1){
          this.list[i] = null;
          this.firstFreeSlot--;
          return true;
        }
        else{
          this.list[i] = this.list[(this.firstFreeSlot-1)];
          this.list[(this.firstFreeSlot-1)] = null;
          this.firstFreeSlot--;
          return true;
        }
      }
    }
    return false;
  }
  // Търсене на студент по факултетен номер
  student findStudent(long fnum){
    for (int i=0; i < this.firstFreeSlot; i++){
      if (fnum == this.list[i].getFNum()){
        return this.list[i];
      }
    }
    return null;
  }
  // Търсене на студент по име (неуникално)
  java.util.LinkedList<student> findStudent(String name){
    java.util.LinkedList<student> result = new java.util.LinkedList<student>();
    for (int i=0; i < this.firstFreeSlot; i++){
      if (name.equalsIgnoreCase(this.list[i].getName())){
        result.add(this.list[i]);
      }
    }
    return result;
  }
  // Намира най-добрите студенти в потока
  java.util.LinkedList<student> getBestStudents(){
    // Ако все още няма ваведени студенти
    if (this.firstFreeSlot == 0){
      System.err.println("No students in the group");
      return null;
    }
    // Намира най-добрия успех
    double maxGPA = this.list[0].getGPA();
    int place = 0;
    for (int i=1; i < this.firstFreeSlot; i++){
      if (this.list[i].getGPA() > maxGPA){
        maxGPA = this.list[i].getGPA();
        place = i;
      }
    }
    // Натрупва в списък най-добрите студенти
    java.util.LinkedList<student> result = new java.util.LinkedList<student>();
    for (int i=place; i < this.firstFreeSlot; i++){
      if (this.list[i].getGPA() == maxGPA){
        result.add(this.list[i]);
      }
    }
    return result;
  }
}

4. Дефинирайте метод, който определя среден успех на потока и връща клас, съдържащ номер на потока, специалност и среден успех.

potokstats.java:

package example;
public class potokstats{
  private int potokN;
  private int specN;
  private double srusp;
  public potokstats(int potokN, int specN, double srusp){
    this.potokN = potokN;
    this.specN = specN;
    this.srusp = srusp;
  }
  public void print(){
    System.out.println("Sp | Gr | GPA");
    System.out.println(this.specN+" | "+this.potokN+" | "+this.srusp);
  }
}

Добавяме в potok.java:

// Намира средния успех на потока
potokstats getSrUsp(){
  if(firstFreeSlot == 0){
    System.err.println("No students in this group yet");
    return null;
  }
  double srusp = 0;
  for (int i=0; i < this.firstFreeSlot; i++){
    srusp += this.list[i].getGPA();
  }
  srusp /= this.firstFreeSlot;
  return new potokstats(this.potokN, this.specN, srusp);
}

5. Демонстрирайте функционалността на създадените класове

mainprog.java:

package example;
class mainprog{
  public static void main(String[] args){
    // Създава поток от студенти
    potok p = new potok(1, 1);
    // Добавя 10 студента
    for (int i=0; i<3; i++){
      student s = null;
      try{
        s = new student();
      }
      catch(java.util.InputMismatchException e){
        System.err.println("Invalid input data!");
        i--;
      }
      catch (calException e){
        System.err.println(e.getMessage());
      }
      finally{
        try{
          while(System.in.available() > 0) System.in.skip(System.in.available());
        }
        catch(java.io.IOException e){}
      }
      if(s!=null) p.addStudent(s);
    }
    // Изтрива студент с фак.номер 1212
    if (p.delStudent(1212)) System.out.println("Successfully deleted student 1212");
    else System.out.println("Student 1212 not found and cannot be deleted");
    // Намира студент с фак.номер 1313 и показва името му и годините му
    System.out.print("Student with fnum 1313 is: ");
    student s1313 = p.findStudent(1313);
    if (s1313 != null){
      try{
        calendar curcal = new calendar(30,10,2009);
        System.out.println(s1313.getName()+" who is "+s1313.showYears(curcal)+" years old");
      }
      catch (calException e){
        System.out.println("Bad calendar");
      }
    }
    else{
      System.out.println("Student 1313 not found and cannot be printed");
    }
    // Сравнява оценките на студент 1313 и 1414:
    System.out.println("Compare s1313 and s1414: ");
    student s1414 = p.findStudent(1414);
    if(s1313!=null && s1414!=null){
      int c = student.compare(s1313, s1414);
      if(c < 0) System.out.println("s1313 is better");
      else if(c > 0) System.out.println("s1414 is better");
      else System.out.println("s1313 and s1414 are equal");
    }
    else System.out.println("cannot compare because one or both do not exists");
    // Търсим студентите с име Peter и им отпечатва факултетните номера и оценките
    System.out.println("The student(s) with name Peter are:");
    java.util.LinkedList<student> peterStudents = p.findStudent("Peter");
    if (peterStudents != null){
      for (int i=0; i<peterStudents.size(); i++){
        System.out.print(peterStudents.get(i).getFNum()+" "+peterStudents.get(i).getGPA());
        System.out.println();
      }
    }
    // Намира най-добрите студенти в потока
    System.out.println("Best students are:");
    java.util.LinkedList<student> bestStudents = p.getBestStudents();
    if (bestStudents != null){
      for (int i=0; i<bestStudents.size(); i++){
        System.out.print(bestStudents.get(i).getFNum()+" "+bestStudents.get(i).getName());
        System.out.print(" "+bestStudents.get(i).getGPA());
        System.out.println();
      }
    }
    // Среден успех на потока
    potokstats ps = p.getSrUsp();
    System.out.println("Statistics for the group:");
    ps.print();
  }
}

1. Обикновено заделяме повече памет, отколкото използваме. Когато говорим за данни с обем в малки граници (брой ученици в клас, работници в малка фирма, продуктова гама от традиционни стоки и др.), това не е проблем. Когато данните обаче варират (унифициран софтуер за малки и големи фирми, данни записани в зависимост от натовареността и посещаемостта на уебсайт и др.), то използването на масив започва да изглежда като голямо разхищение на памет;
2. Ако не желаем да изпадаме в ситуация, в която не можем да добавяме повече елементи, то трябва да се направи доста тежка откъм процесорно време операция:
   a) Заделя се памет за нов масив с 1 или няколко елемента по-голям от стария;
   б) Копират се данните от стария масив в новия;
   в) Премахва се указателят към стария масив и се дава на GarbageCollector да освободи паметта.
3. Най-често ние не „изтриваме“ елементите на масив, а просто слагаме стойност „null“ в съответната клетка (както беше в горния пример). По този начин паметта остава заделена и не може да се освободи. Както и в точка 1 – това е разхищение на памет. Алтернативата с реално изтриване на елемент също изисква много процесорно време и е бавна операция:
   a) Заделя се памет за нов масив с 1 по-малък от стария;
   б) Копират се всички елементи от стария в новия масив, с изключение на изтривания;
   в) Премахва се указателят към стария масив и се дава на GarbageCollector да освободи паметта.

Поради изброените по-горе проблеми, когато имаме данни заемащи голям обем памет и/или когато работим с множества от елементи които не са с фиксирани граници, то традиционните масиви не са препоръчителна структура от данни. Вместо тях е удобно да използваме т.нар. „списъци“ или „динамични масиви“. Традиционните масиви следва да бъдат използвани предимно в случаите, когато работим с фиксирано количество данни.

2. Списъци: в Java съществува клас LinkedList или в превод „свързан списък“. Това е динамична структура от данни (без ограничение на максимален брой елементи, стига да има достатъчно памет). Елементите в LinkedList са „наредени на опашка“, т.е. имаме винаги един първи, един последен елемент, а всички останали имат свой „предходен“ и „следващ“. Такива списъци се наричат „двусвързани“.

LinkedList се дефинира по следния начин:

java.util.LinkedList<Integer> list = new java.util.LinkedList<Integer>();

Естествено в ъгловите скоби вместо Integer (цяло число) може да стои всякакъв друг тип данни или обект. Нека сега разгледаме най-важните методи:

а) Добавяне на елемент в края на списъка:

list.add(new Integer(1));
list.addLast(new Integer(2)); // еквивалентно на първото

б) Добавяне на елемент в началото на списъка:

list.addFirst(new Integer(3));

в) Размер (брой елементи на списък):

System.out.println("\nList size: "+list.size());

г) Отпечатване на съдържанието на списъка чрез итератор:

java.util.Iterator it = list.iterator();
while(it.hasNext()){
   System.out.print(it.next()+" ");
}

Може да приемете, че обектът java.util.Iterator се използва като „указател“ към текущия елемент на списък. В началото той винаги „сочи“ към първия елемент. Показания пример е стандартен за „обхождане“ на списък елемент по елемент.

д) Добавяне на елемент на определена позиция:

list.add(2, new Integer(25)); // първи аргумент е позиция, а втори стойност

е) Прочитане на елемент от определена позиция:

System.out.println("The element at position 2 is: "+list.get(2));

ж) Прочитане на първи и последен елементи:

System.out.println("The first element is is: "+list.getFirst());
System.out.println("The last element is is: "+list.getLast());

з) Отпечатване на съдържанието на списъка БЕЗ итератор:

for (int i=0; i<list1.size(); i++){
 System.out.print(list1.get(i)+" ");
}

и) Изтриване на елемент: тук освен фактическото премахване на елемента имаме и функционалност същевременно да прочетем стойността й. Така например този вид списък може лесно да бъде използван като стек:

int first = list.removeFirst();
System.out.println("First element: "+first+" removed...");
int last = list.removeLast();
System.out.println("Last element: "+last+" removed...");
int x = list.remove(1);
System.out.println("Element with index 1: "+x+" removed...");
System.out.println("Now list contains:");
it = list.iterator();
while(it.hasNext()){
   System.out.print(it.next()+" ");
}

й) Изтриване на всички елементи в списък:

list.clear();

к) Проверка дали списък е празен или не:

if (list.isEmpty()) System.out.println("List is empty");

л) „Клониране“ на списък:

java.util.LinkedList list = new java.util.LinkedList();
list.add(new Integer(1));
list.addLast(new Integer(2));
list.addFirst(new Integer(3));
java.util.LinkedList listClone = list.clone();

м) Търсене на елемент в списък:

if(list.contains(3)) System.out.println("List has element with val 3");

н) Промяна на елемент с нова стойност:

list.set(1, new Integer(25)); // първи аргумент индекс, а втори стойност

о) Добавяне на един списък в края на друг или вмъкването му в даден индекс:

java.util.LinkedList list1 = new java.util.LinkedList();
list1.add(new Integer(1));
list1.addLast(new Integer(1));
list1.addFirst(new Integer(1));
java.util.LinkedList list2 = new java.util.LinkedList();
list2.add(new Integer(2));
list2.addLast(new Integer(2));
list2.addFirst(new Integer(2));
list1.addAll(list2);
list1.addAll(1, list2);

Виждате, основната разлика между LinkedList и Array е в липсата на предварително фиксиране на размера на структурата. Един списък може да бъде толкова голям, колкото налична памет има.

Въпреки, че на няколко места използвахме термина „индекс“, все пак трябва да знаете, че то не е коректно. Физически в паметта обектите на LinkedList са разположени в различни места, а просто се пазят „указатели“ (т.нар. итератори) към следващия елемент. Така всъщност ние не знаем къде точно се намира елемент №4 от самото начало – налага се да тръгнем от елемент №1, през №2 и №3, за да стигнем до търсения. Така въпреки, че остава скрито за нас като потребители, извличането на елемент от даден индекс е значително по-бавна операция от тази при масивите. Изтриването на елемент също включва в себе си първо „намиране“ на елемента. Така можем да заключим, че LinkedList наистина спестява памет в сравнение с масивите, но за сметка на това може да се каже, че е по-бавен.

3. Динамични Масиви: – В общи линии можем да приемем, че динамичните масиви (ArrayList) са нещо средно между свързани списъци и обикновени масиви. Всъщност те се опитват да комбинират предимствата и на едните и на другите. Един ArrayList първоначално заделя определен обем от памет подобно на стандартния масив. Елементите, които добавяме се натрупват един след друг в тази памет (т.е. тук имаме истинско понятие „индекс“, защото елементите са на поредни места в паметта). Достъпването до елемент е бързо както при масивите. Изтриването на елемент също – просто последващите се преместват назад. Проблемът със следенето за препълване на масив обаче липсва – ArrayList си разширява капацитета автоматично. Вече демонстрирахме подобна функционалност при динамичните низове (StringBuffer и StringBuilder).

ArrayList работи подобно на LinkedList. Някои методи са премахнати (addFirst, addLast, removeLast, removeLast). Ето само списък с наличните познати методи (няма да даваме примери, понеже синтаксисът е аналогичен на този на LinkedList):

add(елемент) – добавя елемент в края на списъка;
add(индекс, елемент) – добавя елемент в даден индекс (и премества следващите напред);
clear() – изтрива всички елементи;
contains(елемент) – търси елемента в списъка и връща true или false ако е намерен или не;
get(индекс) – връща стойността на елемент от даден индекс;
isEmpty() – връща true или false в зависимост дали списъка е празен;
remove(индекс) – изтрива елемент на даден индекс;
set(индекс, елемент) – променя стойността на елемент на даден индекс с нова стойност);
size() – връща броя елементи на масива;

Новите методи спрямо LinkedList са:

a) Подсигуряване за минимален капацитет:

java.util.ArrayList<Integer> arrlist = new java.util.ArrayList<Integer>();
arrlist.ensureCapacity(10);

Понеже автоматичното разширяване на динамичен масив може да бъде „скъпа“ операция (ако няма място за разширяването), то с ensureCapacity ние се подсигуряваме, че имаме достатъчно голям размер. Всъщност показаното в горния пример е грешен метод – можем да подсигурим размера директно чрез конструктора при инициализация:

java.util.ArrayList<Integer> arrlist = new java.util.ArrayList<Integer>(10);

Използвайте ensureCapacity() ако е необходимо да разширявате масива с много елементи при извършаването на дадена операция.

б) indexOf(елемент) – връща индекса на първото срещане на елемента вътре в списъка (не се поддържа търсене от „елемент нататък“, както беше при клас String);

в) lastIndexOf(елемент) – индекса на последното срещане на елемента вътре в списъка;

г) removeRange(индекс „от“, индекс „до“) – изтрива елементите от първия до втория индекс подадени като аргумент. Например list.removeRange(2,4); изтрива елементи от 2 до 4 включително;

д) trimToSize() – „свива“ капацитета на масива до броя на елементите му. Обикновено го използваме, за да освободим памет в случаи когато знаем, че няма да има повече добавяне на елементи.

4. Опашка и стек: Като частни случаи на двусвързаният списък (LinkedList) са списъците от тип Queue (опашка) и Stack (стек). При опашката можете да добавяте елементи само в края на списъка и премахване на елемент само от началото на списъка. При опашката операции „търсене“ и „извличане по индекс“ няма. Опашките се използват често при създаване на интернет приложения, при които трябва да обработваме поредни заявки в стил FIFO (first in first out).

При стека пък се добавят елементи (push) само в края на списъка и се изтриват (pop) пак само в края на списъка. Има и операция „прочитане на елемент“, която връща (peek) стойността на последния елемент без да го изтрива. Тази структура е от тип LIFO (last in first out). Представете си стека като натрупана купчина от книги. За да достигнете до най-долната трябва преди това да премахнете една по една по-горните над нея.

Всичко, което трябва да направите при дефиниране на изключение е да създадете клас, който наследява клас Exception:

public class CarsExample{
  public static void main(String args[]) throws Exception {
    try{
      Car c = new Car(-150, "BMW X5");
    }
    catch (SpeedException e){
      System.out.println(e.toString());
    }
  }
}

class SpeedException extends Exception{
  private int speed;
  public SpeedException(int speed){
    this.speed = speed;
  }
  public String toString(){
    return "Speed of Car must not be negative: "+this.speed;
  }
}

class Car{
  private int speed;
  private String model;
  public Car(int speed, String model) throws SpeedException{
    if (speed < 0) throw new SpeedException(speed);
    else{
      this.speed = speed;
      this.model = model;
    }
  }
  public void showInfo(){
    System.out.println("The car "+this.model+" has maxspeed of "+this.speed);
  }
  public int getSpeed(){
    return this.speed;
  }
  public void setSpeed(int speed) throws SpeedException{
    if (speed < 0) throw new SpeedException(speed);
    else this.speed = speed;
  }
  public int compare(Car opponent){
    if (this.speed < opponent.getSpeed()) return 1;
    else{
      if (this.speed > opponent.getSpeed()) return -1;
      else return 0;
    }
  }
}

Виждате, че при изключенията няма абсолютно нищо страшно. Единственото, за което трябва да се погрижите е да предефинирате метод „toString()“. Колкото до другите методи – printStackTrace() си съществува и го наследяваме директно от клас Exception. Проблем се явява метод „getMessage()“, който ако не се предефинира, то ще върне резултат null. Затова обикновено предаваме и съобщение към супер класа:

class SpeedException extends Exception{
  private int speed;
  public SpeedException(int speed){
    super("Speed of car must not be negative: "+speed);
    this.speed = speed;
  }
  public SpeedException(int speed, String msg){
    super(msg);
    this.speed = speed;
  }
  public String toString(){
    return "Speed of Car must not be negative: "+this.speed;
  }
}

Вече можете да извиквате метод „getMessage()“ без проблем. Виждате, че дефинирането на изключения е изключително лесно. Това е и мощен метод за контрол над интегритета на данните в клас.

Когато имаме обект (говорим за който и да е обект създаден с оператор new), то разполагаме с нестатичен метод Object.wait(). Този метод на пръв поглед предизвиква същия ефект както Thread.sleep() – прехвърля текущата нишка (тази, която е извикала метода) в „Not Runnable“ статус за определено време. Такъв обект се нарича „заключващ обект“ за нишката. Първата разлика е, че Object.wait() може да бъде извикан само в синхронизиран метод. Втората разлика е, че Object.wait() може да приспи нишката за неопределено време, докато Thread.sleep() е с фиксирано. Освен това ако имаме Thread T, то T.sleep() ще „приспи“ нишката T, докато T.wait() ще приспи текущата нишка (тази, която е извикала метод T.wait()), докато някой друг не извика T.notify().

Преди да дадем пример трябва да кажем, че wait() и notify() са final методи за клас Object. Понеже Object е базов шаблон за клас, който всеки наследява по подразбиране, то всеки един клас в Java ги притежава.

В първият пример ще демонстрираме как можем да накараме една нишка да „заспи“ докато не се извършат необходимите стартирани в нея изчисления:

public class waitNotifyExample{
  public static void main(String[]args){
    ThreadExample T = new ThreadExample();
    T.start();
    synchronized(T){
      System.out.println("Waiting until calculations finish...");
      try{
        T.wait();
      }
      catch (InterruptedException e){}
    }
    System.out.println("Result: "+T.sum);
  }
}

class ThreadExample extends Thread{
  public static int sum=0;
  public void run(){
    synchronized (this){
      this.sum();
      System.out.println("Finished summing. Now the program can continue...");
      this.notify();
    }
  }
  public void sum(){
    System.out.println("Suming the first 500 integers...");
    for(int i=1; i<=500; i++){
      this.sum = this.sum+i;
    }
  }
}

Преди да бъде извикан „wait()“ методът за обекта, нишката е длъжна да се синхронизира по него (т.е. други методи не могат да го модифицират). След това цялата нишка се „приспива“ в т.нар. „wait list“ (от примера по-горе приспахме главната нишка на main метода). В последствие друга нишка има възможност да „събуди“ обекта чрез метод „notify()“ (това направи самата нишка, по която бяхме приспали main метода).

В този пример показахме как главната нишка (main) извиква друга нишка и изчаква докато тя си свърши работата. Нека погледнем и обратния вариант – главната нишка стартира нова нишка и новата нишка изчаква докато главната не я уведоми:

public class myfirstprogram {
  public static void main(String args[]) throws Exception {
    System.out.println("Starting thread...");
    MyThread T =  new MyThread("MyThread");
    System.out.println("Main thread printing dots...");
    for (int i = 0; i < 50; i++) {
      Thread.sleep(50);
      System.out.print(".");
    }
    T.start();
  }
}

class MyThread implements Runnable{
  boolean ready;
  Thread T;
  String name;
  MyThread(String name){
    this.ready = false;
    this.name = name;
    this.T = new Thread(this, name);
    this.T.start();
  }
  synchronized void suspendThread(){
    System.out.println(this.name+" suspended until main finishes...");
    while (!ready){
      try{
        this.wait();
      }
      catch(InterruptedException e){}
    }
    System.out.println("\n"+this.name+" is now resumed!");
  }
  synchronized void start(){
    ready = true;
    notify();
  }
  public void run() {
    this.suspendThread();
  }
}

Нека сега покажем още един пример, в който две нишки се „блокират“ една друга докато изпълнението на съответните методи не приключи. Имаме два класа и две инстанции – обект, който внася пари и обект, който ги прибира. Нека погледнем следният пример:

public class WaitNotifyExample{
  public static void main(String args[]) {
    MoneyQueue q = new MoneyQueue();
    MoneyGiver mg = new MoneyGiver(q, "MoneyGiver");
    MoneyFetcher mf = new MoneyFetcher(q, "MoneyFetcher");
  }
}

class MoneyQueue{
  double moneyTransfer;
  boolean haveMoneyInAccount = false;

  synchronized double getMoney(String name) {
    if(haveMoneyInAccount == false){
      try {
        this.wait();
      }
      catch(InterruptedException e) {
        System.out.println("This should not happen in this program");
      }
    }
    System.out.println(name +" fetched " + moneyTransfer);
    haveMoneyInAccount = false;
    this.notify();
    return moneyTransfer;
  }

  synchronized void addMoney(){
    if(haveMoneyInAccount == true){
      try {
        this.wait();
      }
      catch(InterruptedException e) {
        System.out.println("This should not happen in this program");
      }
    }
    System.out.print("Add money: ");
    java.util.Scanner s = new java.util.Scanner(System.in);
    double moneyTransfer = s.nextDouble();
    this.moneyTransfer = moneyTransfer;
    haveMoneyInAccount = true;
    this.notify();
  }
}

class MoneyGiver implements Runnable{
  String name;
  Thread T;
  MoneyQueue q;
  public MoneyGiver(MoneyQueue q, String name){
    this.q = q;
    this.name = name;
    T = new Thread(this, "MoneyGiver");
    T.start();
  }
  public void run() {
    while(true){
      q.addMoney();
    }
  }
}

class MoneyFetcher implements Runnable{
  double money;
  String name;
  Thread T;
  MoneyQueue q;
  public MoneyFetcher(MoneyQueue q, String name) {
    this.q = q;
    this.name = name;
    money = 0;
    T = new Thread(this, "MoneyFetcher");
    T.start();
  }
  public void run() {
    while(true) {
      this.money += q.getMoney(this.name);
      System.out.println(this.name+" now have "+this.money);
    }
  }
}

MoneyQueue е клас, в който са дефинирани два синхронизирани метода – addMoney и getMoney. Освен това създаваме два обекта – MoneyGiver (вкарващ пари в системата) и MoneyFetcher (взимащ тези пари и натрупващ ги в собствената си сметка).

Идеята на примера е следната – в началото в MoneyQueue няма никакви пари, което е описано чрез променливата haveMoneyInAccount. Двата обекта MoneyGiver и MoneyFetcher се стартират в две нишки. MoneyFetcher моментално се опитва да вземе пари, но тъй като такива няма, той изпада в спящ режим (в метод getMoney() изпадаме в статус wait(), с което извикващия метод започва да чака). При MoneyGiver ситуацията е точно обратната – виждаме, че няма пари в опашката и затова се поисква въвеждане на такива от клавиатурата. В момента в който вкараме пари в опашката, то haveMoneyInAccount става true и се извиква this.notify(), с което „събуждаме“ другата нишка. MoneyGiver мометално ще изника същия метод (addMoney) отново, но този път ще забележи, че все още има пари за взимане в опашката и затова ще изпадне в wait() статус (докато парите бъдат взети). MoneyFetcher вече е „събуден“ – той ще вземе парите от опашката и ще укаже, че в нея вече няма пари (тоест при следващо извикване на същия метод той самия пак ще е в wait() статус). Естествено отново се извиква this.notify(), за да „събудим“ обекта MoneyGiver. Тази поредност в случая може да се повтаря до безкрайност.

Методът notifyAll() е по-специален – той „събужда“ всички нишки, които са попаднали в wait() статус. По принцип когато пишете програми трябва много добре да прецените колко нишки евентуално могат да заспят. Ако е само една, то notify() е достатъчен. Ако са много, то е по-вероятно да ви трябва notifyAll(). Ако използвате notify() и повече от една нишка заспи, то рискувате нишките ви да „зациклят“. Въпреки това не препоръчваме тактиката да използвате винаги notifyAll() – ако това ви се налага, но не е очаквано, то по-добре си напишете програмата по-добре.

Обикновено използваме notifyAll() когато нишките имат споделен ресурс по който те се заключват:

public class myfirstprogram {
  public static void main(String args[]) throws Exception {
    ThreadsResource tr = new ThreadsResource();
    MyThread T1 = new MyThread("MyThread1", tr);
    MyThread T2 = new MyThread("MyThread2", tr);
    for (int i = 0; i < 50; i++){
      Thread.sleep(50);
      System.out.print(".");
    }
    System.out.println();
    tr.resume();
  }
}

class ThreadsResource{
  boolean ready = false;
  synchronized void suspendThread(){
    System.out.print(Thread.currentThread().getName());
    System.out.println(" suspended until main finishes...");
    while(!ready){
      try{
        this.wait();
      }
      catch(InterruptedException e){}
    }
    System.out.println(Thread.currentThread().getName()+" is now resumed!");
  }
  synchronized void resume() {
    ready = true;
    this.notifyAll();
  }
}

class MyThread implements Runnable{
  ThreadsResource tr;
  Thread T;
  MyThread(String name, ThreadsResource tr){
    this.tr = tr;
    this.T = new Thread(this, name);
    this.T.start();
  }
  public void run() {
    tr.suspendThread();
  }
}

Виждате, че когато споделеният ресурс ThreadsResource извика „notifyAll()“, то всички нишки, които са „заспали“ чрез него се „събуждат“. Това например е често използвана тактика при многопотребителски игри, при които синхронизацията е важна.

public class myfirstprogram{
 public static void main(String[] args){
   ArrayClass arr = new ArrayClass();
   ChangeThread c = new ChangeThread("Change Thread", arr);
   SortThread s = new SortThread("Sort Thread", arr);
   c.T.start();
   s.T.start();
   try{
     c.T.join();
     s.T.join();
   }
   catch(java.lang.InterruptedException e){}
   arr.showArray();
 }
}

class ArrayClass{
  int[] arr;
  public ArrayClass(){
    this.arr = new int[200];
    for(int i=this.arr.length-1; i>=0; i--){
      this.arr[i] = i;
    }
  }
  public void changeArray(){
    for(int i=0; i<this.arr.length; i++){
      this.arr[i] = (int)Math.round(Math.random()*100);
    }
    System.out.println("Change finished");
  }
  public void sortArray(){
    java.util.Arrays.sort(this.arr);
    System.out.println("Sort finished");
  }
  public void showArray(){
    for(int i: this.arr){
      System.out.print(i+" ");
    }
  }
}

class SortThread implements Runnable {
  private String threadName;
  ArrayClass arr;
  Thread T;
  public SortThread(String threadName, ArrayClass arr){
    this.threadName = threadName;
    this.T = new Thread(this, this.threadName);
    this.arr = arr;
  }
  public void run(){
    arr.sortArray();
  }
}

class ChangeThread implements Runnable {
  private String threadName;
  ArrayClass arr;
  Thread T;
  public ChangeThread(String threadName, ArrayClass arr){
    this.threadName = threadName;
    this.arr = arr;
    this.T = new Thread(this, this.threadName);
  }
  public void run() {
    arr.changeArray();
  }
}

При изполнение на програмата ще забележите, че нито числата са подредени произволно, нито масива е сортиран напълно. Ще има няколко поредици от сортирани числа – нещо, което определено нито една от нишките не е пожелала.

За да поправим този проблем, когато една нишка „бърка“ в данните на друга, то използваме т.нар. „синхронизирани методи“. Въвежда се функционалност подобна на тази при транзакциите при бази от данни – достъпваните данни се „заключват“, променят се и се „отключват“ за достъп от други:

public class myfirstprogram{
 public static void main(String[] args){
   ArrayClass arr = new ArrayClass();
   ChangeThread c = new ChangeThread("Change Thread", arr);
   SortThread s = new SortThread("Sort Thread", arr);
   c.T.start();
   s.T.start();
   try{
     c.T.join();
     s.T.join();
   }
   catch(java.lang.InterruptedException e){}
   arr.showArray();
 }
}

class ArrayClass{
  int[] arr;
  public ArrayClass(){
    this.arr = new int[200];
    for(int i=this.arr.length-1; i>=0; i--){
      this.arr[i] = i;
    }
  }
  public synchronized void changeArray(){
    for(int i=0; i<this.arr.length; i++){
      this.arr[i] = (int)Math.round(Math.random()*100);
    }
    System.out.println("Change finished");
  }
  public synchronized void sortArray(){
    java.util.Arrays.sort(this.arr);
    System.out.println("Sort finished");
  }
  public void showArray(){
    for(int i: this.arr){
      System.out.print(i+" ");
    }
  }
}

class SortThread implements Runnable {
  private String threadName;
  ArrayClass arr;
  Thread T;
  public SortThread(String threadName, ArrayClass arr){
    this.threadName = threadName;
    this.T = new Thread(this, this.threadName);
    this.arr = arr;
  }
  public void run(){
    arr.sortArray();
  }
}

class ChangeThread implements Runnable {
  private String threadName;
  ArrayClass arr;
  Thread T;
  public ChangeThread(String threadName, ArrayClass arr){
    this.threadName = threadName;
    this.arr = arr;
    this.T = new Thread(this, this.threadName);
  }
  public void run() {
    arr.changeArray();
  }
}

Когато една нишка извика „синхронизиран“ метод от един обект, то всички други нишки, които в същия момент извикат същия или друг синхронизиран метод от същия обект „заспиват“ и изчакват изпълнението си в опашка. В този смисъл ако първо се стартира ChangeThread, то той ще извика метод changeArray(). Ако стартираме в същия момент SortThread, то той ще извика функцията sortArray(). Тъй като и двете извикани функции са синхронизирани (с ключова дума synchronized), то SortThread ще „заспи“ и ще изчака ChangeThread да си свърши работата. Едва след това метод sortArray() ще бъде стартиран.

Единствените методи, които не могат да бъдат синхронизирани са конструкторите. При тях естествено такава операция е напълно безсмислена – не е възможно две нишки да „създават“ един и същи обект едновременно.

В предишни статии ние споменахме за два обекта, които се различаваха по това как са реализирани техните методи. Това бяха StringBuilder (притежаващ не-синхронизирани методи) и StringBuffer (чийто методи са синхронизирани). Когато пишем подобни класове е хубаво винаги да преценяваме дали те ще бъдат използвани в многонишкови приложения или не. Синхронизирането трябва да се изпълнява много внимателно – в противен случай е напълно възможно при да се появят трудни за локализиране „бъгове“ в последствие при реална експлоатация на софтуера.

Понякога обаче ни се налага да не правим синхронизация на абсолютно целия метод, а само на фрагмент от него. Така на практика оптимизираме програмите, като заключваме нишките за по-кратко време. Синтаксисът е следният:

Оператори 1;
synchronized(<име на обект>){
   Оператори 2;
}
Оператори 3;

По този начин по време на изпълнението на групата „Оператори 2″ обектът дефиниран в блока ще бъде заключен за другите нишки. Чак след излизане от блока те ще бъдат отключени. От предишния пример бихме могли да постигнем аналогична функционалност ако променим методите changeArray и sortArray по следния начин:

  public void changeArray(){
    synchronized(this){
      for(int i=0; i<this.arr.length; i++){
        this.arr[i] = (int)Math.round(Math.random()*100);
      }
    }
    System.out.println("Change finished");
  }
  public void sortArray(){
    synchronized(this){
      java.util.Arrays.sort(this.arr);
    }
    System.out.println("Sort finished");
  }

Виждаме, че вече сме оградили само и единствено блокът, където се прави промяна на данните. Извикването на System.out.println() не променя никакви данни и поради тази причина няма нужда да бъде изчакван от другите нишки.

Още повече – не е задължително блоковете да заключват всички обекти от текущия клас (в горния пример заключихме за синхронизация this). Можем да заключваме само и единствено обектът, с който работим, а именно – arr.this:

  public void changeArray(){
    synchronized(this.arr){
      for(int i=0; i<this.arr.length; i++){
        this.arr[i] = (int)Math.round(Math.random()*100);
      }
    }
    System.out.println("Change finished");
  }
  public void sortArray(){
    synchronized(this.arr){
      java.util.Arrays.sort(this.arr);
    }
    System.out.println("Sort finished");
  }

По този начин е съвсем възможно друга нишка да достъпва и променя други „член-обекти“ от текущия клас.

Първо трябва да правите разлика между „многонишковост“ и „многозадачност“. Когато говорим за „многозадачност“, то се има в предвид изпълнението на множество „процеси“ (програми) от операционната система едновременно. Тяхното „едновременно“ изпълнение не се контролира от тях, а именно от операционната система. При „многонишковост“ говорим за контрол над изпълнението на „подпрограми“ от самата програма. Затова стартирането на едно и също приложение два пъти НЕ създава „две нишки“, а създава „два процеса“.

По същество всяка една програма, която демонстрирахме досега се състоеше от една единствена нишка. Тя от своя страна има право да „пусне“ още една или повече нишки. Естествено никой не ограничава и те да пускат „под-нишки“ от своя страна. По този начин казваме, че се създава „дърво от нишки“. Важното в случая е, че една нишка не може да съществува ако нишката, която я е извикала престане да съществува.

Има два начина за „пускане на нишка“. Първият е чрез наследяване на системния клас „Thread“:

public class ThreadExample extends Thread{
   public void run(){
      ... оператори ...
   }
}

Другият е чрез имплементирането на интерфейс Runnable:

public class ThreadExample implements Runnable{
   public void run(){
      ... оператори ...
   }
}

При първият метод директно наследяваме функционалността на клас Thread и добавяме детайли в неговия „run()“ метод. Във втория ние само имплементираме интерфейсът Runnable, а в последствие предаваме инстанция на създадения клас като параметър за инстанция на клас Thread – така имаме доста по-голяма гъвкавост за промени и по-голям контрол. Затова ще демонстрираме първият метод само като функционалност, но ще наблегнем на вторият.

Интерфейсът Runnable сам по себе си не е нещо интересно. Той съдържа само и единствено дефиниция за съществуване на метод „public void run();“. С други думи думите „implements Runnable“ не правят нищо друго освен да ви задължат да дефинирате нестатичен метод „run()“. Така все пак стигаме до заключението, че истинската работа с нишките се води от клас Thread. За да сме пределно ясни трябва да кажем, че самият клас Thread имплементира Runnable интерфейс!.

За стартиране на Thread се използва метод „start()“. Ето как би изглеждала нашата първа програма имплементираща нишки. В случая показваме двата метода за стартиране на нишка, които имплементират една и съща функционалност:

public class myfirstprogram{
 public static void main(String[] args){
   // Създаване на нишка с подаден обект имплементиращ Runnable:
   Thread T1 = new Thread(new RunnableExample());
   T1.start();

   // Създаване на нишка, чрез наследник на Thread:
   ThreadExtendExample T2 = new ThreadExtendExample();
   T2.start();
 }
}

class RunnableExample implements Runnable {
  public void run() {
    System.out.println("Аз съм нишка!");
  }
}

class ThreadExtendExample extends Thread {
    public void run() {
        System.out.println("Аз също съм нишка!");
    }
}

За да демонстрираме функционалността за „едновременно изпълнение“, нека напишем следната програма:

public class myfirstprogram{
 public static void main(String[] args){
   Thread T1 = new Thread(new RunnableExample("T1"));
   Thread T2 = new Thread(new RunnableExample("T2"));
   T1.start();
   T2.start();
 }
}

class RunnableExample implements Runnable {
  private String threadName;
  public RunnableExample(String threadName){
    this.threadName = threadName;
  }
  public void run() {
    for (int i=0; i<10; i++){
      System.out.print(this.threadName+":"+i+"; ");
    }
  }
}

Едно примерно изпълнение би било следното:

T1:0; T1:1; T1:2; T1:3; T1:4; T1:5; T2:0; T2:1; T2:2; T1:6;
T1:7; T1:8; T1:9; T2:3; T2:4; T2:5; T2:6; T2:7; T2:8; T2:9;

Понеже операциите са сравнително прости и изключително бързи (отпечатване на число на екрана), то първите няколко отпечатани числа на екрана са от T1, а последните от T2 (както по реда на изпълнение на методите start()). Все пак обаче в средата на изходните данни се вижда ясно, че двете нишки са се „засичали“ идна друга, т.е. T2.start() не е изчакало T1.start() да завърши.

Клас Thread съдържа важни функции за контролиране на нишките. Ще разгледаме трите основни от тях поотделно:

1. Thread.sleep(милисекунди): „приспива“ текущата нишка и дава шанс на другите нишки да работят през това време:

public class myfirstprogram{
 public static void main(String[] args){
   Thread T1 = new Thread(new RunnableExample("T1"));
   Thread T2 = new Thread(new RunnableExample("T2"));
   T1.start();
   T2.start();
 }
}

class RunnableExample implements Runnable {
  private String threadName;
  public RunnableExample(String threadName){
    this.threadName = threadName;
  }
  public void run() {
    for (int i=0; i<5; i++){
      try{
        Thread.sleep(1000);
        System.out.print(this.threadName+":"+i+"; ");
      }
      catch (InterruptedException e){
        return;
      }
    }
  }
}

В този пример караме нишката да отпечатва съобщенията през интервали от 1 секунда. Реализирано по този начин ще видим, че изходът е много по-равномерен:

T1:0; T2:0; T1:1; T2:1; T1:2; T2:2; T1:3; T2:3; T2:4; T1:4;

„Приспиването на нишки“ се използва често, за да се дефинира приоритет на едни нишки спрямо други. Обикновено не бихме искали една по-маловажна подпрограма да може да отнеме прекалено много ресурси и по този начин да забавя работата на всички останали. Вземете за пример сайт за обработка на видео в който има два вида потребители – такива, които гледат видео клипове и такива, които ги качват и сървъра в последствие в отделна нишка преработва в удобен файлов формат. Определено „гледането на клипове“ са приоритетни операции спрямо преработката на клипове (тя може да се забави в зависимост от натовареността на системата). Затова можем да „приспиваме“ нишките за преработка на видео за малки периоди от време и по този начин да даваме „повече въздух“ на тези, която изпращат клиповете до потрибителите за гледане.

2. Thread.interrupt(): Изключението от тип InterruptedException вече подсказа, че нишките могат да се прекъсват. По принцип в старите версии на Java съществува метод Thread.stop(), но силно препоръчваме да го забравите веднага (ако работите с по-нова версия на Java, той вече не може да се използва тъй или иначе). Остарелия метод Thread.stop() прекъсваше нишката моментално. Досещате се, че по този начин можем лесно да загубим данни, да оставим файлове отворени и всякакви други поразии на софтуера. Вместо това по-добрият метод е „да кажем на нишката, че трябва да прекъсне“, тя да си довърши работата и да се спре сама. Можете веднага да си направите аналогия с разликата нормално затваряне на програма и „убиване на процеса“ чрез операционната система.

Когато извикаме метод „Thread.interrupt()“, то ние именно „съобщаваме“ на нишката, че трябва да спре. После в самата нишка ние трябва да имаме метод за прихващане на това събитие. Ако вътре в самата нишка използваме Object.wait(), Thread.join() или Thread.sleep() и ние извикаме прекъсване, то тези методи „виждат“ прекъсването и автоматично „хвърлят“ InterruptedException. Именно затова когато извиквахме „Thread.sleep()“ в миналия пример ние трябваше да прихванем това изключение. В него просто извикахме „return“ и приключихме изпълнението на нишката. Нека дадем един пример:

public class myfirstprogram{
 public static void main(String[] args){
   Thread T1 = new Thread(new RunnableExample("T1"));
   T1.start();

   try{
     Thread.sleep(500);
   }
   catch(InterruptedException e){}

   System.out.println("Interrupting thread...");
   T1.interrupt();
 }
}

class RunnableExample implements Runnable {
  private String threadName;
  public RunnableExample(String threadName){
    this.threadName = threadName;
  }
  public void run() {
    for (int i=0; i<50; i++){
      try{
        Thread.sleep(100);
        System.out.println(this.threadName+":"+i+"; ");
      }
      catch (InterruptedException e){
        System.out.println("I was interrupted!");
        return;
      }
    }
  }
}

Резултатът от изпълнението ще бъде:

T1:0;
T1:1;
T1:2;
T1:3;
Interrupting thread...
I was interrupted!

След малко практика ще забележите обаче, че прекъсването никак не настъпва моментално. Вземете например този пример:

public class myfirstprogram{
 public static void main(String[] args){
   Thread T1 = new Thread(new RunnableExample("T1"));
   T1.start();

   try{
     Thread.sleep(50);
   }
   catch(InterruptedException e){}

   System.out.println("Interrupting thread");
   T1.interrupt();
 }
}

class RunnableExample implements Runnable {
  private String threadName;
  public RunnableExample(String threadName){
    this.threadName = threadName;
  }
  public void run() {
    while(true){
      try{
        Thread.sleep(1);
        double time = System.currentTimeMillis();
        while(System.currentTimeMillis()-time < 5000){
          System.out.print(".");
        }
        System.out.println();
      }
      catch (InterruptedException e){
        System.out.println("I was interrupted!");
        return;
      }
    }
  }
}

Нишката изписва точки на екрана в продължение на 5 секунди, след това заспива за 1 милисекунда и продължава да изписва точки на екрана за нови 5 секунди (и така до безкрайност, защото всичко се намира в цикъл while(true)). В главната програма ние стартираме тази нишка, изчакваме 5 милисекунди и я прекъсваме, чрез T1.interrupt(). Ще забележите обаче, че нишката ще продължи да изписва точки на екрана още няколко секунди преди да спре. Това е защото най-вероятно прекъсването ще съвпадне с изпълнението на тялото на вложения while цикъл, който още не е завършил. Чак когато се достигне до Thread.sleep(1) ще бъде хвърлен InterruptedException, който ще бъде прихванат и нишката ще спре според инструкциите в секцията catch.

Какво обаче да правим ако не използваме Thread.sleep() или други готови методи, които следят за interrupt или пък сме започнали алгоритъм, който ще изиска много време преди да се „върнем обратно“ към някоя от тези методи? Естествено се досещаме, че сами можем да следим дали нишката е прекъсната. Ако използваме наследяване на клас Thread, то ни върши работа метод „interrupted()“ връщащ boolean. В нашата имплементация можем да я реализираме сами:

public class myfirstprogram{
 public static void main(String[] args){
   RunnableExample T1Obj = new RunnableExample("T1");
   Thread T1Thread = new Thread(T1Obj);
   T1Thread.start();

   try{
     Thread.sleep(50);
   }
   catch(InterruptedException e){}

   System.out.println("Interrupting thread");
   T1Obj.interrupt();
   T1Thread.interrupt();
 }
}

class RunnableExample implements Runnable {
  private boolean isInterrupted;
  String threadName;
  public RunnableExample(String threadName){
    this.threadName = threadName;
    this.isInterrupted = false;
  }
  public void interrupt(){
    this.isInterrupted = true;
  }
  private void stopMsg(){
    System.out.println("I was interrupted!");
  }
  public void run() {
    while(this.isInterrupted == false){
      try{
        Thread.sleep(1);
        double time = System.currentTimeMillis();
        while(System.currentTimeMillis()-time < 5000 && this.isInterrupted == false){
          System.out.print(".");
        }
        System.out.println();
      }
      catch (InterruptedException e){
        this.stopMsg();
        return;
      }
    }
    stopMsg();
  }
}

Казано накратко ние създаваме една променлива, която ни съобщава дали нишката е прекъсната или не. После в самата програма ние трябва периодично да проверяваме дали случайно тя не е променена.

3. Thread.join() – не-статичен метод на обект от тип Thread. Когато бъде извикан, то извикващата нишка трябва да изчака изпълнението на притежателя на метода. По този начин нишките се изчакват една друга. Нека се върнем към един по-стар пример, но този път го преработим така, че класът RunnableExample сам в себе си съдържа нишката си (всъщност много често използвана практика):

public class myfirstprogram{
 public static void main(String[] args){
   RunnableExample T1 = new RunnableExample("T1");
   RunnableExample T2 = new RunnableExample("T2");
   // Стартираме нишките като член-променливи на класовете
   T1.T.start();
   T2.T.start();
   // Караме главната програма да "заспи" докато свършат нишките
   try{
     T1.T.join();
     T2.T.join();
   }
   catch(InterruptedException e){
     System.out.println("What? Interrupt should NOT happen at all!");
   }
   System.out.println("Main finished!");
 }
}

class RunnableExample implements Runnable {
  private String threadName;
  // Вече нишката е член-променлива на класа
  Thread T;
  public RunnableExample(String threadName){
    this.threadName = threadName;
    // Инициализираме нишката вътре в конструктора
    this.T = new Thread(this, this.threadName);
  }
  public void run() {
    for (int i=0; i<10; i++){
      try{
        // Нарочно слагаме произволно време за "заспиване"
        Thread.sleep((int)Math.random()*1000);
        System.out.print(this.threadName+":"+i+"; ");
      }
      catch (InterruptedException e){
        return;
      }
    }
    System.out.println("\nThread "+this.threadName+ "finished!");
  }
}

Ще видите, че main() метода ще изчака докато и двете нишки са свършили и чак тогава ще изпише съобщението „Main finished!“.

   final int x = 5;
   // x = 6; <<< Не е възможно

В Java обаче е възможно константата само да се декларира и да бъде инициализирана по-късно:

   final int x;
   java.util.Scanner s = new java.util.Scanner(System.in);
   x = s.nextInt();

Все пак след тази инициализация x не може да бъде променяна, т.е. се държи напълно като константа. Така всъщност казваме, че имаме два типа константи:

1. Създадени по време на компилация (първия пример);
2. Създадени по време на изпълнение (втория пример).

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

public class finalExample{
 public static void main(String[] args){
   final A obj = new A(3);
   obj.x = 5; // Няма проблем - x не е константа
   // obj = null;  <<< невъзможно - obj е константа!
 }
}

final class A{
  public int x;
  public A(int x){
    this.x = x;
  }
}

В случая виждаме, че полетата на самия обект не са непроменяеми. Не може да бъде променен само адреса на променливата, която „сочи“ към този обект. Въпреки, че това е възможно, то въобще не се използва.

В Java съществуват още две понятия – константни методи и константни класове. Те също използват ключовата дума final.

Константните методи не могат да бъдат предефинирани в клас-наследник. Например:

class A{
  public A(){}
  final void func(){
    System.out.println("Final function!");
  }
}

class B extends A{
  public B(){ super(); }
  // func() in B cannot override func() in A;
  // overridden method is final
  // void func(){
  //  System.out.println("Predefined?");
  // }
}

Константните класове пък са такива класове, които не могат да бъдат наследявани:

final class A{
  public A(){}
}

// cannot inherit from final A
//class B extends A{
//  public B(){ super(); }
//}

В общи линии константни методи и константни класове се създават тогава, когато желаем сигурност на данните и искаме да сме уверени, че никой няма да създава обекти подобни на нашите, но с променена функционалност.

В Java програмистът няма контрол над унищожението на обектите. Цялата тежест над това е прехвърлена върху т.нар. Garbage Collector. Въпреки това има аналогия на „почистващ метод“ (деструктор) – това е метод „finalize()“. Именно той се извиква в момента, в който даден обект е изтрит от Garbage Collector.

За съжаление програмистите, които преминават от C++ към Java ще забележат бързо, че Garbage Collector не се извиква често. При по-малките програми даже е възможно да не бъде извикан въобще. Ето ви един пример:

public class GCExample{
 public static void main(String[] args){
   User[] u = new User[200];
   for (int i=0; i<u.length; i++){
     u[i] = new User();
   }
   System.out.println("Users online: "+User.count);
   System.out.println("Last id: "+User.lastid);
   // "Изтриваме" 10ти елемент
   u[10] = null;
   System.out.println("Users online: "+User.count);
   System.out.println("Last id: "+User.lastid);
 }
}

class User{
  public static int count = 0;
  public static int lastid = 0;
  public int id;
  public User(){
    this.count++;
    this.lastid++;
    this.id = lastid;
  }
  protected void finalize(){
    count--;
  }
}

Освен ако нямате завиден късмет Garbage Collector да се е включил, то резултатът ще бъде следния:

Users online: 200
Last id: 200
Users online: 200
Last id: 200

Виждате, че finalize() методът не е извикан въобще. Това е защото Garbage Collector не се е стартирал все още. Честно казано при тази програма той не би трябвало да се включи въобще. Опитайте чрез добавянето на следния код:

   while(User.count == 200){}
   System.out.println("Garbage Collection was triggered!");

Програмата почти 100% сигурно ще зацикли и никога няма да спре. Ако обаче ние собственоръчно предизвикаме Garbage Collector да се включи, то ще видим, че всичко е наред:

public class GCExample{
 public static void main(String[] args){
   User[] u = new User[200];
   for (int i=0; i<u.length; i++){
     u[i] = new User();
   }
   System.out.println("Users online: "+User.count);
   System.out.println("Last id: "+User.lastid);
   // "Изтриваме" 10ти елемент
   u[10] = null;
   System.gc();
   System.runFinalization();
   System.out.println("Users online: "+User.count);
   System.out.println("Last id: "+User.lastid);
 }
}

Тук резултатът категорично сигурно ще бъде:

Users online: 200
Last id: 200
Users online: 199
Last id: 200

Метод System.gc() извиква Garbage Collector, а System.runFinalization() го кара да почисти абсолютно всичко. Метод finalize() се е изпълнил и е намалил променливата usersonline с единица – точно това, което желаехме. Сега трябва да отговорим на въпроса „защо Garbage Collector не се включи в предишния пример“ и по-скоро „кога въобще се включва Garbage Collector сам“.

Отговорът е, че Garbage Collector се включва само и единствено тогава, когато е нужно освобождаване на памет. С други думи – ако JVM изпита недостиг на памет, то тя си освобождава такава, като почиства „боклука“. Ето един пример, с който ще демонстрираме това:

public class GCExample{
 public static void main(String[] args){
   while (GCExample.continueFlag){
     new GCExample();
   }
   // "приспиваме програмата за 2 секунди
   try{
     Thread.sleep(2000);
   }
   catch(Exception e){}
   System.out.println(GCExample.ObjectsCreated);
   System.out.println(GCExample.ObjectsDeleted);
 }
}

class GCExample{
  public static boolean continueFlag = true;
  public static int ObjectsCreated = 0;
  public static int ObjectsDeleted = 0;
  public GCExample(){
    this.ObjectsCreated++;
  }
  protected void finalize(){
    continueFlag = false;
    ObjectsDeleted++;
  }
}

Едно примерно изпълнение би върнало следния резултат:

18580
1917

Виждаме, че общо са се създали 18580 обекта и чак тогава се е включил Garbage Collector. Към нито един от тези създадени обекти няма насочена променлива, но въпреки това Garbage Collector е „събрал“ само 1917 от тях. Нарочно „приспахме“ програмата за 2 секунди, за да сме сигурни, че той си е свършил работата и не сме го прекъснали с край на програмата ни. Нека все пак демонстрираме, че System.runFinalization() работи коректно:

public class GCExample{
 public static void main(String[] args){
   while (GCExample.continueFlag){
     new GCExample();
   }
   try{
     Thread.sleep(2000);
   }
   catch(Exception e){}

   System.gc();
   System.runFinalization();

   System.out.println(GCExample.ObjectsCreated);
   System.out.println(GCExample.ObjectsDeleted);
 }
}

Резултатът тук вече очаквано ще бъде нещо подобно на:

18688
18688

Първоначално бихме си казали, че „щом желаем да изтрием обект, то можем винаги да си извикваме сами System.gc() и System.runFinalization()“. Това обаче е лоша практика, понеже „събирането на боклука“ всъщност е доста тежка процедура, която отнема доста ресурси – повече от процедурата на създаване на обект:

public class GCExample{
 public static void main(String[] args){
   long startCreateObjectsTime = System.currentTimeMillis();
   while (GCExample.continueFlag){
     new GCExample();
   }
   long endCreateObjectsTime = System.currentTimeMillis();

   long startGCTime = System.currentTimeMillis();
   System.gc();
   System.runFinalization();
   long endGCTime = System.currentTimeMillis();

   System.out.println(endCreateObjectsTime - startCreateObjectsTime);
   System.out.println(endGCTime - startGCTime);
 }
}

Примерен резултат е:

15
94

С други думи събирането на боклука е отнело в пъти повече време отколкото създаването на обектите, които биват изтрити. Затова е редно да избягваме честото ръчно пускане на Garbage Collection. Всъщност именно концепцията за Garbage Collection и липсата на възможност за контрол над изтриване на обектите е една от най-честите критики към езика Java.

1. Те са общовалидни за всички инстанции на класа;
2. Могат да бъдат извиквани без инстанция;
3. Могат да променят и достъпват всички статични полета на класа;
4. Не могат да променят или достъпват не-статични полета и методи на класа.

Абсолютно същите принципи са валидни и за статичните класове. Когато един вложен клас е статичен то той:

1. Е общовалиден за всички инстанции на външния клас;
2. Има достъп само до статичните полета и методи на своя външен клас;
3. Може да бъде инициализиран без да е нужна инстанция на външния клас;
4. Няма достъп до не-статичните полета и методи на своя външен клас.

Нека дадем един пример за клас, който има два вложени класа – статичен и не-статичен:

public class innerClassesExample{
 public static void main(String[] args){
   // Инстанция на външен клас
   MessagesClass m = new MessagesClass("testing outer class");
   // Извикване на не-статичен метод от външен клас
   m.getMsg();
   // Извикване на статичен метод от външен клас чрез инстанция
   m.defaultMessage();
   // Извикване на статичен метод от външен клас без инстанция
   MessagesClass.defaultMessage();
   // Инстанция на вложен не-статичен клас
   MessagesClass.InnerClass m2 =
          m.new InnerClass("testing inner non-static class");
   // Извикване на не-статичен метод от вложен не-статичен клас
   m2.innerNonStaticMethod();
   // Инстанция на вложен статичен клас:
   MessagesClass.InnerStaticClass m3 =
          new MessagesClass.InnerStaticClass("testing inner static class");
   // Извикване на не-статичен метод от вложен статичен клас:
   m3.innerStaticClassNonStaticMethod();
   // Извикване на статичен метод от вложен статичен клас:
   m3.innerStaticClassStaticMethod();
   // Извикване на статичен метод от вложен статичен клас без инстанция:
   MessagesClass.InnerStaticClass.innerStaticClassStaticMethod();
 }
}

class MessagesClass{
  private String msg;
  public MessagesClass(String msg){
    this.msg=msg;
  }
  void getMsg(){
    System.out.println(this.msg);
  }
  static void defaultMessage(){
    System.out.println("Hello World");
  }

  class InnerClass{
    String innerNonStaticClassMsg;
    public InnerClass(String msg){
      this.innerNonStaticClassMsg = msg;
    }
    public void innerNonStaticMethod(){
      System.out.println("Innerclass.msg: "+this.innerNonStaticClassMsg);
      System.out.println("Innerclass calls Outerclass.msg: "+msg);
      System.out.print("Innerclass calls Outerclass.getMsg(): ");
      getMsg();
      System.out.print("Innerclass calls Outerclass.defaultMessage(): ");
      defaultMessage();
    }
  }

  static class InnerStaticClass{
    String innerStaticClassMsg;
    public InnerStaticClass(String msg){
      this.innerStaticClassMsg = msg;
    }
    public void innerStaticClassNonStaticMethod(){
      System.out.println("InnerStaticClass.msg: "+this.innerStaticClassMsg);
      // System.out.println("InnerStaticClass calls Outerclass.msg: "+msg); <<< No
      // System.out.print("InnerStaticClass calls Outerclass.getMsg(): "); <<< No
      // getMsg(); <<< No
      System.out.print("InnerStaticClass calls Outerclass.defaultMessage(): ");
      defaultMessage();
    }
    public static void innerStaticClassStaticMethod(){
      // System.out.println("InnerStaticClass.msg: "+this.innerStaticClassMsg); <<< No
      // System.out.println("InnerStaticClass calls Outerclass.msg: "+msg); <<< No
      // System.out.print("InnerStaticClass calls Outerclass.getMsg(): "); <<< No
      // getMsg(); <<< No
      System.out.print("InnerStaticClass calls Outerclass.defaultMessage(): ");
      defaultMessage();
    }
  }
}

С този пример всъщност демонстрирахме друго важно свойство на вложените класове – те имат достъп до private променливите на външните им класове. Вложените не-статични класове не могат да имат статични методи (за разлика от вложените статични класове).

Нека се опитаме да направим една аналогия за двата типа вложени член класове:

• Ако един вложен клас е не е статичен, то можем да си го представим като подпрограма, която зависи пряко от инстанцията на главната програма;
• Ако един вложен клас е статичен, то можем да си го представим отново като подпрограма, която може да бъде изпълнена и самостоятелно, независимо от инстанциите на главната програма.

Най-често в практиката ако създаваме не-статични вложени член класове, те ще са private, т.е. за вътрешно ползване от външния им клас. Обратно – по-често ако пишем вложени статични класове, то те ще са публични.

Нека вземем за пример изчисляването на дължината на хипутенизата на правоъгълен триъгълник. „Не-анонимно“ би било извикването на програмата:

    double a = 3;
    double b = 4;
    double c = Math.sqrt(a*a + b*b);
    System.out.println(c);

Защо обаче трябва да пазим променливата „c“ ако не я използваме повече в програмата след това? Ако тя не ни е нужна, то ние по-често изписваме:

    double a = 3;
    double b = 4;
    System.out.println(Math.sqrt(a*a + b*b));

Така променливата „хипутенуза“ се създава в момента на извикването на System.out.println. Ние не сме дали име на стойността, която предаваме като параметър, тоест ние не можем да я използваме по-нататък. Това е съвсем нормално ако не се нуждаем от тази стойност отново. Това е пример за анонимни локални променливи.

Анонимните локални класове действат по същия принцип. Всъщност ние вече неведнъж ги демонстрирахме, но неявно. Например когато дефинирахме буферирани потоци към файлове:

    BufferedReader in = new BufferedReader(new FileReader("text.txt"));

Ние на практика не сме подали никакво име на файловия поток. Така той се използва само и единствено от създадения буфер.

Ето и как самите ние можем да създадем анонимен клас:

public class AnonymousClassExample{
  public static void main(String[] args){
    Dog sparky = new Dog("Sparky");
    sparky.speak();
    sparky.play();

    Dog terry = new Dog("Terry"){
      public void speak(){
        System.out.println("This dog do not want to speak");
      }
    };
    terry.speak();
    terry.play();
  }
}

interface AnimalsActions{
  public void speak();
  public void play();
}

abstract class Animal{
  private String name;
  public Animal(String name){
    this.name = name;
  }
  abstract void speak();
  abstract void play();
}

class Dog extends Animal implements AnimalsActions{
  public Dog(String name){
    super(name);
  }
  public void speak(){
    System.out.println("Woof!");
  }
  public void play(){
    System.out.println("The dog rolled over...");
  }
}

Виждате, че при декларирането на второто куче ние предефинирахме метод „speak“. Чисто функционално това е все едно, че сме наследили клас Dog в нов локален клас и сме предефинирали негов метод. Тъй като на този нов локален клас не сме дали формално ново име, то той се нарича „анонимен клас“.

Първото и може би най-важно нещо, което трябва да знаем за локалните класове е, че те са валидни само и единствено в програмния блок, в който са дефинирани. Можете веднага да си направите аналогия с „локални променливи“.

Ето един пример за локален клас, вложен в метод на клас „потребители“:

public class myfirstprogram{
  public static void main(String[] args){
    User ivan = new User("ivan", 8);
    System.out.println(ivan.getUser()+" has pass "+ivan.getPass());
  }
}

class User{
  private String username;
  private String password;
  private int id;
  private static int userscount = 0;
  public User(String username, int len){
    System.out.println("\nNew user entering...");
    this.username = username;
    this.setId();
    this.setPass(len);
  }
  private void setId(){
    userscount++;
    this.id = userscount;
  }
  private void setPass(int len){
    // Дефинираме локален клас "генератор на пароли"
    class PassGenerator{
      StringBuffer strb;
      public PassGenerator(int len){
        strb = new StringBuffer(len);
        for (int i=0; i<len; i++){
          switch((int)Math.round(Math.random()*2)){
            case 0:
              this.strb.append((char)((int)'0' + (int)(Math.round(Math.random()*9))));
              break;
            case 1:
              this.strb.append((char)((int)'a' + (int)(Math.round(Math.random()*25))));
              break;
            case 2:
              this.strb.append((char)((int)'A' + (int)(Math.round(Math.random()*25))));
              break;
          }
        }
      }
      public String getpass(){
        return strb.toString();
      }
    }
    // Правим локална инстанция на този локален клас
    PassGenerator p = new PassGenerator(len);
    this.password = p.getpass();
  }
  protected String getPass(){
    return this.password;
  }
  public int getId(){
    return this.id;
  }
  public String getUser(){
    return this.username;
  }
  public static void usersOnline(){
    System.out.println("Users online: "+userscount);
  }
}

Не можем да правим инстанция на клас „PassGenerator“ некъде другаде освен вътре в метод „setPass“, където този локален клас е деклариран. По този начин казваме, че „PassGenerator е локален клас за метод setPass“.