Java的部分基础知识

Java常见问题：

• 整型溢出
  JAVA的两大类数据类型：
  • 内置数据类型
  • 引用数据类型
• 基本类型包装类型
• 自动装箱和拆箱
• 逻辑运算符的不同
• 循环的跳出
  
  
• 面向对象的知识

内置数据类型:

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

-byte：

• byte 数据类型是8位、有符号的，以二进制补码表示的整数；

• 最小值是 -128（-2^7）；

• 最大值是 127（2^7-1）；

• 默认值是0；

• byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；

• 例子：byte a = 10，byte b = -10。

• System.out.println(“最小值：Byte.MIN_VALUE=” + Byte.MIN_VALUE);
  最小值：Byte.MIN_VALUE=-128

• System.out.println(“最大值：Byte.MAX_VALUE=” + Byte.MAX_VALUE);
  最大值：Byte.MAX_VALUE=127

-short：

• short 数据类型是 16 位、有符号的以二进制补码表示的整数

• 最小值是 -32768（-2^15）；

• 最大值是 32767（2^15- 1）；

• short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一； 默认值是 0；

• 例子：short c = 100，short d = -200。

• System.out.println(“最小值：Short.MIN_VALUE=” + Short.MIN_VALUE);
  最小值：Short.MIN_VALUE=-32768

• System.out.println(“最大值：Short.MAX_VALUE=” + Short.MAX_VALUE);
  最大值：Short.MAX_VALUE=32767

-int：

• int 数据类型是32位、有符号的以二进制补码表示的整数；
• 最小值是 -2,147,483,648（-2^31）；
• 最大值是 2,147,483,647（2^31 - 1）；
• 一般地整型变量默认为 int 类型；
• 默认值是 0 ；
• 例子：int e = 100, int f = -200。
• System.out.println(“最小值：Integer.MIN_VALUE=” + Integer.MIN_VALUE);
  最小值：Integer.MIN_VALUE=-2147483648
• System.out.println(“最大值：Integer.MAX_VALUE=” + Integer.MAX_VALUE);
  最大值：Integer.MAX_VALUE=2147483647

-long：

• long 数据类型是 64 位、有符号的以二进制补码表示的整数；

• 最小值是-9,223,372,036,854,775,808（-2^63）；

• 最大值是 9,223,372,036,854,775,807（2^63 -1）；

• 这种类型主要使用在需要比较大整数的系统上； 默认值是 0L；

• 例子： long h = 100L，Long i = -200L。

• "L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

• System.out.println(“最小值：Long.MIN_VALUE=” + Long.MIN_VALUE);
  最小值：Long.MIN_VALUE= -9223372036854775808

• System.out.println(“最大值：Long.MAX_VALUE=” + Long.MAX_VALUE);
  最大值：Long.MAX_VALUE=9223372036854775807

-float：

• float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；

• float 在储存大型浮点数组的时候可节省内存空间；

• 默认值是 0.0f；

• 浮点数不能用来表示精确的值，如货币；

• 例子：float j = 1234.5f。

• 后面必须有f

• System.out.println(“最小值：Float.MIN_VALUE=” + Float.MIN_VALUE);
  最小值：Float.MIN_VALUE=1.4E-45

• System.out.println(“最大值：Float.MAX_VALUE=” + Float.MAX_VALUE);最大值：Float.MAX_VALUE=3.4028235E38

-double：

• double 数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数；
  浮点数的默认类型为 double 类型；

• double类型同样不能表示精确的值，如货币；

• 默认值是 0.0d；

• 例子：double a = 7D; double b = 54.; double c = 122.0; double d = 12.54132;

    7 是一个 int 字面量，而 7D，54. 和 122.0 是 double 字面量。
  

• System.out.println(“最小值：Double.MIN_VALUE=” + Double.MIN_VALUE);
  最小值：Double.MIN_VALUE=4.9E-324

• System.out.println(“最大值：Double.MAX_VALUE=” + Double.MAX_VALUE);
  最大值：Double.MAX_VALUE=1.7976931348623157E308

-boolean：

• boolean数据类型表示一位的信息；
• 只有两个取值：true 和 false；
• 这种类型只作为一种标志来记录 true/false 情况；
• 默认值是 false；
• 例子：boolean a = true。

-char：

• char 类型是一个单一的 16 位 Unicode 字符；

• 最小值是 \u0000（十进制等效值为 0）；

• 最大值是 \uffff（即为 65535）；

• char 数据类型可以储存任何字符；

• 例子：char a = ‘A’;

• // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
  System.out.println(“最小值：Character.MIN_VALUE=” + (int) Character.MIN_VALUE);
  最小值：Character.MIN_VALUE=0

• // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
  System.out.println(“最大值：Character.MAX_VALUE=” + (int) Character.MAX_VALUE);
  最大值：Character.MAX_VALUE=65535

引用类型:

• 在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
• 对象、数组都是引用数据类型。
• 所有引用类型的默认值都是null。
• 一个引用变量可以用来引用任何与之兼容的类型。
• 例子：Session session = new Session(“Runoob”)。

整型溢出：

所谓整型溢出其实就是数太大了或太小了，超出了整型所容纳的范围 而int的取值范围是 -2,147,483,648到2,147,483,647；当取的数是2^31时，就会超出这个范围或是取-2,147,483,649时都会溢出。 要先解决可以将变量改为long类型，或者使用大整数BigInteger这个类。

基本类型的包装类型:

引用类型可以赋值为null，表示空，但基本类型不能赋值为null，将一个基本类型视为对象，这样就不能像之前基本数据类型那样初始化。
每个定义：
int对应于Integer类
例如：public class Integer
{
private int value;
public Integer(int value) {
this.value = value;
}
public int intValue() {
return this.value;
}
}
定义好Integer类型就可以int和Integer互相转换：
Integer i = null;

Integer l = new Integer(50);
int j = l.intValue();
因为包装类型非常有用，所以Java核心库为每种基本类型都提供了对应的包装类型：
Integer 、Long、Short、Byte、Character、Double、Float、Boolean、BigInteger(大整数)、BigDecmail(精确计算浮点数)
包装类型是为了方便对基本数据类型进行操作，包装类型可以解决一些基本类型解决不了的问题：

• 集合不允许存放基本数据类型，只能存放应用数据类型。

• 基本类型可以和包装类型直接相互转换，自动装箱拆箱，

• 通过包装类型的parse方法可以实现基本数据类型+String类型之间的相互转换。

• 函数需要传递进去的参数为Object类型，传入基本数据类型就不可行。

包装类高频区间数据缓存范围：
Integer的高频区域为：-128~127即当在该区间建立的对象，只有第一次建立时是新的对象，其余均是该对象，没有新建。
例如：
Integer i = 127;
Integer l = 127;
System.out.println(i == l);输出结果就是true；
Integer i = 128;
Integer l = 128;
System.out.println(i == l);输出结果就是false；

Byte的高频区域为：-128~127
Short的高频区域为：-128~127
Character的高频区域为：0~127
Long的高频区域为：-128~127
Boolean的高频区域为：使用静态final定义，就会返回静态值
Float和Double不会有缓存，其他包装类都有。
而Integer是唯一可以修改缓存范围的包装类，在VM options加入参数： -XX：AutoBoxCacheMax=n即将缓存区间的最大值改为n：

自动装箱和自动拆箱：

       自动装箱就是Java自动将原始类型值转换成对应的对象，比如将int的变量转换成Integer对象，这个过程叫做装箱，反之将Integer对象转换成int类型值，这个过程叫做拆箱。因为这里的装箱和拆箱是自动进行的非人为转换，所以就称作为自动装箱和拆箱。

例如：Integer i=10;即自动装箱，int j=i;即自动拆箱

逻辑运算符：

&运算符就是只有计算完左右两边均为false，才结束是false，两边均是true才是true；

&&运算符有短路特性，当左边是false结束就是false，两边均是true才是true；
|运算符也只有计算完左右两边均是true，才结束是true，两边均是false才是false；
||运算符也有短路特性，当左边是true结束就是true，两边均是false才是false；
逻辑运算符& 和 |只能对布尔型（Boolean）数据进行运算。
而位运算符& 和 |既可以对布尔型（Boolean）数据运算，也可与对数值型数据运算。位运算符是先将数据转化为二进制补码形式，再逐位运算。

循环：

java中循环同C++中相同即for，while，do while三个循环

当循环进行多种嵌套时可以使用break和continue语句来跳出循环；
break是直接结束对应的循环，而continue只是结束本次循环， return是直接结束该方法
而同时continue lab；（跳出外层的本次循环，继续外层下一次循环）当程序中有嵌套的多层循环时，为从内循环跳到外循环，可使用带标号的continue lab语句。此时应在外循环的入口语句前方加上标号。
例如：
lab: for(int i =0; i<2; i++) {
for(int j=0; j<10; j++) {
if (j >1) {
continue lab;
}
System.out.println(“continue”);
}
System.out.println("************");
}
输出结果：
continue
continue
continue
continue
break lab; （可以跳出多重循环的外层循环）break lab语句用在循环语句中，必须在外循环入口语句的前方写上lab标号，可以使程序流程退出标号所指明的外循环。
例如：

lab: for(int i =0; i<2; i++) {
for(int j=0; j<10; j++) {
if (j >1) {
break lab;
}
System.out.println(“break");
}
}
输出结果：
break
break

return语句：
return关键字并不是专门用于跳出循环的，return的功能是结束一个方法。 一旦在循环体内执行到一个return语句，return语句将会结束该方法，循环自然也随之结束。return直接结束整个方法，不管这个return处于多少层循环之内。

面向对象

对象

对象引用

对象作为值传递

在Java中，当对象作为参数传递时，实际上传递的是一份“引用的拷贝”（实际传递的是对象的引用）

对象初始化的顺序

java对象初始化的执行顺序为：静态语句块>静态变量初始化>实例语句块/成员变量初始化>构造方法，实例语句块与成员变量初始化的相对执行顺序取决于定义的先后顺序。