Java初学-Day02知识整理

一、程序基础

1.1程序入口：

               以以下代码为例分析：

public static void main(String[] args){
    System.out.println("10086")    
}

入口方法,程序的入口

可以理解为 java的执行 只会执行main方法

public：公有的，谁都可以访问；

static：静态的

void：空，没有返回值

main：方法名，主方法

String [] args：参数列表

main方法为固定写法，哪里也不能变

唯一可以修改的地方是 args 写成什么都可以，但需要符合命名规则

1.2注意事项：

                1.2.1.Main

以上这几种情况，都是因为没有main方法导致，如果你写了main方法，一定是拼写错误或者没有保存

 1.2.2注意中英文，符号和大小写

111111  IIIIIII lllllllllll

;;;;;;;;; ；；；；；；；；

?????   ？？？？？

1.2.3数据类型

内存存储

类型分类

基本数据类型

数值型

整数型

byte   8bit   字节

short  16bit   短整型

int    32bit   整型

long   64bit   长整型

浮点型

float   32bit   单浮点

double  64bit  双浮点

布尔型

boolean

字符型

char

引用数据类型

类,数组,接口

1.2.4类型使用

// 创建一个8bit的空间,并给空间取名为b1,然后把2保存到该空间中

byte b1 = 127;

short s1 = -32768;

int i1 = 2147483647;

// long类型的值必须使用L或l结尾,不区分大小写,建议大写

long l1 = 45645154146545L;

// float 需要F/f结尾,不区分大小写

float f1 = 3.5F;

// double 需要D/d结尾,不区分大小写,另外也可以省略

double d1 = 55.6;

// 布尔型的值,只有true和false

boolean flag = true;

// 字符型 使用单引号表示,并且有且只有一个字符

char c1 = '!';

 ASCII

ASCII是 字符和整数直接的映射,字符和整数之间可以相互转换的一个标准

‘a’ = 97   ‘b’ = 98 ........

‘A’ = 65   ‘B’ = 66 .......

‘0’ = 48   ‘1’ = 49 .......

c1 = '王';

// 把c1转换为int类型

int c2 = (int) c1;

System.out.println(c2);

// char 也是16位,范围 0~65535 因为不需要负数

System.out.println((char) (45555));

// unnicode 编码,\ u 4位十六进制整型值 0~f

char c3 = '\u4e00';

c3 = '\u9fa5';

System.out.println(c3);

1.2.5类型转换

// 布尔型 不能参与转换

// 低精度到高精度 可以自动类型转换

// 高精度 到低精度 需要强制类型转换

byte b1 = 13;

short s1 = b1;

int i1 = s1;

long l1 = i1;

// 浮点型 采用科学计数法进行存储

// 所以  float的32位  可存储的数据量远大于 long的64位

System.out.println(Long.MAX_VALUE);

// 9223372036854775807

float f1 = 92233720368547758072231231241231231212.2F;

System.out.println(f1);

f1 = l1;

double d1 = f1;

// byte --> short --> int --> long --> float --> double  是自动类型转换,反之则需要强制类型转换

short s2 = 129;

// 高到低,需要强制类型转换,  (类型)

// 强制类型转换有可能损失精度,导致数据不正确

byte b2 = (byte) s2;

System.out.println(b2);

System.out.println(Integer.toBinaryString(-265));

// -265 1111111011110111

//

// 1111111011110111  -265二进制

//  当不考虑符号位时  对应的是 65271

// 正数转换为char是,是忽略负数的,会把响应负数的二进制转换为对应的正数,然后再进行ASCII码对照

char c1 = (char)-265;

System.out.println(c1);

System.out.println((char)65271);

char c2 = 'a';

int i3 = c2;

// byte --> short --> int --> long --> float --> double  是自动类型转换,反之则需要强制类型转换

// char --> int --> long --> float --> double

1.3混合运算

// 布尔型 不能参与运算

byte b1 = 2;

int i1 = 10;

long l1 = 11L;

// 当进行多类型混合运算时,结果为参与运算的最大类型

long result = b1 + i1 + l1;

// 当混合运算类型 只出现了 byte short int char  四种类型时

// 任意一种或多种进行运算,结果一定是int类型 (可以理解为,混合运算,结果为参与运算的最大类型,但最低也是int类型)

byte b2 = 1;

byte b3 = 1;

int b4 = b2+b3;

char c1 = 'a';

int c2 = c1+b2;

1.4 小结

1. long需要L结尾,建议大写
2. float使用F结尾
3. double 结尾D可以省略
4. char类型应用,ASCII码对照表a=97,A=65,0=48,unicode编码
5. 布尔型不参与转换
6. 强制类型转换有可能损失精度
7. byte,short,int,char四种中,任意一种或多种进行混合运算时,结果一定是int类型
8. 当进行多类型混合运算时,结果为参与运算的最大类

1.4.1 常量

// 常量:生命周期中,值不能修改,但是可以复用

final int i = 2;

// i = 3;

// 字面量,占用临时空间存储,数字 默认是int

// 并且不能复用,只能临时使用一次,由于没有找到的路径,所以压根也不能修改

System.out.println(123);

​​​​​​​1.4.2 变量

可以修改的数据

​​​​​​​1.4.3 全局变量

Java中没有全局变量,全局变量一般是指可以直接调用,不需要二次引用的变量

是否使用 .  操作符   , xxx.xxxx

​​​​​​​1.4.5 变量声明

 * 变量声明 : 数据类型 变量名 = 值;

 *

 * 数据类型 变量,变量,....;

 * 数据类型 变量=值,变量=值,....;

 * 使用数据类型划分内存空间 给空间取名字 并赋值

​​​​​​​1.4.6 变量分类

Java中变量分为三类

局部变量 : 在方法中写的变量,是局部变量(参数列表也是)

静态变量 : 在类体中,使用static修饰的变量是静态变量

成员变量 : 在类体中,没有使用static修饰的变量是成员变量​​​​​​​

1.4.7 变量调用

变量必须先声明后使用

// 局部变量

int i = 2;

// 局部变量调用,在方法中,直接写变量名调用,方法外 调用不了

System.out.println(i);

// 静态变量调用,使用类名.静态变量名,需要考虑权限修饰符

System.out.println(_06_Var_02.a);

// 如果在类中调用当前类的静态变量,类名也可以省略

System.out.println(a);

// 创建对象

_06_Var_02 obj = new _06_Var_02();

System.out.println(obj.b);

​​​​​​​1.4.8 变量作用域(作用范围)

变量的范围不会超过往上开始碰到的第一个大括号

​​​​​​​1.4.9 默认值

局部变量没有默认值,不赋值不能使用

静态变量和成员变量,有默认值,不赋值也能使用

整数 : 0

小数 : 0.0

布尔型 : false

字符型 : \u0000

引用类型 : null

​​​​​​​1.4.10变量优先级

局部变量可以和静态变量/成员变量同名吗?  可以

静态变量和成员变量 可以同名吗?  不可以

// 同名后,优先使用局部变量

System.out.println(a);

// 如何区分同名的局部变量和静态变量呢?  类名

System.out.println(_08_Var_04.a);

使用类名 区分同名的局部变量和静态变量

使用this 区分同名的局部变量和成员变量

​​​​​​​1.5 运算符

1.​​​​​​​5.1 算术运算符

System.out.println(10 + 3);

System.out.println(10 - 3);

System.out.println(10 * 3);

// 由于都是整数,所以结果也是整数 3

System.out.println(10 / 3);

// 由于3.0是double 所以结果是 double 3.3333335

System.out.println(10 / 3.0);

// 由于10和3都是整数,所以得 3 , 由于 1.0是double,所以 得 4.0

System.out.println(10 / 3 + 1.0);

// 余数

System.out.println(10 % 3);

// -----------------------

// ++ : 自身+1, 把值取出来+1在放回去 , i++ 就等于 i=i+1

int i = 10;

i++;

++i;

// 如果 i++ 和 ++i 单独出现,则没有区别, 直接自身+1 完事

System.out.println(i);

// 如果 在混合运算中 i++ 和 ++i 就有区别了

// i++ 先赋值 后 + 1(i的值,是+1之前的值)

// ++i 先+1 后赋值 (i的值,是+1之后的值)

i = 10;

i = i++;

// i = i++; i = 10

// i = 10++; i = 10

// i = 10; i = 11

// i = 10;

// ++ -- 属于一元运算, 一元优先级大于二元

i = i++ + i;

// i = i++ + i; i = 10

// i = 10++ + i; i = 10

// i = 10 + i; i = 11

// i = 10 + 11; i = 11

// i = 21; i = 11

// i = 21;

i = 10;

i = ++i + i;

System.out.println(i);

​​​​​​​1.5.2 关系运算符

 * 关系运算符 结果 一定是布尔型 true/false

 *

 * > >= < <= == !=

 *

 * == 比较基本类型时  比较的是值,比较引用类型时则比较内存地址

int a = 10, b = 11;

System.out.println(a > b);

System.out.println(a >= b);

System.out.println(a < b);

System.out.println(a <= b);

System.out.println(a == b);

System.out.println(a != b);

​​​​​​​1.5.3 逻辑运算符

 * & , | , !  与或非

 *

 * & : 与 , 两边都是真,结果才是真 并且的意思

 *

 * & 也支持与运算,两边是数字,即可进行与运算

 * 先把两个数转换为二进制进行每位比较,都是1则取1,反之则取0 , 结果一定不大于两个数中的最小数

 *

 * | : 或 , 两边一个条件成立,结果就是真

 *

 * ! : 非 , 取反意思,真变假,假变真

 *

 * &&   ||   短路

 *

 * & : 不短路,两边都是真,结果才是真,比如第一个条件已经为假了,结果一定是假,但是第二个条件依然会执行

 * && : 短路,第一个为假,则第二个不执行

 *

 * ^ : 异或 , 两边不一样结果才是真

 *  如果两边是数字,则进行异或运算,二进制每位进行比较,不同取1,相同取0

 *

 * >> : 右移运算 : 右移一次,就相当于该数 除2  (符号位不变)

 * 转换二进制,进行移位,右移一次,则删除最右边一个,并在最左边(非符号位)添加一位 (如果是整数则补0,负数则补1)

 * 1 100000 10

 * 11111 111

 *

 * >>> : 右移运算 : 不考虑符号位,并且不考虑正负数,只在最左边补0 , 所以负数 有可能变正数

 *

 * << : 左移运算,向左移动一位,相当于该数乘2,删除左边(非符号位),右边补0

 * 0 0 001000

int a = 10 , b = 11;

System.out.println(a > b & ++a>=b);

System.out.println(a > b | ++a>=b);

System.out.println(!true);

// 0000 0110

// 0000 1000

// 0000 0000

System.out.println(6&8);

a = 10;

b = 11;

System.out.println(a > b && ++a>=b);

System.out.println(a);

System.out.println(true ^ true);

// 0000 1010

// 0000 0111

// 0000 1101

System.out.println(10 ^ 7);

// 相同数 异或两次 , 得0

System.out.println(8^8);

// 0 和任何数进行异或,还是该数

// 0000 0000

// 0000 0111

System.out.println(0^8);

// a ^b ^b  得a

System.out.println(465465^8989^8989);

System.out.println(-2 >> 1);

// 1000 0010   1111 1101  1111 1110

// 01111 111

System.out.println(-2 >>> 1);