一切都是对象

1：用引用操作对象

     在java中一切都被视为对象，我们操作的是对象的引用，而非对象本身。

     引用可以单独存在，它并不是对象;当你试图操作一个空引用（没有赋值给对象）时，

        会报运行时异常，所以：

创建一个引用的同时便进行初始化

 2：对象必须由你创建

    五种不同的数据存储方式：

     1）寄存器（数量有限，你不可以直接控制）

     2）堆    栈（通过上下移动指针来创建和释放内存，通常用来存放对像引用、基本类型数据）

     3）堆       （用来存放对象，有很大的灵活性，但分配时须要更多的时间）

     4）常量存储（存放不可变的值，位于程序内部，放在rom中）

     5）非ram存储：（流：发送到别一台机器；持久对象：存放在磁盘中；jdbc：存放到数据库中）

   基本类型：（不用new来创建变量，而是把值直接存到堆栈中）

基本类型	大小	量小值	量大值	包装类
boolean	-	-	-	Boolean
char	16-bit	unicode 0	2的16次-1	Character
byte	8	-128	127	Byte
short	16	-2的15次	2的15次-1	Short
int	32	-2的31次	2的31次-1	Integer
long	64	-2的63次	2的63次-1	Long
float	32			Float
double	64			Double
void	-	-	-	Void

    基本类型占用存储空间大小固定（boolean除外），不会随着机器的硬件变化而变化，因此可移植性好

    包装类：（在堆中创建对象，基本类型都有）

Character ch = 'x';    //封包：自动转换为包装类型的对象
char c = ch;               //拆包：自动 转换为基本类型

   高精度数字：

      BigInteger和BigDecimal(用于操作任意精度的数字，损失一定效率)对应int和float

   数组：（以少量内存开销和运行时下标检查，换来了安全性和效率）

      创建数组对象时，实际是创建了数组引用，它们被初始化为null

 3: 永远不要销毁对象

        作用域决定了在其内定义的变量名的可见性和生命周期。

     （注：同名变量不能被定义两次）       

         对象可以 存活在作用域之外，但对象引用不可以，所以我们不能在作用域之外访问该对象（即使他现在还存在）

 4:类

       类包含两种类型的元素：字段（用来存放类的属性，普通类成员变量不能被多个对象共享，static字段除外）和方法

     基本成员变量默认值：（最好明确地对其初始化）

基本类型	默认值
boolean	flase
char	'\u0000'(null)
byte	0
short	0
int	0
long	0L
float	0.0f
double	0.0d

   (局部变量不会被自动初始化，否则会报错)

5：方法，参数与返回值

    java中的方法只能作为类的一部分来创建，方法只能通过对象才能被调用

    java中参数都是对象，传递的其实是对象引用

    return关键字用来退出方法，可以在方法的任何位置返回

6:static 关键字（讲得还不错：http://blog.csdn.net/chenssy/article/details/13004291）

     当声明一个事物为static时，就意味着这个域或者方法不会与包含它的哪个类的任何对象实例关联在一起

     对于字段：所有对象都共享它

     对于方法：在于不用创建对象就可以访问

7：操作符

    1）：优先级

          一般是先乘除后加减（不知道时，可以用括号改变运算顺序）

     2）：赋值

          基本类型存储了实际的数值，是直接将一个地方的内容复制到另一个地方。

          对象，实际操作的是对象引用

     3）：算术操作符（+-/*%）

整数除法会直接去掉结果的小数       #Random类，用来生成随机数

           一元加减号作用：将小类型的操作数提升为int

     4)：自增和自减

           a++    ==>   先生成值，再计算（即现在它还代表a的值）

           ++a    ==>   先计算，再生成值（即现在它代表a+1的值）

           a--

           --a

     5)：关系操作符(>,<,>=,<=,==,!=)

等于，不等于适用所有基本数据类型，其它不适用于boolean，因为true和false大于与小于没有意义

          对象的关系操作(==,!=)其实是在比较对象引用,应使用equals()方法，并覆盖它，因为从object继承下来的equals方法，是在比较对象引用。（对象的比较应是对象字段值的比较）

      6）：逻辑操作符（&&，||，！）只应用于boolean

短路：即能够明确无误地确定整表达式的值，就不再计算表达式的余下部分了

      7）：直接常量（后厕所后缀字符标志了它的类型）

           L(无论大小写)代表long，F代表float，D代表double

           十六进制数适用于所有整数类型，以前缀0X[0-9a-zA-Z];如果试图将变量初始化成超过自身表示范围的值，编译器会将值（char,byte,short）自动转换成int，其它将进行窄化转换

Long.toBinaryString() 以二进制形式转示，Integer也有

      8）：按位操作符（&，|，^，~   {一元操作符}）   不会短路

对二进制进行布尔运算，boolean类型不能进行非（~）

      9）：移位操作符（<<，>>，>>>）

          <<：操作数向左移动，低位补0

          >>：向右移动      有符号;正号，高位插入0;负号，高位插入1

          >>>：向右移动，插入0

对char,byte,short类型，移位处理，它们会先转换成Int,在移位，结果为int    #byte,short会截断，结果可能不正确（-1）

       10）:三元操作（boolean-exp ? value1 : value2 ;）

       11）:类型转换

             截尾：比int类型大就会

             舍入：比int类型小（char,byte,short） 

注：1：字符串+,+=时，如果表达式开头为字符串，哪么后续所有操作数都必须是字符类型
       2：java不会将int类型转换为boolean

表达式中出现最大数据类型决定表达式的最终结果类型

 8：控制流程（所有条件语句都用条件表达式的真或假来决定执行路径）

      分支：if(1==9){}else{}

      迭代：while(){}       do{}while()        for(int i=0;i<9;i++){}       for(float a : range(10))

      return :作用：可以返回值，也可以提前退出方法        

      break：退出当前迭代

      continue：退出本次迭代

//java中没有goto，但可用其它实现
label1:
		for(int i=1;i<9;i++){
			for(int j=1;j<9;j++){
				break label1;
//				continue label1;     退出到label1处
			}	
		}	

      switch：选择语句

switch ('a') {                    #接收int或char   emun
		case 'a':
			System.out.print('a');
			break;
		case 'b':
			System.out.print('b');
			break;
		default:
			System.out.print('c');
		}

 9:初始化与清理

 

      1）：用构造器确保初始化

             在java中“初始化”与“创建”捆绑在一起，不能分离（即new对象时，即创建了对象又调用了构造器）     

            格式：与类名相同（区分大小写），没有返回类型或值（void也不可）

       2）：方法重载（同名方法，具有独一无二的参数列表）

             基本类型的重载：传入参数类型小于方法中的声明时，类型会提升，反之会窄化

类型提升是逐级的，即byte-->short-->int-->int-->long(或float--->double)，但char会直传升为int

        3)：默认构造器（如果已经定义了一个构造器，哪么编译器就不会再创建无参构造器了，这样运行时会报错，你必须手动创建一个无参构造器）

        4）：this关键字

           this只能在方法内部使用，表示调用方法的哪个对象的引用

           构造方法可用this([参数列表])来调用其它构造方法，此时this应该在其第一行，否则报错

static方法没有对象，所以在static内部不能使用this，反过来可以

        5）：清理

           垃圾回收器只知道释放哪些经由new创建并不在使用的对象（失去引用）内存。（只有在jvm内存耗尽时才用自动执行，手动执行方法：system.gc()）

           finalize()方法，在垃圾回收器被调用时，运行此方法（避免使用，你不确定它会不会被调用）

垃圾回引器原理 （会停止程序）

jvm会监视，如果所有对象都很稳定（被引用），垃圾回收效率低的话，就切到“标记----清扫”方式（先标记存在引用的对象，然后清理不被引用的对象，后台）;同样会监视“标记----清扫”的效果，要是堆出现很多碎片时，就会切到“停止----复制”方法（停止程序，然后复制存在引用的对象）

写道

jvm使用jit技术编译代码，它会全部或部分翻译成机器码;当java代码被装入内存中时，有两种方式可选：1，让jit翻译所有代码，缺点，耗时长，效率低;2,惰性评估（只在必要时才翻译），这样执行次数越多程序越快

       6）：成员初始化

          基本类型数据会自动初始化，并在构造器初始化之前完成。

          无论创建多少对象，静态数据都只占一份空间，static不能用于局部变量（构造器是静态的）

          静态域只被执行一次，并且是在创建类的第一个对象或第一次访问静态数据时

       7）：数组初始化

          编译器不允许指定数组的大小，创建变量时我们拥有的只是一个引用，没给数组对象分配任何空间。

          数组下标从0开始，并且长度不会引变

数组效率 写道

每次访问数组时，都会检查数组的长度，保证不会越界，这个功能无法禁用，它们可能会导致程序效率低下

 

Integer [] a = new Integer[rand.nextInt(20)];
int [] a = new int[rand.nextInt(20)];

       8)：可变参数（重载方法时，至多只有一个方法有可变参数，并且有与之区分的参数）

public void geta(String ... a){}      //它必须是最后一个位置，其实是一个数组

       9）：枚举类型

           

public void aaa() {
		switch (b.NOT) {
		case NOT:
			System.out.print('a');
			break;
		case MAX_S:
			System.out.print('b');
			break;
		default:
			System.out.print('c');
		}
	}


enum b{
	NOT,MAX_S
}

使用字符串查找枚举

public enum Operator {
	ne, gt, lt, ge, le
}

String errorCompare="gt";
switch (Operator.valueOf(errorCompare)) {
			case ge:
				return (a - b) >= error;
			case le:
				return (a - b) <= error;
			case gt:
				return (a - b) > error;
			case lt:
				return (a - b) < error;
			case ne:
				return (a - b) != error;
			}

 

 10:访问控制

     public  声明自己可以被所有成员使用

     不写（包访问） 同一包内的成员才可以使用

     private 声明自己只能被自己调用  （尽量使用，不会被子类继承）

    producted  也提供包访问，并且可被不同包的子类访问

类只有public或包访问权限