目录
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);
}
}
2235
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
