//Nasledujuci program nema ziaden uzitocny vyznam, je len ukazkou zakladnych
//konstrukcii jazyka Java, pre tych ktori vedeli, ale zabudli, a potrebuju si
//rychlo pripoomenut. Kto nevedel, nebude vediet, ani ked si toto precita.
//Teda okrem profikov, kotri programuju v inom jazyku, a Javu este nevideli
//
//Program sa da skompilovat a spustit, ale zamerne skonci run-time-errorom!!!!
//
public class BasicJava {
  int n = 1000;
  long m = 10000000000000L;
  float r = 1.0f;
  double d=1.0;
  double []f = new double[4];
  String s = "jojo";
  boolean t = true;
  //////////////constructors///////////////
  public BasicJava() {
  }


  public BasicJava(int n){
    this.n=n;
  }

  ////////////////simple statements//////////////////////
  public void basicStatements(){
  ///// cykly /////
    for(int i=0;i<n;i++){
      m++;
    }
    int i=0;
    while(i<n){
      i++;
      m++;
    }
    i=0;
    while(true){
      i++;
      if(i<100) continue;
      m++;
      if(i>=n) break;
    }
    i=0;
    do{
      i++;
      m++;
      if(i>=n)break;
    }while(true);
//////////////////////// if, else /////////////
    if(n>100){
      m++;
      s = "100";
    }
    else if(n>200) s="200";
    else if(n>300) s="300";
    else s="0";
//////////////////// switch /////////////
    switch(n){
      case 1: s="jedna"; break;
      case 2: s="dva";break;
      case 3: s="tri"; break;
      default: s="undefined";
    }
  }
///////////////// Arrays //////////////////////
  public void Arrays(){
    int [] aoi;  // array of ints (deklarovane ale pamat na tie int nepriradena)
    double [] aod = new double[4]; //array od doubles (pamat alokovana)
    double [] aod5 = new double[5];
    //java nema viacindexove polia ale ma polia poli
    double [][] aoaod = new double[3][4]; //array of arrays of double

    aoi = new int[5]; // az tu sa sa alokuje pamat
    for(int i=0;i<5;i++) aoi[i] = 2*i;

    //tu je priklad na vyskusanie si ako funguje pole poli, ktory index robi co
    //nebudeme to vysvetlovat, staci precitat si nasledujuci kusok kodu, zbehnut
    //program a pozriet si vystup a potom podumat, co to tu vlastne ukazujeme
    for(int i=0;i<4;i++) aod[i] = 0.;
    for(int i=0;i<3;i++)
      for(int j=0;j<4;j++) aoaod[i][j]= 1.2*i+4.8*j;
    aod = aoaod[2];
    for(int i=0;i<4;i++) System.out.println(aod[i]+" "+aoaod[2][i]);

    //nasledujuci kuseok je len pre fajnsmekrov, je zamerne chybne
    //naprogramovany aby sa ukazala ista vlastnost javy
    //pole aod5 je pridlhe, presledujte, co to spravi
    for(int i=0;i<5;i++) aod5[i] = 0.;
    System.out.println("dlzka pola aod5: "+aod5.length);
    aod5 = aoaod[2]; //pole aod5 bolo deklarovane ako 5-prvkove
                     //tu ale bolo presmerovane na stvorprvkovu strukturu!!!
    //Ak uz na to prideme, presvedcime sa o tom nasledujucim vypisom, ale
    //tak lahko nas to nenapadne.
    System.out.println("dlzka pola aod5: "+aod5.length);
    System.out.flush();
    //na nasledujucom riadku sa to zruti, ale az pri behu programu, kompilacia
    //samozrejme nenajde nic zle, ani programator si nemusi uvedomit
    //ze pise zle: ved pole aod5 bolo deklarovane ako 5-prvkove

    for(int i=0;i<5;i++) System.out.println(aod5[i]);

    //Na jave je sympaticke ze ma run-time kontrolu pretecenia indexu pola
    //takze program tu skonci cez ArrayIndexOutOfBoundsException
    //Uplne pochopit, co sa vlastne stalo sa neda bez znalosti a istej
    //skusenosti s tym, co su to pointre. Pointre v Jave nie su explicitne
    //ale vnutorna realizacia je cez pointre a tu je jedno z miest, kde pointre
    //vystrtcia rozky. Nemozno byt dobrym programatarom v Jave a neprecitat
    //si c-cko a c++ a pochopit, co su pointre a ako su realizovane polia
    //a vobec organizacia pamate, co je memory leak a co vlastne robi
    //garbage collector v Jave

  }

//////////////////////Math. functions ///////////////
  public double Functions(double x){
    switch(n){
      case 0: return Math.sin(x); //tu nesmie byt break, lebo je tam return, takze dalej to nejde
      case 1: return Math.sin(Math.PI/4.);
      case 2: return Math.exp(x);
      case 3: return Math.sqrt(x);
      case 4: return Math.pow(Math.E,x);
      case 5: return Math.log(x);
      default: return 0.;
    }

  }

//////////////////////String operations, len zopar ukazok //////////////////
  public String StringOps(String name){
    switch(n){
      case 0: return name;
      case 1: name="Dr."+name; return name;//po return nesmie byt nic, ani break
      case 2: return name.toUpperCase();
      case 3: return name.replace('i','y');
      case 4: return name.substring(0,name.lastIndexOf("ova"));
      case 5: return ("Vysledok je: "+ (d+Double.parseDouble(name)));
      default: return "";
    }

  }
//////////////////Throwing and handling exceptions////////////
  public double MySqrt(double x) throws IllegalArgumentException{
    if(x<0) throw new IllegalArgumentException("x must be >=0");
    else return Math.sqrt(x);
  }
  public double CorrecectedSqrt(double x){
    double y;
    try{
      y = MySqrt(x);
    }
    catch (IllegalArgumentException e){
      y = 0;
    }
    return y;
  }
/////////////////////////////////////



  public static void main(String[] args) {
    //main program nevyvola vsetky metody, len ukazky StringOps a Arrays
    System.out.println("Tento program zamerne konci run-time-errorom!");
    BasicJava bJ = new BasicJava();
    // vypis command line parametrov
    for(int i=0;i<args.length;i++)
      System.out.println(args[i]);
    bJ.n=4;
    System.out.println(bJ.StringOps("Kirschenrova"));
    bJ.n=5;
    System.out.println(bJ.StringOps("1.4"));
    bJ.Arrays();
  }

}