数据类型

Java语言是静态类型的（statical typed)，也就是说所有变量和表达式的类型再编译时就已经完全确定。由于是statical typed，导致Java语言也是强类型（Strong typed）的。强类型意味着每个变量都具有一种类型，每个表达式具有一种类型，并且每种类型都是严格定义的，类型限制了变量可以hold哪些值，表达式最终产生什么值。

在java源代码中，每个变量都必须声明一种类型，有两种类型：基本类型和引用类型。其中基本类型直接包含值，而引用类型引用对象。

1 基本类型

Java为基本类型提供语言级别的支持，即已经在Java中预定义，用相应的保留关键字表示。基本类型是单个值，而不是复杂的对象，基本类型不是面向对象的，主要出去效率方面的考虑，但是同时也提供基本类型的对象版本，即基本类型的包装器。可以直接使用这些基本类型，也可以使用基本类型构造数组或者其他自定义类型。基本类型具有明确的取值范围和数学行为。

1.1 整型

整型有byte short int long char，分别用1、2、4、8，2字节表示。有些地方可能不会把char列入整型范畴，但本质上char类型是int的一个子集。整型的宽度不应该被看成整数所占用的内存空间大小，而应当理解成定义为整型的变量或者表达式的行为。JVM可以自由使用它们希望的、任何大小的内存空间，只要类型的行为符合规范。

1.1.1 byte

byte由1个字节8位表示，是最小的整数类型。主要用于节省内存空间关键。当操作来自网络、文件或者其他IO的数据流时，byte类型特别有用。

1.1.2 short

用16为表示，取值范围为：[- 2^15, 2^15 - 1]。short可能是最不常用的类型了。

1.1.3 int

32 bits, [- 2^31, 2^31 - 1].有符号的二进制补码表示的整数。常用于控制循环，注意byte 和 short在运算中会被提升为int类型或更高。Java 8以后，可以使用int类型表示无符号32位整数[ 0, 2^31 - 1]。

1.1.4 long

64 bits， [- 2^63, 2^63 - 1,默认值为0L].当需要计算非常大的数时，如果int不足以容纳大小，可以使用long类型。如果long也不够，可以使用BigInteger类。

1.1.5 char

16 bits, [0, 65535], [0, 2^16 -1],从’\u0000’到’\uffff’。无符号，默认值为’\u0000’。Java使用Unicode字符集表示字符，Unicode是完全国际化的字符集，可以表示全部人类语言中的字符。Unicode需要16位宽，所以Java中的char类型也使用16 bit表示。 赋值可能是这样的：

char ch1 = 88;
char ch2 = 'A';

ASCII字符集占用了Unicode的前127个值。之所以把char归入整型，是因为Java为char提供算术运算支持，例如可以ch2++;之后ch2就变成Y。当char进行加减乘除运算的时候，也被转换成int类型，必须显式转化回来。

1.2 浮点类型

包含单精度的float和双精度的double，分别用32、64bits表示，遵循IEEE 754规范。

1.2.1 float

使用32 bit表示，对应单精度浮点数，运行速度相比double更快，占内存更小，但是当数值非常大或者非常小的时候会变得不精确。精度要求不高的时候可以使用float类型。
可以将byte、short、int、long、char赋给float类型，java自动完成转换。

1.2.2 double

64为表示，将浮点子面子赋给某个变量时，如果不显示在字面值后面加f或者F，则默认为double类型。java.lang.Math中的函数都采用double类型。建议默认使用double类型。
如果double和float都无法达到想要的精度，可以使用BigDecimal类。

1.3 boolean类型

boolean类型只有两个值true和false，默认为false。boolean与是否为0没有任何关系，但是可以根据想要的逻辑进行转换。许多地方都需要用到boolean类型。

2 字面值

在Java源代码中，字面值用于表示固定的值。数值型的字面值是最常见的，字符串字面值可以算是一种，当然也可以把特殊的null当做字面值。字面值大体上可以分为整型字面值、浮点字面值、字符和字符串字面值、特殊字面值。

2.1 整型字面值

从形式上看是整数的字面值归类为整型字面值。

2.2 浮点字面值

浮点字面值简单的理解可以理解为小数。分为float字面值和double字面值，如果在小数后面加上F或者f，则表示这是个float字面值，如11.8F。如果小数后面不加F（f），如10.4。或者小数后面加上D（d），则表示这是个double字面值。

2.3 字符及字符串字面值

Java中字符字面值用单引号括起来，如‘@’‘1’。字符串字面值则使用双引号，字符串字面值中同样可以包含字符字面值中的转义字符序列。字符串必须位于同一行或者使用+运算符，因为java没有续行转义序列。

2.4 特殊字面值

null是一种特殊的类型，可以将它赋给任何引用类型变量，表示这个变量不引用任何东西。

3 引用类型

3.1 什么是引用类型

引用类型（reference type）指向一个对象，不是原始值，指向对象的变量是引用变量。在java里面除去基本数据类型的其它类型都是引用数据类型，自己定义的class类都是引用类型，可以像基本类型一样使用。

3.2 引用类型的赋值

在java编程语言中，用类的一个类型声明的变量被指定为引用类型，这是因为它正在引用一个非原始类型，这对赋值具有重要的意义。如下代码：

int x = 7;
int y = x;
String s = "Hello";
String t = s;

四个变量被创建：两个原始类型 int 和两个引用类型String。x的值是7，而这个值被复制到y；x和y是两个独立的变量且其中任何一个的进一步的变化都不对另外一个构成影响。至于变量s和t，只有一个String对象存在，它包含了文本”Hello”，s和t均引用这个单一个对象。

如果将变量t重新定义为t=”World”；则新的对象World被创建，而t引用这个对象。

3.3 按值传递和按引用传递的区别

1) 按值传递

指的是在方法调用时，传递的参数是按值的拷贝传递。示例如下：

public class test7 {
private void test(int a) {
//做点事情
a++;
    }

public static void main(String[] args) {
        test7 t = new test7();
int a = 3;
        t.test(a);//这里传递的参数a就是按值传递。
System.out.println("main方法中的a===" + a);
    }
}

按值传递的重要特点：传递的是值的拷贝，也就是说传递后就互不相关了。第9行的a和第2行的a是两个变量，当改变第2行的a的值，第9行a的值是不变的，所以打印结果是3。

main 方法中的a 为 3
test1 方法中的a 为 4

我们把第9行的a称之为实参，第2行的a称之为形参；对于基本数据类型，形参数据的改变，不影响实参的数据。

2)按引用传递

指的是在方法调用时，传递的参数是按引用进行传递，其实传递的是引用的地址，也就是变量所对应的内存空间的地址。
示例如下：

public class TempTest {
private void test(A a) {
        a.age = 20;
        System.out.println("test方法中的age = " + a.age);
    }

public static void main(String[] args) {
        TempTest t = new TempTest();
        A a = new A();
        a.age = 10;
        t.test(a); //这里传递的参数a就是按引用传递
System.out.println("main方法中的age = " + a.age);
    }
}

class A {
public int age = 0;
}

运行结果如下：test1方法中的age = 20 main方法中的age = 20
按引用传递的重要特点：
传递的是值的引用，也就是说传递前和传递后都指向同一个引用（也就是同一个内存空间）。
要想正确理解按引用传递的过程，就必须学会理解内存分配的过程，内存分配示意图可以辅助我们去理解这个过程。

用上面的例子来进行分析：

（1）、运行开始，运行第8行，创建了一个A的实例，内存分配示意图如下：

main方法中的a

（2）、运行第9行，修改了A实例里面的age的值，内存分配示意图如下：

main方法中的a

（3）、运行第10行，是把main方法中的变量a所引用的内存空间地址，按引用传递给test1方法中的a变量。请注意：这两个a变量是完全不同的，不要被名称相同所蒙蔽，但它们指向了同一个A实例。内存分配示意图如下：

（4）、运行第3行，为test1方法中的变量a指向A实例的age进行赋值，完成后形成新的内存示意图如下：

此时A实例的age值的变化是由test1方法引起的。

（5）、运行第4行，根据此时的内存示意图，输出test1方法中的age=20

（6）、运行第11行，根据此时的内存示意图，输出main方法中的age=20

说明：
（1）、“在Java里面参数传递都是按值传递”这句话的意思是：按值传递是传递的值的拷贝，按引用传递其实传递的是引用的地址值，所以统称按值传递。
（2）、在Java里面只有基本类型和按照下面这种定义方式的String是按值传递，其它的都是按引用传递。就是直接使用双引号定义的字符串方式：String str = “Java快车”;

运算符

1、算术运算符

算术运算符也就是我们小学所学过的：+ - * /；还有取模运算符：%；取模运算符也就是求余的运算；
运算形式：操作数 + 操作数；操作数 - 操作数；操作数 * 操作数；操作数 / 操作数；操作数% 操作数；

2、递增和递减运算符

递增运算符是++，递减运算符是–；
也就是相当于递增就加1，递减就减1的运算；
运算形式：（递增）变量++；++变量； （递减）变量–；–变量；
怎么理解呢？
也就是递增或递减即可放在变量的前面，也可以放在变量的后面；运算符在前面的（++、–），就先运算前面的（++、–），在后面的就后运算（++、–）；

3、关系运算符

运算形式：左操作数 关系运算符 右操作数；
在关系运算符中，最终得到的一定是布尔类型中的真（true）或者假（flase），不会 有第三种值；关系运算符包括：
== 等于：如果两个值相等，则返回真值
！= 不等于：如果两个值不想等，则返回真值
<小于：如果左操作数的值小于右操作数的值，则返回真值
> 大于：如果左操作数的值大于右操作数的值，则返回真值
<= 小于等于：如果左操作数的值小于或等于右操作数的值，则返回真值
>= 大于等于：如果左操作数的值大于或等于右操作数的值，则返回真值
在计算机编程中，关系运算符是比较重要的一部分；它是根据某个变量的值来执行特定的操作；

4、位运算符

运算符 包括& 与，| 或，^ 异或，~ 非（把0变成1，把1变成0）。在java中，位运算很少，大家只有知道就行了，到用了的时候，参照一下真值表就行了；

5、逻辑运算符

在逻辑运算符中，最后得到的值也是一个布尔类型的teue（真）或flase（假）；运算符 描述：&& 与，|| 或，！ 非。

6、位移运算符

首先我们先阐述一下符号位的概念，符号位：是数的最后一位，不用来计算的，当符号位为0时，值为正数；当符号位为1时，值为负数；无符号位时为正数，有符号位时为正数或者负数。运算符包括：
<<左移
>> 右移
>>> 右移（补零）
左移（<<） 运算形式：值 <<位数
右移（>>） 运算形式：值 >> 位数
移动后，左移、右移都会保留符号位！
右移（补零），移动后，不保留符号位，永远为正数，因为其符号位总是被补零。

顺序结构

程序至上而下逐行执行，一条语句执行完之后继续执行下一条语句，一直到程序的末尾

选择结构

选择结构是根据条件的成立与否，再决定要执行哪些语句的一种结构

1、IF语句–单分支结构

if (判断条件){
语句1 ；
…
语句2 ；
}

示例一、 比较2个整型变量的大小

public class test {
public static void main(String[] args) {
int x = 3;
int y = 10; //定义两个整数变量x， y
System.out.println("==========开始比较=========");
if(x > y)
            System.out.println("x比y大！");
if(x             System.out.println("x比y小");
if(x == y)
            System.out.println("x等于y");
        System.out.println("==========比较完成==========");
    }
}

2、if…else语句–双分支结构

if (判断条件){
语句主体1 ；
}else{
语句主体2；
}

示例二、判断一个数字是奇数还是偶数

public class test2 {
public static void main(String[] args) {
int x = 3; //定义变量x
if(x % 2 == 0)//如果余数为0则是偶数
System.out.println("x是偶数");
else
System.out.println("x是奇数");
    }
}

3、三目运算符

使用三目运算符时，操作数有3个，其格式如下：变量 = 条件判断？表达式1：表达式2
根据条件的成立与否，来决定结果为“：”前或“：”后的表达式，如果条件判断为true，则执行表达式1，为false则执行表达式2
示例三、求出2个数字中的最大值

public class test3 {
public static void main(String[] args) {
int max; //定义变量来保存最大值
int x = 3, y = 10; //定义两个变量
max = x > y ? x : y;
        System.out.println("max为： " + max);
    }
}

4、if…else if…else语句 –多分支结构

如果需要在if..else里判断多个条件时，就需要if..else if … else语句了，其格式如下：
if (条件判断1){
语句主体1 ；
}else if (条件判断2){
语句主体 2 ；
}
… // 多个else if()语句
else{
语句主体3 ；
}
示例四、

public class test4 {
public static void main(String[] args) {
int x = 3;
if(x == 1)
            System.out.println("x的值是1！");
else if(x == 2)
            System.out.println("x的值是2！");
else if(x == 3)
            System.out.println("x的值是3！");
else
System.out.println("x的值不是1， 2， 3中的一个");
    }
}

5、Switch结构

要在许多的选择条件中找到并执行其中一个符合判断条件的语句时，除了可以使用if..else不断地判断之外，也可以使用另一种更方便的方式即多重选择——switch语句，语法格式：
switch (表达式){
case 选择值1 ： 语句主体 1 ； break ；
case 选择值2 ： 语句主体 2 ； break ；
…….
case 选择值n ： 语句主体 n ； break ；
default： 语句主体 ；
}
执行流程：

示例五、判断学生成绩，并给于评分，90~100分，A级大于80分，B级，大于70分，输出C级，大于60分，D级，低于60分输出E级

public class test5 {
    public static void main(String[] args) {
        int score = 75; //声明学生分数
        switch (score / 10) {
            case 10:
            case 9:
                System.out.println("A级");
                break;
            case 8:
                System.out.println("B级");
                break;
            case 7:
                System.out.println("C级");
                break;
            case 6:
                System.out.println("D级");
                break;
            default:
                System.out.println("E级");
        }
    }
}

结果:C级
还是上面的如果不加break;

public class test6 {
    public static void main(String[] args) {
        int score = 75; //声明学生分数
        switch (score / 10) {
            case 10:
            case 9:
                System.out.println("A级");
            case 8:
                System.out.println("B级");
            case 7:
                System.out.println("C级");
            case 6:
                System.out.println("D级");
            default:
                System.out.println("E级");
        }
    }
}

结果：C级,D级,E级

循环结构

一个完整的循环结构具有以下四个部分
1）初始部分，设置循环的初始状态
2）循环体，即重复执行的代码
3）迭代部分，下一次循环开始前执行的部分
4）循环条件，即判断是否继续循环的条件

1、while循环

语法：
while(循环条件) {
循环操作
}
例：

public class Test{
    public static void main(String [] args){
        int i = 0;
        while(i <= 10){
            System.out.println("i的值="+i);
            i++;//每循环一次i的值累加自增1
        }
    }
}

循环条件是一个布尔表达式，while循环特点是：先判断条件再执行循环操作。只要满足循环条件就执行循环操作，例中i的值初始为0，满足i<=10条件，执行循环操作，循环一次i的值会加1（i++）,用以跳出循环防止死循环的发生。

2、do-while循环

语法：
do{
循环操作
}while(循环条件);
例：

public class Test{
    public static void main(String [] args){
        int i = 1;
        do{
            System.out.println("i的值="+i);
            i++;
        }while(i <= 10);
    }
}

相对while循环，do-while是先执行循环操作，再判断条件是否满足，也就是说dou-while循环至少执行一次循环操作。

3、for循环

语法：
for(表达式1;表达式2;表达式3){
循环操作
}
表达式1：赋值语句，为循环变量赋初始值
表达式2：条件语句，循环结构的循环条件
表达式3：赋值语句，循环结构的迭代部分，通常用来修改循环变量的值以退出循环操作
与while循环只要区别在于其变量的作用域不同，fo循环中定义的变量只能在fo循环内使用（如下边定义变量i）
例：

public class Test{
    public static void main(String [] args){
        for(int i = 1;i <= 10; i++){
            System.out.println("i的值="+i);
        }
    }
}

public class Test{
    public static void main(String [] args){
        //利用for循环获取1~1000之间是8的倍数的数字有多少个
        int count = 0;//定义count变量用以保存数量
        for(int x = 1;x<=1000;x++){
            //判断是否是8的倍数
            if(x % 8 ==0){
                count++;
            }
        }
        System.out.print("count="+count);
    }
}

4、二重循环

即一个循环体内包含另一个完整的循环结构
例：

public class Test{
    public static void main(String [] args){
        for(int i = 0;i <2;i++){
            for(int x = 0;x <3;x++){
                System.out.print("*");//循环3次打印*
            }
            System.out.println();
        }
    }
}

public class Test{
    public static void main(String [] args){
        // 利用多重循环打印出如下图
        // *****
        // ****
        // ***
        // **
        // *
        // 外循环控制打印行数，内循环控制打印的数量
        for(int i = 1;i <= 5;i++){
            for(int a = i;a <= 5;a++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

5、循环操作的控制：跳转语句

break、continue、return

break：用于跳出当前的循环操作，使程序跳到循环块外的下一条语句，而break后面的语句将不再执行
例：

public class Test{
    public static void main(String [] args){
        for(int i = 0;i <= 10;i++){
            System.out.println(i);
            if(i == 5){
                System.out.print("i的值等于5了，循环停止并跳出循环结构");
                break;
            }
        }
    }
}

当i的值增加到5时，则执行break语句，跳出循环结构不再执行
continue：可以跳过此次循环操作，直接进行下一次循环操作
例：

public class Test{
    public static void main(String [] args){
        for(int i = 0;i <10;i++){
            if(i == 5){
                System.out.println("i的值等于5了，跳过此次循环操作");
                continue;
            }
            System.out.println(i);
        }
    }
}

当i的值等于5，则执行continue语句跳过此次循环，即跳过输出值5

java注意事项

编写Java程序时，应注意以下几点：
1、大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。
2、类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
3、方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
4、源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。
5、主方法入口：所有的Java 程序由public static void main(String args[])方法开始执行。