黑马程序员--java基础知识点总结

——- android培训、java培训、期待与您交流！ ———-

标识符

概念
在java语言中的包、类、方法、参数、变量也有自己的标识，允许程序员对程序中的各个元素加以命名，这种字符串称为标识符。

标识符命名规则

1.标识符由字母、数字、下划线（_）和美元符号（$）组成，但标识符不能以数字开头。

2.标识符不能是java的关键字和保留字，但可以包含其在内。

3.标识符中字符大小写敏感，abc和ABC不是同一标识符。

4.标识符长度没有限制。

5.标识符不能含有空格。

认识变量

变量是程序运行过程中其值可以改变的量。变量可以表示程序的状态，可以表示不同的对象，程序通过改变变量的值来改变程序运行的状态或对象的特征。换句话说，变量可以实现程序的功能逻辑。

数据类型

分为基本数据类型和引用数据类型

基本数据类型:分为四类八种

    byte  占1个字节，取值范围是—128到+127
    short 占2个字节，取值范围是—2^15到+2^15+1
    int   占4个字节，取值范围是—2^31到+2^31+1，整数默认数据类型
    long  占8个字节，取值范围是—2^63到+2^63+1
    float 占4个字节，单精度,没有指定大小
    double占8个字节，双精度，浮点型默认数据类型
    char  占2个字节，取值范围是0到65535
    boolean占八分之一个字节只有true和false

引用数据类型：

接口和数组

class Demo1 {
                    public static void main(String[] args) {
                        byte b=100;
                        short s=1000;
                        int i=10000;
                        long l=1234567890000L;//如果long的值大于int范围必须在数值结尾加L，注意尽量大写，否则容易看成数字1
                        //浮点类型
                        float f=11.2f;//此处数值后如不加f(不分大小写），会报错，因为小数数据类型默认为double，所以会损失精度
                        double d=11.2;
                        //字符类型
                        char c1='a';
                        char c2='0';
                        char c3='中';//字符中可以储存有汉字，因为Java是unicode编码，char占用两个字节，而汉字也是两个字节
                        //布尔类型
                        boolean b1=true;
                        boolean b2=false;
                        //System.out.println(l);
                    }
                }

使用变量注意事项

class Demo2 {
                public static void main(String[] args) {
                    int i=10;
                    i=20;                   //这是一个赋值动作，可以把初始化值覆盖掉
                    System.out.println(i);
                    int x;                     //变量使用前必须赋值，
                    System.out.println(x);
                    int a,b,c;               //一条语句可以声明多个变量
                    a=10;
                    b=20;
                    c=30;
                    System.out.println(a);
                    System.out.println(b);
                    System.out.println(c);
                    }
            }

自动类型提升与强制类型转换

class Demo3 {
                public static void main(String[] args) {
                /*int i=100;
                byte b=30;              //自动类型提升(隐式转换）
                i=i+b;
                System.out.println(i);*/
                int i=100;
                byte b=50;
                b=(byte)(i+b);        //强制类型转换
                System.out.println(b);
                }
            }

数据类型转换之默认转换
byte,short,char – int – long – float – double

float和long它们底层的存储结构不同。
float表示的数据范围比long的范围要大
long：2^63-1
float：3.4*10^38 > 2*10^38 > 2*8^38 = 2*2^3^38 = 2*2^114 > 2^63-1
字符char可以存储一个中文汉字吗?为什么呢?
可以。因为Java语言采用的是Unicode编码。Unicode编码中的每个字符占用两个字节。
所以，Java中的字符可以存储一个中文汉字

字符和字符串参与运算

‘0’——–48

‘a’——–97

‘A’——–65

class Demo5 {
                public static void main(String[] args) {

                System.out.println("Hello World!"+'a'+1);//任何数据用+和字符串相连接，会产生新的字符串
                                }
            }

认识常量

常量是在程序运行中恒定不变的值。

大概分为以下六种：

       1.整数常量。包括所有整数
           对于整数有四种表现形式:
           二进制，0、1，满2进1
           八进制，0-7，满8进1，从0开头表示
           十进制，0-9，满10进1
           十六进制，0-9，A-F，满16进1，用0x开头表示。


       2.小数常量。包括所有小数


       3.布尔常量。较为特有，只有两个数值，true false， true false同时是关键字

       4.字符常量。将一个数字字母或符号用单引号（‘’）标识,“单引号里只能放单个数字，字母，符号，一个也没 有不可以”

       5.字符串常量。将一个或多个字符用双引号("")标识


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

变量相加与常量相加的区别

 class Demo4 {
                public static void main(String[] args) {
                byte b,b1,b2;
                b1=3;
                b2=4;
                b=b1+b2;       //此处报错，原因是b1,b2 是byte类型变量，在运算中自动提升为int类型，
                               //因为b1,b2变量原因,Java无法获取其具体值
                1b=3+4;        //3,4是两个常数，Java有一个常数优化机制，在编译时直接将常数相加结果算出并赋值
                //问这两种编译哪种会报错？
                System.out.println(b);
                }
            }

不同进制的表现形式

二进制的数据表现形式：二进制加0b
八进制的数据表现形式：八进制加0
十进制的数据表现形式：十进制无标示
十六进制的数据表现形式：十六进制加0x，x不分大小写。10到15分别用a到f表示，不分大小写

运算符

1、算数运算符

  正号：+      负号：-                      

  加法：+      减法：-       乘法：*       除法：/       取模：%  

  自增：++，即自加1，可至于前或后；如：++a（a先自增，然后再和a相加），a++（先和a相加，a再自增）

  自减：- -，即自减1， 可至于前或后；如：- -a（a先自减，然后再和a相减），a- -（先和a相减，a再自减）

  字符串相连：+

2、赋值运算符：=、+=、-=、*=、/=、%=等

如：s += 5，就是将s的值和5相加再赋值给s。但是这种运算和s = s + 5;是有区别的。

s += 5有自我提升的功能，而 s = s + 5;可能就会编译失败。比如，s为short型的值，对于后者那么编译时就会报错：可能损失精度。对于前者，会将5强转为short型，在与s的值相加，然后再赋值给s。

3、比较运算符：==、!=、< 、> 、<= 、>= 、instanceof

结果均为boolean型，即所得的值为true或者false

如：5 == 3为false；5 != 3为true

4、逻辑运算符：&、|、^、!、&&、||

  与： &； 如：true & false 为false；

  或：|；    如：true | false为true；

  非： !；    如：  ! true 为false

  异或： ^； 如：true ^ false 为true（真异或真为假）

  短路：&&：只要有一边为false，结果则为false

               ||：只要有一边为true，结果则为true

5、位运算：<< 、>> 、>>> 、 &、|、^ 、~；在二进制水平上运算

  左移：<<；3 << 2 = 12  ---->3*2*2=12

  右移：>>；3 >> 1 = 1     ---->3/2 =1

  无符号右移：>>>； 3 >>> 1 = 1     ---->3/2 =1

  与： &；6 & 3 = 2 

  或：|；6 | 3 = 7

  异或： ^；6  ^ 3 = 5。一个数以后两次相同点数，那么结果还为本身。在加密和解密中有应用。

  ~：反码：~ 6 = -7，其实就是对当前数的二进制的取反。

注：

a.对于>>，最高位补什么由原有数据的最高位值而定，若最高位为0，右移后，用0补空位。如果最高位为1，右移后，用1补空位。

b.对于>>>，无论最高位是0还是1，右移后，都用0补空位。

三元运算符

格式：布尔型表达式 ? 表达式1 : 表达式2

说明：当布尔型表达式的值为true时，则计算表达式1；否则计算表达式2。

如：返回两个数中较小的值—-> x < y ? x : y。

注意：

a.这个是有返回值的，需要由变量接收这个返回值，如：int a = x < y ? x : y;

b.表达式1和表达式2必须都返回相同类型，或是相同类型的数据。

运算符优先级

运算符间有不同的优先级。就是谁先运算的问题。具体如下：从左向右运算的：

运算级别由高到低

1级—– 方法调用：[ ] . ()

2级—– 一元运算符：! 、~ 、++、– 、+、-；强制类型转换：( )；创建：new

3级—– 二元运算符：*和 / 优于 + 和 -

4级—– 位运算：<<、>> 、>>>

5级—– 比较运算符：< 、> 、<= 、>= 、instanceof 优于 ==、!=、

6级—– 逻辑运算符：&、|、^、!、&&、||

7级—– 三元运算符：? :

8级—– 算数运算符等: =、+=、-=、*=、/=、%=、&=、|=、 ^=、 <<=、>>= 、>>>=

上面除了第2、7和8级的是从右向左运算，其他的都是从左向右进行的运算。

转义字符

1、概述：通过 \ 来转变后面字母或符号的含义。如：\n表示换行。

2、常用转义字符：

  \b：退格           \n：换行

  \t：制表符，相当于tab键         \r：回车

  \\：表示反斜杠       \'：表示单引号         \"：表示双引号

流程控制结构

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说程序的流程对运行结果有直接的影响。所以，清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们要完成的功能。

流程控制语句分类
顺序结构
选择结构
循环结构

顺序结构概述
是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
总的来说：写在前面的先执行，写在后面的后执行

选择结构概述
也被称为分支结构。
选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。
Java语言提供了两种选择结构语句
if语句
switch语句

循环结构概述
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。

循环语句的组成
初始化语句：
一条或者多条语句，这些语句完成一些初始化操作。
判断条件语句：
这是一个boolean 表达式，这个表达式能决定是否执行循环体。
循环体语句：
这个部分是循环体语句，也就是我们要多次做的事情。
控制条件语句：
这个部分在一次循环体结束后，下一次循环判断条件执行前执行。通过用于控制循环条件中的变量，使得循环在合适的时候结束。

class Demo5 {
    public static void main(String[] args) {
        /* if语句的格式1
         if(比较表达式) {
             语句体;
         }
           比较表达式无论简单还是复杂，结果必须是boolean类型
           先计算比较表达式的值，看其返回值是true还是false。
           如果是true，就执行语句体；
           如果是false，就不执行语句体；*/
        int x=7;
        int y=8;
            if (x>y){//此处大括号前不能加;加分号此语句就结束，下面语句与其不是一体了
                int c=9//如果去掉大括号，就先执行离他最近的语句，而此语句又分为声明语句int x和赋值语句=9

                    System.out.println("Hello World!");//如果是一条语句大括号就可以省略，多条语句不可以
            }
    }
}

class Demo6{

    /**if语句的格式2

        if(比较表达式) {
            语句体1;
        }else {
            语句体2;
        }
        首先计算比较表达式的值，看其返回值是true还是false。
        如果是true，就执行语句体1；
        如果是false，就执行语句体2；
        */
    //判断一个数据是奇数还是偶数,并输出是奇数还是偶数
    public static void main(String[] args) {
        int x = 10;

        if(x % 2 == 0) {//此处==号谨记不能写成=号，一个是比较运算符（关系运算符），一个是赋值运算符
            System.out.println(x + "是一个偶数");
        }else {//else后面是没有比较表达式的，只有if后面有
            System.out.println(x + "是一个奇数");
        }
    }//三元运算符和if语句第二种格式的区别：三元运算符是一个运算符，运算符操作完毕就只有一个结果
                                           //if语句控制的操作能给出结果也能够输出语句。

}

import java.util.Scanner;
class Demo7{
    //if语句的格式3：

    //  if(比较表达式1) {
    //      语句体1;
    //  }else if(比较表达式2) {
    //      语句体2;
    //  }else if(比较表达式3) {
    //      语句体3;
    //  }
    //  ...
    //  else {
    //      语句体n+1;
    //  }
    // 执行流程：
    //  首先计算比较表达式1看其返回值是true还是false，
     // 如果是true，就执行语句体1，if语句结束。
      //如果是false，接着计算比较表达式2看其返回值是true还是false，

    //  如果是true，就执行语句体2，if语句结束。
     // 如果是false，接着计算比较表达式3看其返回值是true还是false，

     // 如果都是false，就执行语句体n+1。*/



    /*
      需求：
         键盘录入x的值，计算出y的并输出。

          x>=3  y = 2 * x + 1;
          -1<x<3    y = 2 * x;
          x<=-1 y = 2 * x – 1;
    */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int x = sc.nextInt();
        int y;
        if(x >= 3) {
            y = 2 * x + 1;
            System.out.println(y);
        }else if(x > -1 && x < 3) {
            y = 2 * x;
            System.out.println(y);
        }else if(x <= -1) {
            y = 2 * x - 1;
            System.out.println(y);
        }
    }
}

import java.util.Scanner;
class Demo8 {
    /**switch(表达式){  

            case值1：
                    语体1
                break；
                case值2：
                    语体2
                break;
                ……
                default:
                    语体n+1
                break;
                 }
        表达式可以是byte，short，char,int,只要自动提升为int类型的都可以，
                              另外jdk1.5版本可以接受枚举
                               jdk1.7版本可以接受字符串String
     执行流程：
      先计算表达式的值
      然后和case后面的匹配，如果有就执行对应的语句，否则执行default控制的语句 
     */


    /*
    分别用switch语句和if语句实现下列需求：
    * 键盘录入月份，输出对应的季节
    3,4,5是春季,6,7,8是夏季,9,10,11是秋季,12,1,2是冬季
    */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入月份:");
        int month = sc.nextInt();
        switch (month) {
        case 3:// ----------------------------case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
        case 4:
        case 5:
            System.out.println(month +"月是春季");
        break;// ----------------------------- break省略会形成case穿透
        case 6:                                    
        case 7:
        case 8:
            System.out.println(month +"月是夏季");
        break;
        case 9:
        case 10:
        case 11:
            System.out.println(month +"月是秋季");
        break;
        case 12:
        case 1:
        case 2:
            System.out.println(month +"月是冬季");
        break; // -------------------------------这个break如果在最后就可以省略不影响效果，但最好不省略  
        default://-------------------------------
                                            //  不是只有在最后，可以在任意位置。但是建议在最后。
                                            //  但备胎永远都是备胎，无论在什么位置switch都是先走case再走default
            System.out.println("输入有误");
        }//switch语句的结束条件是遇到break就结束了和执行到末尾就结束了

class Demo11 {

    /*for(初始化表达式;条件表达式;增量表达式) {
            循环体;
        }
      执行流程：
     a:执行初始化语句
     b:执行判断条件语句,看其返回值是true还是false
         如果是true，就继续执行
         如果是false，就结束循环
     c:执行循环体语句;
     d:执行控制条件语句
     e:回到B继续。*/
    public static void main(String[] args) {
         int count = 0;
         for ( int x = 100;x<1000; x++){
                int ge = x % 10;
                int shi = x/10%10;
                int bai = x/100%10;
                if (x == ge*ge*ge +shi*shi*shi+bai*bai*bai){
                    count++;//这是想知道符合要求的数的个数（累计思想）
                    //System.out.println(x);这是输出所有符合要求的数（遍历思想）
                } 

         }

 System.out.println(count);//输出语句一定要对应相应的返回语句

    }
}

class Demo12 {


    /*  初始化语句;
        while(判断条件语句) {
             循环体语句;
             控制条件语句;
        }
    执行流程：
     a:执行初始化语句
     b:执行判断条件语句,看其返回值是true还是false
         如果是true，就继续执行
         如果是false，就结束循环
     c:执行循环体语句;
     d:执行控制条件语句
     e:回到B继续。*/
    public static void main(String[] args) {
        int count = 0;
        int x = 100;//初始化语句
        while (x<1000){//判断条件语句
            int ge =x%10;
            int shi = x/10%10;
            int bai = x/100%10;                        
            if (x==ge*ge*ge+shi*shi*shi+bai*bai*bai){
                count++;
            }//这之前的是循环体语句
             x++;//控制条件语句   #######需要区别的是此处变量  循环完毕后不会消失
                                        //而for循环中的变量循环完后会从内存中消失，
                                         //说白了就是如果想循环完后再用变量就用while循环
        }
        //System.out.println(count);
    }
}

class Demo14 {
    /**
     循环结构do...while语句的格式：

        do {
            循环体语句;
        }while(判断条件语句);

        完整格式；
        初始化语句;
        do {
            循环体语句;
            控制条件语句;
        }while(判断条件语句);
    */
    public static void main(String[] args) {
        int x = 1;
        do {
            System.out.println(x);
            x++;
        }
        while (x < 12);//如果这的控制条件为x<o同样会有输出也就有了下面的结论

        /*
        while和do while的区别
        while如果条件不满足,不执行循环体
        do while 无论条件是否满足,至少会执行一次循环体
        */
       }
}

class Demo13 {
    public static void main(String[] args) {
        int x = 1;
        while (true) {              
            if (x == 10) {
                //break;//无限循环,如果在内部不做任何的跳转语句,无限循环的下面是不能定义语句的
                                        //因为永远执行不到
            }
            x++;
        }
        /*for (; ; ) {          另一种死循环  
        }*/

        System.out.println("能否执行到");
    }
}

数组的概念

数组数组是存储同以数据类型多个元素的集合。是一个数据结构也可看成是一个容器，既可以存储基本数据类型，也可以存储引用数据类型。通过数组名和角标可以引用数组中的元素

每个数组都有自己的成员变量length，用来表示数组所包含的元素个数，length只能是正整数和零，数组创建后length就不能被改变。

数组的定义格式

A：当不明确数组中的元素时,动态初始化 举例 : int[] arr = new int[3]; arr[0] = 3;

B：当明确数组中的元素时,静态初始化 举例 : int[] arr = new int[]{1,2,3,4,5}; int[] arr = {1,2,3,4,5};

什么时候使用数组？

当要操作的同种数据类型的数据是多个的时候，你就得想着先把这些数据用数组进行存储。

数组的内存位置
A：栈

存储的是局部变量(在函数中定义的变量)。

变量被使用完后，立即自动释放。

B：堆

存储的是实体(数组和对象)。

实体：new出来的东西，可以存放很多数据的东西。

堆内存数据的特点：是每个实体都有内存地址，堆内存中的变量都有默认初始化值

int 类型的初始化值是 0

double 类型的初始化值是 0.0

boolean 类型的初始化值是false

char 类型的初始化值是’\u0000’ 空字符，unicode编码。

当实体不在被使用的时候，会在jvm空闲的时候，通过java垃圾回收机制使其自动释放。

class Demo1Array {
    public static void main(String[] args) {
        //声明数组
        //int[] arr1;                           //数据类型[] 数组名;
        //int arr2[];                           //数据类型 数组名[];

        //动态初始化,没有给数组赋具体的值
        int[] arr = new int[5];                 //new是一个关键字,用来创建实体对象
                                                //5代表数组的长度

        arr[0] = 5;

        arr[4] = 10;

        //静态初始化
        int[] arr2 = new int[]{1,2,3};          //静态初始化,不用知道数组长度,长度根据元素个数


               //int[] arr1 = new int[]{1,2,3,4,5};     //静态初始化,一初始化就赋值,不允许声明后赋值，根据值的个数决定长度
        //int[] arr2 = {1,2,3,4,5};                 //静态初始化的简写形式,只能在一行定义


    }
}

class Demo4Array {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3,4,5};
        //System.out.println(arr1[-1]);         //ArrayIndexOutOfBoundsException:数组索引越界异常
        System.out.println(arr1);               //[I@1afb7ac7
        arr1 = null;                            //将数组赋值为null
        System.out.println(arr1[0]);            //NullPointerException:空指针异常
    }
}

class Demo7Array {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};           

        /*for (int x = 0;x < arr.length ;x++ ) {            //正序遍历
            System.out.println(arr[x]);
        }

        for (int x = arr.length - 1;x >= 0 ;x-- ) {     //倒序遍历
            System.out.println(arr[x]);
        }*/

        revArray(arr);                                  //对数组反转操作
        print(arr);                                     //遍历打印数组
    }

    /*
    将数组反转
    1,返回值类型void
    2,参数列表,int[] arr
    */

    public static void revArray(int[] arr) {            
        for (int x = 0;x < arr.length / 2 ; x++) {
            int temp = arr[x];
            arr[x] = arr[arr.length-1-x];
            arr[arr.length-1-x] = temp;
        }
    }                                               

    /*
    将数组打印
    1,返回值类型void
    2,参数列表,int[] arr
    */

    public static void print(int[] arr) {
        for (int x = 0;x < arr.length ;x++ ) {
            System.out.print(arr[x] + " ");
        }
    }
}

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

函数的格式

修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，…) { 执行语句; return 返回值;}public static int add(int a,int b){}

A：修饰符 public static

B：返回值类型 这个特定的功能完成后，需要返回一个结果。这个地方就是返回结果的类型。

C：函数名 为了方便使用这个函数，给它起个名字。这个名字要符合标识符命名规则。

D：参数类型 形式参数的数据类型 形式参数 自定义的接收方 实际参数 发出方add(3,5)

E：执行语句 那么这个语句是由多条语句组成。

F：return 这个功能执行完以后，需要有一个返回值，那么这个值有关键字return带回。

函数的使用及注意事项
一般函数只有被调用后，才执行。

void 表示没有返回。

在这个函数的结尾可以不写return。其实jvm会自动的结尾处加上return;

函数中不能定义函数

如果定义自己的函数 两个明确

明确该功能的结果 说白了就是返回类型。

明确该功能的参数 其实就是明确该功能中是否需要未知内容(形式参数)参与运算。明确未知内容的类型和个数。就是参数列表。

函数的重载
函数名相同，参数列表不同。

参数类型不同。int add(int i)void add(double d)

参数个数不同。add(int a,int b);add(int a,int b,int c)

参数顺序不同 print(String name, int age) //参数顺序不同的重载是可以存在的,但是没有什么实际意义

特点：与返回值类型无关，只看参数列表。

好处：便于阅读，优化程序设计。

class Demo2Method {
    public static void main(String[] args) {
        //int sum = getSum(4,5);            //赋值调用
        //System.out.println(sum);
                //有具体返回值
        //getSum(4,5);                      //单独调用不推荐
        System.out.println(getSum(4,5));    //输出调用
                //return;                           //如果方法的返回值类型是void,有return语句是这样写的return;//这个return可以省略,省略之后jvm会帮我加上

    /*求两个整数的和
    1,明确返回值类型
    2,明确参数列表
    */

    public static int getSum(int x,int y) {//int x = 4,int y = 5
        int sum = x + y;                    // sum = 9

        return sum;
    }
class Demo6Method {
    //方法重载,方法名相同,只看参数列表,不看返回值类型
    /*
    1,参数个数不同
    2,参数类型不同
    3,参数顺序不同(开发时不建议，因为没什么意义)
    */
    public static void main(String[] args) {
        double sum = getSum(3,4.0);
        System.out.println(sum);
    }

    //求两个数的和
    /*
    1,返回值类型int
    2,参数列表 int a,int b
    */

    public static double getSum(int a,double b) {
        return a + b;
    }

    //求三个数的和
    /*
    1,返回值类型 int
    2,参数列表 int a,int b,int c
    */


    public static double getSum(double a,int b) {
        return a + b;
    }