day02-Java学习

最新推荐文章于 2024-10-16 18:20:22 发布

谪缺day

最新推荐文章于 2024-10-16 18:20:22 发布

阅读量261

点赞数

分类专栏： Java学习文章标签： java

本文链接：https://blog.csdn.net/baidu_41884426/article/details/107425138

版权

Java学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

第二天学习总结

1.数据类型转换

低精度–>高精度。
高精度–>低精度时：需要进行强制类型转换，不然编译无法通过。
例如：

byte a = 1;
int b = 10;
byte a = (byte) (b+1);

变量参加的运算时，首先看的是数据的类型。然后看其值是否在类型的取值范围内

变量在进行运算的时候,需要保证这些数据的类型一致!

Java中存在强制类型转换:
语法格式:
目标数据类型变量名 = (目标数据类型)(变量值) ;

注意事项:
强制类型不要随便使用,损失数据的精度!

适用范围:基本数据类型以及引用类型

	class DataTypeDemo4{
	public static void main(String[] args){
    //定义两个变量
	int a = 3 ;
	byte b = 4 ;
	
	//目标数据类型  变量名 = (目标数据类型)(变量值) ;
	byte result = (byte) (a + b) ;
	System.out.println(result) ;
    }
    }

Java存在默认类型提升(基本数据类型):
byte,short,char三者不会相互转换,一旦这三个中间的某个类型参与运算了,它会提升
int类型(考点)—long类型–double类型

注意:
boolean类型的变量不会进行数据类型的相互转换(true/false)

2.变量的定义

定义变量的注意事项:

1)要遵循的变量的三要素
数据类型变量名 = 初始化值;
2)先定义,但是必须在使用之前对这个变量进行初始化,否则编译不通过

3)Java是一种强类型,不能重复定义变量

Java语言数据类型的划分:
	两大类:
		基本数据类型
		四类八种
		整数类型
byte: 字节类型	占1个字节  byte  范围:-128~127(重点)   
					short:短整型				                 占2个字节
					int(整数默认的类型):整数类型   				占4个字节
					long:长整型						          占8个字节

应用场景:定义时间(系统时间换算成时间毫秒值)相关的变量(都是用long类型)
							浮点类型:(小数默认的就是double类型)
								单精度:float类型				    占4个字节
								双精度:double类型				占8个字节
							字符类型:		
								char类型						  占2个字节
							布尔类型							 占1个字节
								boolean类型(true/false)			
					应用场景:用在逻辑判断中,布尔类型一般不参与运算!

2.引用数据类型 :数组,类(具体类,抽象类),接口

面试题:

byte b ,b1=3,b2 =4 ; 
		
		b = b1 + b2 ;
		b = 3 + 4  ; 
/*两个整数常量
		
		//  b = b1 + b2 ; 此句编译错误
		
		变量相加,先判断类型,然后看是否存在默认提升,最接接收的类型是什么类型,判断是否符合结果类型

		常量相加:先相加,然后看其结果是否在接收类型的 范围之内,在范围,就正确!
				byte:-128~127
 */

class DataTypeDemo6{
	public static void main(String[] args){
		
		//定义三个变量
		byte b, b1 = 3 ,b2 = 4;
		//b = b1 + b2;//不兼容的类型: 从int转换到byte可能会有损失
		//存在java的隐式类型转换:byte,short,char三者之间不转换,
		//一旦参与运算,对应的类型都先默认提升int.
		
		//使用小的类型来接收大的结果类型, 解决方案:强制类型转换
		//b = (byte)(b1+b2) ;
		//System.out.println(b) ;
		
		b = 3 + 4 ;
		System.out.println(b) ;
		
	}
}

//求出 byte b = 130 ;
class DataTypeDemo7{
	public static  void main(String[] args){
	//-128~127
	//byte b = 130 ;//从int转换到byte可能会有损失
	
	//存在问题:超出了byte类型范围,结果:整数默认int,需要将int--->byte 强制类型转换
	byte b = (byte)130;
	
	System.out.println(b) ;//-126
 }
}

整数默认int : 4个字节 

//130对应二进制数据是:0b10000010

130整数的:原码

最高符号位:0  原码,反码,补码都一样
	00000000	00000000	00000000	10000010
	
	
补码: 计算机底层计算需要用补码进行计算:byte b = (byte)130;
	00000000	00000000	00000000	10000010
	
截取三个字节---->变成一个字节:byte类型

计算后的结果:	10000010  (补码)

最高符号位					数值位
	1					0000010				补码

                                                              -1

    1		            0000001				 反码

负数的反码--->原码:最高符号不变,数值位按位取反,0变1,1变0
	1						1111110			原码
	
结果:

-						64+32+16+8+4+2	=   126

3.“+”用法java

+:

	表示一个数据是正数,同时也能表示一个字符串拼接符号,也能做加法运算，字符串拼接符号使用居多。
字符串数据+(拼接符号) 任何数据= 新的字符串

class DataTypeDemo8{
	public static void main(String[] args){
		
		//+:此时就是运算符号
		//字符参与运算的时候,就需要在ASCII码表中找对应的数据值进行计算
		//'a'----- 97 (代表小写字母字符)
		//'A'----- 65 (代表大写字母字符)
		//'0'----- 48 (代表数字字符)
		System.out.println('a'+1) ;
		System.out.println('A'+1) ;
		System.out.println('0'+1) ;
		
		int a = 10 ;
		System.out.println("a:"+a) ;//"a:10"
	}
}

字符串+任何数据=字符串数据

class DataTypeDemo9{
	public static void main(String[] args){
		System.out.println("hello"+'a'+1) ;//"helloa"+1 = "helloa1"
		System.out.println('a'+1+"hello") ; //97+1 +"hello" = 98+"hello" = "98hello"
		
		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"
	}
}

4.算术运算符

Java中的运算符号的分类:
算术运算符:
基本的算术运算符:
+,-,*,/(默认取整),%(模)

扩展的算术运算符: ++或者–
赋值运算符:
关系(比较)运算符
逻辑运算符
位运算符
三目(三元)运算符

class OperatorDemo{
	
	public static void main(String[] args){
		
		//定义两个变量
		int x = 3 ;
		int y = 4 ;
		
		System.out.println(x+y) ;
		System.out.println(x-y) ;
		System.out.println(x*y) ;
		//System.out.println(x/y) ; //默认取整
		//计算具体结果:浮点类型
		System.out.println(x*1.0/y) ; //小数
		System.out.println(x%y) ;
		System.out.println("----------------") ;
		System.out.println(1.0-0.32) ;//0.6799999999999999 (永远近似某个值)
		//如果小数做减法或者除法要精确计算: 常用类:BigDecimal(针对小数进行精确计算)
	}
}

扩展的算术运算符: ++或者–

++或者--:
	情况1:
		单独使用:无论操作符++或者--在数据的前面还是数据的后面,都是对当前数据本身的值进行
		自增1或者自减1;
	情况2:
参与运算使用:
	1)如果++或者--在数据的前面,是先对当前数据值进行自增1或者自减1,然后参与运算
	2)如果++或者--在数据的后面,先运算,然后在对该数据值本身进行自增1或者自减1

class OperatorDemo2{
	public static void main(String[] args){
		
		//定义两个变量
		int a = 3 ;
		int b = 4 ;
		System.out.println("a:"+a) ;
		System.out.println("b:"+b) ;
		System.out.println("--------------------------") ;
		
		//单独使用
		//运算符在数据之前(++或者--在数据的前面)
		//++a;
		//--b ;
		//++或者--在数据的后面
		a++ ;
		b--;
		System.out.println("a:"+a) ;
		System.out.println("b:"+b);
		System.out.println("--------------------------") ;
		
		//定义两个变量
		int x = 3 ;
		int y = 4 ;
		System.out.println("x:"+x) ;
		System.out.println("y:"+y) ;
		
		System.out.println("--------------------------") ;
		
		//++或者--参与运算使用
		//1)在数据的前面
		//int m = ++ x ; 
		//int n = -- y ;
		
		//2)在数据的后面
		int m = x ++ ; //m = x = 3 ;        x ++= 3+1 = 4 ;
		int n = y -- ;//n = y = 4 ;			y -- = 4-1 = 3 ;
		System.out.println("x:"+x) ;
		System.out.println("y:"+y) ;
		System.out.println("m:"+m) ;
		System.out.println("n:"+n) ;
		
	}
}

练习题

class OperatorTest{
	public static void main(String[] args){
		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
		System.out.println("a:"+a+",b:"+b+",c:"+c);
		
		System.out.println("--------------------------");
		
		int x = 4; //初始化值	 (JVM:变量区 / (暂存区))
			//x = 5 ---->6
		int y = (x++)+(++x)+(x*10) ; // y = 4 + 6  + (6*10) =  70;
		System.out.println("x:"+x+",y:"+y) ;
		
	}
}

5.赋值运算符

赋值运算符:
基本的赋值运算符:
=
将等号右边的值赋值给等号左边的变量;
int a = 10 ; 将整数10赋值给int类型的变量a

   赋值运算符:
   基本的赋值运算符:
		= 
		将等号右边的值赋值给等号左边的变量;
		int a = 10 ; 将整数10赋值给int类型的变量a  
		注意:= 不能写成==(比较运算符)
	扩展的赋值运算符
	+=,-=,*=,/=,%=...
	
	举例:
		+=
			将等号左边的数据和右边的数据相加,在赋值给左边的变量

class OperatorDemo{
	public static void main(String[] args){
		
		int a = 10 ;
		int b ; 
		
		b = a = 20 ;//将整数20赋值给变量a,将a结果留下来再赋值给b
		//b = a == 20 ; //将整数20和a的进行比较(不兼容的类型: boolean无法转换为int)
		System.out.println("a:"+a+",b:"+b) ;
		System.out.println("---------------------") ;
		
		int x = 20 ;
		x += 10 ;  //相当于 x = x + 10 ;
		System.out.println(x) ;
	}
}

面试题

short s = 1 ;
s = s+ 1;
s+=1 ;

后面哪一句会编译失败,原因什么?如何解决呢?

第二句会编译失败,byte,short,char三者不转换,一旦参与运算—>默认先提升int类型
s = (short)(s+1) ;

扩展的赋值运算符里面隐藏了一个强制类型转换(不会出现问题)

class OperatorTest{
	
	public static void main(String[] args){
		
		//定义一个变量
		short s = 1 ;
		
		//s = s + 1 ; //肯定会失败,byte,short,char三者不转换,一旦参与运算--->默认先提升int类型
		//等号的右边int类型,等号左边short类型,不能接收结果!
		//解决方案
		
		//s = (short)(s+1) ;
		//System.out.println(s) ;
		
		
		s += 1 ;//等价于s = (short)(s+1) ;
		System.out.println(s) ;
	}
}

6.关系比较运算符

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

特点:使用比较符合连接的表达式无论是简单表达式还是复杂的表达式,结果都是boolean类型

注意:
== 比较的两个数据值是否相等,不要写成= (赋值运算符)

数学表达式: 3<=x<=5
Java语言: x>=3 && x<=5 并列关系

class OperatorDemo{
	public static void main(String[] args){
		
		//定义三个变量
		int x = 3 ;
		int y = 4 ; 
		int z = 5 ;
		
		System.out.println(x>=y) ;
		System.out.println(x!=z) ;
		System.out.println(y==z) ; //不要写成=
		System.out.println(x<=y) ; //x<y (使用逻辑运算符|  ||) x = y
		
		int m = 10 ;
		int n = 20 ;
		boolean flag =  m==n;
		//boolean flag = m =n; //千万注意:不要将==写成"="
		System.out.println(flag) ;
		
	}
}

7.逻辑运算符

逻辑运算符的分类:
基本的逻辑运算符:
逻辑单与 & :有false,则false
逻辑单或 | :有true,则true
逻辑异或 ^ :相同则为false,不同则为true
简单记忆:男女关系
男男(false) 女女(false) 女男(true) 男女(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)) ; // flase & flase  = false
		System.out.println((a>b) & (a<c) ) ;//false & true  = false
		System.out.println((a<b) & (a>c) ) ; //true & false = false
		System.out.println((a<b) & (a<c) ) ;//true &  true = true
		System.out.println("----------------------------") ;
		
		//逻辑单或 |
		System.out.println((a>b) | (a>c)) ; // flase | flase  = false
		System.out.println((a>b) | (a<c) ) ;//false | true  = true
		System.out.println((a<b) | (a>c) ) ; //true | false = true
		System.out.println((a<b) | (a<c) ) ;//true | true = true
		
		System.out.println("----------------------------") ;
		//逻辑异或^
		System.out.println((a>b) ^ (a>c)) ; // flase ^ flase  = false
		System.out.println((a>b) ^ (a<c) ) ;//false ^ true  =  true 
		System.out.println((a<b) ^ (a>c) ) ; //true ^ false = true
		System.out.println((a<b) ^ (a<c) ) ;//true ^ true = false
		
		System.out.println("----------------------------") ;
		System.out.println(!(a>b)) ; //!false,则true
		System.out.println(!!(a>b)) ;//false
	}

扩展的逻辑运算符

逻辑双与 &&
逻辑双或 ||

面试题:

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

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

逻辑双与&&最大的不同点:
存在逻辑双与&&短路效果: (经常在笔试题中选择题!)
逻辑双与&&连接的表达式左边如果结果为false,右边的表达式不执行了;

逻辑双|| :逻辑双||连接的表达式左边为true,右边不执行了!(逻辑双||的短路效果)

class OperatorDemo2{
	public static void main(String[] args){
		
				
		int a = 3 ;
		int b = 4 ;
		int c = 5 ; 
		
		System.out.println((a>b) && (a>c)) ;//false && false 
		System.out.println((a>b) && (a<c)) ; //false && true
		System.out.println((a<b) && (a>c)) ;//true && false
		System.out.println((a<b) && (a<c)) ;//true && true
		
		System.out.println("--------------------------");
		
		//定义两个变量
		int x = 3 ;
		int y = 4 ;
		System.out.println("x:"+x+",y:"+y) ;
			//true    &&   	 false  = false;
		//System.out.println(((++x) == 4) && ((--y)==4)) ;
		
		//false 
		System.out.println(((++x) == 3) && ((--y)==4)) ;
		System.out.println("x:"+x+",y:"+y) ;
	}
}

8.位运算符

位运算符 :针对两个具体的数据值进行运算

基本的位运算符
位与&
位或|
位异或^
~反码(按位取反,0变1,1变0)
移动符号
<<(左移),>>(右移),>>>(无符号右移)

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

/*
	位运算--->计算整数的二进制数据
	3 --->二进制 0b11
	4---->二进制 0b100
	
默认int类型(整数)
位与&:有0,则0
3&4
	00000000   00000000		00000000	00000011		3
											 位&
	00000000   00000000		00000000    00000100		4
----------------------------------------------------------
	00000000   00000000		00000000	00000000		
结果:0


3 | 4
位或| :有1,则1

	00000000   00000000		00000000	00000011		3
											 位|
	00000000   00000000		00000000    00000100		4
----------------------------------------------------------
	00000000   00000000		00000000    00000111

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


	00000000   00000000		00000000	00000011		3
 位^
	00000000   00000000		00000000    00000100		4
----------------------------------------------------------
	00000000   00000000		00000000    00000111
结果:7


~3:按位取反,0变1,1变0

~  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
	
	结果:-4

位异或的特点:
一个数据对另一个数据位移或两次,结果是它本身

int a = 10 ;
		int b = 20 ;
		
		将a,b的值进行互换!

		a = a ^ b ;
		b = a ^ b ; // b = a ^ b ^ b = a
		a = a ^ b ;//a = a ^ b ^ a = b
		
		可以将两个数据的值进行交互/第三方变量(Java开发中常用的)

class OperatorDemo2{
	public static void main(String[] args){
	
		int a = 10 ;
		int b = 20 ;
		
		System.out.println(a ^ b ^ b) ; //结果就是a
		System.out.println(a ^ b ^ a) ; //结果就是b
	}
}