Day02 数据类型、变量、运算符

1.1数据存储

程序：可执行文件，一堆命令的集合，属于静态。一般保存在硬盘中

进程：进程就是正在执行的程序，是动态的，保存在运行内存中

1 数据存储：想运算，必须先存储

2 数据存储方式：

内存：可以看作两端无限延生的线

硬盘：螺旋线

3 储存单位

为了保存负数，高位舍弃，作文符号位

1未负数 0为整数

所有类型都需要损失一倍的精度

比如byte 8 位 最大值 为2^7-1 最小是-2^7

Byte=-128~127

Bit = 比特

Byte = 8bit 字节

Short = 2byte = 16bit    短整型

Int = 4byte = 32bit  2147483647   整型

Long = 8 byte = 64bit   长整型

4 存储

正数 存原码

比如保存2  , 2对应的二进制为 0000 0010

负数 存补码

-2  : 1000 0010 原码

1111 1101  反码 除了符号位,1变0,0变1

1111 1110 补码 = 反码+1

1.2数据分类

本质 就是规定占用内存空间的大小,用位和字节表示

基本数据类型

数值型

整数型

Byte,short,int,long

浮点型

Float,double

字符型 char

布尔型 boolean

引用数据类型

类,数组,接口

ASCII码 : 字符和整数之间的映射

1.3数据类型的使用

数据类型 名字=值；

1.3.1 整数型

1.3.2 浮点型

浮点型

float: 单浮点 32位

double 双浮点 64位

//float声明，值必须加F，不区分大小写
		float f1 = 1.2F;
		//double 声明 值需要加D，不区分大小写
		double d1 = 10.2D;
		
		//java中 整数默认是int。小数默认是double，所以在声明double 的时候，D可以 省略
		double d2 = 123.321;
		

1.3.3 字符型

字符型使用

java中字符型 占用两个字节，也就是16位 并且以英文单引号表示，且只能一个字符

short 也是16位：-32768-32767

char也是16位：0-65535 因为char没有负数，所以不需要符号位

        short s = 32767;
		char c = 35422;
		System.out.println(c);
		
		//引号中，只能有一个字符，空格也算
		char c1 = '张';
		//字符可以转换为对应的整数ASCII
		int i1 = c1;
		System.out.println(i1);

转义符：把有意义字符转换为位意义字符，并且Java中char采用unicode编码 \uxxxx;

        //单引号设置
		char c_1 = '\'';
		int i_1 = c_1;
		//\ 设置
		c_1 = '\\';
		i_1 = c_1;
		//制表符
		c_1 = '\t';
		i_1 = c_1;
		System.out.println(c_1);
		System.out.println(i_1);
		//支持unicode编码
		c_1 = '\u4e2d';
		i_1 = c_1;
		System.out.println(c_1);
		System.out.println(i_1);

1.3.4 布尔型

        // Java中布尔类型不参与任何转换，只有true和false，没有其他的
		// 在内存中占用1字节，全0位false，00000001 位ture
		boolean b1 = false;
		b1 = true;

1.3.5类型转换

Java中，八种基本类型，除了布尔型，其他的均可进行转换

自动类型转换：低精度到高精度为自动转换

比如 byte 到 int就是自动转换

强制类型转换：高精度到低精度为强制转换

比如int 到byte

自动转换类型

byte->short->int->long->float->double

          char->nt->long->float->double

		byte b2 = 12;
		//自动转换
		short s2 = b2;
		int i2 = s2;
		long l2 = i2;
		
		// int 到   byte需要强制转换
		b2 = (byte)i1;
		
		//整数保存二进制，而浮点数保存科学计算法，所以float虽然是32位，但是最大值远大于long
		//所以是强制转换
		float f2 = l2;
		double d3 = f2;
		
		char c2 = 'a';
		i2 = c2;

强制转换可能导致数据出错，需谨慎

		int i3 = 257;
		//强制转化可能导致数据出错，需谨慎
		byte b3 = (byte)i3;
		System.out.println(b3);
		

1.3.6 混合运算

在进行混合运算是，结果的类型是当前运算中最大的类型

比如int 和long 相加，结果是 long 类型，int和double 相加，结果是double

注意：当byte   short   char   int   四种类型中，或多种进行运算，结果都是int

比如 两个byte相加，结果是int，byte和char相加，结果为int

		int x = 1;
		byte b = 2;
		double d = 3.3;
		double result = x+b-c;
		System.out.println(result);
		
		short s4 = 2;
		int result1 = s4+s4;
		System.out.println(result1);
		

2 变量

2.1常量

常量在整个生命周期内，值不可更改

字面量/直接量

字面量也是有数据类型的

整数默认是整形 int

小数默认 是 double

final修饰的是常量，值不能更改

2.2 变量

可以更改的量，方便可以操作，并且可以复用

	public static void main(String[] args){
		int a = 10;
		System.out.println(a);
		a = 11;
		System.out.println(a);
		
	}

2.3 全局变量

全局：允许在类外创建变量，和类同级别，所有类都可以直接访问这个变量，不需要二次引用，

所谓二次引用,就是指  没有使用 . 操作符  xxx.xxx

而在java中类之外是不允许写变量的,但是可以把一个变量的访问权限设置为public,然后通过类名进行引用调用即可

全局的缺点 就是命名冲突问题

2.4 变量声明

数据类型 变量名 = 值；

int i_1= 10；
char c_1 = '张'；
bloolean b_1 = false;
// 字符串，用双引号表示，String是引用类型
String str = "我叫XXX";

2.5 变量作用域

作用域，一个大括号就是作用域

//变量不能先使用，后说明
int i_1 = 10;
char c_1 = 'han';
boolean b_1 = false;
// 字符串，用双引号表示，String是引用类型
String str = "我叫xxx";
//通过名字，找到对应的变量
System.out.println(i_1);
{
  System.out.println(i_1);
  int a = 1;
  System.out.println(a);


}
// 访问不到，因为一个变量的使用作用域不会超过包含他的这个大括号

2.6变量分类

根据声明的不同位置，划分了不同的分类，分别解决不同的问题

局部变量和成员变量，而成员变量分为成员和静态成员，静态成员又称为静态变量

局部变量：在方法中声明的变量称为局部变量，改变量只能在该方法中被使用，并且直接通过名字调用该变量即可 且 局部变量没有默认值，必须复制

静态变量：在类体中，使用static声明的变量，和方法是平级关系

并且 需要通过类名，静态变量名 才能调用，另外在当前类中调用当前类的静态变量时，类名可以省略

默认值：整数 默认值为0， 小数，默认 0.0，布尔型 默认false，字符型，默认 \u0000，引用类型 默认 null

成员变量：在类体中，没有使用Static声明的变量，和方法是平级关系

并且成员变量 需要通过 对象引用，成员变量才能调用

默认值：整数 默认值为0， 小数，默认 0.0，布尔型 默认false，字符型，默认 \u0000，引用类型 默认 null

 public class Var_03{
      //静态变量
     static int age = 18;
     static String name;
     //成员变量
     double score ;
     public static void main (String[] args){
         int i = 2;
         System.out.println(i);
         int a ;
         //局部变量没有默认值，不复制不能使用
         //System.out.println(a);
         //调用静态变量
         System.out.println(Var_03.age);
         //调用当前类中的静态成员变量时，类名可以省略
         System.out.println(age);
         System.out.println(name);
          
 }
}

3  运算符

3.1 算术运算符

 int a = 10; 
 int b = 3;
 //3
 System.out.println(a/b);
 System.out.println(a%b);
 //注意小数相加
 double a1 = 0.1;
 double a2 = 0.2;
 //0.3000000000000004
 //一定要注释，千万不要判断小数是否相等
 System.out.println(a1+a2);
 

 // 注意： 优先级 单目>双目>三目>(三元)
 // ++ :把值拿出来+1再放回去(会发生赋值)
 // i++: 先赋值,再自身+1(先确定i的值)
 // ++i : 先自身+1 在赋值
 int s = 100;
 // s = s + s++;
 s = s+ ++s;
 System.out.println(s);//201

3.2 关系运算符

关系运算符

>     >=     <       <=

== :判断相等,基本类型比较值,引用类型比较地址,判断不相等

关系运算的结果,是布尔型,true/false

int a = 10;
int b = 11;
boolean resule = a<b;
//true
System.out.println(result);
//true
System.out.println(a<=b);
//false
System.out.println(a>b);
//false
System.out.println(a>=b);
//false
System.out.println(a==b);
//true
System.out.println(a!=b);

3.3 位运算符

 &  位与,两边都是真,结果才是真,如果两把都是数值,则是与运算

|   位或,两边一个位置为真,结果就是真

!   位非,取反,真就是假,假就是真

^ 位异或,两边不一样,结果就是true

~按位非,0 二进制,0000 0000 按位非(按位取反)11111111

11111111补码 11111110反码 10000001源码

//false
System.out.println(1<2&2>3);
//true
System.out.println(1<2|2>3);
//false
System.out.println(!true);
//true
System.out.println(false^true);
//按位非 -1
System.out.println(~10);

>>:右移运算符(考虑符号位,再怎么移动,符号位不变)

向右移动一次,就等于 除以 2

8>>2: 0000000 10

如果是整数,左边补0(符号位之后补0),如果是负数,左边补 1

<<: 左移运算符(考虑符号位,再怎么移动,符号位不变)

向左移动一次,就等于乘以2

2<<2 向左移动两次,向右补0(正负数 都补0)

>>> : 右移运算符(不考虑符号位,符号位之前补0,并且不管正负数 只补0)

8>>2和8>>>2没有区别

-8>>2和-8>>>2 就有区别了

&& :短路与,且 两边都是真,结果才是真,

|| :短路或, 或 两边一个为真,结果就是真

//测试短路和非短路
//boolean result = (a1 == b1|a1>b1++);
boolean result= (a1 == b1|| a1>b1++);
System.out.println(result);
System.out.println(b1);