Java开发必备点01_变量、数据类型、运算符

变量 数据类型 运算符

内存和外存

硬盘
内存条

变量

什么是变量

概念：是内存中一块空间，是数据存储的基本单元  数据的容器

关于变量的理解

内存----酒店
变量----房间
数据类型----房间的类型
变量名----房间号
变量值----房间里住的人或者放的杂物
注意：Java是强类型的编程语言 要求变量值的数据类型 和 变量规定的数据类型保持一致

组成变量的三要素

数据类型
变量名
变量值

定义变量

分为两步
	1.变量的声明（规定了变量所要存储的数据是什么类型  规定了变量名称）
		语法：  数据类型  变量名；
	2.变量的赋值
		语法： 变量名 = 变量值； 
案例：
public class Demo{
	public static void main(String[] args){
		//声明一个变量
		int a;
		//变量的赋值
		a = 10;
		System.out.println(a);
		
	}
}

注意：变量未赋值不能使用
案例：
public class Demo{
	public static void main(String[] args){
		//声明一个变量
		int a;
		//变量的赋值
		//a = 10;
		System.out.println(a);//编译错误
		
	}
}

定义变量的方式
	1.先声明 后赋值 
		int a;
		a = 10;
	2.声明的同时并赋值
		int a = 10;
	3.同时声明多个相同类型的变量 可以为变量部分赋值 也可以不赋值
	案例：
public class Demo{
	public static void main(String[] args){
		//声明一个变量
		//int a;
		//变量的赋值
		//a = 10;
		int a ,b,c = 10;
		a = 10;
		b = 20;
		System.out.println();//编译错误
		
	}
}

改变变量的值
案例：
public class Demo{
	public static void main(String[] args){
		int a = 10;
		System.out.println(a);

		a = 20;
		System.out.println(a);
		
		
	}
}

数据类型

字面值：可以给一个数据类型的变量赋的合法的值

基本数据类型（四类八种）

整数类型（四种）
		        字节Byte	         范围
	byte         1B               -128---127
	short		 2B				  -32768---32767
	int	         4B				  -2147483648---2147483647
	long		 8B					不要求
关于字节：




注意：
	1.字面值默认的数据类型是int
	2.在定义long类型的变量时需要在字面值后加 L 或者 l
案例：
public class Demo{
	public static void main(String[] args){
		//byte  a = 10;
		//byte a = 128;
		//System.out.println(a);
		/*int b = 2147483648;
		System.out.println(b);*/
		
		long c = 2147483648L; 
		System.out.println(c);
		
	}
}		

关于Bit和二进制

小数类型（浮点）（两种）
						字节
float（单精度） 			4B
double（双精度）			8B

注意：
	1.在定义float类型变量的时候  必须在字面值后加 F/f
	2.在浮点类型的变量定义中，字面值的默认类型是double
	3.double类型的变量定义时 字面值后可加D/d也可不加
***~~面试题：~~ ***
	int类型和float类型所占都是4个字节，那么哪种数据类型所存储的数据大呢？
	答：float在数据结构中存在的方式是用指数表示的 采用的是科学计数法
		所以float表示的数据范围要比int大
案例：
public class Demo{
	public static void main(String[] args){
		float f = 12.7F;
		System.out.println(f);
		
		//科学计数法 2.14748365 E9  E代表10 E后的数字代表指数
		
	}
}		

字符类型
			字节        表示范围
char		2B         0-65535

变量的定义：
	1.用 ''为字符类型的变量赋值
		案例：
		char c = 'A';
		System.out.println(c);
	2.用数字进行赋值
		案例：
		char c = 65;
		System.out.println(c);
	3.用unicode编码
		案例：
		char c = '\u0041';
		System.out.println(c);
	注意：A： 65  a ：97  0 ： 48
    char c = 'AB';AB属于字符串 是错误的
==================================================================
转义字符:
	案例：
public class Demo{
	public static void main(String[] args){
		char c = '\'';
		System.out.println(c);
		
	}
}		

常用的转义字符；
	\t    制表符 tab键
	\n    换行
	\\    \
	\'    '
    \"    "
    \r    回车

布尔类型
					字节  
boolean：		没必要了解 
	true ：真
	false：假
注意：不要讲true写成ture
案例：
public class Demo{
	public static void main(String[] args){
		boolean b = true;
		System.out.println(b);
		
		
	}
}		

引用数据类型（无数种）

String :字符串类型
案例：
public class Demo{
	public static void main(String[] args){
		String s = "电信1501 班帅哥美女众多";
		System.out.println(s);
		
		
		
	}
}	

反例：千万别这么干  打印变量的值不需要加双引号
public class Demo{
	public static void main(String[] args){
		int a  = 10;
		System.out.println("a");
	}
}		

数据类型的转换

自动类型提升

要求：
	1.数据类型兼容
	2.目标数据类型（你将要最终转换的数据类型）大于源数据类型（原来的数据类型）
情况：
	byte---->short---->int----->long--->float--->double
	char--->int----->long--->float--->double
	boolean不参与数据类型转换
案例：
public class Demo{
	public static void main(String[] args){
		//其他的情况自己写
		float f = 12.9F;
		double d = f;
		
		System.out.println(d);
		
	}
}		

强制类型转换

要求：
	1.数据类型兼容
	2.目标数据类型小于源数据类型才会发生强制类型转换
案例1：
public class Demo{
	public static void main(String[] args){
		int i = 250;
		byte b = (byte)i;
		System.out.println(b);
		
	}
}	

案例2：
public class Demo{
	public static void main(String[] args){
		double d = 123.9;
		int i = (int)d;
		System.out.println(i);
		
	}
}
注意：浮点类型数据强转为整数类型 直接将小数舍弃

将.class文件 反编译为java文件
案例：
public class Demo{
	public static void main(String[] args){
		byte b = 120;
		System.out.println(b);
		
	}
}

表达式

概念：表达式是由变量 字面值 运算符组合而成式子
注意：表达式最终一定会由一个值

在表达式中，如果出现两个变量或者多个变量产生运算，而且变量的类型不一致就会出现自动类型提升

规则：
	1.当表达式中有double类型，那么表达式的值就为double
	2.反之当表达式中float类型，那么表达式的值类型就是float
	3.反之当表达式中有long类型，那么表达式的值就为long类型
	4.其他情况都为int类型
案例：
public class Demo{
	public static void main(String[] args){
		byte b = 10;
		short s = 20;
		int d = b+s;
		System.out.println(d);
		
		
	}
}		

运算符

算数运算符

+  
-  
*  
/   除     取的是商
%  取余     取的余数
注意：

+可以作为字符串拼接的符号
特点：和字符串拼接后结果还是字符串
public class Demo{
	public static void main(String[] args) {
		int a = 3;
		int b = 5;

		System.out.println("拼接"+a+b);//结果 拼接35
		System.out.println(a+b+"拼接");//结果 8拼接
	}
		
}


案例：
public class Demo{
	public static void main(String[] args){
		int a = 5;
		int b = 2;
		int c = a/b;//商2余1
		int d = a%b;
		System.out.println(c);
		System.out.println(d);
		
	}
}
案例2:
public class Demo{
	public static void main(String[] args){
		int a = 1;
		int b = 0;
		int c = a/b;
		System.out.println(c);//报异常  
		
		
	}
}
案例3
public class Demo{
	public static void main(String[] args){
		double a = 1.0;
		double b = 0;
		double c = a/b;
		System.out.println(c);//infinity 无限的   
	}
}		

赋值运算符

=   +=  -=  *=  /=  %=

a = 10;
a+=10;------>a=a+10;

案例：
public class Demo{
	public static void main(String[] args){
		byte b = 10;
		b = b+1;//报错
		System.out.println(b);
		   
	}
}	

public class Demo{
	public static void main(String[] args){
		byte b = 10;
		b+=1;
		System.out.println(b);//正确的
		   
	}
}

赋值运算符不会进行类型提升

自增自减运算符

++   --
    
案例：
public class Demo{
	public static void main(String[] args){
		/*int a = 5;
		a++;
		System.out.println(a);//6*/


		int b = 5;
		++b;
		System.out.println(b);//6
		   
	}
}
结论：无论++ --在变量的前或者后 都是对此变量的值进行加1或者减1操作

变量的值：
表达式的值：
	a++ 和 ++a 都是表达式
	a++表达式的值是a没有加一之前的值
	++a表达式的值是a加一之后的值
案例：
public class Demo{
	public static void main(String[] args){
		int a = 5;
		System.out.println(a++);//表达式的值 5
		//System.out.println(++a);
		System.out.println(a);//变量a的值  6
		
		   
	}
}		

关系运算符

关系运算符表达式最后的结果是 一个布尔值  
==  
>
>=
<
<=
!=
案例：
public class Demo{
	public static void main(String[] args){
		int a = 10;
		int b = 10;
		System.out.println(a!=b);
		
	}
}		

逻辑运算符

两边都是布尔表达式
&  与       如果两边的布尔表达式都为true  那么表达式为true
&&  短路与   如果两边的布尔表达式都为true  那么表达式为true
注意：
	当&&的第一个布尔表达式为false那么 就不再执行第二个布尔表达式
	当&的第一个布尔表达式为false还会执行第二个布尔表达式
案例：
public class Demo{
	public static void main(String[] args){
		int a = 10;
		int b = 20;
		int c = 20;
		boolean f = (a>b)&(b++==c);
		System.out.println(b);//&&20    &21
		
	}
}		
==================================================================
|   或  当两边的布尔表达式的值都为false  那么这个表达式的值才为false
||  短路或  当两边的布尔表达式的值都为false  那么这个表达式的值才为false
案例：
public class Demo{
	public static void main(String[] args){
		int a = 10;
		int b = 20;
		int c = 20;
		//           true  
		boolean f = (a>b)||(++b==c);
		System.out.println(f);
		
		System.out.println(b);//| 21 ||20
		
	}
}
===============================================================
！  非
案例：
public class Demo{
	public static void main(String[] args){
		boolean f = true;
		System.out.println(!f);
		
		
	}
}		

三元运算符

语法：
布尔表达式？值1：值2；

当布尔表达式的值为true 那么整个的表达式的值取值1  反之 取值2
案例：

public class Demo{
	public static void main(String[] args){
		int a = 10;
		int b = 20;
		String c = a<b?"a<b":"a>b";
		
		System.out.println(c);
	}
}		

运算符的优先级