1.1数据类型

1.1.1数据存储

程序 : 一堆命令的集合,一般是个可执行文件

1 数据想要运算,必须先存储

2 存储方式

内存 : 两端无限延伸的线

硬盘 : 螺旋线

3 存储单位

Bit = 比特 = 位

Byte = 字节 = 8bit 

-128 ~127 为了保存正负数,只能丢失一半精度,最高位作为符号位

1 表示负数 0 表示正数

负数存储 存补码

比如 2  : 0 0000010

比如 -2 : 1 0000010(原码) -> 1 1111101 (反码) -> 1 1111110(补码)

反码 : 1变0 , 0变1

补码 : 反码+1

Short = 短整型 =  2byte = 16bit

Int = 整型 = 4byte = 32bit  -2147483648 ~2147483647

Long = 长整型 = 8byte = 64bit

1.1.2进制

二进制 : 0101010100011 java中没有办法直接表示二进制

八进制 : 0~7   , 满8进一 , java中 如果数据是以 0开头 表示八进制 012

十进制 : 满10进1 , java中数据非0开头,都是10进制  2450

十六进制 : 满16进1,a表示10,b表示11....f表示15 , java中数据以0x开头,表示16进制   0x12

1.1.3数据类型分类

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

引用数据类型

类,数组,接口

基本数据类型

数值型

整数型

byte,short,int,long

浮点型

float,double

字符型

char

布尔型

boolean

Byte : 字节  8位

Short : 短整型 16位

Int : 整型 32位

Long : 长整型 64位

Float : 单浮点,32位

Double : 双浮点 64位

Char : 字符 16位

Boolean : 布尔型 8位, 00000001 是true , 00000000 是false

ASCII码

0 : 48

1 : 49

A : 65

B : 66

a : 97

b : 98

1.1.4 命名规则

所有需要我们命名的地方,都适用

1  变量名

2  类名

3  文件名

4  文件夹名

5  方法名

强制 : 只能出现 大小写字母,美元符号$,数字,下划线_,且数字不能开头

不能使用关键字和保留字,(不能只使用关键字和保留字,关键字1 是可以)

关键字 : 就是java中目前已经使用的有代表意义的单词

保留字 : 就是java目前还没有使用的关键字,但是在后续版本可能会用到

非强制 : 望文知义,驼峰命名法

Int a = 18;

Int x = 18;

Int age = 18;

1.1.5数据类型的使用

1.1.5.1整数型

package src;

public class sjsy {
	public static void  main(String[] arg){
		//使用byte声明一个8位大小的空间,并给空间取名为b_1把11放到空间中
		byte b_1=11;//字节
		byte b_2=011;
		System.out.println(b_2);
		//打印b-1空间中的内容,注意,没有双引号
		System.out.println(b_1);
		int i_1=111419;//整形,十进制
		int i_2=11111011;//二进制
		System.out.println(i_1);
		System.out.println(i_2);
		short s_1=7777;//短整型
		System.out.println(s_1);
		long l_1=111419555L;//长整型,需要加L/l建议大写,因为小写和1不太好区分
		System.out.println(l_1);
	}

}

1.1.5.2浮点型

package src;

public class day_02 {

	public static void main(String[] args) {
		double d_1=1.2;
				//可以加D/d,一般不加
				System.out.println(d_1);
				float f_1=7.7f;
						//float需要加f/F,因为不加f/F默认是double类型的小数
						//加F说明7.7就是float类型的值
						System.out.println(f_1);
						//强制转换,把double类型强制转换成float类型
						float f_2=(float)1.2;
						System.out.println(f_2);
	}
}

1.1.5.3字符型

package src;
/**
 *字符型:char,使用单引号表示,并且单引号中有且只有一个字符
 *Java中的字符型采用Unicode编码
 *short短整型16位 -32768~32767
 *char字符型16位0~65535 没有负数
 *
 * @author 人间失格
 *
 */
public class day_03 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		char c_1='a';
		int i_1=c_1;
		System.out.println(i_1);
		System.out.println(c_1);
		char c_2='张';
		//空格也算
		char c_3=' ';
		System.out.println(c_2);
		System.out.println(c_3);
		s
	}
}

1.1.5.4转义符

package src;
/**
 * \把有意义的字符转换成无意义的字符
 * @author 人间失格
 *
 */

public class day_04 {
	public static void main(String[] args){
		char c_1 ='\'';
		//字符串类型,双引号表示
		String str="guanqianlong1114";
		System.out.println(c_1);
		System.out.println(str);
		//制表符tab键
		char c_2='\t';
		//保存\要写两个\,把转义符转化
		char c_3='\\';
				//换行符\n,重新对c_3赋值换行
				c_3='\n';
				System.out.println(c_3);
		
	}

}

1.1.5.5布尔型

package src;
/**
 * java中Boolean类型,取值只有两个true/false
 * 占用一个字节:全部是0为false,00000001为true
 * 布尔类型不可以参与任何形式的转换
 * 一般用于流程控制,做判断操作
 * @author 人间失格
 *
 */

public class day_05 {

	public static void main(String[] args) {
		boolean f_1=true;
		f_1=false;
	}
}

1.1.6数据类型转换

package src;
/**
 * 布尔类型不参与转换
 * 自动类型转换:低精度到高精度是自动类型转换,又称隐式转换
 * byte->short->int ->long ->float -> double
 *             char->int ->long ->float -> double
 * 强制类型转换:高精度到低精度是强制类型转换,又称显示转换
 * 格式:低精度类型 名字=(低精度类型)高精度值;可能会导致数据出错
 * int i1=12
 * 
 * byte b1=(byte)i1;
 * @author 人间失格
 *
 */

public class day_06 {

	public static void main(String[] args) {
		byte b1=123;
		int i1=b1;
		short s1=(short)i1;
		int i2=111419;
		byte b2=(byte)i2;
		System.out.println(b2);
		System.out.println(s1);
	}
}

1.1.7混合运算

package src;

public class day_07 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		byte b3 = 10;
		double d3 = 30;
		// 在混合运算中,结果是运算中最高的类型
		double result = d3 - b3;
		int i3 = 20;
		int i4 = 3;
		// 6 , 不要余数
		int i5 = i3 / i4;
		// 6.0 因为i3/i4结果为int类型的6,然后把6自动类型转换为double类型为6.0 而不是6.66666....
		double i6 = i3 / i4;
		System.out.println(i5);
		
		byte b_1 = 1;
		short s_1 = 2;
		// 当 byte , short , char , int 四种中 任意一种或多种进行混合运算是,结果都为int类型
		int s_2 = s_1 + b_1;
	}

}

1.2 常量和变量

1.2.1常量和字面量

package _02_Var;
/**
 * 常量:整个生命周期中,值不可更改
 * 
 * 字面量:整个生命周期中,值不可更改,并且也不可以重复使用
 * @author 人间失格
 *
 */

public class Var_01 {

	public static void main(String[] args) {
		//字面量,不可以重复使用
		//但是有类型,有空间,不过空间是临时的
		//整数默认int ,小数默认 double
	
	}

}

1.2.2变量

1.2.2.1声明

1.2.2.2变量分类

1.2.2.3变量调用

package _02_Var;
/**
 * 变量:可以更改的数据,方便对数据进行操作,并且可以对空间进行复用
 * 变量声明:数据类型 变量名 =值; int i=2;
 * 变量分类 : 
 * 
 * 局部变量 : 在方法中声明的变量是局部变量 
 * 
 * 静态变量 : 在类体中使用static声明的变量 
 * 
 * 成员变量 : 在类体中没有使用static声明的变量
 * 
 * 变量的调用 :
 * 
 * 局部变量 : 在方法中,直接写变量名调用即可,在方法外调用不了
 * 
 * 静态变量 : 类名.静态变量名;  当前类中,类名可以省略
 * 
 * 成员变量 : 对象.成员变量名;
 * 
 * 作用域 : 变量的使用范围, 变量声明处,向上走,碰到的第一个大括号,向下穿透
 * 
 * @author 人间失格
 *
 */

public class Var_02 {
	// 静态变量
		static int a = 2;
		// 成员变量
		int b = 10;

	public static void main(String[] args) {
		System.out.println(Var_02.a);
		System.out.println(a);
		// 创建一个int空间,命名为 i , 并赋值为10
		int i = 10;
		// 根据i 找到对应的数据,并打印
		System.out.println(i);
		System.out.println(i);
		// 更改i空间的值为2
		i = 2;
		System.out.println(i);
		System.out.println(i);
		if (true) {
			int x = 2;
			System.out.println(x);
			System.out.println(i);
		}
		
	}

}

1.2.2.4变量默认值

package _02_Var;
/**
 * 默认值,局部变量没有默认值
 * 
 * 静态变量和成员变量有 默认值
 * 整数:0
 * 小数:0.0
 * 布尔型:false
 * 引用类型:null
 * @author 人间失格
 *
 */

public class Var_3 {
static int b;

	public static void main(String[] args) {
		//局部变量没有默认值,不复赋值就不能用,用了就报错
		int a;
		int i =1;
		System.out.println(i);
		System.out.println(b);


	}

}

1.3运算符

1.3.1算数运算符

package _03_Operator;
/**
 *  * 算术运算符
 * 
 * + - * / %
 * 
 * ++ --
 * 
 * ++ : 自身+1,把值取出 +1之后 在放回去(会发生赋值)
 * 
 * 一元(单目) 优先级 大于双目(二元)
 * 
 * 一元运算 就是指 有一个操作数 比如 i++
 * 
 * 二元 就是两个操作数 : a*b
 * 
 * @author 人间失格
 *
 */

public class Operator_01 {

	public static void main(String[] args) {
		int a = 10;
		int b = 3;
		// 因为是整数 所以 不要余数 就是 3
		System.out.println(a / b);//除法
		// 1
		System.out.println(a % b);//取余

		int s = 100;
		// i++ 和 ++i 的区别 : i++ 先赋值后+1, ++i 先+1 后赋值
		// 如果单独出现,没有区别
		// s++;
		// ++s;
		// 代码从左到右执行初始化,先赋值 后++
		// s = s++ + 10;
		// s = 100 +10; s=101
		// s = 110
		s = s++ + s;
		// s = 100 + 101; s = 101
		System.out.println(s);

		int k = 100;
		// 先++ 再赋值
		k = ++k + k;
		// k = 101 + 101; k = 101
		System.out.println(k);

		int m = 10;
		int e = 2 + m++;
		System.out.println(m);
		System.out.println(e);

		int p = 2;
		// 先从左到右初始化在计算
		p = 2 + p++ + ++p + p++ + ++p;
		// p = 2 + 2 + 4 + 4 + 6; p = 6
		System.out.println(p);

		int x = 10;
		x = 10 + x++ + ++x + (10 * x++) + ++x;
		System.out.println(x);
	}
}

1.3.2关系运算符

package _03_Operator;
/**
 * 关系运算符 :  结果是布尔型 只有 true和false
 * 
 *  >  , <  , >= ,  <= , 
 *  
 *  == : 判断是否相等
 *  
 *  != : 判断不相等
 * @author 人间失格
 *
 */

public class Operator_03 {

	public static void main(String[] args) {
		int a =10;
		int b=11;
		System.out.println(a>b);//flase
		System.out.println(a>=b);//flase
		System.out.println(a<b);//true

	}

}

1.3.3逻辑运算符

package _03_Operator;
/**
 * &:位与,两边都为真,结果才为真
 * |:位或,一边为真,结果就为真
 * !:位非,取反,真就是假,假就是真!true=false
 * ^:位异或,两边不一样,结果才为真,true^false=true,true^true=false
 *  ~ : 按位非 , 按数值的进制位,进行取反 , 
 * 	 		~2 : 2 的二进制 0 000 0010  每位取反 , 1 变0  , 0 变1
 * 					1 111 1101  -> 反码 -> 1 111 1100  -> 源码 -> 1 000 0011
 * 
 * @author 人间失格
 *
 */


public class Operator_02 {

	public static void main(String[] args) {
		System.out.println(~2);
		// 如果 & 两边是数字 , 就变成了与运算
		// 转换为二进制,每位比较, 都是1 取1,否则 取0
		// 最终结果,不会超过两个数中最小的一个
		// 0 000 1000
		// 0 000 1001
		// 0 000 1000
		System.out.println(8 & 9);
		// false
		System.out.println(1>2 & 1<2);
		// true
		System.out.println(1>2 | 1<2);
		// true 
		System.out.println(1>2 ^ 1<2);
		// true
		System.out.println(!(1>2));
	}
}

1.3.4短路与,短路或

public class Operator_04 {
/**
 *  && : 且 , 短路与  , 两边都为真结果才为真,假如第一个就为假了,第二个判断就不执行了,直接返回false
 * 
 *  || : 或 , 短路或 , 两边有一个为真,结果才为真,假如第一个就为真了,第二个判断就不执行了,直接返回true
 * 
 * @author 人间失格
 *
 */



	public static void main(String[] args) {
		int a = 10;
		int b = 10;
		int e = 10;
		// 第一个条件为false,第二个不执行了
		boolean c = (a > b && a > b++);
		boolean c1 = (a > e& a > e++);
		
		System.out.println(b);
		System.out.println(c1);
		// 如果一个运算中, && 和 || 都有,那么 && 优先级 大于 ||
		boolean flag = true || false && false;
		System.out.println(flag);
	}
}

1.3.5位运算符

package _03_Operator;
/**
 *  位移运算
 * 
 * 	<< : 左移运算(符号位不变) 转换为二进制,向左移位,最右边补0
 * 		x << y  = x*2^y
 * 		左移一次 等于 乘2
 * 
 * >> : 右移运算(符号位不变) 转换为二进制,向右移位,最左边补0 , 如果是负数,最左边补1
 * 		x >> y  = x/2^y
 * 		右移一次 等于 除2
 * 
 * 面试题 : 如何快速计算 2的3次方
 * 		2<<2
 * @author 人间失格
 *
 */

public class Operator_05 {

	public static void main(String[] args) {
		System.out.println(-2 << 2);
	}
}

1.3.6赋值运算符

package _03_Operator;
/**
 * 赋值运算
 * 
 * =
 * 
 * += , *= , /= , -= , %=
 * 
 * -= : 左边减去右边 结果赋值给左边
 * 
 * i+=2;   等价于  i = i + 2;
 * @author 人间失格
 *
 */

public class Operator_06 {

	public static void main(String[] args) {
		int i = 10;
		// 等于 i = i + 10;
		i+=10;
		System.out.println(i);
		i -=5;
		System.out.println(i);
		
		byte b = 2;
		// 等价于 b = b + 1 , 和 b+=1;
		b++;
		// b = b + 1;
		b+=3333;
		// 虽然 += , ++  和 b= b + xxx 是等价关系.但是 b+xxx 这种运算,需要进行强制类型转换
		// 而 ++ 和 += 这些 会自动强制转换
		b=127;
		b++;
		System.out.println(b);
	}
}