1, 基本数据类型
Java是强类型语言， 对于每一种数据都定义了类型，基本数据类型分为数值型，字符型，布尔型。数值型又分为了整型和浮点型。
整型又分为byte, int, short long.
浮点型又分为了float 和double.
字符型是char 类型， 一般不用。
布尔型是boolean, 取值为 true 和 false.
2, 变量
由于强类型，java在声明变量的时候，必须指定数据类型。Type variable, 比如int num; 给这个变量进行赋值的时候，也必须是相同的数据类型， 必须变为num 赋组一个int 型，如num = 5; 变量的使用一定要注意数据类型。
3, 常量
常量也有类型，但是我写了个123，没有给它定义数据类型啊，它是什么数据类型？ 对于常量来说，它采用的是默认数据类型。对于整数来说，默认类型为int, 小数的默认类型则是double. 字符类型为char等。但对于采取默认类型来说，整型和浮点型又有所不同。
当我们写一个整数字面量的时候，这个字面量默认是int 类型，但是，它也可以赋值给byte 和short 类型，只要不超过byte 类型和short 类型取值范围。当然，这个整型字面量也可以赋值给long. 以下三种写法都不会报错。
byte b = 2; short s = 5; long l = 10;
但对于浮点数就有所不同，写一个浮点数，默认是double ， 它就不能赋值float.
float f = 3.14;
它会报错，报错的原因是，我们正在把一个double类型的值赋值给一个float类型，而float类型的精度比double类型小，所以报错了，损失精度了。所谓的精度，就是小数点后有几位小数，对于float类型来说，它小数点后面有6-7位小数，而对于double类型来说，它小数点后面有15位小数，所以double类型比float类型精度高。又由于15是 7的两倍多，所以float称为单精度浮点型, double称之为双精度浮点型。那怎么办，就不能把常量赋值给float 类型了？也不是，不过要对这个常量进行标识，给它加个后缀f，表示它是一个float类型。像下面这样就没有问题了。
float f = 3.14f;
这又让我想到了整数long型， 我们都知道long类型的取值范围比int 类型大，如果是一个特别大的整数，我们就把它赋值给long. 但是你会发现报错了。
long l = 100000000000;
超出了整型int 的最大取值范围， 数值字面量默认是int 类型，太大就超出了。那怎么才能赋给long，也要在后面加一个标识 L ,
long l = 100000000000L;
对于这种很大的数值，JDK7 还提供了一种便利，可以在各个数字间添加_ , 这样我们一看就可以知道这个数值多少了。
long l = 100_000_000_000L;
4，类型转换
类型转换分为自动类型转换和强制类型转换。自动类型转换必须满足两个条件：1, 两种类型必须是兼容的(compatible); 2, 目标类型的取值范围必须大于来源类型(The destination type is larger than source type). 通过这两个条件，可以发现，自动类型转换是发生在数值类型之间，因为类型是兼容的，可以把 byte 类型的值赋值给int 类型，也可以把int 类型赋值给double 类型。
int a = 10; long l = a;
自动类型转换绝对不会出现到 数值类型转化到char 类型或 布尔类型， 同样布尔类型和char 类型也不能互相转换， 因为他们类型不兼容，是不同的数据类型， 所以，如果你把一个布尔类型赋值给char 类型或数值类型，它就会出错， 同样的一个数值类型也不可能赋值给布尔类型或char 类型。
int a = 10; char c; c = a; // 报错了，不能把int 转换为char
但你会发现，当使用数值字面量进行变量初始化的时候，它也发生了自动类型转换，并且没有满足上面的两条，因为你可以int 类型的字面量赋值为char 类型或 byte 类型
byte b = 10; char c = 20;
强制类型转换，也是在满足第一个条件的情况下进行的（char 类型除外），当第二个条件不满足的时候，对类型进行强制转换， 比如把int 类型转化成 byte 类型。语法是 (目标类型) 值 ，把要转换的数据前面加上它要转换成的类型
int a = 4; byte b = (byte) a;
但是强制类型转换最大的问题是丢失数据，因为它的工作原理是舍弃高位，这里的位是二进制位。int 类型的数据在内存中占32位，如 int 4 在内存中的表示是 00000000 00000000 00000000 00000100，而byte 类型在内存中只占8个字节， 把int 类型转换成byte 类型，就要把前面24个字节全部舍弃， 00000000 00000000 00000000 00000100 变成 00000100， 如果前面24个二进制位有数据，那就舍弃了，肯定丢失数据了。
当把double 等浮点类型的数据转换为int 的时候，它会舍弃小数点，也会损失精度
double d = 10.2; int intD = (int) d; // 10 去掉了小数点0.2
所以在真正的程序中很少用到强制类型转换。
最后看一下特殊的char 类型 和数值类型的转换。
int a = 10; char c = (char) a ;
char 类型之所以和数值类型进行转换，是因为char 类型在存储的时候，要转换成数字进行存储，这涉及到了Unicode 编码了，就不细说了。
数值类型和char 类型是不可能和布尔类型进行转换的， 因为类型不同。
Java 是强类型语言，只有在两种类型兼容的情况下，才可能进行类型转换，比如整数型内部类型的变量转换， 不同类型是不可能进行类型转换的。
5，运算中的类型转换
首先要记住一点，对于java 的强类型来说，运算两端一定要数据类型相同，如果数据类型不同，是无法进行计算的。一个数值类型，是无法和一个布尔类型进行计算。但数值类型自己除外，因为它会自动类型的提升，就是把小类型转化成大类型，大小主要指的是类型的取值范围，byte 就是小类型，int 就是大类型。byte 类型 + int类型，结果就会转化为int 类型。这个法则应用到字面量默认类型时，容易引发错误
byte b = 4; b = b+3;
就会报错。计算时，先计算右边b+3; b 是一个byte类型，3是int 类型(默认类型)， 那就是byte 类型 + int类型，就把byte类型转化成int类型然后再进行计算，计算结果是int 类型的数字7，最后进行赋值运算，把int类型赋值给byte 类型，肯定报错了。这时如果必须要这么做，让计算成立，那要用到强制类型转换， 把int 型转化成byte.
byte b = (byte) b+3; 就没有问题了
除了类型之外，还要注意除法， 当一个整数去除以0的时候，它会报错，但一个浮点数去除以0 时，它确不会报错，而是返回NaN.
最后是计算越界的问题，当计算结果超出一个类型的取值范围后，它就会报错。但对于int 默认类型来说，它不会。如果计算结果超出int 的取值范围，它会把计算结果的高位舍弃掉（这里的高位是二进制的位，计算结果用二进制表示），得到的结果还是int 类型， 在int 类型的取值范围内。对于浮点类型它也不会，如果上溢，它返回负无穷或正无穷，如果下溢，则返回0.
布尔类型：它也不会进行类型转化，也就是说，只有数值类型才能进行大小判断，使用> < 等。其他的同类型只能进行相等性判断。还有在if 条件语句的时候要注意。if 中的条件表达式，一定要显示的返回的true or false. 如果习惯了js, 我们会直接写一个变量如 if (done) ，但在java 中不行， 要写 if (done == 0)
字符串String
在java 中，字符串不是基本数据类型，而是String 类的对象，当我们创建一个字符串的时候，真的是要使用new 来调用String 构造函数
String str = new String();
但是如果仅仅想创建一个字符串对象的话，完全可以使用字面量的方法，字面量还是使用双引号
String str = “abc”;
这里要注意的一点是，在Java中字符串字面量是共享的。当我们使用字面量的方式创建字符串对象的时，java在内存中会开辟一个字符串缓冲区,也可以理解为字符串常量池。当我们真正创建字符串对象时，如这里的”abc” ，它就会到字符串常量池中查找这个对象有没有存在，如果没有，它就会新建这个对象, 然后把这个对象的地址引用赋值给我们声明的变量str。这时我们再声明一个变量，
String anotherString = “abc” ;
它又会到字符串常量池中寻找“abc”，这时候发现”abc” 这个对象已经存在，那它直接把常量池中存在的对象的地址赋值给声明的变量anotherString. 这就是字符串共享。
字符串的共享也仅仅适用于字符串字面量，如果使用加号，或其它方法进行拼接形成的字符串，那就不一定在字符串常量池中了。如
String c = “Hello”;
Stirng st = c + “word”;
那st 应该在堆内存中了。
但
String str = ‘Hello’ + ‘world’;
str 确是在字符串常量值中。这是为什么呢？因为java 都是先编译，然后再运行，编译器在编译的时候会对代码进行优化。‘Hello’ + ‘ world’ 都是确定好的，不会再发生改变，编译时，str 就会拼接成‘Hello world’, 所以当程序运行时，它是一个字符串常量，要在字符串常量池中进行查找。但 c + “word” 就不一样了，因为c是一个对象引用，在编译的时候，不会进行任何优化， 所以在运行的时候，它会在堆内存中生成一个对象，虽然内容都相同，但是地址不同。这也引出了一个判断两个字符串变量相等性的问题，如果使用==进行判断，那么判断的是这两个变量所引用的对象的地址，而不是这两个字符串变量所持有的内容，
str == st; // false 地址不同
一般情况下，这不是我们想要的。大多数情况下，只想判断两个字符串持有的内空是否相同，那要使用字符串中的方法，equals(), 如果内容相同，返回true, 如果内容不同，返回false
str.equals(st); // true
在java 中，虽然字符串是作为对象存在的，但是一旦创建之后，这个字符串对象就不会再发生变化，字符串的任何操作都会生成一个新的对象。对于频繁进行字符串操作来说，要生成好多个对象，不利于性能， 所以java 就有了一个类，StringBuilder， 专门用来操作大量变化的字符串。
StringBuilder 类的操作步骤如下：
1， 首先通过StringBuilder类生成一个空的字符串对象 builder
StringBuilder builder = new StringBuilder();
2， 调用方法去操作这个空字符对象builder， 如append()方法，是向里面填加字符串，setCharAt修改某个位置上的字符等。
//调用append方法添加字符。
builder.append("hello");
// 修改某个位置上的字符
builder.setCharAt(2,'c');
// 在某个位置插入字符
builder.insert(3, "wordl");
// 删除字符
builder.delete(0, 2);
// 还有一个length方法，一共有多少个字符System.out.println(builder.length());
3， 调用toString() 方法，把SringBuilder对象转化成字符串对象
// 调用toString 方法，转化成字符串
String completeString = builder.toString();
System.out.println(completeString);
整 个代码如下，输出 cwordllo
public class FirstSimple {
public static void main(String[] args) {
StringBuilder builder = new StringBuilder();
builder.append("hello");
builder.setCharAt(2,'c');
builder.insert(3, "wordl");
builder.delete(0, 2);
String completeString = builder.toString();
System.out.println(completeString);
}
}
数组
java是强类型语言，对于数组来说，这就意味着一个数组中只能保存相同的数据类型的内容，所以数组声明时，要指定其要保存的数据类型，同时还要指定保存的最大数量，保存的最大数量一旦声明就不会再改变。那数组怎么进行声明呢？我们都知道，声明一个变量，使用的是数据类型加变量名，如 int num, 就声明了一个int 类型的num变量，但它只能保存一个数据。如果在int 类型的后面加一个[] 呢，就表示可以存多个数据了，就是数组了。
int[] numbers = new int[10];
int[] 就是一个类型，声明数组的专用类型，想要声明其它类型的数组，就把前面的类型改为其它类型就好了，String[] str = new String[10], 保存字符串的数组。数组的使用，基本都是一样的，都是基于索引
numbers[0] = 10; // 赋值
当然声明数组变量的时候，还可以初始化。它这里用的是{} 进行的初始化
int[] numbers = {2,5};
这里还要注意java数组元素的默认值，在java中，只要声明了数组，数组中元素都会有默认值。对于数值型数组，它的默认值是0；对于Boolean型数组，它的默认值是false. 对于对象型数组，它的默认值是null， 这里指的是数组中的每个元素的默认值。在 java中字符串是对象，所以一个字符串对象数组，它里面中的所有元素的默认值为null。