黑马程序员_Java语言基础组成

 Java语言基础组成
01标识符

 关键字 标识符 注释 常量和变量 运算符 语句 函数 数组

1.1关键字

  定义：被java语言赋予了特殊含义的单词

  特点：关键字中所有字母都为小写

1.2标识符

  在程序中自定义的一些名称。

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

  定义合法标识符规则：

    1 数字不可以开头

    2 不可以使用关键字

  Java中严格区分大小写

  注意：在起名字的时候，为了提高阅读性，要尽量有意义

Java中的名称规范：

  包名：多单词组成时所有字母都小写   xxxyyyzzz

  类名接口名：多单词组成时，所有单词的首字母小写，第二个单词开始每个单词首字母大写xxxYyyZzz

  常量名：所有字母都大写。多单词时每个单词用下划线连接。XXX_YYY_ZZZ

1.3注释

  用于注解说明解释程序的文字就是注释

  提高了代码的阅读性

  Java中的注释格式

      单行注释  //注释文字

      多行注释  /*注释文字*/

      文档注释  /**注释文字*/

 文档注释：（类上面，函数上面）对程序进行说明后，可以通过jdk当中的另外一款工具javadoc将这个程序当中的文档注释都提取出来，形成一个网页，这个网页，就是你所写程序的说明书。是给开发者使用的！

   注释小知识点   

   调试程序 单行注释中可以添加单行注释

                   多行注释中可以添加单行注释

                   多行注释中不可以添加多行注释 比如/*  /* */  */  (前面三个就结束了，最后一个就没有意义了) 不断的扩大调试范围
#注释是一个程序员必须要具有的良好编程习惯。

 初学者编写程序可以养成习惯：先写注释再写代码。

 将自己的思想通过注释先整理出来，再用代码去体现。

 因为代码仅仅是思想的一种体现形式而已

02常量

常量和变量

   常量表示不能改变的数值

   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开头表示

03进制的特点

  进制的由来：任何数据在计算机中都是以二进制的形式存在的，二进制早期由电信号开关演变而来；

  一个整数在内存中一样也是二进制的，但是使用一大串的1或者0组成的数值进行使用很麻烦。所以就想把一大串缩短点，将二进制中的三位用一位表示。这三位可以取到的最大值就是7，超过7就进位了，这就是八进制。

   但是对于过长的二进制编程八进制还是较长，所以出现的用4个二进制位表示一位的情况，四个二进制位最大是15，这就是十六进制。
  规律：进制越大，表现形式越短

04进制转换(二进制和十进制)

   二进制和十进制之间的转换

     十进制-->二进制。 原理：对十进制数进行除2运算

     二进制-->十进制。 原理：二进制乘以2的过程 110    0*2(0次幂)+1*2(1)+1*2(2)   110

   规律                                                                               0             +    2       +   4      =6

进制取后八位   从后往前依次是 (二进制位上的数1)*2(0次幂)+(0)*2(1)+(1)*2(2)......   最大取到128   将其相加就是 这个二进制八位表达的十进制数

    1 (255)   0     1        1      0      1         0       1

*  2(7)       2(6)  2(5)  2(4) 2(3)  2(2)   2(1)   2(0)

    128       64    32    16       8      4         2      1 

05进制转换(八进制和十六进制)

   二进制转成16进制(四个二进制位就是一个十六进制位)

       90          

      0101-1010     表示成二进制

        5    10 (A)    变成十进制

      90 = 0x5A     换成十六进制

   二进制转成8进制(三个二进制位代表一位)

    001 011 010

     1   3   2  

06进制转换(负数二进制)

  负数的二进制表现形式

    6 = 110

   -6 ：其实就是6的二进制取反+1

    取反：将二进制的1变成0,0变成1

 0000-0000 0000-0000 0000-0000 0000-0110  110在内存中的表现形式

 

  1111-1111 1111-1111 1111-1111 1111-1001  取反

+0000-0000 0000-0000 0000-0000 0000-0001  +1

————————————————————

 1111-1111 1111-1111 1111-1111 1111-1010  =-6

  规律：负数的最高位都是1.

07变量

  变量的概念：内存中的一个存储区域

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

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

  为什么要定义变量：用来不断的存放同一类型的常量，并可以重复使用

  什么时候定义变量？

      当数据不确定的时候，需要对数据进行存储时，就定义一个变量来完成存储动作

  使用变量注意：变量的作用范围(一对{}之间有效)

                初始化值

  定义变量的格式：数据类型 变量名=初始化值；

                 注：格式是固定的；记住格式，以不变应万变

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

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

     如何开辟内存空间呢？ 就是通过明确数据类型，变量名称，数据来完成

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

                                                                    整数类型(byte,short,int,long)

                                                     数值型

                                                                    浮点类型(float,double)

                            基本数据类型          

                                                     字符型(char)

  数据类型                                    布尔型(boolean)

                                                                                          类(class)

                           引用数据类型                                         接口(interface)  (两个值：指向一个具体的；不指向 为null)

                                                                                          数组([])

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

08类型转换

自动类型转换(也叫隐式类型转换)

强制类型转换(也叫显示类型转换)

类型转换的原理

什么时候要用强制类型转换？

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

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

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

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

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

分析：

  System.out.println('a')与System.out.println('a'+1)的区别

前一句 是把a那个字母效果显示出来  

后一句 字符a+1  进行了运算， a是两个八位    1是 四个八位    a会自动提升  a一提升就把里边的数字体现出来了

System.out.println((char)('a'+1))   将字符加一所得到的数字强制转换成字符

09运算符

                      范例               结果    

   算术运算符

      +  加           5+5                10

      -  减           6-4                2

      *  乘           3*4                12

      /  除           5/5                1

      %  取模         5%5                0

             规律 左边小于右边 结果是左边

                  左边等于右边 结果是0

                  右边是1      结果是0

      若出现负数 只看被模数(看左边，右边不管){面试}

                      1%-5                1

                      -1%5                -1

      ++ 自增(前)     a=2;b=++a;         a=3;b=3

           先加，再出去赋值

      ++ 自增(后)     a=2;b=a++;         a=3;b=2      a++-->a=a+1

         b=a++;   先把a的值进行赋值运算赋给b，然后a再自增(a先出去运算，然后自己再自增运算)         

        ++(给a这个变量中的值进行一次加1操作并把加1操作后的值从新赋给a) 

        规律  无论你怎么写   b的值不管   a的值肯定是3(都要自增)  

      -- 自减(前)     a=2;b=--a;         a=1;b=1

      -- 自减(后)     a=2;b=a--;         a=1;b=2

      +  字符串相加   "he"+"llo"         "hello"

           字符串数据和任何数据使用+都是相连接，最终都会变成字符串

           "5+5="+5+5-->"5+5=5"+5-->"5+5=55"

           "5+5="+(5+5)-->10

  以后再做打印的时候，输出结果要看着直观有意义都需要做这样的动作(将固定的放到字符串里(双引号里)把不固定的与双引号连接)；用字符串与别的数据相连接

10转义字符

   通过\来转变后面字母或者符号的含义。

   \n:换行

   \b:退格   相当于backspace

   \r:按下回车键。windows系统，回车符是由两个字符来表示\r\n

   \t:制表符。相当于tab键

    (当想在屏幕上显示双引号时，不能两个双音后相套)

   {""hello""} 当中双引号用来标示字符串，

   {"(字符串开始)"(字符串结束)hello(就会变成无效代码)""}

这个时候需要转变双引号的含义{"\"hello\""}[转义字符应该写在被转义字符的前面]

    (两端都有反斜线时)

    {""hello""} -->{"\\hello\\"}

  char ch = '\n'   等号右边相当与一个回车符 

     

   '''这是错的

     '\'' 转一下就对了

   ''号里也可以装中文，因为一个中文是两个字节(十六个二进制位组成)组成  char类型是两个字节

11赋值和比较运算符

  赋值运算符

  =  +=  -
1adf1
=  *=  /=  %=

示例   int a,b,c;   a=b=c=3;

       int a = 3;  a+=5;等同运算a=a+5
思考

   short s = 3;   short内存占两个八位

   s = s+2;       int占四个八位    右边变成四个八位，不能赋值给左边两个八位 容易丢失精度

   s+=2;有什么区别

s =s+2  编译失败，因为s会被提升为int类型，运算后的结果还是int类型。无法赋值给short类型。

s+=2    编译通过，因为+=运算符在给s赋值时，自动完成了强转操作。(内部有一个自动转换动作)

    int x=3;  叫做右边赋值给左边

    x+=3；(x=x+3)把左右两边的和赋值给左边

 特殊形式

int a,b,c;

a=b=c=5;同时给abc赋值这句话是正确的！！！

比较运算符

==    相当于                     4==3                         false

!=    不等于                     4!=3                         true

<     小于                       4<3                          false

>     大于                       4>3                          true

<=    小于等于                   4<=3                         false

>=    大于等于                   4>=3                         true

instanceof  检查是否是类的对象  "Hello" instanceof String     true

   比较运算符的结果都是boolean型，也就是要么是true，要么是false

   比较运算符"=="不能误写成"="(赋值运算符)

12逻辑运算符(重点)

逻辑运算符用于连接boolean类型的表达式

 &    and(与)           false &  true        false  

    true  & true  = true 

    true  & false = false 

    false & true  = false 

    false & false = false

特点 只要两边的boolean表达式结果，有一个为false，那么结果就是false；

     只有两边都为true，结果为true
 |    or(或)            false |  true        true

 true  | true   =  true

 true  | false  =  true 

 false | true   =  true 

 false | false  =  false

特点 两边只要有一个为true，结果为true

     只有两边都有false，结果为false
 ^    xor(异或)         false ^  true        true  就是和|有点不一样，当true^true=false

 true  ^  true  = false 

 true  ^  false = true 

 false ^  true  = true 

 false ^  false = false

特点 两边相同结果是false；

     两边不同结果是true
 !    not(非)           !  true        false

 &&   and(短路)         false && true        false  短路就是左边运算完为假，右边就不运算
&和&&的特点

   &：无论左边是true还是false，右边都运算

   &&：当左边为false时，右边不运算

 ||   or(短路)          false || true        true

特点

|：两边都参与运算

||：当左边为true，右边不运算(两边只要有一个为true，结果为true)

13位运算符

左移  右移(其中位表示二进制的位，是用来进行二进制运算的一种运算符号)

<<   左移           3<<2=12-->3*2*2=12   相当于乘与2的倍数 其实就是乘以2的移动的位数的次幂

    3<<2=12;

         0000-0000 0000-0000 0000-0000 0000-0011

     0000-0000 0000-0000 0000-0000 0000-001100   补零

>>   右移           3>>1=1-->3/2=1       相当与除以2的倍数 其实就是除以2的移动位数次幂

          移n位，就是对乘以或者除以2的n次幂

    用处：做运算时，最快的运算是位运算

     6>>2=1

       0000-0000 0000-0000 0000-0000 0000-0110

       000000-0000 0000-0000 0000-0000 0000-0110 最后两位不要

   规律：一个数往左移，越移越大；往右移，越移越小(个位有效位最后会移光)

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

    >>：最高位补什么由原有数据的最高位值而定；

        如果最高位0，右移后，用0补空位

        如果最高位1，右移后，用1补空位

   >>>：无论最高位是什么，右移后，都用0补

14位运算符(与-或-异或)

0视为假，1视为真

&    与运算         6&3=2

    110   真真假

  &011   假真真

————

   010   假真假

|    或运算         6|3=7

   110

  |011

————

   111

^    异或运算       6^3=5

     110

    ^011

————

     101

~    反码           ~6=-7

    000....000110     6的二进制表现

  ~111....111001     6的取反   十进制表示为-7

   -000....000001    -7减1 

  =111....111000    得数取反  

  ~000....000111    就是整数7，加上负号就是第二行的-7

位运算符的细节

<<  空位补0，被移除的高位丢弃，空缺位补0

>>  被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，空缺位补1

>>> 被移位二进制最高位无论是0或者是1，空缺位都用0补

&   二进制位进行&运算，只有1&1时结果是1，否则是0

|   二进制位进行|运算，只有0|0时结果是0，否则是1

^   任何相同二进制进行^运算，结果是0；1^1=0;0^0=0

    不相同二进制位^运算结果是1；1^0=1;0^1=1

    一个数异或同一个数两次，结果还是那个数(用处：加密算法)

技巧   二进制1就是true；0就是false

15位运算符(练习)

1.最有效率的方式算出2乘以8等于几？

2<<3

2.对两个整数变量的值进行互换(不需要第三方变量)

int n=3,m=8;
//1,通过第三方变量(真正开发中用这种)

int temp;

temp = n;

n = m;

m = temp;

这种方式最容易想到，最容易简单应用，阅读性很强，

//2,不用第三方变量

11=3+8

3=11-8

8=11-3

n=n+m   //如果n和m的值非常大，容易超出int范围

m=n-m

n=n-m   局限性：int型有最大值(2的31次方减1)；n和m都是int型，两个数值相加就超出int型的范围(容易损失精度)

这种方式容易超出范围

//3,用异或中的(一个数与另外一个相同的数异或两次还是原来的数)

n=n^m;

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

n=n^m;//n^(n^m)  这种方法不涉及到超值范围的运算

这种方式是一种技巧型方式，

16-位运算符(练习2 三元运算符)

在求一个数的十六进制的时候，就是在获取它这个32位二进制中的每四位，那么每四位获取怎么获取？要拿到二进制当中的最低四位做什么运算？分析：先不看左边一大部分，就看最低四位，最低四位我要想拿到其实拿的是最低四位当中的有效位那个1，怎么拿那个1呢？只拿1剩下的都不要，是不是代表着拿四个1&一下，为什么这样想(只有真&真时结果为真，剩下的全为假)；而最低四位中我只要1就是只要真，拿一堆真和它&一下，就这样取到一次最低四位。第一组取完怎么取第二组？最低四位取完可以不要，把原来的数向右移四位，把那四位移光后，第二组四位就变成最低四位，再拿这个最低四位和四个1一&，就将第二个四位取出来。以此类推，移几次就能够将其中的数全取出来，取完每个数后，再换算成十六进制

0000-0000 0000-0000 0000-0000 0011-1100  =60；

60&15=12

0000-0000 0000-0000 0000-0000 0011-1100  

0000-0000 0000-0000 0000-0000 0011-1111

————————————————————

0000-0000 0000-0000 0000-0000 0000-1100 = 12

temp=60>>4

temp&15=3

0000 0000-0000 0000-0000 0000-0000 0011  (-1100)  60 

0000-0000 0000-0000 0000-0000 0011-1111          15

————————————————————

0000 0000-0000 0000-0000 0000-0000 0011   =3

用代码表示

[java] view
plaincopy

int num = 60;//获取60的最低4位，通过&15；  

int n1 = num & 15;  

  

System.out.println((char)(12-10+'A'));  //  (n1>9?(char)(n1-10+'A'):n1)  

                                                       //要获取下一组四位，将60右移4位；  

int temp = 60 >>> 4;   //(为什么要用三个>号右移：要把原有数据移光，最终移到0)  

  

int n2 = temp & 15;       //对temp的值进行最低四位的获取  

System.out.println(n2);    //  (n2>9?(char)(n2-10+'A'):n2)  

 

    

 

0-9      'A' 'B' 'C' 'D' 'E' 'F'

ASSIK码  65  66   67  68  69  70

         10  11   12  13  14  15

  12 - 10 = 2 + 'A' = (char)67 减去数字基数，得出的结果再加上字母基数('A')

想的方式：十六进制中你算的那个数字超出了数字基数多少个，先算这个值；算完后让它加上字母的基数使之继续顺延(12-10超过两个，对应字母'C','C'对应的ASSIK码值为67,67也是超过65两个，那么将超过的值加上字母基数'A'得出数值，将这个数值强转回来就是对应的字母'C')

三元运算符(?  : 三个元素参与运算的符号)

一定有结果  若是一个字符和数字比较，字符会自动提升
格式 (条件表达式)?表达式1:表达式2;

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

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

（1）如果表达式1和表达式2具有相同的类型，那么整个条件运算符结果的类型就是这个类型。

（2）如果一个表达式的类型是T，T是byte或short或char，另一个表达式的类型是int类型的常量表达式，而且这个常量表达式的值是可以用类型T表示的（也就是说，常量表达式的值是在类型T的取值范围之内），那么整个条件运算符结果的类型就是T。

（3）除以上情况外，如果表达式1和表达式2的类型不同，那么将进行类型提升，整个条件运算符结果的类型就是提升后的类型。

17语句(if)

程序流程控制

顺序结构  从入口进来，然后一条一条语句执行

判断结构

if语句

三种格式

1.

if(条件表达式)    满足条件为真，才会执行大括号内的语句，否则不执行

{                  如果if后没有大括号，只控制离它最近的那个单挑语句

  执行语句;

}

2.

if(条件表达式)

{

  执行语句;

}

else

{

 执行语句;

}

区别！！！

if else 结构  简写格式： 变量=(条件表达式)?表达式1：表达式2; 
三元运算符：好处：可以简化if else代码

            弊端：因为是一个运算符，所以运算完必须要有一个结果。

3.

if(条件表达式)

{

  执行语句;

}

else if(条件表达式)

{

 执行语句;

}

.....

else

{

  执行语句;

}

&18if练习

需求1：根据用户定义的数值不同，打印对应的星期英文。

[java] view
plaincopy

int num = 1;  

if(num==1)  

   System.out.println("monday");  

else if(num==2)  

   System.out.println("tsd");  

else  

   System.out.println("nono");  

需求2：根据用于指定月份，打印该月份所属的季节。

3，4，5春季 6,7,8夏季 9,10,11秋季 12,1,2冬季

[java] view
plaincopy

int x = 4;  

if(x==3||x==4||x==5)  

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

else if(x==6||x==7||x==8)  

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

else if(x==9||x==10||x==11)  

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

else if(x==12||x==1||x==2)  

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

else  

   System.out.puintln(x+"月份不存在");  

  

  

if(x>12||x<1)  

  System.out.println(x+"月份不存在");  

else if(x>=3 && x<=5)  

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

else if(x>=6 && x<=8)  

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

else if(x>=9 && x<=11)  

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

else   

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

写软件的目的是为了处理数据的，数据是不确定的，是由用户帮你输入的，那么他输入什么我们不知道，怎么办？我们一定要先对数据判断，只有正确的数据才能由我们的软件帮他运算，非正确数据我们不要运算，应该很人性化的给用户一个提示，这才是做软件的一个基本道理！！

19语句(switch)

switch语句

格式

 switch(表达式)

{

   case 取值1： case用来定义备选答案  取值就是答案的具体内容

     执行语句;

      break;      跳出switch语句

   case 取值2:

     执行语句;

       break;

      .......

        default;   缺省默认，当所有都不对的情况下就读这个默认情况

      执行语句;

        break;

}
switch语句特点：

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

b.case之间与default没有顺序，先执行第一个case，没有匹配的case执行default

执行顺序是固定的，定义的位置可以不固定

c.结束switch语句的两种情况：遇到break，执行到switch语句结束

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

20switch练习

[java] view
plaincopy

int x = 4;  

switch(x)  

{  

 case 3:  

 case 4:  

 case 5:  

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

     break;  

 case 6:  

 case 7:  

 case 8:  

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

     break;  

 case 9:  

 case 10:  

 case 11:  

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

     break;  

 case 12:  

 case 1:  

 case 2:  

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

     break;  

 default:  

     System.out.println("nono")  

}  

switch 和if 的区别 if 除了能判断具体数值还能判断区间，switch判断区间会很费劲；对于运算结果是boolean型的if能判断，switch不能判断  重点:开发时选择哪个合适：如果你要对具体数值进行判断的话，数值不多，用switch完成(一加载，答案全进内存，在内存中直接判断就可以；而if需要顺序执行，写好多条if语句);其他情况一般都用if

if和switch语句很像

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

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

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