1.概念

java基础知识黑马程序员

（1）标识符：

        由26个英文字母大小写，数字：0-9 符号：_ $ 组成

  定义合法标识符规则：

    1、数字不可以开头。

    2、不可以使用关键字。

    3、Java中严格区分大小写。

（2）Java中的注释格式：

单行注释：

    格式： //注释文字

多行注释：

     格式： /* 注释文字*/

文档注释：

     格式：/ 注释文字 */

（3）常量：

常量表示不能改变的数值。

java中常量的分类：

1、整数常量。所有整数

2、小数常量。所有小数

3、布尔型常量。较为特有，只有两个数值。true 和false。

4、字符常量。将一个数字字母或者符号用单引号( ' ' )标识。

5、字符串常量。将一个或者多个字符用双引号标识。

6、null常量。只有一个数值就是:null.

   对于整数：java有三种表现形式。

   十进制：0-9 ，满10进1.

   八进制：0-7 ，满8进1. 用0开头表示。

   十六进制：0-9，A-F，满16进1. 用0x开头表示。

（4）进制的基本转换：

        1、十进制二进制互转：

              十进制转成二进制除以2取余数，能整除就计为0，不能整除计为1，从右往左写。

              例如：6是十进制，变二进制的时候就用6去除以2,6除以2等于3，能整除计为0。

              3在除以2于1，不能整除，就计为1。然后1再除以2，计为1。依次从右往左写，为110。

       2、二进制转成十进制乘以2的幂数：

      例如：将110变成十进制，整数是4个8位，00000000 00000000 00000000 00000110

      从右往左，开始位为2的0次方，然后指数逐渐的增加，最后将2的幂次方结果乘以二进制位，

      所以上边的从右往左，第一个1对应的是2，第二个1对应的是4，然后相加，等于6。

      3、十进制十六进制互转：

        先将十进制转成二进制，再转成十六进制，4个二进制位代表1个十六进制位。

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

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

（5）变量：

就是将不确定的数据进行存储，也就是需要在内存中开辟一个空间。

1、变量的概念：

内存中的一个存储区域。

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

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

2、为什么要定义变量：

用来不断的存放同一类型的常量，并可以重复使用。

3、使用变量注意事项：

        变量的作用范围（在一对{}中有效）。

4、变量的格式：

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

Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间。

开辟空间有三个要素：

       1、数据类型。

       2、变量名称。

       3、数据。

       整数默认：int 小数默认：double

       自动类型转换（也叫隐式类型转换）

       强制类型转换（也叫显式类型转换）

类型转换的原理 ：

表达式的数据类型自动提升：

     1、所有的byte型、short型和char的值将被提升到int型。

     2、如果一个操作数是long型，计算结果就是long型；

     3、如果一个操作数是float型，计算结果就是float型；

     4、如果一个操作数是double型，计算结果就是double型。

自动类型提升例子：

         byte b = 5;

         int  x = 6;

         x = x + b;          //b会自动提升为int类型进行运算。

强制类型转换例子：

       byte b = 5;

       b = b + 6;     //报错 因为b是byte类型的，6是int类型的，

       b = (byte)b+6;//强制类型转换，强制将b+6的结果转换为byte类型，再赋值给b。

（6）算术运算符：

        Java中的运算符主要有 +（加）、-（减）、*（乘）、/（除）、%（求余数），它们都是二元运算符。

（7）比较运算符：

比较运算符属于二元运算符，用于程序中的变量之间，变量和自变量之间以及其他类型的信息之间的比较。比较运算符的运算结果是boolean型。当运算符对应的关系成立时，运算结果是true,否则为false。所有比较运算符通常作为判断的依据用在条件语句中。

“&”和“&&”的区别：

单&时，左边无论真假，右边都进行运算；

双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。

（9）位运算：
   1、通过第三方变量交换两个变量的值：
         int  temp;
         temp = n;
         n = m;
         m = temp;

   2、不用第三方变量交换两个变量的值：
        n = n + m;//如果n和m的值非常大，容易超出int范围。
        m = n - m;
        n = n - m;

        n = n ^ m;
        m = n ^ m;    //(n^m)^m;
        n = n ^ m;     //n ^ (n ^ m)

移位操作：

   还可以对二进制位进行移位操作，java中移位运算有三种。

        （1） <<: 左移

        （2） >>: 右移

        （3） >>>>: 无符号右移

（10）三元运算符：

格式：

(条件表达式)?表达式1：表达式2；

如果条件为true，运算后的结果是表达式1；

如果条件为false，运算后的结果是表达式2；

（11）程序流程控制：

判断结构：if语句

三种格式：   

View Code

if语句特点：

       1、每一种格式都是单条语句。

       2、第二种格式与三元运算符的区别：三元运算符运算完要有值出现。     

            好处是：可以写在其他表达式中。

       3、条件表达式无论写成什么样子，只看最终的结构是否是true 或者false。

（12）选择结构：

    switch语句

    格式：

View Code

      switch语句特点：

      1、switch语句选择的类型只有四种：byte，short，int，char。

      2、case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。

      3、结束switch语句的两种情况：遇到break，执行到switch语句结束。

      4、如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到

            break或者switch结尾结束。

          如果判断的具体数值不多，而且符合byte short int char这四种类型。

           虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。

      其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。

  （13）循环结构：

      while语句格式：

       while(条件表达式)

       {

           执行语句；

        }

      do while语句格式：

      do

      {

         执行语句；

      }

      while(条件表达式);

     do while特点是条件无论是否满足，

     循环体至少被执行一次。

     格式：

     for(初始化表达式；循环条件表达式；循环后的操作表达式)

     {

         执行语句；

     }

     1、for里面的连个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然

          后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。

     2、while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放。而while

         循环使用的变量在循环结束后还可以继续使用。

     3、最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某

          些条件，来控制循环。

     break(跳出)，continue(继续)：

         break语句：应用范围：选择结构和循环结构。

         continue语句：应用于循环结构。

（14）for和while的区别：

       1、变量有自己的作用域，对于for来说：如果将用于控制循环的增量定义在for语句中。那么该变量只在for语

            句内有效。For语句执行完毕，该变量在内存中被释放。

      2、For和while可以进行互换，如果需要定义循环增量。用for更为合适。

   例子：

     for(int x=0;x<6;x++)

     {

       System.out.println("x"+x);

     }

      int x =0;

     while(x<6)

    {   

      System.out.println("x=="+x);

          x++;

     }

for练习代码

（15）函数：

   1、什么是函数：

       函数就是定义在类中的具有特定功能的一段独立小程序，是最小的功能单元,函数也称为方法。

   2、函数的格式：

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

       {

         执行语句;

         return 返回值;

        }

      返回值类型：函数运行后的结果的数据类型。

      参数类型：是形式参数的数据类型。

      形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。

      实际参数：传递给形式参数的具体数值。

       return：用于结束函数。

       返回值：该值会返回给调用者。

3、函数的特点：

     3.1、定义函数可以讲功能代码进行封装。

     3.2、便于对该功能进行复用。

     3.3、函数只有被调用才会去执行。

     3.4、函数的出现提高了代码的复用性。

     3.5、对于函数没有具体返回值的情况，返回值类型用关键字void来表示，那么此时

      该函数中的returm语句可以省略不写。

注意：

函数中只能调用函数，不可以下函数内部定义函数。

定义函数时，函数的结果应该返回给调用者，交由调用者处理。

例子：

     public static void main(String[] args)

     {

          int x =getSum(3);

         System.out.println(x);

      }

     public static int getSum(int num)

     {

         return num+3;

     }

4、重载：

在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。

例子：void show(int a,char b,double c){} 判断与给定函数是否重载：

     4.1、void show(int x,char y,double z){}  //没有重载，与原函数一样。

     4.2、int show(int a,double c,char b){}   //重载，因为参数列表与原函数的参数列表顺序不一样。

     4.3、boolean show(int c,char b){}  // 重载，参数列表的个数不同。

     4.4、void show(double c){}      //  重载，参数列表的个数不同。

     4.5、double show(int x,char y,double z){} //没有重载，不可以与原函数同时出现在一个类中，因为它与原函数的

       参数列表相同，且它有返回值类型，如果放在同一个类中，就分不清调用的是有返回值类型的函数，还是没

       有返回值类型的参数。

重载特点：

与返回值类型无关，只看参数列表（参数的个数，参数的类型，参数的顺序）。

2.数组：

（1） 数组的慨念：

       1、具有相同数据类型的一组数据的集合，其实数组就是一个容器。

       2、包含一维数组和二维数组。

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

       4、元素类型[] 数组名= new 元素类型[元素个数或数组长度];

（2）一维数组例：

            格式1：int[] arr =new int[3];

            格式2：int[] arr ={1,3,4,5};

    格式1：

       定义了名称为arr的一维数组，这个一维数组的长度是3。

    格式2：

       arr数组中的长度是4，并且明确了元素。

（3）二维数组例：

               格式1：int[][] arr = new int[3][2];

               格式2: int[][] arr = new int[3][];

               格式3: int[][] arr = {{1,9,2},{2,5},{4,8,0,2}};

   格式1：

       定义了名称为arr的二维数组二维数组中有3个一维数组,每一个一维数组   中有2个元素， 一维数组的名称分别   

       为: arr[0], arr[1], arr[2]，给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;

    格式2：

        arr中定义了3个未定义长度的一维数组。

    格式3：

        arr中定义了3个一维数组，第一个一维数组为{1,9,2}，第二个一维数组为{2,5}，第三个一维数组{4,8,0,2};

（4） 栈内存：

        1、作用：用于存储局部变量。

        2、特点：当数据使用完，所占空间会自动释放。

（5） 堆内存：

        1、作用：数组和对象，通过new建立的实例都存放在堆内存中，用来封装数据。

        2、特点：

             2.1、每一个实体都有内存地址值。

             2.2、 实体中的变量都有默认初始化值，初始化值根据数组中元素的类型而定。

       例：int型的初始化值为0。

              double型的初始化值为0.0。

              float型的初始化值为0.0f。

              boolean型的初始化值为false。

              String型的初始化值为null。  

       3、当实体不在被使用时，会在不确定的时间内被垃圾回收器回收。

（6）数组在内存中的分配情况：

（7）数组的应用：

     获取最大值第一种方式：

 1 class ArrayDemo1 2 3  { 4 5 public static void main(String[] args) 6 7  { 8 9 int[] arr ={1,3,5,6,8}; 10 11 int max =getMax(arr); 12 13  System.out.println(max); 14 15  } 16 17 public static int getMax(int[] arr) 18 19  { 20 21 int max =[0]; //定义一个变量max，赋一个数组中的值。 22 23 for(int x=1; x<arr.length; x++) 24 25  { 26 27 if(arr[x]>max) //如果数组中某一个值大于max对应的值， 28 29 max = arr[x]; //就将数组中的值赋给max。 30 31  } 32 33 return max; //将获取到的最大值返回。 34 35  } 36 37  } 38 39 

（8）获取最大值第二种方式：

讯享网 1 class ArrayDemo2 2 3  { 4 5 public static void main(String[] args) 6 7  { 8 9 int[] arr ={1,3,5,6,8}; 10 11 int max =getMax(arr); 12 13  System.out.println(max); 14 15  } 16 17 public static int getMax(int[] arr) 18 19  { 20 21 int max =0; //定义一个变量max，赋一个数组中的角标。 22 23 for(int x=1; x<arr.length; x++) 24 25  { 26 27 if(arr[x]>arr[max]) 28 29 max = x; //如果数组中的值大于arr[max]的值， 30 31 } //就将这个值对应的角标赋给max。 32 33 return arr[max]; //将获取到的最大值返回。 34 35  } 36 37 }

（9）排序：

1、选择排序：

原理：

如图（1）每次都是前一个和后一个比，而且第一圈比完，最小值就去了前面。当0角标位和其它的角标位比完以后，那么第二次是从1角标位开始与后面的角标位比，以此类推，每次比完就减少一位，当只剩下最后一个角标位时就不用比了。比的时候需要定义一个第三方变量，如图（2）：3大于1，所以将3赋给变量，1到了3的位置上，然后变量再将3赋到1的位置上。

　　　　　　　　 View Code

2、冒泡排序：

原理：

如图（3）：每次都是相邻的俩个比较，而且第一圈比完，最大值就去了后面，每次都减少一位，每次都是从0角标位开始比，如图（4）：3大于1，所以将3赋给变量，1到了3的位置上，然后变量再将3赋到1的位置上。

　　　　　　 View Code

（10）查找：

   一般查找：

 1 public static int getIndex(int[] arr,int key) 2 3  { 4 5 for(int x=0,x<arr.length;x++) 6 7  { 8 9 if(arr[x]==key) 10 11  { 12 13 return x; //如果arr[x]等于了这个要查找的key值 14 15 } //就返回arr[x]对应的角标 16 17 return -1; //如果不等于就返回 -1 18 19  } 20 21 }

1、折半查找：

前提：必须是有序的数组。

原理：定义3个变量，最小角标min，中间角标mid，最大角标max,

      int  min =0;  mid =(min+max)/2;  max = arr.length-1; 它们分别对应了一个指针，当我们要查找的值大于了中间角标所对应的值，那么将min+1，也就是

min所对应的指针向右移动一位，当要查找的值大于了中间角标所对应的值，那么将max-1，也就是max所对应的指针向左移动一位。如果数组中存在这个值，直到找到为止，但是得确保min<=max。　　

View Code