ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 编程语言> 文章详细

Java学习 数据存储、数据类型、变量、运算符

2021-09-26 21:01:11  阅读：104  来源： 互联网

标签：Java int 数据类型 System 运算符 ++ println public out


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);
	}
}

标签：Java,int,数据类型,System,运算符,++,println,public,out
来源： https://blog.csdn.net/qq_58765786/article/details/120494861

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有