一、数据类型

在java中 的数据类型主要有两种数据类型
①基本数据类型
②引用数据类型

java中的八种基本数据类型：

1.整数的数据类型：

注意： 如果一个整数没有加上任何的标识的时候，那么默认是int类型的数据。
如果需要把该数据表示成一个long类型的数据，那么需要加数据后面加上L表示，L是不区分大小写的，但是建议使用大写。

选用数据类型的原则： 在能满足需求的情况下，能小就小。节省内存空间。

2.小数的数据类型：
float(单精度浮点型) 32bit
double(双精度浮点型) 64bit

注意： 如果一个小数没有加上任何标识的时候，那么该小数默认是double类型的数据，如果需要表示成float类型，那么需要在小数的后面加上f表示。f不区分大小写的。

3.布尔类型： 布尔类型只有两个 值，true或者false。
boolean 1字节或者4个字节

注意：如果使用boolean声明一个基本类型的变量时，那么该变量占4个字节，
如果使用boolean声明一个数组类型 的时候，那么每个数组的元素占一个字节。

4.字符类型：
char 2字节（16bit）

八种基本数据类型：
整数：byte short int long
小数： float double
布尔： boolean
字符： char

字符串的数据类型是：String 引用数据类型,不属于基本数据类型。

二、数据类型转换

数据类型转换要注意的细节：

1. 凡是byte、short 、 char数据类型数据在运算的时候都会自动转换成int类型的数据再运算。
2. 两个不同数据类型的数据在运算的时候，结果取决于大的数据类型。

class Demo
{
    public static void main(String[] args) 
    {
        int i = 10;  
        byte b = i;  // 一个整数没有加上任何标识的时候，默认是int类型的数据。
        //10 是一个常量， 编译器在编译的时候就能够确认常量的值了，byte b = 10,在编译到的时候
        //java编译器就会检查到10并没有超出byte的表示范围，所以允许赋值。
        //java编译器在编译 的时候并不能确认变量所存储的值，变量存储的值是在运行的时候才在内存中分配空间 的。
        System.out.println(b);

    }
}

三、 运算符

1.算术运算符:

+ (正数、加法、连接符)
连接符的作用： 让任何的数据都可以与字符串进行拼接。
如果+号用于字符串的时候，那么+号就是一个连接符，不是做加法功能了。

连接符要注意：任何类型的数据与字符串使用连接符连接，那么结果都是字符串类型的数据。
–
*
/ (除法)
%(取模、取余数)

注意：做取模运算的时，结果的正负号是取决于被除数。

class Demo {

    public static void main(String[] args){
    /*  
        int i1 = 1; // 
        int i2 = 2;
        //System.out.println(i1 +" world");  // "hello wolrd" ，    1 world
        
        // 计算机每次运算的时候只能取两个 数据运算。
        System.out.println(1+2+3 +" world"+1+2+3); // 123world123   33world15

        1+2+3 +" world"+1+2+3
        3+3 +" world"+1+2+3 
        6+" world"+1+2+3
        "6world"+1+2+3
        

        double a= 12.0;
        int b = 3;
        System.out.println(a/b); //3  4.0

        在java中做取模 运算的时，结果的正负号是取决于被除数。
    */  
        System.out.println("结果:"+(10%3));  // 1
        System.out.println("结果:"+(10%-3)); // 1 
        System.out.println("结果:"+(-10%3)); // -1
        System.out.println("结果:"+(-10%-3)); //-1  
    }
}

自增和自减操作：
++ （自增） : 自增就是相当于操作数+1.
前自增：++位于操作数的前面。 比如： ++a；
前自增：先自增，后使用。
后自增： 先使用，后自增。

class Demo
{
    public static void main(String[] args) 
    {
    /*
    int a = 0;
    //int sum = ++a; //前自增。 a = a+1  ， sum = a
    int sum = a++; //后自增  sum = 0 , a = a+1
    System.out.println("sum= "+ sum+ " a = "+ a); //1 


    后自增在jvm的运行原理：
    
    因为后自增要使用 到没有+1之前 的值，那么jvm会先声明一个变量用于保存没有+1之前的值。
    
    
    int i = 0;
    i = temp;

    原理：
        1. int temp = i; // 声明了一个临时变量用于记录了i没有加1之前的值。
        2. 自增。  i = i+1;   i = 1;
        3. temp把用作了表达式 的结果。
    
    i的值发生了3次变化：
            i = 0 -----> 1----> 0
    */
        int i = 0;
        i = i++; // 后自增...  后自增要使用到没有+1之前的值。
        System.out.println("sum ="+ sum+ "i= "+i);//0
    }
}

2.赋值运算符：

• = (赋值运算符)
• +=
• -=
• *=
• /=
• %=

class Demo
{
    public static void main(String[] args) 
    {
        
        int i = 10; // 把10赋予给i变量。
        i+=2;  // i = i+2; 
        System.out.println("i = "+i);
    
    
        byte b1 = 1;
        byte b2 = 2;
        //b2 = (byte)(b2+b1); //报错。， 需要强制类型转换
        b2+=b1;  //b2 = b2+ b1;  b2+=b1 在编译的时候，java编译器会进行强制类型转换，不需要我们手动转换了。
        System.out.println("b2 : "+ b2);
    }
}

3.比较运算符：

比较运算符的结果都是返回一个布尔值的。

== (判断是否等于)
==用于比较两个基本数据类型数据的时候，比较的是两个变量所存储的值是否一致.
==用于比较两个引用类型变量的数据时候，比较的是两个 引用类型变量所记录的内存地址是否一致.

1. (不等于) !=
2. (大于)>
3. (小于)<
4. (大于等于)>=
5. (小于等于)<=

class Demo
{
    public static void main(String[] args) 
    {
        /*
        int a = 10;
        int b =10;
        System.out.println("10等于10吗？"+ (a==b));  
        System.out.println("10不等于1吗？"+ (10!=1) ); //true  
        */
        
        byte b  = 10;
        long l = 30;
        System.out.println(l>b); //两个不同类型的数据也可以进行比较，但是两个不同类型的数据必须是兼用的数据。
        //这个比较的过程会先把b转换了long类型的数据，然后再进行比较 。
        System.out.println('a'>50);//true 先把a变成97再比较
    }
}

4.逻辑运算符 ：

逻辑运算符的作用是用于连接布尔表达式的。

& （与,并且）
规律： 只有左右变量同时 为true，那么结果才是true，否则就为false。

| (或,或者)
规律： 只要两边的布尔表达式有一边为true，那么结果就为true，只有两边同时为false 的时候，结果才是false.

^ (异或)
规律： 只要两边的布尔表达式 结果不一致，那么结果就为true，如果左右两边 的布尔表达式一致，那么就为false.

！ (非)

&& (短路与\双与)
短路与和单与符号的相同与不同点：

• 相同点： 短路与和单与运算 的结果是一样的。
• 不同点： 使用短路与的时候，如果左边的布尔表达式为false，则不会在运算右边的布尔表达式，从而提高了效率。使用单与的时候，即使发现左边的布尔表达式为false，还是会运算右边的布尔表达式的。

注意：只有左边的布尔表达式为false时，双与的效率才要高于单与的.

|| (短路或\双或)
短路或与单或的相同点与不同点：

• 相同点：运算的结果是一致的。
• 不同点：使用短路或的时候，当发现左边的布尔表达式为true时，则不会运算右边的布尔表达式。使用单或的时候发现左边的布尔表达式为true，还是会运算右边布尔表达式。

4.位运算符：

位运算符就是直接操作二进制位的。

& (与)
| (或)
^ (异或)
规律： 如果操作数A连续异或同一个操作数两次，那么结果还是操作数A。
应用： 对数据加密.
~ (取反)

class Demo{
    public static void main(String[] args){
        System.out.println(6&3); // 2 
        System.out.println(6|3); // 7
        System.out.println(6^3); //  5
        System.out.println(~7);  // -8
    }
}

位运算符可能会出现的笔试题目：

1. 交换两个变量的值,不准出现第三方变量。
2. 取出一个二进制数据的指定位数。要求读取该二进制数据的低4位
   00000000-00000000-00010100-01001101
   & 00000000-00000000-00000000-00001111
   ——————————————
   00000000-00000000-00000000-00001101

class Demo{

    public static void main(String[] args) 
    {
        int a = 3;
        int b = 5;
        
        /*
        方式1： 定义第三方变量。
        int temp = a;  //3 
        a = b; //a = 5 
        b = temp; 
        
        方式2：相加法， 缺点： 两个int类型的数据相加，有可能会出现超出int的表示范围。
        
        a = a+b;  // a =8
        b = a-b; //b = 8 - 5 = 3
        a = a-b; // a = 8 - 3 = 5
        
        方式3： 可以使用异或。 缺点： 逻辑不清晰。
        */
        a = a^b;  // a = 3^5
        b = a^b;  // b = (3^5)^5 = 3
        a = a^b; //  a = (5^3)^3 = 5 
        System.out.println("a = "+ a+" b="+b);
    }
}

加密demo：

/*
使用异或对图片数据进行加密.

*/
import java.io.*;
class ImageTest 
{
    public static void main(String[] args)  throws Exception
    {
        //找到图片文件
        File inFile = new File("e:\\加密的图片.jpg");
        File outFile = new File("e:\\解密的图片.jpg");

        //建立数据通道，让图片的二进制数据流入
        FileInputStream input = new FileInputStream(inFile);
        FileOutputStream output = new FileOutputStream(outFile);
        //边读，把读到的数据异或一个数据，把把数据写出

        int content = 0; //该变量是用于存储读取到的数据
        while((content = input.read())!=-1){  // 如果没有到文件的末尾，那么继续读取数据，读取到的数据已经存储到content变量中了。
            output.write(content^12);
        }
        //关闭资源
        output.close();
        input.close();
    }
}

5.移位运算符

<<(左移)
规律：一个操作数进行左移运算的时候，结果就是等于操作数乘以2的n次方，n就是左移 的位数.

3<<1 = 3 *2(1) = 6;
3<<2 = 3*2(2) = 12
3<<3 = 3*2(3) = 24

>>(右移)
规律：一个操作数在做右移运算的时候，实际上就是等于该操作数除以2的n次方，n就是右移的位数。

3>>1 = 3 / 2(1) = 1
3>>2 = 3 / 2(2) = 0 

注意：在使用普通方法时，操作数左移，空缺位都是用0补；
如果是右移，操作数是正数，左边空缺位使用0补，如果操作数是负数，则使用1补。

>>>(无符号右移) ：
无符号右移与右移的区别：
进行右移运算的时候，如果操作数是一个正数，那么左边的空缺位使用0补，如果操作数是一个负数，那么左边的空缺位使用1补。
而使用无符号右移的时候，不管是正数还是负数都统一使用0补。

笔试题目：使用最高的效率算出2乘以8的结果。
2<<3 = 2*2(3) = 16;

6.三目运算符(三元运算符)

格式：

布尔表达式？值1:值2  ;

三目运算符要注意的细节：
使用三元运算符的时候，一定要使用该表达式返回的结果，或者是定义一个变量接收该表达式返回的结果。

四、流程控制语句

1.switch语句

switch语句的格式：

    switch(你的选择){
        
        case 值1：
            符合值1执行的代码
            break;
        case 值2：
            符合值 2执行的代码
            break;
        case 值3：
            符合值 3执行的代码
            break;
        case 值4：
            符合值 4执行的代码
            break;
        ......

        default: 
            你的选择都符合上述的选项时执行的代码;
            break;
    }

switch语句要注意的事项：

1. switch语句使用的变量只能是byte、 char、 short、int、 String数据类型，String数据类型是从jdk7.0的时候开始支持的。
2. case后面跟的数据必须是一个常量。
3. switch的停止条件：
   switch语句一旦匹配上了其中的一个case语句，那么就会执行对应的case中的语句代码，执行完毕之后如果没有遇到break关键字或者是结束switch语句的大括号，那么switch语句不会再判断，按照代码的顺序从上往下执行所有的代码。直到遇到break或者是结束siwitch语句的大括号为止。
4. 在switch语句中不管代码的顺序如何，永远都是会先判断case语句，然后没有符合的情况下才会执行default语句。

break关键字
break适用范围：只能用于switch或者是循环语句中。

break作用：

1. break用于switch语句的作用是结束一个switch语句。
2. break用于循环语句中的作用是结束当前所在的循环语句。

笔试题目：break目前位于内层的for循环，如何才能让break作用于外层 的for循环。可以标记解决
标记的命名只要符合标识符的命名规则即可。

class Demo 
{
    public static void main(String[] args) 
    {
        outer:for(int j = 0 ; j<3 ; j++){ // j=0 外层for循环
            inner:for(int i = 0 ; i< 2 ; i++){  // i=0 内层for循环
                System.out.println("hello world"); // 只打印一次
                break outer;
            }
            
        }
    }
}

continue关键字
continue的适用范围： continue只能用于循环语句。
continue的作用：continue的作用是跳过本次的循环体内容。继续下一次。

continue要注意的事项：

1. 在一种情况下，continue后面不能跟有其他语句，因为是永远都无法执行到。
2. continue 也可以配合标记使用的。

五、转义字符：

特殊字符使用”\”把其转化成字符的本身输出，那么使用”\”的字符称作为转移字符。

常见的转义字符有：

\b  Backspace （退格键）
\t  Tab    制表符(制表符的作用就是为了让一列对齐)  一个tab一般等于四个空格。

\n  换行
\r  回车  把光标移动到一行的首位置上。

注意： 如果是在windows系统上操作文件的时候需要换行，是需要\r\n一起使用的。
如果是在其他的操作系统上需要换行，仅需要\n即可。

六、函数

函数的重载：
在一个类中出现两个或者两个以上的同名函数，这个称作为函数的重载。

函数重载的作用：
同一个函数名可以出现了不同的函数，以应对不同个数或者不同数据类型的参数。

函数重载的要求：

1. 函数名一致。
2. 形参列表不一致。（形式参数的个数或者是对应的数据类型不一致）
3. 与函数的返回值类型是无关的。

七、数组

数组的特点：
1. 数组只能存储同一种 数据类型的数据。
2. 数组是会给存储到数组中 的元素分配一个索引值的，索引值从0开始，最大的索引值是length-1；
3. 数组一旦初始化，长度固定。
4. 数组中的元素与元素之间的内存地址是连续的。