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

*/

}