java语言的基础

2Java语言的基础组成：

2.1关键字

   特征：一般是被赋予java含义的英文字母，一般是小写。

 

2.2标示符

   标识某些东西的符号：一般有26个字母，,数字（0~9）下划线 $美元符号。一般是指自定义的名称。

     注意：

         标识符不能是数字开头。

         标示符不能是关键字。

         在为标示符起名字的时候一般应该起得要有意义。

 

2.3注释

   分为单行注释，多行注释，文档注释；

注意点：

      单行注释中够可以包含单行注释和多行注释。

      多行注释中不能包含多行注释,能够包含单行注释。

      注释的内容是不能够读取进class文件中的。

注释的作用：易于阅读了解程序的意思。也能够进行调试作用。

在开发中和面试中注释有作用。

 

这个时候：代码只是思想的一种体现。以后写程序是时应该先写思想：

   需求：

   思路：

   步骤：

   最后用代码实现

 

2.4常量和变量

   常量表示不能改变的值。

   JAVA中常量的分类:

     1:整数常量，所有整数

     2：小数常量。所有小数

     3：布尔常量：只有两个值true false

     4：字符常量：将一个数字或者字母用单引号进行包含。

     5：字符串常量：将一个或者多个字符用双引号进行包含

     6：null常量：只有一个数值就是null

 

   对于整数有四种表现形式:

     二进制：0,1满2进一

     八进制：0~7,满八进一,用0开头表示

     十进制：0~9:满10进一

     十六进制：0~9A~F,满16进一，用0x开头表示。

 

  计算机中最小的数据单位是字节：byte =8 bit 位

 

  进制之间的转换：

十进制--二进制：

   十进制转换成二进制：除以2取余数

   二进制转换成十进制：乘以2的幂次最后累加。

二进制--八进制

二进制--十六进制

负数的二进制的表现形式：

   对应正数的二进制数取反再加1

   变量：
       概念：

           内存中的一个存储区域 

           该区域有自己的名称（变量名）和类型（数据类型）

           该区域的数据可以在同一类型的范围内不断变化。

       为什么要定义变量：

           因为要标识不断变化的数据常量，并且可以重复使用。

       使用变量请注意：

           变量的作用范围

           初始化值

       变量的定义格式：

           数据类型 变量名=初始化值；

           注意：格式是固定的。

        理解：变量就如同数学中的未知数。

    

      数据类型：

         基本数据类型：

             数值型：

                    整数类型：

                        Byte: 一个字节  -2^7-1~2^7-1

                        Short: 两个字节  -2^15-1~2^15-1

                        Int :   四个字节  -2^31-1~2^31-1

                        Double 八个字节  -2^63-1~2^63-1

                    浮点类型

                        Float：四个字节

                        Double 8个字节

             字符类型：

                     2个字节 能表示一个汉字

            

             布尔型： 

                     True false

          

             引用数据类型：

                类（class）

                接口（interface）

                数组（[]）

 

      注意：

（1）整数默认Int  小数默认：double：在定义变量时候注意数值的默认类型

            Long l=1231232132133; 出现错误此时的整数默认为int类型，要想扩 大范围在整数后面加上Long l=1231232132133l;进行标识此整数类型为长整 型。

            Float f=2.3; 会出现错误：此时浮点数默认是双精度类型与类型float类型 的范围不够。如果2.3后面加上f ,就可以了。

     

            （2）变量的作用域问题。

主要用{}进行限定变量的作用域问题。如果在作用 域之外进行访问该变量就会出现问题。

 

            （3）自动类型转换问题：

                例子：

                Byte a=3;

                Int b=7;

                B=a+b;

               这个例子是正确的。涉及到自动类型转换问题。本质上是内存中数据存储 区域的长度变化。大的能够容纳小的。而小的不能容纳大的。如果实在小的要 容纳大的，必须进行强转。

               注意：等式两边的数据类型不一致，会出现编译错误。所以等式两边必须     类型要一致。除外：如果等式两边数据类型是数值类型，及隐式转换没有出现 问题，就不会出现问题。如果出现精度的变小。就是小的要容纳大的，必须要              进行强制转换。

      例子：

                Byte a=2;

                Int b=5;

                a=(byte)(a+b);//此时必须进行强制转换。

             例子：

                 Float c=3.5;  //此时会出现精度的损失编译的错误

             纠正： 

                 Float c=3.5f;

 

               例子：整型和char类型进行隐性互转

                    System.out.println(‘a’+1);

               进行解释：

                    首先一个字符两个字节，int 类型有四个字节。首先计算机将一个字    符的两个字节进行扩容到4个字节。进行运算。同时还有一点。ASCII的    编码表，将一些美国的基本语言进行用计算机进行编码。底层的计算机还    是用数字进行标识美国的字符。

             

            注意：在java中内置了涵盖了全世界的文字的编码表叫做：ASCII码表。

                

           面试题： 

             byte b1=3;

                //首先进行解释 b1=3;底层会将int 类型的3进行判断有没有超过byte类 型的最大值.

//如果没有超过，就将3的整数的比特位的前四位进行删除。将后四位赋 给b1;

          byte b2=5+6;  

          byte b3=b1+b2;

                //而b1+b2;两个标识符都是变量，不好进行确实判断。

//如果两个变量相加超过byte类型的最大值。

//有这个可能，所以编译发生一些错误可能损失精度。

 

                //下面的例子，就不一样了

             int a=5;

             int b=10;

             int c=a+b;

//这样不会报错，整型是默认的类型，如果两个变量相加超过Int最大值。

//那么可能出现33位，那么第33位舍弃。发现最高位是1为负数。

 

2.5运算符

2.5.1运算符的分类：

    1：算术运算符

           +  -  *  /  %（模运算） +（连接符）

           注意：

（1）java语言是强类型语言类型必须为一致，及时结果不是一致性，也可以行转换；

            例子：

            Int a=6350/1000*1000; 结果是6000,因为6350/1000的结果是6而不 是6.35。

                （2）：+与任何字符串进行运算时，+作为一种连接符。

                （3）：%模运算：可以作为以后的开关算法的判断条件。

 

           ++（自增） --（自减）

           a=++a与a=a++的区别:

            1:a=++a;

              Int temp=a;

              a=a+1; 

              A=temp;

             总结：其实运算的顺序就是先将等号右边的进行运算完，然后将值赋给左边。  针对这个，先在内存中开辟一个临时空间进行存储a变量的初始值。

          

         2：+=和-=赋值运算符：

          其实整体上就是一个运算符，但是先进行底层的先检测，有没有超出相应的变量   的范围。

          而一般的赋值

           例子：

              Short b=12; //底层是帮我们检测的，如果符合值的范围，就进行内存的4个    字节转换为2个字节。

              b=b+2;  //底层是不帮我们进行检测的。看右边是个变数，不是常量，而是    常量才能帮我们检测。

              b+=2;  //这个其实就是一个运算符，但是过程就是：先进行b+2得出结果，    然后查看这个结果有没有超出范围，其实底层是帮我们进行检测的。

 

         3：比较运算符

             主要是：== ,< ,>,>= ,<=,!= ,等等

            结果是boolean类型的值。

 

         4：逻辑运算符：

             & ，| ，！，|| ，&&

             &：逻辑与

                （1）逻辑&的运算特点及其规律是：

                     True & true=true；只有&两边都是true时才能够为true。

                 

             |：逻辑或

 （1）逻辑！的运算特点及其规律是：

                       false& false=false；只有&两边都是false时才能够为false。

             !：逻辑非

                 （1）逻辑！的运算特点和运算规律为：

                      与boolean 变量的值相反。

             &&：短路  

                  （1）逻辑&&的运算特点和运算规律为：

                      运算的结果和逻辑&一致性。

                   但是区别是：

                      当短路&&的左边是false，那么无论其右边的表达式的是true 或者    false，右边都不会进行参与运算。

             ||：短路

                   （1）逻辑||的运算特点和运算规律为：

                      运算的结果和逻辑|一致性。

                   但是区别是：

                      当短路||的左边是true，那么无论其右边的表达式的是true 或者    false，右边都不会进行参与运算。

              ^：异或

                    规律：只要两个逻辑值不一样就是true;

           5：位运算符： 

    &：与运算

  直接将两个操作数进行转换成二进制数进行与运算。

 

              |：或运算:

                  直接将两个操作数进行转换成二进制数进行或运算。

 

              ^异或运算：

                  直接将两个操作数进行转换成二进制数进行异或运算。关键一点，一个  数字与另个一个数进行两次异或运算。最终结果还是这个数。这个关键点用  于加密数字。

           

              ~反码运算：

      对一个数进行反码运算：先对这个数的二进制数进行取反，再进行加1；  快速辨别是：先给这个数去负数，然后在这个数的基础上进行减一。

 

 <<:左移：

     主要符号的表面特征是：箭头方向指向左边。

 其实就是该数乘以2的几次方，<<：可以完成乘以2的次幂运算

 

 >>:右移:

     主要符号的表面特征是：箭头方向指向右边。

     其实就是该数除以2的几次方；

     关键一点：高位缺失的位用原有的高位进行替补；

 

 >>>无符号右移：

     关键一点就是：高位缺失的不管原有的高位是什么：都用0进行替补。

 

面试题：

     （1）2*8进行最为有效的运算。

          知识点：主要对原来的数进行左移2位；

     （2）交换两个数，不用第三方变量。

    知识点：主要通过异或运算；

                      Int a=3,b=8；

                      a=a^b;

                      b=a^b;

                      a=a^b;

 

           6：三元运算符：

              格式：

                  （条件表达式）？表达式1：表达式2；

        如果条件表达式为true,那么运算后的结果为表达式1

如果条件表达式为false,那么运算后的结果为表达式2

 

2.6语句

1：程序流程的控制语句if

   目的：

       就是对某个事务的逻辑进行判断。

   表现形式：

        If .....else

        If......else if  else...

 

   简写格式什么时候用呢？

     当if else 运算后，有一个具体的结果时，就可以进行简化成三元运算符；

 

   开发中遇见的问题： 

     1：If(false)；   //导致if语句没有相关的控制体。

           Syso(“zh angyang”);

    

 2：局部代码块：

    可以定义局部变量的生命周期。

 

 3：选择结构：

    Switch(){

      case 3：

        语句

        Break;

     case 3：

        语句

        Break;

     case 3：

        语句

        Break;

     Default:

语句

        Break;

}

 

选择结构的注意点：

   （1）：选择的数据类型为：byte，short，int，char 以及枚举性Enum（1.5）,及 在7.0识别字符串;

   （2）：选择结构的顺序为：

          如果default:在首行，以及相关break缺失的情况下。

          第一种：

case中break缺失，如果进入相关case中，如果没有braek.那么。 如果下还有相关的case判断，那么就不用判断，一直执行到}

                   

  第二种：

       如果选择条件不在case中，同时default在首行，同时没有相关的    break;那么执行default下的内容，那么一直往下执行，下面的case    就不用进行判断，如果遇到case中的break，那么结束，否则一    直执行到}；

 

             （3）if和switch的应用：

                  If应用：

                    1：对具体值进行判断。

                    2：对区间进行判断

                    3：对运算结果的boolean值进行判断。

                   Switch应用：

                    1：对具体的值进行判断

                    2：值的几个数是固定的。

                       对于几个固定的值进行判断，建议使用switch语句,因为switch    中的内容能够一次性的加载进内存。而if条件判断，就不是了。

           4：循环结构

              While(条件表达式){

     循环语句

  }

              Do{

 循环语句

  }while();

  

 F or(;;){

 循环语句

  }

 

 循环总结：（重要）

  （1）Do循环：循环语句至少执行一次,而while循环则不一样。

    （2）for 与while 的特点：

             第一：for循环与while循环可以互换；

             第二：格式上的不同，在使用上有点区别：

                   如果通过变量进行控制循环，该变量只是作为循环区域      内有效。

     （3）：什么时候使用循环结构：

             当对某些代码进行执行很多次时，使用循环结构完成。

             当对一个条件进行一次判断时,可以用if条件结构。

             当对一个条件进行多次判断时，可以使用while语句结构。

       注意：

            在使用循环结构时，一定要明确哪些语句进行循环。

            在循环语句通常情况下，要定义循环条件，循环的次数。

 

 累加思想：

    对一写不断有规律的变化的数据进行求和。

 

 循环结构中的嵌套结构：（重要）

    其体现的是大圈套小圈的思想：有多种重复的情况，每种重复的情况又对应另外多种重复的情况。

 

整体的程序流程控制总结：

    （1）应当进行注意程序的健壮性。

    （2）注重程序代码的复用性。当多个条件对一同一语句时，将多个条件进行整合。

2.7函数

   （1）：定义函数的格式：

 

修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，...)

{

执行语句;

return 返回值;

}

 

    （2）特殊情况：

功能没有具体的返回值。

 

（3）定义函数时有两个明确：（重要）

    思路：既然定义功能，就是可以用函数来体现。

如何定义一个函数呢？

通过两个明确来完成。

明确一：这个功能的结果是什么？

是和。是功能的结果，所以该功能的返回值类型是int 。

其实就是在明确函数的返回值类型。

 

 

明确二：这个功能实现过程中是否需要未知内容参与运算？

有，加数和被加数。这就是函数的参数列表(参数的个数，参数的类型)

其实就是在明确参数列表。

 

 （4）：函数的重载：（重要）

1：同一个类，

2，同名。

3，参数个数不同。or 参数类型不同。

4，函数重载和返回值类型无关。

5，java是严谨性语言，如果函数出现的调用的不确定性，会编译失败。

2.8数组

  （1）数组的定义

     概念：

            同一种类型数据的集合，其实就是一个容器；

        好处：

            可以自动给数组中的元素从0开始编号，以至于方便操作这些元素；

       格式：

           （1）需要一个容器，但是不明确容器中的数据

元素类型[] 数组名=new 元素类型[元素的个数]：int[] arr=new int[]；

 

   （2）需要一个容器，存储已知具体的数据

元素类型[] 数组名=new 元素类型[]{1,2,3,4}；

        Int[] arr=new int[]{1,2,3,4};

        Int[] arr={1,2,3,4};

 

     （2）数组的本质：

1：对数组的操作就是存和取，及其核心的思想就是对角标的处理。

    2：对数组的操作：

         对数组中的元素进行遍历。

 从数组进行获取最值

 排序（选择和冒泡排序）

 折半查找（二分查找）

           

      3： 数组中的一些对元素的操作:都跟Arrays类相关；

                其中Arrays.binarySearch(arr,10);如果敢数组中该元素不存在，返回的-6； 指的是：如果数组中该元素不存在，那么应该将这个元素插入在数组中 的6的位置上

 

 

  注意：

（1）如果没有给数组中的元素进行初始化，那么数组中有默认值为0；而数组的定义并且赋值时，其实有两步：栈内存和堆内存

（2）当访问到数组中不存在的角标时，就会发生ArrayIndexOutOf..异常

     当引用类型没有任何实体指向时，还在用操作实体时，就会发生异 常。

（3）在计算机中容器是一个非常重要的数据，计算机就是为了处理数据，但是在处理数据值钱啊，首先要将数据进行存储起来。

 

 

（2） JVM内存的划分的问题：

     为什么：主要是管理处理不同种类的数据，就像田径场上，比赛时划分好相应的 区域，整理有序进行运作。

 主要划分为5片区域：

    寄存器：存储主要指cpu中运行的数据。

    本地方法区：关于系统平台的资源（针对不同的操作系统,那么会有不同版本 的JVM）。

    方法区：存储相关加载类中的方法。

    堆内存：

          存储的是数组和对象（其实数组就是对象）。通过New进行建立在堆中；

          特点： 

              （1）每一个实体都会有一个首地址

              （2）堆内存中每一个变量都会有默认数值：整数默认为0；

                   小数默认为:0.0 ；Char 字符类型默认为 “\u0000” ；boolean    类型的是false,

          图解：

    

          

                         对象的图解

 

 

二维数组的图解

 

 

 

栈内存的相关运作图

 

    栈内存：将正在所需要的方法进行加载进来。主要进行存储的是局部变量，而且变量所属的作用域一旦结束，那么所属的局部变量就自动释放。

 

 另外注意的一些地方：

   局部代码块：主要用来进行限定局部变量的生命周期的。