Java基础-第二章(类型和运算)

一.变量和常量

1.字面量和常量

常量:程序中固定不变的值;

常量分类:比如:整数常量 1,2,3,小数常量,布尔常量false,true等;

字面量:就是表示直接给出的一个值(可以是整数,小数,true,false等等),直接量;

定义的final变量:后详;

2.变量的定义和基本使用

变量的定义:表示存储空间,可用来存放某一类型的常量,没有固定的值,并可以重复使用,也可以用来存储某种类型的未知数据;

变量的特点:
- 占据着内存中的某一块存储区域;
- 该区域有自己的名称(变量名)和类型(数据类型);
- 可以被重复使用;
- 该区域的数据可以在同一类型范围不断变化;

变量的书写:

先定义变量再赋值:
数据类型变量名; 变量名 = 值;

或在声明时同时赋值:
数据类型变量名 = 初始化值;

注:格式是固定的,记住格式,以不变应万变;
不推荐:同时定义多个变量;

3.变量的分类-作用域

变量的分类:
随着变量定义在类中的位置不同,故把变量分成两大类:
- 成员变量:直接定义在类里的变量,又称为全局变量或字段(方法外);
- 局部变量:变量除了成员变量之外,其他的就是局部变量(方法内).根据定义的位置不同有3中表现形式:方法形参,方法内变量,代码块变量;

变量作用域:
指变量的存在范围,只有在这范围内,程序代码才能访问他.当一个变量被定义时,他的作用域就确定了:
- 作用域是定义开始到定义所在的花括号结束;

变量使用规则:
- 1.变量必须先声明,并且初始化后才能使用;
- 2.声明变量必须要有数据类型;
- 3.同一作用域内变量名不能重复定义;

4.表达式

表达式:是由数字,运算符,数字分组符号(括号),常量,变量等以能求得结果的有意义排列的组合.用运算符号连接的变量/常量可以称为表达式.那么也就是说表达式是由常量,变量,运算符,括号组成能求得值的有意义结果的语句;
如:

a + b
3.14 + a
(x + y) * z + 100

表达式中操作数进行运算得到的最终结果就是表达式的结果;
表达式的运算顺序(大多数和数学一样,参照后面的运算符操作优先级);

二.数据类型

1.数据类型和分类

2.八种基本数据类型

NO.	数据类型	占位(字节)	数据范围	默认值
1	byte	1	[-128,127]	0
2	short	2	[-215,215-1]	0
3	int	4	[-231,231-1]	0
4	long	8	[-263,263-1]	0L
5	char	2	[0,216-1]	‘\u0000’
6	float	4	[-3.4E38(-3.41038),3.4E38(-1.71030)]	0.0F
7	doule	8	[-1.7E308(-1.710308),1.7E308(-1.710308)]	0.0D
8	boolean	1位	true,false	false

1).boolean类型(true-false)

booblean类型: 通常用于逻辑运算和程序流程控制(条件选择/循环);
- 该类型的值只能是true或false,表示真或假;
- 不可以使用0或非0的整数来代替false和true,区分于c语言;
- (其实JVM中对boolean的处理也是用0表示false,非0表示true的);
- false和true是boolean的常量;

2).整数类型(byte-short-int-long)

byte,short,int,long类型:
整型常量的四种表示形式:
- 二进制整数: 0B或0b开头(Java7的新特性),如: int a = 0B110;
- 八进制整数: 要求以0开头,如: int a = 012;
- 十进制整数: 如: int a = 17;
- 十六进制整数: 要求0X或0x开头,如: int a = 0x12;

Java语言的整型常量默认是int型,声明long型变量后加上”l”或”L”,因为小写的”l”容易和数字1相混淆,建议使用大写的”L”;

默认情况下,一个整型的字面量默认是int类型;

3).小数类型(float-double)

float,double类型: 表示小数类型又称为浮点型,其中float表示单精度浮点型,double表示双精度浮点型,但二者都不能表示精确的小数;
Java的浮点类型常量有两种表现形式:
- 十进制形式: 例如: 3.14,168.0,.618;
- 科学计数法形式: 例如: 3.14e2,3.14E2,1000E-2;

科学计数法表达式返回的结果是double类型;

默认情况下,一个浮点型的字面量默认是double类型,若要声明一个常量为float类型,则需要在常量后加上f或F,double常量后面的D或d可以省略;

注意: Java里只有浮点型的变量才可以接受科学计算式的结果;

因为float和double都不能精确的表示小数,在精度要求较高的系统中可以使用BigDecimal类型,它表示任意精度的数据;

4).字符类型(char) [字符,字母,符号]

char类型: 表示16位的无符号整数或者Unicode字符,Java对字符采用Unicode字符编码;

Unicode收集了世界上所有语言中的字符,是一种跨平台的编码方式,Java的字符占两个字节,可以表示一个汉字;

编码: 计算机只能表示0和1两个数,于是人们做出规定使用一个数字去表示一个特定的字符,比如a使用97表示;

char前256个字符和ASCII(美国信息交互标准编码)码中的字符重复;

char常量有4种表示形式:
- 1.直接使用单个字符来指定字符常量,格式如”A”,”7”;
- 2.直接作为十进制整数数值使用但是数据范围在[0,65535],格式如97,但是打印出来的值依然是ASCII码表对应的符号,如97打印出来的就是字符a;
- 3.和2一样,只不过表示的是十六进制的数值,格式如’\ux’,x表示十六进制整数;如: 97的十六进制是61;那么表示为’\u0061’打印出来的也是a;

所以有人说char本质上也是整型,也是有道理的;

5).最常用的引用类型String

除了8种基本数据类型,其他的所有类型都是引用类型,包括类,接口,数组;引用数据类型默认初始值都是null;

String是一个类: 表示字符串,所谓字符串就是一串字符,也就是n个字符连接在一起组成的;
字符串都得使用”“括起来的,连接字符串使用”+”符号;

字符串拼接: 字符串和任意数据类型相连接,结果都是字符串数据类型;
转义字符: “\”,可以使字符表示他本身的意思;

三.基本数据类型转换

1.数据过大和溢出

当要表示的数据超出数据类型的临界范围时,称为溢出;溢出的情况发生时程序并没有做数据范围检查处理,此时会出现数据紊乱情况;

int最大值;
int intMax = 2147483647;

1).分析数据发生紊乱的原因

public class OverFlowDemo{
    public static void main(String[] args){
        //int类型最大的值
        int intMax = 2147483647;
        //让intMax变量的值加1之后,在赋值给intMax变量
        intMax = intMax + 1;
        System.out.println("int最大值 " + intMax);//-2147483648

        /*
            OB01111111_11111111_11111111_11111111
         +  OB00000000_00000000_00000000_00000001
        -------------------------------------------------------
            OB10000000_00000000_00000000_00000000
        */

        int intMin = -2147483648;
        intMin = intMin - 1;
        System.out.println(intMin);
    }
}

2.自动类型转换

自动类型转换,也称为”隐式类型转换”:
当把小数据范围类型的数值或变量赋给另一个大数据范围类型变量,系统可以完成自动类型转型;这好比把一斤水容器的水倒入可以装两斤水的容器一样;

注意: 在八大数据类型中,boolean不属于数值类型,所以boolean不能参与转换;

转换规则其实就是各自数据类型的空间大小;
这里写图片描述

/*
    byte的二进制:   00000101
    short的二进制:  00000000_00000101
    int的二进制:    00000000_00000000_00000000_00000101
*/
byte b1 = 5;
short s1 = b1; //小转换为大
int i1 = s1;
long l1 = i1;

float f1 = l1; //long-->float
double d1 = f1;

System.out.println(d1); //5.0

3.强制类型转换

强制类型转换,也称为”显示类型转换”:
当把大范围类型的数值或变量赋值给另一个小范围变量时,此时系统不能自动完成转换,需要加上强制转换符,但这样操作可能造成精度的降低或溢出,所以使用时要格外注意;

这就好比把装两斤水的容器里的水倒在装一斤水的容器里,可以造成水的溢出;若要坚持把两斤水装入一斤水的容器里,我们需要动用暴力手段—强制类型转换;

注意: 强制类型转换,可能造成溢出和精度损失;

double pi = 3.14;
int i2 = (int)pi; //double-->int
System.out.println(i2);

//直接把double类型的常量,赋给int类型变量i3
int i3 = (int)(3.14 + 1.4);
System.out.println(i3);

/*
    整数常量,默认是int类型
    把一个int类型的常量,直接赋值给byte类型变量
*/
byte b2 = 125;
//编译器发现125在byte的范围之内,底层就直接转换了

4.表达式类型的自动提升

当一个算术表达式中包含多个基本类型(boolean除外)的值时,整个算术表达式的数据类型将在数据运算时出现类型自动提升,其规则是:

所有的byte,short,char类型被自动提升到int类型;

整个表达式的最终结果类型被提升到表达式中类型最高的类型;

//在表达式中的最高类型为double类型,所以我们就要使用double类型的变量来接收表达式的最终结果
double d1 = 123 + 1.1F + 99L + 3.14;

//在表达式中char对应的'a'会被自动提升为int类型,所以结果为98
System.out.println('a' + 1); //98

//编译出错,在表达式中11为默认int类型,所以此时的类型应该为int
byte b = 22;
b = b + 11;

注意: String和任意数据使用+连接起来,结果都是String(字符串);

四.运算符

1.算术运算符

用来处理四则运算的符号;

运算符	运算	范例	结果
+	正号	+3	3
-	负号	b = 4; -b;	-4
+	加	5 + 5	10
-	减	6 - 4	2
*	乘	3 * 4	12
/	除	5 / 5	1
%	取模	5 % 5	0
++	自增(前)	a = 2; b = ++a;	a = 3; b = 3;
++	自增(后)	a = 2; b = a++;	a = 3; b = 2;
- -	自减(前)	a = 2; b = - -a;	a = 1; b = 1;
- -	自减(后)	a = 2; b = a- -;	a = 1; b = 2;
+	字符串相加	“He” + “llo”	“Hello”

加号: 在操作数值,字符,字符串时结果是不同的;当两个字符相加得到的是ASCII码表值,当两个字符串相加时表示两个字符串连接在一起,从而组成新的字符串;

除号: 整数在使用除号操作时,得到的结果仍为整数(小数部分忽略),当整数除以0的时候,会引发算术异常;

正无穷大(Infinity): 当一个正浮点类型数除以0时,或者正整数除以0.0时;
负无穷大(-Infinity): 当一个负浮点类型数除以0时,或者负整数除以0.0时;

取模(求余数): 模数的符号忽略不计,结果的正负取决于被模数;

注意: 无穷大和NaN都属于double浮点类型,但是所有的正无穷大都是相等的,所有负无穷大也是相等的,NaN永远不相等,也不等于自己;

1).++和- -详解

++和- -都是只能操作变量,不能操作常量;

++: 表示当前操作变量自己累加1;
- -: 表示当前操作变量自己减去1;

自增: ++,递增操作符,使变量值增加1,有前置和后置之分,只能操作变量;
自减: - -,递减操作符,使变量值减去1,有前置和后置之分,只能操作变量;

自增和自减具体的操作是一样的,仅仅是一个加1,一个减1而已;

代码a++和++a,都将使a变量的值加1;唯一区别是:

前置(++a): 表示对a加1之后的结果进行运算;
后置(a++): 表示对a变量加1之前的值(原始值)进行运算;

如果仅仅执行简单的递增操作(只写a++或++a),那么选用任意一个都可以;

//前置++
int a1 = 5;
int b1 = ++a1; //a1 = a1 + 1
System.out.println("a1 = " + a1 + ", b1 = " + b1); //a1 = 6, b1 = 6

//后置++
int a2 = 5;
int b2 = a2--; //a2(5) + 1
System.out.println("a2 = " + a2 + ", b2 = " + b2); //a2 = 6, b2 = 5

2).自增的面试题分析

面试题(1):

//第一题
int num1 = 1;
num1 = num1 ++;
System.out.println(num1); //1

//第二题
int num2 = 1;
num2 = ++ num2;
System.out.println(num2); //2

分析:

//第一题分析
num1 : 1
num1 ++ ---> num1 + 1;
             原始值1
num1 = 原始值;

//第二题分析
num2 : 1
++ num2 ---> num2 + 1;
num2 = 2;

面试题(2):

int i = 5;
i++;

System.out.println("i = " + i); //6

++i;
System.out.println("i = " + i); //7

int a = ++i;
System.out.println("a = " + a); //8
System.out.println("i = " + i); //8

int b = i++; // 8 + 1
System.out.println("b = " + b); //8
System.out.println("i = " + i); //9

2.赋值运算符

赋值运算符专门为变量指定值或重新指定值;

运算符	运算	范例	结果
=	赋值	a = 3; b = 2;	a = 3; b = 2;
+=	加等于	a = 3;b = 2; a += b;	a = 5; b = 2;
-=	减等于	a = 3;b = 2; a -= b;	a = 1; b = 2;
*=	乘等于	a = 3;b = 2; a *= b;	a = 6; b = 2;
/=	除等于	a = 3;b = 2; a /= b;	a = 1; b = 2;
%=	模等于	a = 3;b = 2; a %= b;	a = 1; b = 2;

注意: java支持同时给多个变量赋值,好比支持同时声明多个变量一样,但因影响代码可读性,故不推荐;

加等于: x += 5;相当于x = x + 5,但还包括隐式类型转换;

int a,b,c; //不推荐
a = b = c = 5; //不推荐

short s = 5;
//s = s + 3; //编译出错,需要强转 s = (short)(s + 3);
s += 3;//编译通过,隐式类型转换

3.比较运算符

用于比较两个变量或者常量之间的关系,比较运算符的结果是boolean类型;

其操作格式为:

boolean result = 表达式A 比较运算符 表达式B;

== : 等于,若比较的两个操作数都是数值类型,即使他们的类型不同,只要值相同就返回true;当然==也可以比较引用数据类型;

运算符	运算	范例	结果
==	相等于	4 == 3	false
!=	不等于	4 != 3	true
<	小于	4 < 3	false
>	大于	4 > 3	true
<=	小于等于	4 <= 3	false
>=	大于等于	4 >= 3	false
instanceof	检查是否是类的对象	“Hello” instanceof String	true

4.三元运算符

三元运算符又称为三目运算符;

其操作格式为:

数据类型 变量 = boolean表达式 ? 值1 : 值2;

如果boolean表达式的结果为true,三元运算符表达式结果就是值1;

示例:

判断一个数是奇数还是偶数;

注意: 判断一个数据是奇数还是偶数,只要判断除以2之后的余数是否为0,为0则是偶数;
不能直接判断余数是1,考虑小数的情况;

1.三元运算符在分页业务逻辑中使用

public class PageDemo{
    public static void main(String[] args){
        /*
            需求: 给出一共有46条数据,要求每一页最多10条数据
            计算: 一共多少页
        */
        int totalCount = 51;
        int pageSize = 10;// 每页最多10条数据

        //总页数
        int totalPage = totalCount % pageSize == 0 ? totalCount / pageSize : totalCount / pageSize + 1;

        int currentPage = 2;

        //上一页
        int prevPage = currentPage -1 >= 1 ? currentPage -1 : 1;
        System.out.println(prevPage);
    }
}

5.逻辑运算符

运算符	运算	范例	结果
&	AND(与)	false & true	false
\|	OR(或)	false \| true	true
^	XOR(异或)	true ^ false	true
!	NOT(非)	!true	false
&&	AND(短路与)	false && true	false
\|\|	OR(短路或)	false \|\| true	true

&: 表示并且,当操作数A和B都为true结果才为true,否则结果为false;
&&: 和&结果相同,具有短路效果,如果左边操作数A是false,结果一定为false,并且不运行B的运算;
|: 表示或者,A和B都为false结果为false,只要A或B是true,结果就是true;
||: 和|结果相同,并具有短路效果,如果左边操作数A是true,结果一个为true,且不运行B的运算;
^: 判断A和B是否不同,不同则为true,相同则为false;
!: 取反,!true结果是false,!false结果是true;

6.位运算符

1.位运算符规则

若要交换两个变量的值,如int a = 3, int b = 5;交换后a等于5,b等于3,我们可以定义第三方的变量来完成;

位操作是程序设计中对位模式按位或二进制的一元和二元操作;

NO.	逻辑运算符	描述
1	&	按位与
2	\|	按位或
3	^	异或(相同为0,不同为1)
4	~	取反
5	<<	左移位
6	>>	右移位
7	<<<	无符号右移位

遵循规则:
&: 参与运算的两个数,若相应位数的值都为1,则该位结果值是1,否则为0;
|: 参与运算的两个数相应位中只要有一个1,结果就是1;
^: 参与运算的两个数相应位相同则结果为0,否则为1;
~: 表示把每个二进制的1换成0,把0换成1;

boolean的true和false,在底层使用一位的1和0来表示:
- true:1
- false:0

二进制数 a	二进制数 b	与(&)	或 (\|)	异或 (^)
0	0	0	0	0
1	0	0	1	1
0	1	0	1	1
1	1	1	1	0

2.移位操作

<<: 将操作数的二进制码整体左移指定位数,左移之后的空使用”0”来补充;
>>: 将操作数的二进制码整体右移指定位数,右移之后的空使用”符号位”来补充:
- 若是正数使用”0”补充;
- 若是负数使用”1”补充;

>>>: 将操作数的二进制码整体右移指定位数,右移之后的空使用”0”来补充 (无符号右移);

3.交换两个变量

public class SwapVarDemo{
    public static void main(String[] args){
        /*
            传统交换
        */
        int a = 10;
        int b = 20;

        int temp = a;// 把a的值赋给临时变量temp
        a = b;// 把b的值存储到a中
        b = temp;
        System.out.println("a=" + a + ",b=" + b);

        /*
            异或交换
        */
        a = a ^ b;
        b = a ^ b;
        a = a ^ b;
        System.out.println("a=" + a + ",b=" + b);
    }
}

7.运算符的操作优先级

优先级	运算符	结合性
1	() [] .	从左到右
2	! +(正) -(负) ~ ++ - -	从右到左
3	* / %	从左到右
4	+(加) -(减)	从左到右
5	<< >> >>>	从左到右
6	< <= > >= instanceof	从左到右
7	== !=	从左到右
8	&(按位与)	从左到右
9	^	从左到右
10	\|	从左到右
11	&&	从左到右
12	\|\|	从左到右
13	? :	从右到左
14	= += -= *= /= %= &= \|= ^= ~= <<= >>= >>>=	从右到左

反馈与建议

博客：关注我的CSDN博客
邮箱：pengtdy@gmail.com
QQ交流群： 644402856 (新)
版权声明：本博客所有的内容,包括文字、图片,均为作者JasonPeng原创。对未经许可擅自使用者,博主将保留追究其法律责任的权利。

感谢你阅读这篇博客。如果您喜欢这篇博客就请关注我和朋友一起分享吧！

posted @ 2018-01-12 01:10 PengTdy 阅读(248) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部