package com.zlc.array;
 
public class TestField {
  {
    String b ;
    //如果不初始化，编译器就会报The local variable b may not have been initialized
    System.out.println(b);
  }
  public static void main(String[] args) {
    int a ;
    //如果不初始化，编译器就会报The local variable a may not have been initialized
    System.out.println(a);
  }
}

package com.zlc.array;
 
public class TestField {
  public TestField(int age){
    System.out.println("构造函数中初始化 this.age = "+this.age);
    this.age = age;
  }
  {
    System.out.println("非静态块中初始化");
    age = 22;
  }
  //定义的时候初始化
  int age = 15;
  public static void main(String[] args) {
    TestField field = new TestField(24);
    System.out.println("最终 age = "+field.age);
  }
}

package com.zlc.array;
 
 class TestStatic {
  //类成员 DEMO TestStatic实例
  final static TestStatic DEMO = new TestStatic(15);
  //类成员 age
  static int age = 20;
  //实例变量 curAge
  int curAge;
   
  public TestStatic(int years) {
    // TODO Auto-generated constructor stub
    curAge = age - years;
  }
}
 public class Test{
  public static void main(String[] args) {
    System.out.println(TestStatic.DEMO.curAge);
    TestStatic staticDemo = new TestStatic(15);
    System.out.println(staticDemo.curAge);
  }
}

package com.zlc.array;
class Father{
  int age = 50;
  public Father() {
    // TODO Auto-generated constructor stub
        System.out.println(this.getClass());
        //this.sonMethod();无法调用
    info();
  }
  public void info(){
    System.out.println(age);
  }
}
public class Son extends Father{
  int age = 24;
  public Son(int age) {
    // TODO Auto-generated constructor stub
    this.age = age;
  }
  @Override
  public void info() {
    // TODO Auto-generated method stub
    System.err.println(age);
  }
  public static void main(String[] args) {
    new Son(28);
  }
    //子类特有的方法
    public void sonMethod(){
         System.out.println("Son method");
    }
}

package com.zlc.array;
class Animal{
  int age ;
  public Animal(){
     
  }
  public Animal(int age) {
    // TODO Auto-generated constructor stub
    this.age = age;
  }
  void run(){
    System.out.println("animal run "+age);
  }
}
class Dog extends Animal{
  int age;
  String name;
  public Dog(int age,String name) {
    // TODO Auto-generated constructor stub
    this.age = age;
    this.name = name;
  }
  @Override
  void run(){
    System.out.println("dog run "+age);
  }
}
public class TestExtends {
  public static void main(String[] args) {
    Animal animal = new Animal(5);
    System.out.println(animal.age);
    animal.run();
     
    Dog dog = new Dog(1, "xiaobai");
    System.out.println(dog.age);
    dog.run();
     
    Animal animal2 = new Dog(11, "wangcai");
    System.out.println(animal2.age);
    animal2.run();
     
    Animal animal3;
    animal3 = dog;
    System.out.println(animal3.age);
    animal3.run();
  }
}

package com.zlc.array;
 
 class TestStatic {
  //类成员 DEMO TestStatic实例
  final static TestStatic DEMO = new TestStatic(15);
  //类成员 age
  final static int age = 20;
  //实例变量 curAge
  int curAge;
   
  public TestStatic(int years) {
    // TODO Auto-generated constructor stub
    curAge = age - years;
  }
}
 public class Test{
  public static void main(String[] args) {
    System.out.println(TestStatic.DEMO.curAge);
    TestStatic static1 = new TestStatic(15);
    System.out.println(static1.curAge);
  }
}

package com.zlc.array;
 
public class TestString {
  static String static_name1 = "java";
  static String static_name2 = "me";
  static String statci_name3 = static_name1+static_name2;
   
  final static String final_static_name1 = "java";
  final static String final_static_name2 = "me";
  //加final 或者不加都行 前面兩個能被宏替換就行了
  final static String final_statci_name3 = final_static_name1+final_static_name2;
   
  public static void main(String[] args) {
    String name1 = "java";
    String name2 = "me";
    String name3 = name1+name2;
    //(1)
    System.out.println(name3 == "javame");
    //(2)
    System.out.println(TestString.statci_name3 == "javame");
    //(3)
    System.out.println(TestString.final_statci_name3 == "javame");
  }
}

public class SizeOfAgent {

  static Instrumentation inst;

  /** initializes agent */
  public static void premain(String agentArgs, Instrumentation instP) {
    inst = instP;      
  }

  /**
   * Returns object size without member sub-objects.
   * @param o object to get size of
   * @return object size
   */
  public static long sizeOf(Object o) {
    if(inst == null) {
      throw new IllegalStateException("Can not access instrumentation environment.\n" +
                    "Please check if jar file containing SizeOfAgent class is \n" +
                    "specified in the java's \"-javaagent\" command line argument.");
    }
    return inst.getObjectSize(o);
  }

  /**
   * Calculates full size of object iterating over
   * its hierarchy graph.
   * @param obj object to calculate size of
   * @return object size
   */
  public static long fullSizeOf(Object obj) {
    Map<Object, Object> visited = new IdentityHashMap<Object, Object>();
    Stack<Object> stack = new Stack<Object>();

    long result = internalSizeOf(obj, stack, visited);
    while (!stack.isEmpty()) {
      result += internalSizeOf(stack.pop(), stack, visited);
    }
    visited.clear();
    return result;
  }        

  private static boolean skipObject(Object obj, Map<Object, Object> visited) {
    if (obj instanceof String) {
      // skip interned string
      if (obj == ((String) obj).intern()) {
        return true;
      }
    }
    return (obj == null) // skip visited object
        || visited.containsKey(obj);
  }

  private static long internalSizeOf(Object obj, Stack<Object> stack, Map<Object, Object> visited) {
    if (skipObject(obj, visited)){
      return 0;
    }
    visited.put(obj, null);

    long result = 0;
    // get size of object + primitive variables + member pointers 
    result += SizeOfAgent.sizeOf(obj);

    // process all array elements
    Class clazz = obj.getClass();
    if (clazz.isArray()) {
      if(clazz.getName().length() != 2) {// skip primitive type array
        int length = Array.getLength(obj);
        for (int i = 0; i < length; i++) {
          stack.add(Array.get(obj, i));
        } 
      }    
      return result;
    }

    // process all fields of the object
    while (clazz != null) {
      Field[] fields = clazz.getDeclaredFields();
      for (int i = 0; i < fields.length; i++) {
        if (!Modifier.isStatic(fields[i].getModifiers())) {
          if (fields[i].getType().isPrimitive()) {
            continue; // skip primitive fields
          } else {
            fields[i].setAccessible(true);
            try {
              // objects to be estimated are put to stack
              Object objectToAdd = fields[i].get(obj);
              if (objectToAdd != null) {            
                stack.add(objectToAdd);
              }
            } catch (IllegalAccessException ex) { 
              assert false; 
            }
            }
          }
      }
      clazz = clazz.getSuperclass();
    }
    return result;
  }
}