day02程序基础

1. 程序基础

1.1. 入口程序

public 公共的

class 定义类关键字

DT_01 类名,自定义命名

创建一个公共的类,类名是DT_01

一个java文件中,可以有很多class,但是 public class 只能有一个,并且 public class 的类名 必须和文件名一致

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

static 静态的

void 没有返回值

main 方法名

(String[] args) 参数列表

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

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

控制台打印

System.out.println(123);

如果出现以上下三种情况肯定是main方法拼写错误

其中下面这种情况是因为当前界面没有main方法导致只能运行上一个main方法

1.2. 数据类型

1.2.1. 内存存储

1.2.2. 数据类型

基本数据类型

        数值型

                整数型

                        byte 8bit

                        short 16bit

                        int 32bit

                        long 64bit

                浮点型

                        float 32bit

                        double 64bit

        布尔型

                boolean

        字符型

                char

引用数据类型

        类，数组，接口

1.2.3. 类型使用

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

        byte a1 = 127;

        short b1 = 127;

        int c1 = 2147483647;

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

        long l1 = 45645154145645L;

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

        float f1 = 1.4f;

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

        double d1 = 33.3;

        //布尔型只有true和false

        boolean flag = true;

结果

1.2.4. ASCII

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

‘a’ = 97 ‘b’ = 98

‘A’ = 65 ‘B’ = 66

‘0’ = 48 ‘1’ = 49

以此类推

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

        // ASCII是 字符和整数直接的对应

        char e1 = 'a';

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

        int z1 = (int)e1;

        System.out.println(z1);

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

        char x1 = '\u4e01';

        System.out.println(x1);

结果

1.2.5. 类型转换

// 布尔型 不能参与转换

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

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

        byte b1 = 11;

        short s1 = b1;

        int i1 = s1;

        long l1 = i1;

        System.out.println(Long.MAX_VALUE);

        //9223372036854775807

        float f1 = 3383838383838383838F;

        double d1 = f1;

        

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

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

short s2 = 128;

byte b2 = (byte)s2;

System.out.println(b2);

// 正数转换为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.2.6. 混合运算

//布尔型不参与运算

        byte b1 = 12;

        short s1 = 120;

        long l1 = 22L;

        long l2 = b1+s1+l1;

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

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

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

        byte b2 = 5;

        byte b3 = 7;

        int b4 = b2 + b3;

        char c1 = '!';

        int i2 = c1 + b3;

结果

1.2.7. 小结

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.3. 变量

1.3.1. 常量

常量:

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

字面量:

        占用临时空间存储,数字 默认是int 并且不能复用,只能临时使用一次,由于没有找到的路径,所以压根也不能修改

1.3.2. 变量

        可以修改的数据

1.3.2.1. 全局变量

        Java中没有全局变量

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

1.3.2.2. 变量声明

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

        数据类型 变量,变量;

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

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

1.3.2.3. 变量分类

Java中变量分为三类

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

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

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

1.3.2.4. 变量调用

// 局部变量

        int c=10;

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

        System.out.println(c);

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

        System.out.println(_Basic_06.a);

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

        System.out.println(a);

//成员变量

//创建对象

        _Basic_06 obj = new _Basic_06();

        System.out.println(obj.b);

结果

1.3.2.5. 变量作用范围

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

1.3.2.6. 默认值

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

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

        整数 : 0

        小数 : 0.0

        布尔型 : false

        字符型 : \u0000

        引用类型 : null

1.3.2.7. 变量优先级

        局部变量可以和静态变量/成员变量同名----同名后,优先使用局部变量

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

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

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

1.4. 运算符

1.4.1. 算术运算符

        System.out.println(10 + 3);

        System.out.println(10 - 3);

        System.out.println(10 * 3);

        System.out.println(10 / 3);

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

        System.out.println(10 + 3.0);

// 由于10和6都是整数,所以是1, 由于 5.0是double,所以结果是double

        System.out.println(10/6 + 5.0);

        System.out.println(10 % 6);

//余数为4

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

        int i = 6;

        i++;

        ++i;

//++i和i++单独出现,则没有区别

        System.out.println(i);

        i = 9;

        i = i++ + i + ++i + i + ++i + i++ +i;

        System.out.println(i);

结果

1.4.2. 关系运算符

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

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

1.4.3. 逻辑运算符

/*

* * & , | , ! 与或非

*

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

*

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

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

*

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

*

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

*

* && || 短路

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

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

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

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

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

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

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

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

        int a = 12 , b = 11;

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

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

        System.out.println(!false);

        System.out.println(8&10);

//0000 1000

//0000 1010

//0000 1000

        a = 10;

        b = 11;

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

        System.out.println(a);

        System.out.println(8 ^ 10);

// 0000 1000

// 0000 1010

// 0000 0010

        System.out.println(8^8);

//0000 1000

//0000 1000

//0000 0000

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

// 0000 0000

// 0000 0111

        System.out.println(0^10);

        System.out.println(10 >> 1);

//0000 1010

//0000 0101

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

//1000 0011

//1111 1100

//1111 1101

//右移

//0111 1110

结果