变量和运算符

1)在Java语言中,不能重复定义一个变量

2)目前来说定义的变量都是在main方法中,方法中定义变量都称为 "局部变量"
    这种变量必须在使用之前初始化,否则 jvm提示"可能尚未初始化变量"

class DataTypeDemo{
	
	
	public static void main(String[] args){
		
		//定义一个变量 a ,初始化值10
		int a = 10 ;
		int b = 20 ;
		int c = 30 ;
		//int a = 20 ;//已在方法 main(String[])中定义了变量 a
		
		
		//同一行上同时定义多个变量
		int x = 10,y = 25, z ;
		
		//System.out.println("z:"+z) ;//可能尚未初始化变量z
		
		//使用之前,给z初始化
		z = 30 ;
		System.out.println("z:"+z) ;
		
		
		
		
	}
}

变量相加和常量相加的区别:

变量相加:要考虑这两个变量的数据类型,小数据类型无法接受大数据类型,必须强制类型转换

常量相加:先相加,然后看计算结果是否在固定的类型范围内,在范围内就直接赋值

class  DataTypeDemo2{
	
	public static void main(String[] args){
		
		  
		  //定义三个变量
		  byte b1 = 10,b2 = 20,b ;
		  
		  //第一句话
		 // b=b1+b2 ;//不兼容的类型: 从int转换到byte可能会有损失
		 
		 //需要强转
		// b = (byte)(b1+b2) ;
		
		
		//第二句话
		b=10+20;
		
		System.out.println("b的结果是:"+b) ;
	}

byte x=129;

byte类型的取值范围:-128~127

129已经超出范围,整数类型默认值就是int,jvm在编译的时候通过不了,认为129应该int类型接收,而左边使用的byte类型,无法接受int类型,必须强转

class DataTypeDemo3{
	
	public static void main(String[] args){
		
		
		//定义一个变量x
		//byte x = 129 ;//不兼容的类型: 从int转换到byte可能会有损失
		
		//强转
		byte x = (byte)129;
		System.out.println(x) ;
	}
}

+:运算符,字符串拼接符号

"字符串"+任何数据="新的字符串"

任何数据+"字符串"="新的字符串"

class DataTypeDemo4{
	
	public static void main(String[] args){
		
		System.out.println("hello"+'a'+1+"JavaEE") ;//"hello"+'a' ="helloa"+1="helloa1"+"JavaEE"="helloa1JavaEE"
		System.out.println('a'+1+"hello"+"JavaSE") ;//97+1+"hello"="98hello"+"JavaSE"="98helloJavaSE"
		
		System.out.println("5+5="+5+5) ;//"5+5="+5="5+5=5" +5="5+5=55"
		System.out.println(5+5+"=5+5") ;//10+"=5+5" =  "10=5+5"
	}
}

基本算数运算符:+,-,*,/,%(模),求余数

class OperatorDemo{
	
	public static void main(String[] args){
		
		//定义两个变量
		int a = 3 ;
		int b = 4 ;
		
		//基本算术运算符:+,-,*,/,%(模),求余数
		System.out.println(a+b) ;
		System.out.println(a-b) ;
		System.out.println(a*b) ;
		System.out.println(a/b) ;注意事项:/:在Java语言中默认取整
		//System.out.println(a*1.0/b) ;
		
		System.out.println(a%b) ;//求余
		
		System.out.println("---------------------------------------------") ;
		
		//Java中,针对小数进行计算 (计算机小数数据的时候,伪计算),可能产生的小数值会无限制的近似于某个值
		
		//如果后期需要让小数进行精确计算:jdk提供了类 BigDecimal(常用类去讲)
		System.out.println(1.01/0.35) ;
		System.out.println(1.52-0.34) ;
	}
}

扩展算数运算符 :++或者--

情况1:单独使用,比较简单

        ++或者--在数据前面

        ++或者--在数据的后面

        无论在数据的前面还是后面,都是对当前变量的值进行自增1,或者自减1

情况2:参与运算使用

        ++或者--在数据前面:先进行自增1或者自减1,然后参与运算

        ++或者--在数据的后面:先进行运算,然后在自增1或者自减1

1)
	int a = 10;
	int b = 10;
	int c = 10;
	
	a = b++;    //a=10,b=11  ,c=10
	c = --a;    //a=9,    b=11,c=9
	b = ++a;    //a=10,b=10 c = 9
	a = c--;    //a=9,  b=10,c=8
请分别计算出a,b,c的值


2)
int x = 4;
int y = (x++)+(++x)+(x*10);    int y = 4 + (++5) +(6*10) = 70 

			(x++)---->x是4,将()看成一个整体,将4先给(),然后在自增1----5

基本赋值运算符:=

        将=右边的数据赋值给=左边的变量

        举例:int x=4;//将4这个值赋值给int类型的变量x

        等号不能写成==,==属于比较运算符,比较的是两个数据值相同

扩展赋值运算符:+=,-=,*=,/=,%=

        +=举例:int x=100;

                        x+=100;现在都是int类型,等价于x=x+100;

                        将=右边的数据和左边的变量值相加再赋值给左边的变量

class OperatorDemo{
	
	public static void main(String[] args){
		
		
		//基本赋值运算符=
		int a = 10 ;
		System.out.println("a的值是:"+a) ;
		
		//int b == 20 ; //=不能写成==,==比较两个数据是否相等,true或者false
		
		System.out.println("----------------------------------------") ;
		
		//定义一个变量m
		int m = 150 ;
		m += 200 ;  //都是int类型 等价于 int m = m+200 ;
		System.out.println("m:"+m) ;
	}

short  s = 1 ;
          s+=1 ;===等价于 (short)(s+1) ;

<,<=,>,>=,==,!=

这些符号连接的表达式无论是简单或者是复杂的,最终结果肯定是boolean类型,要么true,要么false

注意事项:==不能写成=

class OperatorDemo{
	
	public static void main(String[] args){
		
		//定义两个变量
		int a = 3 ;
		int b = 5 ;
		int c = 4 ; 
		
		//直接输出结果
		System.out.println((a+b)>=(a+c)) ;
		System.out.println((a+b)==(a+c)) ;
		System.out.println(a!=b) ;
		System.out.println((b+c)<(a+c)) ;
		
		
		System.out.println("---------------------------------") ;
		
		//可以使用boolean类型变量接收
		boolean flag = ((a+b)>=(a+c)) ;
		System.out.println(flag) ;
		System.out.println("---------------------------------") ;
		
		//定义一个变量m
		int m = 100 ;
		int n = 120 ;
		//boolean flag2 = m=n ; // 不兼容的类型: int无法转换为boolean (==不能写成=,==比较,=是赋值)
		boolean flag2 = m==n ;
		System.out.println("flag2:"+flag2) ;
	}
}

基本的逻辑运算符:

        逻辑单与&:并列关系(交集),有false,则false

        逻辑单或|:或的关系(并集),有true,则true

        逻辑异或^:相同则为false,不同则为true

        逻辑非:非true,则false;非false,则true;偶数个非是它本身

class OperatorDemo{
	
	
	public static void main(String[] args){
		//定义三个变量
		int a = 3 ;
		int b = 4 ;
		int c = 5 ; 
		
		//逻辑单与&:并列条件
		System.out.println((a>b) & (a>c)) ; //false & false =false
		System.out.println((a>b) & (ac)) ; // true & false = false
		System.out.println((ab) | (a>c)) ; //false | false =false
		System.out.println((a>b) | (ac)) ; // true | false = true
		System.out.println((ab) ^ (a>c)) ; //false ^ false = false
		System.out.println((a>b) ^ (ac)) ; // true ^ false =  true
		System.out.println((ab)) ;
		System.out.println(!!(a>b)) ;
	}
}

扩展的逻辑运算符:

        逻辑双与&&

        逻辑双或||

逻辑双与&&和逻辑单与&的区别?

        共同点:都表示并列关系,有false,则false

        不同点:

                        逻辑双与&&连接的表达式如果左边false,则右边不执行了,它具有短路的效果

                        实际开发中,针对逻辑判断,并列条件都使用&&,效率要比单与&要高,左边为false,整个结果就是false

                        逻辑单与&:执行效率低,左边false,右边还要执行

逻辑双或||:连接的表达式如果左边为true,则右边不执行,具有短路的效果,有true,则true

实际开发中,逻辑符号用的都是逻辑双与&&或者逻辑双或||

使用变量或者数据本身进行计算的

基本的符号:

        位与&:有0则0

        位或|:有1则1

        位异或^:相同则为0,不同则为1

        反码~:在数据的补码的基础上,全部按位取反,0变1,1变0

位移符号:

        <<,>>,>>>

class OperatorDemo{
	
	public static void main(String[] args){
		
		System.out.println(3 & 4) ;//3位与4
		System.out.println(3 | 4) ;//3位或4
		System.out.println(3 ^ 4) ;//3位异或4
		System.out.println(~3) ;//反码3
	}
}

位与&:有0则0
        
    将这个数据默认int    
    3和4的二进制数据---原码 ,反码,补码相同
    00000000 00000000 00000000 00000011    
    位与&
    00000000 00000000 00000000 00000100
    -------------------------------------------
    00000000 00000000 00000000 00000000
        
    结果:0
    
    
    位或|: 有1则1
    
    3和4的二进制数据---原码 ,反码,补码相同
    00000000 00000000 00000000 00000011    
    位或|
    00000000 00000000 00000000 00000100
    ------------------------------------
    00000000 00000000 00000000 00000111  ---补码---反码---原码
    
    结果:7
    
    
    位异或:^ :相同则为0,不同则为1

    
    3和4的二进制数据---原码 ,反码,补码相同
    00000000 00000000 00000000 00000011    
    位异或^
    00000000 00000000 00000000 00000100
    ------------------------------------
    00000000 00000000 00000000 00000111
    
    结果:7
    
    
    
    反码~:
        ~数据:不分最高符号位,所有的数据按位取反,0变1,1变0
    
    00000000 00000000 00000000 00000011 ---原码---反码---补码
    
    补码:
    00000000 00000000 00000000 00000011
    
    11111111 11111111 11111111 11111100  ----补码操作
    
    
    有符号位的数据表示法
    
    最高符号位        数值位      补码
        1            1111111 11111111 11111111 11111100
        -                                             1
        ------------------------------------------------
        1            1111111 11111111 11111111 11111011  反码
        -------------------------------------------------
        1            0000000 00000000 00000000 00000100
        
=        -                        4
   

关于位运算符号中位异或的最大特点:

        一个数据被另一个数据位异或两次,其值是它本身

class OperatorDemo2{
	
	
	public static void main(String[] args){
		
		//定义两个变量
		int a = 10 ;
		int b = 20 ;
		System.out.println(a^b^b) ;//10
		System.out.println(a^b^a) ;//20
	}
}

int a = 10 ;
    00000000 00000000 00000000 00001010---原,反,补相同
    
    int b = 20 ;
    00000000 00000000 00000000 00010100---原,反,补相同
    
    
    a^b
    00000000 00000000 00000000 00001010
    位异或^
    00000000 00000000 00000000 00010100
    ------------------------------------
    00000000 00000000 00000000 00011110    
    
    ^b
    
    
    00000000 00000000 00000000 00011110  
    位异或^
    00000000 00000000 00000000 00010100
    --------------------------------------------
    00000000 00000000 00000000 00001010
    
    = 10

位移符号:

        <<:左移

                将<<符号左边的数据向左移动多少位,右边不够的补0,最高位丢弃掉

                特点:将<<符号左边的数据乘以2的移动次幂

                3<<2=3*2^2=12

        >>:右移

                将符号位左边的数据向右移动多少位,

                        做高位是0,右移后,空缺位补0;最高位是1,最高位补1

                特点:使用>>左边数据除以2的移动次幂

                24>>2=24/2^2=6

         >>>:无符号右移

                将>>>符号位左边的数据进行向右移动,无论是高位是1还是0,都是补0

class OperatorDemo3{
	
	public static void main(String[] args){
		
		
		//<<
		System.out.println(3<<2) ;//3左移2位
		
		//>>
		System.out.println(24>>2) ;//24右移动2位
		
		
		//>>
		System.out.println(-24>>2) ;
		
		//>>>:无符号右移
		System.out.println(-24>>>2) ;
	}
}

3<<2:左移2位
    
    将3-----原码,反码,补码相同
            00000000 00000000 00000000 00000011
        (00)000000 00000000 00000000 0000001100----> 补码 000000 00000000 00000000 0000001100
        
        --反码---原码:相同00000000 00000000 00000000 00001100
        
        =12
        
        
        
        
    24>>2    24右移动2位
    
    24的原码,反码,补码相同
    00000000 00000000 00000000 00011000
      0000000000 00000000 00000000 000110  (00)
        00000000  00000000 00000000 00000110  补码----反码---原码 :相同
        
        
        =6
        
        
        
    -24>>2 :负的24右移2位
    
    1         0000000 00000000 00000000 00011000                -24  原码
    
    
    反码:最高符号位不变,数值位按位取反
    1         1111111 11111111 11111111 11100111         -24  反码
    +                                           1
    ------------------------------------------------
    1         1111111 11111111 11111111 11101000        -24的补码  移动向右移动2位
    
      111         1111111 11111111 11111111 111010(00)
      
      
      11111111 11111111 11111111 11111010 补码
      -                                    1
      ---------------------------------------
      11111111 11111111 11111111 11111001 反码
      10000000 00000000 00000000 00000110  原码
      
      -   6
      
      
      
      
      
      -24>>>2  无符号右移
      1         0000000 00000000 00000000 00011000                -24  原码
      反码:最高符号位不变,数值位按位取反
    1         1111111 11111111 11111111 11100111         -24  反码
    +                                           1
    ------------------------------------------------
    1         1111111 11111111 11111111 11101000        -24的补码  >>>2
    
      001         1111111 11111111 11111111 111010(00)
      
      001         1111111 11111111 11111111 111010  ---补码---反码---原码
      
      1,073,741,818

格式:(表达式)?执行true的结果:执行false的结果

执行流程:

        1)首先表达式是否成立,成立,则执行true的结果

        2)不成立,执行false的结果

没有提示类型,默认都是int

class OperatorDemo{
	
	public static void main(String[] args){
		
		//需求:有两个变量a,b,分别初始化,比较两个数据的最大值;
		int a = 10 ;
		int b = 5 ;
		
		//定义结果变量
		//(表达式)?执行true的结果:执行false的结果;
		int max = (a>b)?a:b;
		
		System.out.println("max:"+max) ;
		
	}
}