Loading

Paste #p4kkn8pzc

  1.  
  2. public class Foo {
  3.     private int x;
  4.  
  5.     public Foo(int x) {
  6.         this.x = x;
  7.         System.out.println("in constructor cu param");
  8.     }
  9.  
  10.     public Foo() {
  11.         this(0);
  12.         System.out.println("in constructor fara param");
  13.     }
  14.  
  15.     public String toString() {
  16.         String s1 = "Valoarea noastra este: " + Integer.toString(x);
  17.         return s1;
  18.         /*
  19.          * In situatii simple, puteti folosi de asemenea direct return
  20.          * return "Valoarea noastra este: " + Integer.toString(x);
  21.          */
  22.     }
  23.  
  24. }
  25.  
  26. class FooChild extends Foo {
  27.     /*
  28.      * In mod normal, in Java, campurile se declara cu specificatorul de acces
  29.      * private pentru a permite incapsularea ==> folositi getteri, setteri
  30.      */
  31.     private String name;
  32.     private String age;
  33.  
  34.     public FooChild(int x, String name, String age) {
  35.         super(x); /*
  36.                      * apel al constructorului cu parametru din clasa parinte --
  37.                      * ce se va afisa?
  38.                      */
  39.         this.name = name;
  40.         this.age = age;
  41.         System.out.println("in constructor derivat cu param - name: " + name + ", age: " + age);
  42.     }
  43.  
  44.     public FooChild() {
  45.         this(1, "Unnamed", "42");
  46.         System.out.println("in constructor derivat fara param");
  47.     }
  48.  
  49.     /* getteri + setteri pentru campurile private */
  50.     public String getName() {
  51.         return name;
  52.     }
  53.  
  54.     public String getAge() {
  55.         return age;
  56.     }
  57.  
  58.     public void setName(String name) {
  59.         this.name = name;
  60.     }
  61.  
  62.     public void setAge(String a) {
  63.         age = a;
  64.     }
  65.  
  66.     public String toString() {
  67.         /*
  68.          * foarte important, de observat modul in care se apeleaza o metoda din
  69.          * superclasa
  70.          */
  71.         return "Obiect copil: " + super.toString();
  72.     }
  73.  
  74.     public int trickySum() {
  75.         int sum = 0;
  76.         for (int i = 0; i < age.length(); ++i) {
  77.             sum += age.charAt(i) - '0';
  78.         }
  79.  
  80.         return sum;
  81.     }
  82.  
  83.     public static void main(String[] args) {
  84.         Foo[] foos = new Foo[3];
  85.  
  86.         /* Analizati output-ul pentru cele 3 instantieri */
  87.         System.out.println("OUTPUT INSTANTIERI:");
  88.  
  89.         foos[0] = new Foo(3);
  90.         System.out.println("------------------");
  91.  
  92.         foos[1] = new FooChild(5, "Gigel", "20");
  93.         System.out.println("------------------");
  94.  
  95.         foos[2] = new Foo();
  96.         System.out.println("------------------");
  97.  
  98.         for (int i = 0; i < foos.length; ++i) {
  99.             System.out.print(i + " is a ");
  100.  
  101.             if (foos[i] instanceof FooChild) {
  102.                 FooChild child;
  103.  
  104.                 child = (FooChild) foos[i];
  105.  
  106.                 System.out.println("Child and has tricky sum " + child.trickySum());
  107.             } else {
  108.                 System.out.println("Foo and has no tricky sum :(");
  109.             }
  110.         }
  111.  
  112.         System.out.println("------------------");
  113.  
  114.         for (int i = 0; i < foos.length; ++i) {
  115.             /*
  116.              * Analizati rezultatul. De ce credeti ca se intampla acest lucru?
  117.              */
  118.             System.out.println(i + ": " + foos[i]);
  119.         }
  120.     }
  121. }