黑马程序员——>第二天<基础知(标识符、进制转换、if switch语句)>

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

2 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赋值和比较运算符
  赋值运算符
  =  +=  -=  *=  /=  %=
示例   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

用代码表示

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：根据用户定义的数值不同，打印对应的星期英文。

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冬季

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练习

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的使用范围更广

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