java之2天运算符,进制转换,流程控制

java的语言的基础组成

1.关键字:  被java赋予了特殊意义的单词
2.标识符:  类名  函数   26个字母  0-9   _ $ ,不能数字开头 不使用关键字
           包名: 全小写
           类名 接口名: XxxYxxZzzz 所有单词首字母大写
           变量和函数名:   xxxYyyZzzz: 第一个单词首字母小写,其余单词首字母大写
           常量名: XXX_YYY_ZZZ 所有字母都大写.多单词每个单词用"_" 连接

3.注释  :  单行, 多行, 文档 , 不能嵌套注释

4.常量和变量:

5.运算符
6.语句
7.函数
8.数组

常量

整数的表示方式
 十进制:0-9,
 八进制 0-7 用0 开头,
 十六进制:0-9 A-F 用0x开头,
 二进制 1 和0
             小数点
             布尔类型常量 
             字符常量  
             字符串常量
             null常量

    1.  一个字节用 8个二进制位 表示 可以用 8个开关 表示 
    2.  8进制是   3个二进制表示一位 (3个二进制的最大数是 7)
    3.  16进制是  4个二进制表示一位 (4个二进制的最大数是 15) 
    4.  8位的二进制的最大值 就是  255 ,可以想到 IP地址中 最大数就是 255,说明ip使用字节表示的 .  

   Interge.toBinaryString(-6);    \\java中将二进制 转换成 十进制的方法
   Interge.toBinaryString(6);

变量

变量:就是将不确定数据进行存储,也就在内存中开辟一个存储空间.
有明确的数据类型, 变量名, 数据 来完成

数据类型

数据类型:  基本数据类型  引用数据类型
 
基本数据类型 : 数值型     整数类型byte(8位二进制-128~127) short(16二进制32767) int(32位二进制65535) long(64位二进制)          浮点类型(float(32位进制),double (64二进制)

               字符型  char (0-32767)   16位 
               布尔型  boolean

引用数据类型 :  类     class   
                接口   interface
                数组   [] 

类型转换

1.自动类型提升,将两个不同类型数值运算 提升为同一种类型 然后再进行运算.
2.强制类型转换,有风险,可能会损失精度. 一般用于保留整数部分
3.float和int进行运算的时候 结果为 float 类型

运算符

1.算术运算符 ：　+ - * /  %   ++  --  
2.赋值运算符
3.比较运算符
4.逻辑运算符
5.位运算符
6.三元运算符

代码1

//注意整型元算时候  小数点后面的都会舍弃
public static void main(String [] args){
   int x=4272;
   x=x/1000*1000;   //4270/1000=4.27-->int x=4  -->*1000--->int x=4000
   System.out.println(x);    //   4000  
}

取模
左边小于右边    结果 为左边
左边=右边       结果 为 0
右边为 1        结果 为 0 

出现 负数  只看 左边
1 % -5          结果 为  1
-1 % 5          结果 为 -1

public static void main(String[] args){
int a=3,b;
b=a++;   --->  b=3  a=4
b=++a;   --->  b=a=4
//  ++ 在前        先加
// ++ 在后        后加

System.out.println("5+5="+5+5);   // 5+5=55 (不是五十五) 是 五五
System.out.println("5+5="+(5+5));   // 5+5=10 
}

转义字符 \

转移字符:通过 \ 来转变后面字符或者符号的意义
\n: 换行
\b:退格 相当于 backspace
\r:按下回车键.window系统中回车符是由连个字符来表示\r\n  在linux DOS下面是使用 \r 表示
\t: 制表符.相当于tab键
System.out.println("hello \n world");

System.out.println("\"hello\"");
System.out.println("\\hello\\");

赋值运算符  

public static void main(String[] args) {
//   +=  -= *= /= %=  前面都是一个运算符 不是两个运算符
int x=3;
x+=4;  ==>  x=x+4;  

short s=4;
s=s+5;   // 先将 x自动类型提升 为 int 然后  =5 等于  9  然后 int 9  赋值给 short s  丢失精度 编译失败 ,需要强制类型转换

s+=5;   //编译通过  会自动完成强制类型转换 所以就通过了. 

int a,b,c;
a=b=c=5;  //编译通过

}

比较运算符 只可能是  true  和false

//   != > < >= <= == instanceof 

public static void main(String[] args) {
  System.out.println("hello" instanceof String);
}

逻辑运算符

&    and
|    or 
^   异或
!   not  非
&&  and (短路) 
||  or (短路)

public static void main(String[] args) {

//短路 案例
        int x=4;  
        System.out.println(x>4 && x++<5);
	System.out.println(x);     // 4
	System.out.println(x>4 & x++<5);
	System.out.println(x);     //5


/*  &  &&  和  |  ||
&  : 无论左边 是true 还是 false  右边都运算
&& : 当左边为false时, 右边不运算

|  : 两边都运算
|| : 左边为false 的时候 , 右边不运算
*/


/* & 与
true & true   =true;
true & false  = false
false & true  = false
false &  false =false
只要有一个false  结果就是false
两边都为 true 的时候  才为 true
*/

/*  |  或
true | true =true
true | false  =true
false | true =true
false | false =false

只要有个 true  结果为 true
都为 false 的时候就为 false
*/

/* ^ 异或
true ^ true =false
true ^ false =true
false ^ true =true
false ^ false= false
两边结果相同 为 false
两边结果不同 为  true
*/

/*  !
 !true =false;
!!true=true;
!!!true=false;
*/


}

位运算符号

// <<左移动  >>右移  >>>无符号右移  &与  |或   ^异或  ~反码

         3<<2   
 二进制  11
         1100  ==>  12
         
         6>>2    ==>  6/ 2*2=1
         110
         1  = 1

         6>>1=3  ==>  6/ 2=3

       3<<2 =12    3<<3=24
       3*2*2=12    3*2*2*2 =24  

  左移动    <<      就是 * 2的n位次幂    右边 补 0 
  右移动    >>      就是  / 2 的n位次幂  移动后 高位 补什么由原高位值定


  >>   移动后 高位 补什么由原高位值定
  >>>  不管 是负数还是正数  高位 都用 0 补 

// &: 与

6 & 3= 2

  110    0 是假  1 是真
& 011
-----
  010  ==>   假真假  ==>2

一个数 与 自己 等于自己
6 & 6 = 6
//  |: 或

6 | 5 =7

   110
|  101
-------
   111  ==>真真真  ==> 7

一个数 或 自己 等于 自己
6 | 6 = 6

//异或 ^

// ^ 异或
6 ^ 5 ==  3

   110       0 假  1 真
^  101
-------
   011  ==> 假真真 ==> 3


异或: 一个数 异或一个数两次 结果还是 那个数.
      一个数 异或 自己 = 0
      6^6=0 

// ~ 取反

//  ~ 反码 规律 N = -N-1
一个数取反 = 这个数的相反数 -1  

   ~6 =  -7

    0000...  0110
~   1111...  1001      -->取反      -7   
    0000.....0001      -->减1
    1111.....1000            
    0000.....0111     --> 取反     ==>7  

  -6 == 6的二进制取反 + 1 ==> 6的取反　=　 -6 -1 =-7
  A  =  B  +  C           ==> B　　　　=  　A-C
  
  
  ~ 9 来试试  是不是 = -9 -1  =-10 

     0000 .... 1001
取反 1111 .....0110   A:一个负数不好算 就算他的正数取反数B  所以减一
-    0000 .... 0001
-------------------
     1111 .... 0101      B的取反   去掉反  ==> B
     0000 .....1010      B=10   ===>  A=-10 =10取反+1

//求负数的 二进制

  -6= 6的取反+1;

  6取反= -6-1;

问题1. 2 乘以  8 的最有效运算 就是  2<<3  =2*2(3)= 2*8=16  
问题2: 两个数的 互换 

public static void main(String [] args){   
int n=3,m=8;
方法一: 使用中间变量 temp  

方法二:   两个数比较大的时候 容易丢失精度
    n=n+m;
    m=n-m;
    n=n-m;


方法三: 技巧性方式没有丢失精度
   n=n^m;
   m=n^m;   // (n^m)^m = n
   n=n^m;   // (n^m)(n^m)^m = m
}

位移运算的巧用 求一个数的16进制位数

注意下使用  >>> 才对 不是  >>


流程控制语句

1.判断结构
2.选择结构
3.循环结构

if 和三元运算符 的比较

public static void main(String [] args0){

int a=3;
if(a>2)
   System.out.println("a");
if(a>3)
  System.out.println("b");

int x=2,b;

b=(x>3)? 100:200; 

b=(x>1)? System.out.println("a"):200;  这样就不行 


/*
if esle 的简写格式为: 变量= (条件表达式) ? 表达式1: 表达式2;

三元运算符:
  好处: 可以简化if else 代码
 qu  弊端:  因为是一个运算符,所以运算完后必须有一个结果.


*/

}

switch的使用
switch 在  5.0 的时候 增加了对枚举类型的判断
在  7.0 的时候增加了对字符串类型的判断

public static void main(String[] args){
  int x=3;

  switch(x){  //byte short int char
      default:  
           System.out.println("d");           // 4 
      case 2:
           System.out.println("a");   // 1 判断        5 不判断
      case 4:
           System.out.println("b");  // 2 判断        6  不判断 -->  跳出 
           break;
      case 6:
           System.out.println("c");  // 3 判断
           break;

    //结果  d  a  b   
    //当某一次匹配成功,而没有遇到"break" 的时候,接下来,程序 不会判断剩下的case 而是直接运行下面的可以执行语句,直到遇到 break 或者 switch 结尾 "}"
    //default 总是最后执行的,提前是没有遇到break;
    //如果运行到default后,但是 default里没有break,那么程序还会一直往下运行,知道遇到break; 或者 "}" 结束判断
 
  }

  switch(x){
       case 3:
       case 4:
       case 5:
              System.out.println("春季");
       case 6:
       case 7:
       case 8:
              System.out.println("夏季");
       case 9:
       case 10
       case 11:
              System.out.println("秋季");
       case 12:
       case 1:
       case 2:
              System.out.println("冬季");
       default:
            System.out.println("you are so best!"); 

  }

/*
 if 和switch 很像

 具体什么场景下,应用那个语句呢?
 如果判断的具体数值不多,而是符合  byte short int char 这四种类型 
 虽然 两个语句都可以使用, 建议使用switch 语句  ,因为 效率稍高 
  
 其他情况,对区间判断,对结果为 boolean 类型判断 ,使用 if ,if使用范围更广

*/

}