Java基础知识笔记（二）

一，常量和变量

1. 常量
程序在运行过程中，值不会发生改变的标识符
常量分类：整数常量，小数常量，布尔常量【true和false】，字符常量，null常量
System.out.println和System.out.print都可以实现打印，并且可以打印不同的数据类型
二者在进行打印的时候，不管是打印哪种数据类，每次只能打印一个值
整数常量：
System.out.println(10);
小数常量：
System.out.println(3.14);
布尔常量：
System.out.println(true);
System.out.println(false);
字符常量：——–用单引号表示
System.out.println(‘1’);
System.out.println(‘f’);
System.out.println(‘&’);
System.out.println(‘我’);
字符串———–用双引号表示
System.out.println(“我”);
System.out.println(“hello java”);
System.out.println(“2467857782”);

【注意】字符表示单个的字母，数字，特殊符号都可以是字符

2.变量
在程序运行过程中，值随时可以发生改变的标识符
a.需要在内存空间【运算区域】中开辟一块空间，将不确定的数据存储到这个空间中
b.语法：数据类型 标识符 = 不确定的数据
c.特点：
1>变量的值是可变的
2>如果需要使用变量，就必须开辟空间
3>标识符：遵循小驼峰【首字母小写，其他的单词首字母大写】，例如：personAge
4>变量存储一定类型的数据，一旦类型被规定，其他的类型将存储不进去

二，数据类型

Java语言还是一种强类型的语言【对于每一种数据类型都定一了非常明确的数据类型，在内存中分配了不同大小的内存空间，进行数据的存储】
1,数据类型的分类

---

    基本数据类型
                    数值型
                            字节整形【byte】
                            短整型【short】
                            整形【int】
                            长整形【long】
                    浮点型
                            单精度【float】
                            双精度【double】
                    字符型
                            【char】
                    布尔型
                            【boolean】
    引用数据类型
                    类【class，字符串属于类【String】】
                    接口【interface】
                    数组【array：不是关键字】
                    枚举【enum】

2,每种数据类型占用空间的大小

类型名	关键字	占用的字节数	取值范围
字节整型	byte	1	-2^7 ~ 2^7 - 1(-128~127)
短整型	short	2	-2^15 ~ 2^15 - 1
整型	int	4	-2^ 31~ 2^31 - 1
长整型	long	8	-2^63 ~ 2^63 - 1
单精度	float	4	-2^128 ~ 2^127
双精度	double	8	-2^1024 ~ 2^1023
字符型	char	2	0~65535
布尔型	boolean	1	true和false

---

需要注意的问题：
a.浮点型
1>如果数据小的话，显示的是数据本身
2>如果数据较大的时候，显示的科学计数法
3>同字节的浮点数比同字节的整数能够s存储更大数据
b.字符型
1>使用单引号表示，只有单个字符，可以使字母，数字，符号，中文
2>使用字符集【ASCII码】表示【表示将语言文字和计算机表示建立起来的一个映射关系】
例如：a—->97
A—–>65
0—–>48

3.不同数据类型变量的定义

需求：定义一个int类型变量num，赋值为4
语法：数据类型 变量名称 = 数值
int num = 4;
对于同一个变量，如果要进行二次赋值的话，就不需要再指定数据类型
num = 10;
其他类型变量的定义
byte b = 2;//-128~127
byte b2 = 128;
byte类型的变量，在赋值的时候，只要在-128~127范围内，都会赋值成功
short s = 100;
会选用L来进行标记
long l = 10L;
浮点型：所有的浮点型，默认数据类型是double，会选用f来进行标记
float f = 2.3f;
double d = 3.14;
字符型：
char ch1 = ‘f’;
char ch2 = ‘3’;
char ch3 = ‘%’;
char ch4 = ’ ‘;
布尔型：
boolean b1 = true;
boolean b2 = false;
字符串类型：字符串是由多个字符组合而成，使用双引号表示，其中引入的内容没有限制，使用String关键字来进行定义变量
String str1 = “hello world”;
String str2 = “473645838574378”;
/********************特殊写法**********************************/
//写法一
//int number = 10;
int number;
number = 10;
System.out.println(number);
number = 100;
System.out.println(number);
//写法二
//可以连续定义多个变量，使用逗号分隔，但是前提条件是：只能定义同种数据类型
double dou1 = 1.0,dou2 = 3.4,dou3 = 10.5;
System.out.println(dou1);
System.out.println(dou2);
System.out.println(dou3);
/****************可能会出现的错误**************************************/
//错误一：在定义变量的时候，缺少三要素中的任何一个
//给变量第一次赋的值称为初始值，对变量赋初始值的过程就称为初始化变量
boolean boo;
System.out.println(boo);//错误：可能尚未初始化变量boo
//错误二：在同一个方法中或者类中，出现同名的变量
int number = 200;
System.out.println(number);//错误: 已在方法 main(String[])中定义了变量 number
/*****************************final关键字************************************/
如果在一个变量的前面加上final关键字，那么这个变量其实就是一个常量
//被final修饰的变量，变量名称的定义将不再遵循小驼峰命名法，遵循常量命名法：所有的字母全部大写，并且不同的单词之间使用下划线分隔
final int SCORE = 99;
score = 66;//错误：无法为最终变量score分配值
System.out.println(score);
//问题：不同数据类型之间能直接进行加法运算吗？
//答案：不能，不同的数据类型之间如果要进行运算的话，必须将他们转化为同一种数据类型

4,数据类型的转换

 a.自动类型转换
     还可以称为隐式类型转换，转换的原理：相兼容的数据类型之间，将取值范围较小的数值或者变量赋值给取值范围较大的数据类型对应的变量
                 大 = 小

/************************自动类型转换*************************/
        int num1 = 20;
        //当int类型的num1赋值给long类型的num2的时候，num1会自动将其类型提升为long类型
        long num2 = num1;
        System.out.println(num2);

        byte b = 10;
        int i = 20;
        //b + i之前，首先会将b自动提升为int类型，然后才参与运算
        int c = b + i;
        System.out.println(c);

        float f1 = 10.0f;
        float f2 = 3.14f;
        int num = 1;
        //num在参与运算之间，先自动提升为float类型，然后才参与运算
        float result = f1 + f2 + num;
        System.out.println(result);

        char c1 = 'c';//ASCII码99
        int i1 = 1;
        //c1先提升为int类型，参照ASCII码
        int result2 = c1 + i1;
        System.out.println(result2);

        System.out.println('a');//a
        System.out.println('a' + 2);//99
        System.out.println('1');//1
        System.out.println('1' + 0);//49

        byte b1 = 10;
        byte b2 = 20;
        // 错误: 不兼容的类型: 从int转换到byte可能会有损失
        //char，byte，short在参与运算之前，都会自动提升为int类型
        byte b3 = (byte)(b1 + b2);
        System.out.println(b3);//30

b.强制类型转换
    还可以称为显式类型转换，转换的原理：相兼容的数据类型之间，将取值范围较大的数值或者变量赋值给取值范围较小的数据类型对应的变量

    语法：小范围 变量名 = （小范围）大范围的变量或者数值
                小 = 大

/************************强制类型转换*************************/
        int age = 18;
        byte age1 = (byte)age;

        double d1 = 3.14;
        float d2 = (float)d1;

        float d3 = (float)10.0;

总结：
a.整型数据默认情况下数据类型是int，浮点型数据默认情况下是double
b.byte,short,char类型的变量在参与运算的时候，首先会自动提升为int类型，然后才参与运算
    特殊：char提升为int类型的时候遵循ASCII码
c.整型和浮点型之间运算的时候，整型会统统提升为浮点型，然后才参与运算

三、运算符

1.算术运算符
+ - * / %【求余】 ++【自加】 –【自减】

        int a = 10;
        int b = 20;
        System.out.println(a + b);//30
        System.out.println(a - b);//-10
        System.out.println(a * b);//200
        //整型/整型= 整型【取整】
        System.out.println(a / b);//0

        //求余
        System.out.println(a % b);//10

        /*
        求余运算 时，如果有负数参与运算，结果为正为负看左边
        左边为正则结果则为正
        左边为负反之
        */
        System.out.println(-1 % 5);//-1
        System.out.println(1 % -5);//1

        //自增自减运算符
        //++:自增1
        //--自减1
        int c = 3;
        //++出现在变量的后面，在参与运算的时候，先使用原来的值，然后自增1
        int c1 = c++ + 2;
        System.out.println(c);//4
        System.out.println(c1);//5

        int d = 3;
        //++出现在变量的前面，在参与运算的时候，先自增1，然后再参与运算
        int d1 = ++d + 2;
        System.out.println(d);//4
        System.out.println(d1);//6

        int e = 5;
        int e1 = e-- + 10;
        System.out.println(e);//4
        System.out.println(e1);//15

        int f = 5;
        int f1 = --f + 10;
        System.out.println(f);//4
        System.out.println(f1);//14


        int g = 10;
        //自增和自减可以单独当做一条语句
        //g++;
        g = g + 1;
        System.out.println(g);//11


        //特殊情况：+【连接运算符】，主要针对字符串
        //作用：可以将基本数据类型转换为字符串
        //任何类型的数据和字符串使用+相连，最终的结果都为字符串
        System.out.println("hello" + "," + 100 + "," + 3.14);

        System.out.println("" + 100);

2.赋值运算符
= 
复合赋值运算符：+= -= *= /= %=

//复合赋值运算符：+= -= *= /= %=
        int num1 = 100;
        num1 += 1;//等价于num1 = num1 + 1
        System.out.println(num1);

        short num2 = 50;
        num2 += 5;//等价于num2 = (short)(num2 + 5)
        System.out.println(num2);


        int x = 10;
        int y = 20;
        int z = 30;
        //赋值方向：从右往左
        x = y = z;
        System.out.println(x);//30
        System.out.println(y);//30
        System.out.println(y);//30

        //int m;
        //1 = m;

3.关系运算符【条件运算符】
> < <= >= ==【恒等于】 !=【不等于】
用于比较两个变量的大小，如果成立则结果为true，反之为false
注意：在使用关系运算符时，保证参与比较的两个变量是同一种类型

//> < <= >= ==【恒等于】 !=【不等于】
        System.out.println(5 > 3);

        System.out.println(5 == 3);

4.逻辑运算符
用于连接布尔类型的表达式

与【&、&&：短路与】、或【|、||：短路或】、异或【^】、非【！】

        int x = 4;

        //1.与： &  &&
        /*
        true & true = true;
        true & false = false;
        false & true = false;
        false & false = false;

        规律总结：全真为真，有假为假

        & 和 &&的区别：
        &：无论左边是true还是false，两边都会参与运算
        &&：只要左边是false，则右边不参与运算，直接得到结果为false
        */
        System.out.println(x > 3 & x < 6);//true
        System.out.println(x > 3 && x > 6);//false

        //举例
        int a = 10;
        boolean result = (a++ > 10) & (a-- < 10);
        System.out.println(a);//10
        //false & false  = false 

        int b = 10;
        boolean result1 = (b++ > 10) && (b-- < 10);
        System.out.println(b);//11

        //2、或 | ||
        /*
        true | true = true;
        true | false = true;
        false | true = true;
        false | false = false;

        规律总结：有真则真，全假为假

        | 和 ||的区别：
        |：无论左边是true还是false，两边都会参与运算
        ||：只要左边是true，则右边不参与运算，直接得到结果为true
        */


        //3.异或 ^
        /*
        true ^ true = false;
        true ^ false = true;
        false ^ true = true;
        false ^ false = false;

        规律总结：相同为假，不同为真
        */

        //4.非
        /*
        !true = false;
        !false = true;

        规律总结:假则为真，真则为假
        */

5.位运算符【★★】
& | ^   ~ <<【左移】  >>【右移】  >>>【无符号右移】

<>
<>
6.三元运算符【★★★★★】
作用：实现了二选一的操作
语法：条件表达式？表达式1：表达式2
注意：运算之后一定要有一个结果

        //需求：判断一个数是否是偶数，如果是则结果为“是偶数”，反之，结果为“是奇数”
        int num = 11;

        //语法：条件表达式？表达式1：表达式2
        String result = num % 2 == 0 ? "是偶数" : "是奇数";
        System.out.println(result);

        //三目运算符实现了二选一，如果条件表达式成立，则最终的结果为表达式1，反之，为表达式2

        int x = 3,y;

        y = (x > 1) ? 100 : 200;
        System.out.println(y);

7.转义运算符
通过\来改变后面字母或者符号的含义

    /*
        \n  换行
        \b  退格，相当于backspace键
        \r  按下回车键，相当于enter键
        \t  制表符，相当于tab键
        */

        System.out.println("hello\tworld");

        //在Window下，如果要进行回车，直接使用\r是不可以，必须\r\n结合使用
        //但是，\n单独可以使用
        System.out.println("hello\r\nworld");

        //需求："hello java"
        System.out.println("\"hello java\"");

        //需求：\hello java\
        System.out.println("\\hello java\\");

8.运算优先级

<>
注意：
a.尽量不要把一个表达式写的过于复杂，如果涉及到稍微复杂一点的运算时，建议分步操作
b.不要过多的依赖于运算符的优先级来控制表达式的执行顺序，这样可读性太差，推荐使用（）