String str="abc";
System.out.println(str);
str=str+"de";
System.out.println(str);

package base;
/**
 * 对类加载、构造方法执行顺序的研究
 * @author wdb
 *
 */
public class InitOrder {
	private String s = print("main函数所在类成员变量初始化");
	
	private static String s1 = print("main函数所在类静态成员变量初始化");
	
	public InitOrder(){
		System.out.println("main函数类构造执行");
	}
	
	public static void main(String[] args) {
		InitOrder test = new InitOrder();
		test.print("单个类加载执行完成！");
		
		System.out.println("--------------具有继承关系的类加载执行顺序演示-------------");
		Demo2 demo = new Demo2();
		demo.print("具有继承关系的类执行完毕");
	}
	
	public static String print(String s){
		System.out.println(s);
		return s;
	}
}
class Base{
	private String s=print("基类BASE私有成员初始化");
	private static String s1=print("基类BASE静态成员初始化");
	public Base(){
		System.out.println("基类构造方法执行");
	}
	public static String print(String s){
		System.out.println(s);
		return s;
	}
}
class Demo1 extends Base{
	private String s=print("导出类Demo1私有成员初始化");
	private static String s1=print("导出类Demo1静态成员初始化");
	public Demo1(){
		System.out.println("导出类Demo1构造方法执行");
	}
}
class Demo2 extends Demo1{
	private Demo demo = new Demo();
	private String s=print("导出类Demo2私有成员初始化");
	private static String s1=print("导出类Demo2静态成员初始化");
	public Demo2(){
		System.out.println("导出类Demo2构造方法执行");
	}
}
class Demo {
	public Demo(){
		System.out.println("Demo类构造方法执行");
	}
}
/*output:
 	main函数所在类静态成员变量初始化（只要main方法被执行就会有此输出哪怕不进行对象创建）
	main函数所在类成员变量初始化
	main函数类构造执行
	单个类加载执行完成！
--------------具有继承关系的类加载执行顺序演示-------------
	基类BASE静态成员初始化
	导出类Demo1静态成员初始化
	导出类Demo2静态成员初始化
	
	基类BASE私有成员初始化
	基类构造方法执行
	
	导出类Demo1私有成员初始化
	导出类Demo1构造方法执行
	
	Demo类构造方法执行
	导出类Demo2私有成员初始化
	导出类Demo2构造方法执行
	
	具有继承关系的类执行完毕
*///

int i = 5;//直接在栈中分配空间 
Integer i = new Integer(5);//对象是在堆内存中,而i(引用变量)是在栈内存中

List list=new ArrayList();
list.add(new Integer(1));

List list=new ArrayList();
list.add(1);

Integer a = new Integer(10);// 使用new Integer()显式创建对象
Integer b = new Integer(10);
Integer c = 10;   //JVM中一个字节以下的整型数据会在JVM启动的时候加载进内存，除非用new Integer()显式的创建对象，否则都是同一个对象
Integer c1 = 10;
Integer c2 = 10;
Integer d = 130; //超过一个字节,非同一个对象 d!=d1
Integer d1 = 130;
int e = 10;
int f = 10;
System.out.print(a==b);//false
System.out.print(a==c);//false
System.out.print(c==c1 && c==c2);//true
System.out.print(d==d1);//false
System.out.print(e==f);//true
System.out.print(a==e && c==e);//true 对于==，一般比较引用地址，有基本数据类型的都是比较值

package com.lijingdong.leetcode;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
class Person {
  //私有属性
  private String name = "Tom";
  //公有属性
  public int age = 18;
  //构造方法
  public Person() {
  }
  //私有方法
  private void say() {
    System.out.println("private say()...");
  }
  //公有方法
  public void work() {
    System.out.println("public work()...");
  }
}
public class Test {
  public static void main(String[] args) throws Exception {
    Class c2 = Person.class;
    //获得类完整的名字
    String className = c2.getName();
    System.out.println(className);//输出com.ys.reflex.Person
//获得类的public类型的属性。
    Field[] fields = c2.getFields();
    for (Field field : fields) {
      System.out.println(field.getName());//age
    }
//获得类的所有属性。包括私有的
    Field[] allFields = c2.getDeclaredFields();
    for (Field field : allFields) {
      System.out.println(field.getName());//name    age
    }
//获得类的public类型的方法。这里包括 Object 类的一些方法
    Method[] methods = c2.getMethods();
    for (Method method : methods) {
      System.out.println(method.getName());//work wait equals toString hashCode等
    }
//获得类的所有方法。
    Method[] allMethods = c2.getDeclaredMethods();
    for (Method method : allMethods) {
      System.out.println(method.getName());//work say
    }
//获得指定的属性
    Field f1 = c2.getField("age");
    System.out.println(f1);
//获得指定的私有属性
    Field f2 = c2.getDeclaredField("name");
//启用和禁用访问安全检查的开关，值为 true，则表示反射的对象在使用时应该取消 java 语言的访问检查；反之不取消
    f2.setAccessible(true);
    System.out.println(f2);
//创建这个类的一个对象
    Object p2 = c2.newInstance();
//将 p2 对象的  f2 属性赋值为 Bob，f2 属性即为 私有属性 name
    f2.set(p2, "Bob");
//使用反射机制可以打破封装性，导致了java对象的属性不安全。
    System.out.println(f2.get(p2)); //Bob
//获取构造方法
    Constructor[] constructors = c2.getConstructors();
    for (Constructor constructor : constructors) {
      System.out.println(constructor.toString());//public com.ys.reflex.Person()
    }
  }
}