2~5章

第二章
1,引用操纵对象： String s；只是引用，String s="gkl";
2，存储位置： 引用-堆栈 对象-堆 常量-一般代码内部
3，作用域： {
int x=0;
{
int x=0;
}
}//错误
4，class成员变量会有默认的初始化，但局部变量没有，且必须人为初始化，否则出错。
5，除特殊类型，传递的是引用
6，消除了向前引用的问题，即使在后面定义
7，java。lang默认的导入每个java文件中，里面有许多的类，比如System
8，类名的首字母大写，如GaoKuiLin


第三章
1，对象和基本数据类型的赋值不相同。对象为引用，在赋值和传递中要注意
2，java.util.Random类对象产生随机数字，我们可以在构造Random对象的时候指定种子（），如：
Random r1 = new Random(20);
或者默认当前系统时间对应的相对时间有关的数字作为种子数:
Random r1 = new Random()。
例
Random rand=new Random(77)；//77种子,
int j=rand.nextInt(100);//0-100
3，==和！=比较的是对象的引用，而不是对像本身，默认的equals（）比较的也是引用，需重载。
package test;
public class test {


public static void main(String[] args) {
// TODO Auto-generated method stub
Integer t1=new Integer(1);
Integer t2=new Integer(1);

System.out.println(t1==t2);
System.out.println(t1!=t2);
System.out.println(t1.equals(t2));

}


}
输出：
false
true
true
4，&& || ！ 只能用于boolean，如果在使用String的地方使用了boolean，输出false，true
5，Integer(Long).toBinaryString()显示位信息
6，指数记法，1e-2f，e相当于10，并将指数当做double处理
7，boolean的位操作看作单比特，不能用^，不能算数操作，不能>,<,~
8，位操作只能用于整型，>> 有符号右移，>>>无符号右移，高位始终填0，byte 和 short会县转换为int，可能与想要的不一样
9，java不能重载操作符
10，字符串操作符+，+=：
如果一个以字符开始的表达式，后面的所有操作数都必须是字符串型
package test;
public class test {
public static void main(String[] args) {
int x=2,y=2,z=3;
String s="x,y,z ";


System.out.println(s+x+y+z);
System.out.println(s+(x+y+z));
System.out.println(x+s+y);
System.out.println(""+x);//作为Integer.toString()的替换
}
}
输出：
x,y,z 223
x,y,z 7
2x,y,z 2
2
2
11，类型转换：boolean不允许类型转换，类不允许类型转换
package test;
public class test {
public static void main(String[] args) {
double x=2.9;
double y=0.4f;

System.out.println((int)x);
System.out.println(Math.round(x));
System.out.println(Math.round(y));//四舍五入，而不是截断
}
}
输出：
2
3
0
12，java没有sizeof，为了移植，因为不同的机器可能不同，而java认为不同的机器的相同数据类型大小一样




第四章 控制执行流程
1，math.random产生[0-1)之间的数字，注意和Random区别
2，java.lang.Character包转类的isLowerCase（）检验大小写
3，foreach： for(int x:f)//f为数组
例：import java.util.*;
public class ForEach{
static void main(String[] arg){
for(char c: "gkl is a study".toCharArray() )
System.out.println(c);
}


}
4.java中的标签，用在有多重迭代的时候，避免break和continue只能跳出一层，必须在迭代前面且刚刚好。
例：
package p1;


public class Mark {
public static void main(String[] a){
m1:
for(int i=0;i<10;i++){
System.out.print(i+"i"+"   ");
for(int j=0;j<10;j++){
if(j==5)
break m1;
System.out.print(j+" ");
}
}
}


}
输出：0i   0 1 2 3 4 
5，switch的case可以多重匹配


第五章 初始化与清理
1，每个方法首字母小写的规则不适用与构造器
2，如果重载了构造器，则不在提供默认构造器
3，不能与返回值的类型来区分重载的方法
4，this（当前对象的引用）关键字，编译器暗自的吧对象的引用作为类方法的第一个参数传递来区分是由哪个对象的调用，
可用来避免参数和成员同名的歧义，也可以用来调用构造函数
例：
package p1;
import java.util.*;
class Gkl{
int i=0;
Gkl(){
System.out.println("default");
}
Gkl(int i){
this();
System.out.println("int");
}
Gkl(char c,int i){
this(i);//构造必须是第一个
System.out.println(this.i);
System.out.println("char");
}
}


class Mark{
public static void main(String[] a)
{
new Gkl();
new Gkl(1);
new Gkl('c',2);
}
}
输出：
default
default
int
default
int
0
char


5，static方法就是没有this的方法，static 可以充当java禁止的全局方法
6，垃圾回收器只能回收由new分配的内存，回收不同于c++的析构
7，java的垃圾回收器（看书）
8，System.gc()用来请求JVM进行垃圾回收，但不一定会马上执行，并首先调用finalize（编程思想，可用于终结的验证条件）
9,所有的引用的大小都是固定的，存在于堆栈区
10，所用的对象的成员都会得到初始化，即便没有认为指定 
11，在构造器初始化前，每个成员都得到了默认的初始值，如果为对象引用，则为NULL,静态成员只有在用到的时候才会初始化否则不会得到初始化，初始化的顺序是先静态
12，静态初始化块，这回执行一次，块内的都会初始化，对应有非静态的实例初始化，不要static关键字，且在构造器之前执行
例：
package p1;
 class Cup{
Cup(int i){
System.out.println("Cup "+i);

}
void f(){

}

}
class Gkl{
static Cup x;
static Cup y;
static {
x=new Cup(1);
y=new Cup(2);
}
}


public class Mark{
public static void main(String[] arg)
{
Gkl.x.f();

}
}
输出：
Cup 1
Cup 2
13，数组：int [] a;a只是数组的引用，并没有指定一块内存，a.lenght长度，println(Array.toString(a))（java.util ）打印一维数组
一种用法：
Integer[] a;
a=new Integer[]
{
new Integer(1),
new Integer(2),
,


} 
14,可变参数列表有两种方式 例：1,f(Object[] agr)(Object为所有类的基类)，2,f(int a,String... s)
可以接受0个参数，而如果有重载的话，很可能引起不知道用哪个的情况，故总是只在重载方法的一个版本上使用或不使用。
如：
package p1;


class A1{
static void f(Object[] args)
{
for(Object x : args)
System.out.println(x);
}
public static void main(String[] a)
{
f(new Object[] {new Integer(1),new Float (2)});
}
}
输出：1
2.0
package p1;
public class Mark{
static void f(Integer i,Object... agr){
System.out.println("first");
}
static void f(Object... agr){
System.out.println("second");
}


public static void main(String[] arg)
{
f(1,'a',"gkl");
f('a','b',"h");
f(new Object[]{new Integer(1),new Float (2)});


}
}
输出：
first
second
second
14，枚举，枚举符号大写，为常量，可以用在switch中，有toSring方法，ordinal（）显示顺序，
for(枚举类型 s：枚举类型.values)每个枚举值