Задача 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“.

Всяка виртуална машина на Java идва с определен набор (всъщност доста голям) от готови пакети с класове. Такива пакети са java.io (съдържат класове работещи с входно-изходни устройства), java.net (класове свързани с мрежови потоци) и т.н. Забелязвате веднага, че „системните“ за Java класове започват винаги с думата „java“ последвана от точка и конкретизиране на името на друг пакет (io, net, …). Тук вече имаме наличие на йерархия – системния пакет java има свой под-пакет io, който пък притежава клас FileInputStream. За да достигнем до този клас ние указваме пълният път до него – java.io.FileInputStream.

Когато пишем наша собствена програма ние обикновено я слагаме извън системната директория на JDK, например в „c:\myprogram“. Нека за пример в тази директория сме сложили един клас HelloWorld.class, който показва тривиалното съобщение на екрана. Ако изпълните този клас от текущата директория, програмата ще стартира:

Файл HelloWorld.java намиращ се в c:\myprogram:

package myprogram;

public class HelloWorld{
 public static void main(String[] args){
  System.out.println("Hello World");
 }
}

Поредица от команди и тяхното изпълнение:

C:\> cd myprogram
C:\myprogram> dir
14.10.2009 a.  13:52    <:DIR>:          .
14.10.2009 a.  13:52    <:DIR>:          ..
14.10.2009 a.  13:44               133 HelloWorld.java
               1 File(s)           133 bytes
               2 Dir(s)  213 201 666 048 bytes free
C:\myprogram> javac HelloWorld.java
C:\myprogram> cd ..
C:\> java myprogram.HelloWorld
Hello World
C:\>

С програмата javac ние компилирахме файл HelloWorld.java и създадохме байткод HelloWorld.class. Чрез програмата java ние заредихме main метода на този клас. Виждате, че достъпваме класа чрез пътя до него – „myprogram.HelloWorld“.

Ето какво ще стане обаче ако се намираме в друга директория, различна от c:\:

C:\> cd temp
C:\temp> java myprogram.HelloWorld
Exception in thread "main" java.lang.NoClassDefFoundError: myprogram/HelloWorld
Caused by: java.lang.ClassNotFoundException: myprogram.HelloWorld
        at java.net.URLClassLoader$1.run(Unknown Source)
        at java.security.AccessController.doPrivileged(Native Method)
        at java.net.URLClassLoader.findClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at java.lang.ClassLoader.loadClassInternal(Unknown Source)
Could not find the main class: myprogram.HelloWorld.  Program will exit.
C:\temp>

Явно е, че виртуалната машина не може да намери нашият клас. Логично е да се досетим защо се получава така – в директория temp, в която се намираме, няма поддиректория myprogram и няма файл HelloWorld.class. Веднага можете да си направите аналогия със стандартните програми с разширение „.exe“ – можете да стартирате изпълнимия файл от неговата собствена директория.

Когато говорим за пакети обаче аналогията с изпълнимите .exe файлове не е достатъчна. Освен, че изпълняваме класове от някой пакет като програми (т.е. класове с main метод), ние често използваме класовете и като библиотеки. Става въпрос за абсолютно същия принцип, по който вие създавахте обект java.util.Scanner или още повече – правихте import „java.util.*“ и вмъквахте множество от класове от един пакет. Естествено е, че бихме желали да можем да правим същото и с наши класове и пакети и не желаем да сме ограничени да работим само и единствено в една главна директория. Например може да пожелаем да вмъкнем клас SayHello от директория c:\myprogram2 в нашия клас HelloWorld от директория c:\myprogram.

За щастие java ни дава такава функционалност чрез environment variable „CLASSPATH“. По подразбиране в тази променлива е записана само „.“, т.е. „текущата директория“. Именно затова ние можехме да извикаме myprogram.HelloWorld от c:\ – само от такава „текуща директория“ може да се „види“ този пакет и класа в него. Ето един пример как можем да вмъкнем един пакет от „чужда“ директория в нашата програма:

Файл SayHello.java в директория c:\myprogram2:

package myprogram2;
public class SayHello{
  String message;
  public SayHello(String message){
    this.message = message;
  }
  public void speak(){
    System.out.println(this.message);
  }
}

Файл HelloWorld.java в директория c:\myprogram:

package myprogram;
import myprogram2.SayHello;
public class HelloWorld{
 public static void main(String[] args){
   SayHello msg = new SayHello("Hola amigos");
   msg.speak();
 }
}

Ето какво би се случило ако се опитаме не да изпълним, а дори само да компилираме програмата HelloWorld.java:

C:\>cd c:\myprogram2
C:\myprogram2>javac SayHello.java
C:\myprogram2>cd c:\myprogram
C:\myprogram>javac HelloWorld.java
HelloWorld.java:2: package myprogram2 does not exist
import myprogram2.SayHello;
                 ^
HelloWorld.java:5: cannot find symbol
symbol  : class SayHello
location: class myprogram.HelloWorld
   SayHello msg = new SayHello("Hola amigos");
   ^
HelloWorld.java:5: cannot find symbol
symbol  : class SayHello
location: class myprogram.HelloWorld
   SayHello msg = new SayHello("Hola amigos");
                      ^
3 errors
C:\myprogram>

Случи се точно това, което предположихме – пакет myprogram2 не е видим от програмата в пакет myprogram. За да се справим с този проблем трябва да добавим базовата директория за пакета myprogram2 (в случая това е c:\, защото именно тя „вижда“ директорията/пакета myprogram2) в променливата CLASSPATH:

C:\myprogram>set CLASSPATH=.;C:\;
C:\myprogram>javac HelloWorld.java
C:\myprogram>cd ..
C:\>java myprogram.HelloWorld
Hola amigos
C:\>

Сега вече е време да поговорим и за „под-пакети„. Те не са нищо по-различно от под-директории в директориите на някой пакет. Ето един пример:

Файл SayHello.java в директория C:\myprogram2\myprogram2sub:

package myprogram2.myprogram2sub;
public class SayHello{
  String message;
  public SayHello(String message){
    this.message = message;
  }
  public void speak(){
    System.out.println("Subpackage says: "+this.message);
  }
}

Файл SayHello.java в директория c:\myprogram2:

package myprogram2;
public class SayHello{
  String message;
  public SayHello(String message){
    this.message = message;
  }
  public void speak(){
    System.out.println(this.message);
  }
}

Файл HelloWorld.java в c:\myprogram:

package myprogram;
import myprogram2.*;
public class HelloWorld{
 public static void main(String[] args){
   SayHello msg = new SayHello("Hola amigos");
   msg.speak();
   myprogram2.myprogram2sub.SayHello msg2 =
		new myprogram2.myprogram2sub.SayHello("abc");
   msg2.speak();
 }
}

Изпълнение:

C:\>cd myprogram2
C:\myprogram2>javac SayHello.java
C:\myprogram2>cd myprogram2sub
C:\myprogram2\myprogram2sub>javac SayHello.java
C:\myprogram2\myprogram2sub>cd c:\myprogram
C:\myprogram>javac HelloWorld.java
C:\myprogram>cd ..
C:\>java myprogram.HelloWorld
Hola amigos
Subpackage says: abc
C:\>

Виждате, че при първото създаване на обект „SayHello msg =…“ се създаде обекта от клас myprogram2.SayHello – това е така, защото ние вмъкнахме всички класове от пакет myprogram2 чрез „import myprogram2.*“. Така компилаторът не се „обърква“ от факта, че имаме два класа с едно и също име. Вторият клас обаче сме длъжни да го достъпваме чрез пълният път myprogram2.myprogram2sub.SayHello. В противен случай ще се получи грешка и компилаторът няма да знае кой от двата класа да „избере“. Ето един пример – модифицираме файла HelloWorld.java в:

package myprogram;
import myprogram2.*;
import myprogram2.myprogram2sub.*;
public class HelloWorld{
 public static void main(String[] args){
   SayHello msg = new SayHello("Hola amigos");
   msg.speak();
   SayHello msg2 = new SayHello("abc");
   msg2.speak();
 }
}

При компилация ще се получи грешка:

C:\myprogram> javac HelloWorld.java
HelloWorld.java:6: reference to SayHello is ambiguous,
both class myprogram2.myprogram2sub.SayHello in
myprogram2.myprogram2sub and class myprogram2.SayHello in
myprogram2 match SayHello msg = new SayHello("Hola amigos");
...

За изход от такива ситуации е нужно винаги да достъпваме класовете чрез пълният път до техните пакети. Принципно за да сме сигурни, че няма да попадаме в такива ситуации е нужно да спазваме следните две правила:

• Давайте уникални имена на пакетите, които пишете;
• Давайте уникални имена на класовете, които пишете .

Йерархията на пакети и под-пакети всъщност много наподобява тази на класове и „вложени класове„. В езика Java ни е дадена възможност да правим следните конструкции:

class ВъншенКлас {
    ...
    class ВложенКлас {
        ...
    }
}

В предишната статия споменахме, че има два вида класове – публични и стандартни. Публичните класове можеха да се виждат от всички класове, включително от класове в „чужди“ пакети (в горните примери направихме именно това – клас SayHello беше публичен в пакет myprogram2 и по този начин клас HelloWorld от пакет myprogram го виждаше). Когато един клас не е публичен (т.е. видимост по подразбиране) казахме, че се вижда само и единствено от други класове в текущия клас.

В случая на вложените класове имаме на първо място логическо групиране на класовете:

public class HelloWorld{
 public static void main(String[] args){
   // Създаваме инстанция на външен клас:
   MessagesClass m = new MessagesClass("Hello World", 3);
   m.speak();
   // Създаваме инстанция на вложен клас на клас m:
   MessagesClass.SpeakerClass s = m.new SpeakerClass("Hola");
   s.speak();
 }
}

class MessagesClass{
  String msg;
  int times;
  public MessagesClass(String msg, int times){
    this.msg=msg;
    this.times = times;
  }
  public void speak(){
    SpeakerClass s = new SpeakerClass(this.msg);
    for(int i=0; i<this.times; i++){
         s.speak();
    }
  }

  class SpeakerClass{
    String msg;
    public SpeakerClass(String msg){
      this.msg=msg;
    }
    public void speak(){
      System.out.println(this.msg);
    }
  }
}

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

public class HelloWorld{
 public static void main(String[] args){
   // Създаваме инстанция на външен клас:
   MessagesClass m = new MessagesClass("Hello World", 3);
   m.speak();
   // Вече не е възможно да правим инстанция:
   //MessagesClass.SpeakerClass s = m.new SpeakerClass("Hola");
   //s.speak();
 }
}

class MessagesClass{
  String msg;
  int times;
  public MessagesClass(String msg, int times){
    this.msg=msg;
    this.times = times;
  }

  public void speak(){
    SpeakerClass s = new SpeakerClass(this.msg);
    for(int i=0; i<this.times; i++){
         s.speak();
    }
  }

  private class SpeakerClass{
    String msg;
    public SpeakerClass(String msg){
      this.msg=msg;
    }
    public void speak(){
      System.out.println(this.msg);
    }
  }
}

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

Виждате, че вложените класове могат да бъдат освен public и default (както външните) така и private и protected. Именно затова казваме, че чрез тяхната функционалност се засилва капсулацията на данни.

И за да усложним още повече нещата ще кажем, че представеният пример е само един от четирите вида вложени класове – нарича се „вложен член клас“. Съществуват още „статичен вложен член клас“, „локален клас“ и „анонимен клас“. Ще ги разгледаме поотделно в следваща статия.

Тенденцията за „скриване на алгоритъма“ от „външния свят“ естествено се пренася и при обектно-ориентираното програмиране. Дотук във всички дадени примери използвахме ключова дума „public“ при дефиниране на класове, техни полета и методи. Ключовата дума „public“ се превежда като „публичен“, а в програмирането има значение на „достъпен от всеки“. Такива данни казваме, че не са „капсулирани“, т.е. „не са скрити/защитени“. За да капсулираме данни в даден клас, то ние използваме ключови думи „private“ или „protected“. Наричат се още „модификатори за достъп“.

Нека да вземем следния пример – клас за автомобили:

public class myfirstprogram{
  public static void main(String[] args){
    Car c1 = new Car("BMW", "5", 220);
    System.out.println("The "+c1.manufacturer+" "+c1.model+
                       " car has max speed of "+c1.getSpeed());
  }
}

class Car{
  public int speed;
  public String manufacturer;
  public String model;
  public Car(String manufacturer, String model, int speed){
    this.setSpeed(speed);
    this.manufacturer = manufacturer;
    this.model = model;
  }
  public int getSpeed(){
    return this.speed;
  }
  public void setSpeed(int speed){
    while (speed<0){
      System.out.println("Speed must be positive integer!");
      try{
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("Enter the correct value: ");
        speed = s.nextInt();
      }
      catch (java.util.InputMismatchException e){
        speed = -1;
      }
      finally{
        try{
          while(System.in.available() > 0) System.in.skip(System.in.available());
        }
        catch(java.io.IOException e){}
      }
    }
    this.speed = speed;
  }
}

Както виждате в метод „setSpeed(int speed)“ сме вмъкнали функционалност, която гарантира, че винаги ще въвеждаме скорост на автомобила по-голяма от 0. Да, но полето „speed“ в клас Car е публично. Това означава, че в главната програма ние можем лесно да направим следното:

    c1.speed = -200;

Така на практика ние „прескачаме“ защитата, която сме направили в метод „setSpeed()“ и вкарваме некоректни стойности. Когато пишем програма ние не трябва да позволяваме подобни неща. Затова ние можем да защитим данните от полетата, като ги направим например private:

public class myfirstprogram{
  public static void main(String[] args){
    Car c1 = new Car("BMW", "5", 220);
    System.out.println("The "+c1.manufacturer+" "+c1.model+
                       " car has max speed of "+c1.getSpeed());
    // c1.speed = -200; // Вече НЕ работи
  }
}

class Car{
  private int speed;
  public String manufacturer;
  public String model;
  public Car(String manufacturer, String model, int speed){
    this.setSpeed(speed);
    this.manufacturer = manufacturer;
    this.model = model;
  }
  public int getSpeed(){
    return this.speed;
  }
  public void setSpeed(int speed){
    while (speed<0){
      System.out.println("Speed must be positive integer!");
      try{
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("Enter the correct value: ");
        speed = s.nextInt();
      }
      catch (java.util.InputMismatchException e){
        speed = -1;
      }
      finally{
        try{
          while(System.in.available() > 0) System.in.skip(System.in.available());
        }
        catch(java.io.IOException e){}
      }
    }
    this.speed = speed;
  }
}

От този пример се вижда ясно и каква е концепцията на т.нар. „get“ и „set“ методи. Вместо да добиваме директен достъп до полетата на даден клас, ние ги правим „private“, а достъпът до тях осъществаваме чрез вътрешни за класа методи. По този начин алгоритмите в методите гарантират, че данните са коректни!

Това поведение се прехвърля не само при създаването на инстанция на клас, но и при наследяването:

public class usersexample{
  public static void main(String[] args){
    User pesho = new UserWithInfo("batman", "Petar Petrov");
    pesho.getId();
    pesho.getInfo();
    User.usersOnline();
    User ivan = new UserWithInfo("dexter", "Ivan Ivanov");
    ivan.getId();
    ivan.getInfo();
    User.usersOnline();
  }
}

class User{
  private String username;
  private int id;
  private static int userscount = 0;
  public User(String username){
    System.out.println("\nNew user entering...");
    this.username = username;
    this.setId();
  }
  private void setId(){
    userscount++;
    this.id = userscount;
  }
  public static void usersOnline(){
    System.out.println("Users online: "+userscount);
  }
  public void getId(){
    System.out.println("User id:"+this.id);
  }
  public void getInfo(){
    System.out.println("Username: "+this.username);
  }
}

class UserWithInfo extends User{
  private String name;
  public UserWithInfo(String username, String name){
    super(username);
    // id = 15; // НЯМА ДОСТЪП до private поле!
    // super.userscount = 10; // Също няма достъп!
    // super.setId(); // и пак няма достъп!
    this.name = name;
  }
  // Предефинираме метод
  public void getInfo(){
    super.getInfo();
    System.out.println("Name: "+this.name);
  }
}

Виждате, че наследникът на класа няма достъп до private полетата и методите на супер класа (родителския клас). По този начин казваме, че супер класа е капсулирал своите данни – в примера той не предоставя възможност да бъдат променяни идентификационните номера на потребителите или пък да бъде подменяна стойността на броят на влезлите потребители в системата.

Модификатор за достъп „protected“ има малко по-различно значение от това, което познаваме в C++. Ако направите едно поле „protected“, то ще бъде видимо не само от наследниците на класа (както е в C++), но и от всички други класове в текущия пакет (package). Ако нашата програма се разпростира само в един пакет (каквито програми сме писали досега), то public и protected ще имат едно и също действие. Разликата идва тогава, когато желаем да свържем класове от различни пакети. Независим клас от чужд пакет не може да достъпи protected данни. Това обаче не важи за наследник от чужд пакет на класа с protected данни (наследниците, независимо от пакета, на който принадлежат, виждат protected данните на своите родителски класове). Аналогичен на C++ protected модификатор (видимост само и единствено от наследниците) е имало в миналото чрез „private protected“ модификатор в Java, но от Sun са го премахнали в съвременните версии на езика.

Почти аналогично на „protected“ модификатор на достъп е „липсата на модификатор на достъп“ (т.нар. „default“). Когато пред поле или метод не сложите нито една от ключовите думи private, protected или public, то полето/метода получават ниво на достъп default. Това е почти същото както protected достъп, т.е. всички класове и наследници в пакета могат да достъпват тези данни. Разликата е, че когато клас от друг пакет е наследник, то той няма достъп до тези данни. С други думи „protected“ данните на един клас са видими за текущия пакет, но са напълно скрити (private) за всички други пакети (независимо дали класът от тях който се опитва да ги достъпи е наследник или не).

Колкото до декларациите на класове имаме две възможности – това са default (без модификатор) и public. Когато един клас е публичен (public), то той е видим от чужди пакети. Когато един клас се декларира без модификатор, то само и единствено класове в текущия пакет могат да правят негови инстанции или да го наследяват. Важно за Java правило е, че ако искате да направите един клас публичен, то той трябва да стои в самостоятелен .java файл (тоест за него ще се компилира отделен .class файл).

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

Досега се запознахме с  предефинирането на методи. При тях знаем, че можем да извикваме различни методи с едно и също име. Това се наричаше „предефиниране на метод“:

public class polyexample{
  public static void main(String[] args){
    ClassExample c = new ClassExample(5);
    int imultiplyer = 2;
    double dmultiplyer = 2.5;
    int x = c.multiply(imultiplyer);
    double d = c.multiply(dmultiplyer);
    System.out.println("x = "+x+", d = "+d);
  }
}

class ClassExample{
  public int x;
  public ClassExample(){
    x = 0;
  }
  public ClassExample(int x){
    this.x = x;
  }
  public int multiply(int x){
    return this.x*x;
  }
  public double multiply(double x){
    return (double)this.x * x;
  }
}

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

Динамичен полиморфизъм се получава тогава, когато предефинираме методи на базов клас в негов наследник. Казваме също, че по този начин променяме съществуващата реализация на метод с нова. Ето един пример – създаваме наследник и предефинираме метод print():

public class polyexample{
  public static void main(String[] args){
    ClassExample c = new ClassExample(5);
    c.print();
    SubClassExample c2 = new SubClassExample(5);
    c2.print();
  }
}

class ClassExample{
  public int x;
  public ClassExample(){
    x = 0;
  }
  public ClassExample(int x){
    this.x = x;
  }
  public void print(){
    System.out.println(this.x);
  }
}

class SubClassExample extends ClassExample{
  public int y;
  public SubClassExample(){
    super();
    y = 0;
  }
  public SubClassExample(int x){
    super(x);
    y = 0;
  }
  public void print(){
    System.out.println(this.x+" "+this.y);
  }
}

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

public class polyexample{
  public static void main(String[] args){
    Animal a;
    Dog kuche = new Dog("Sharo");
    Cat kotka = new Cat("Pisana");
    a = kuche;
    a.speak();
    a = kotka;
    a.speak();
  }
}

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

class Dog extends Animal{
  public Dog(String name){
    super(name);
  }
  public void speak(){
    System.out.println("Бау, бау!");
  }
}

class Cat extends Animal{
  public Cat(String name){
    super(name);
  }
  public void speak(){
    System.out.println("Мяу!");
  }
}

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

Тук е мястото да вмъкнем аналогията с програмирането на C++ където имаше понятие „виртуални функции„, тоест такива, които могат да бъдат предефинирани. В Java всички методи са виртуални и могат да бъдат предефинирани. В C++ наричахме такова предефиниране като „полиморфизъм по време на изпълнение“ или както го дефинирахме тук – динамично свързване на метод.

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

Нека дадем един класически пример за абстрактен клас. Ще създадем клас „геометрична фигура“, в която ще има абстрактен метод, наречен „лице“:

abstract class Figure{
  double dim1;
  double dim2;
  public Figure(double dim1, double dim2){
    this.dim1 = dim1;
    this.dim2 = dim2;
  }
  abstract double getArea();
}

Ние не можем да кажем колко ще бъде лицето на фигурата и колко ще бъде нейния периметър, защото все още не знаем точно каква ще е тя – правоъгълник или успоредник при който dim1 и dim2 са страните, триъгълник при който dim1 е основа, а dim2 е височина към нея и т.н. Когато наследим клас Figure обаче можем да дадем имплементация на този метод:

class Rectangle extends Figure{
  public Rectangle(double a, double b) {
    super(a,b);
  }
  public double getArea(){
    return this.dim1 * this.dim2;
  }
}

class Triangle extends Figure{
  public Triangle(double a, double b) {
    super(a,b);
  }
  public double getArea(){
    return (this.dim1 * this.dim2)/2;
  }
}

Още по-голямо ниво на абстракция е понятието „интерфейс“. Интерфейсът съдържа само и единствено абстрактни методи и евентуално константи (за константи ще говорим по-късно). Чрез интерфейсите ние даваме само и единствено обща насоченост как трябва да изглежда даден клас, който го „имплементира“. Нека преработим горния пример да работи по същия начин, но чрез интерфейс:

interface Figure{
  public double getArea();
}

class Rectangle implements Figure{
  double dim1;
  double dim2;
  public Rectangle(double a, double b) {
    this.dim1 = a;
    this.dim2 = b;
  }
  public double getArea(){
    return this.dim1 * this.dim2;
  }
}

class Triangle implements Figure{
  double dim1;
  double dim2;
  public Triangle(double a, double b) {
    this.dim1 = a;
    this.dim2 = b;
  }
  public double getArea(){
    return (this.dim1 * this.dim2)/2;
  }
}

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

Нека вземем един примерен клас за деца с метод, в който децата играят играта „камък – ножица – хартия“. В главната програма ще пуснем децата да изиграят 10 поредни игри:

Файл kid.java:

package kids;
import java.util.Scanner;
class Kid{
  public String name;
  public Kid(){
    Scanner s = new Scanner(System.in);
    System.out.print("Enter the kid name: ");
    this.name = s.next();
  }
  public Kid(String name){
    this.name = name;
  }
  public static void introduce(){
    System.out.println("Hello, nice to meet you!");
  }
  public int getRand(){
    int r = (int)Math.floor(Math.random()*3);
    return r;
  }
  public void playRPS(Kid oponent){
    int i = this.getRand();
    int j = oponent.getRand();
    String[] rps = {"leafs", "scissors", "rocks"};
    if (i == j){
      System.out.println(this.name+" and "+oponent.name+
                         " both played "+rps[i]);
      System.out.println("The game is tie");
    }
    else{
      System.out.println(this.name+" played "+rps[i]+
                         " and "+oponent.name+" played "+rps[j]);
      switch(i){
        case 0:
          if (j == 1) System.out.println(oponent.name+" wins!");
          else System.out.println(this.name+" wins!");
          break;
        case 1:
          if (j == 2) System.out.println(oponent.name+" wins!");
          else System.out.println(this.name+" wins!");
          break;
        case 2:
          if (j == 0) System.out.println(oponent.name+" wins!");
          else System.out.println(this.name+" wins!");
          break;
      }
    }
  }
}

Файл kidsplay.java:

package kids;

public class kidsplay{
  public static void main(String[] args){
    Kid ivancho = new Kid("Ivancho");
    Kid pencho = new Kid("Pencho");
    for (int i=0; i<10; i++){
      ivancho.playRPS(pencho);
      System.out.println();
    }
  }
}

Нека сега създадем клас „момче“, което има същите свойства, каквито и клас „дете“, но добавя и нова функция:

Файл Boy.java:

package kids;
class Boy extends Kid{
  public String sex = "male";
  public Boy(){
    // извикване на конструктора на базовия клас
    super();
  }
  public Boy(String name){
    // извикване на конструктора на базовия клас
    super(name);
  }
  public void proposeGame(){
    System.out.println(this.name+" said: Let's go play football!");
  }
}

Виждате, че можем да извикаме конструктора на базовият клас (също познат специално в Java и като „сурер клас“) чрез извикване на метод „super()“. Това все пак е нужно, защото всеки клас трябва да има конструктор (в случая конструктора на Boy изниква конструктора на Kid).

Можем да наследим класа и втори път:
Файл Girl.java:

package kids;
class Girl extends Kid{
  public String sex = "female";
  public Girl(){
    super();
  }
  public Girl(String name){
    super(name);
  }
  public void proposeGame(){
    System.out.println(this.name+" said: Let's play fast and loose!");
  }
}

Нека сега променим главната програма така, че да работи вече с класове Boy и Girl:

Файл kidsplay.java:

package kids;

public class kidsplay{
  public static void main(String[] args){
    Boy ivancho = new Boy("Ivancho");
    Girl mariika = new Girl("Maria");
    for (int i=0; i<10; i++){
      ivancho.playRPS(mariika);
      System.out.println();
    }
    ivancho.proposeGame();
    mariika.proposeGame();
  }
}

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