Javase基础（二）——数据类型
Javase基础（二）——数据类型和运算
常量
什么是常量：在程序执行的过程中其值不可以发生改变
常量的分类
- 字面值常量 5， 10 ，99 之类的
- 自定义常量(面向对象部分讲) final PI=3.14159
- 字面值常量的分类
- 字符串常量 用双引号括起来的内容
"avadsfasdfasdf" - 整数常量 所有整数
- 小数常量 所有小数
- 字符常量 用单引号括起来的内容,里面只能放单个数字,单个字母或单个符号(注意，单引号里面什么也不放是不行的)
- 布尔常量 较为特殊，只有true和false
- 空常量 null(当数组引用属于局部变量且未初始化时候)
- 字符串常量 用双引号括起来的内容
进制概述和二,八,十六进制
进制：就是进位制，是人们规定的一种进位方法。 对于任何一种进制–X进制，就表示某一位置上的数运算时是逢X进一位。二进制就是逢二进一，八进制是逢八进一，十进制是逢十进一，十六进制是逢十六进一。
不同进制表现同一个数据的形式特点：进制越大，表现形式越短
-
二进制的数据表现形式
由0,1组成。以0b(b可以大写也可以小写)开头(JDK1.7版本可以表示二进制了)
-
八进制的数据表现形式
由0,1,…7组成。以0开头
-
十进制的数据表现形式
由0,1,…9组成。整数默认是十进制的
-
十六进制的数据表现形式
由0,1,…9,a,b,c,d,e,f(大小写均可)。以0x开头
进制转换
- 任意进制到十进制的转换原理
- 系数：就是每一位上的数据。
- 基数：X进制，基数就是X。
- 权：在右边，从0开始编号，对应位上的编号即为该位的权。
- 结果：把系数*基数的权次幂相加即可。
- 十进制到任意进制的转换
-
除积倒取余法
-
8421码
8421码是中国大陆的叫法，8421码是BCD代码中最常用的一种。在这种编码方式中每一位二值代码的1都是代表一个固定数值，把每一位的1代表的十进制数加起来，得到的结果就是它所代表的十进制数码。
通过8421码的方式进行二进制和十进制的相互转换
二进制到八进制的简易方式：三个二进制数为一组
二进制到十六进制的简易方式：四个二进制数为一组
-
源码、反码、补码
原码
- 就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。
- 通过一个字节,也就是8个二进制位表示+7和-7
- 0(符号位) 0000111
- 1(符号位) 0000111
反码
- 正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。
补码
计算机计算时候都是以补码形式运算的
- 正数的补码与其原码相同；负数的补码是在其反码的末位加1。
例子：
已知原码求补码
0b10110100 原
0b11001011 反//符号位不变
0b11001100 补
已知补码求原
0b11101110 补
0b11101101 反
0b10010010 原
变量的概述及格式
变量：在程序执行的过程中，在某个范围内其值可以发生改变的量，用来不断的存放同一类型的常量，并可以重复使用
格式：数据类型 变量名 = 变量值;
基本数据类型占用字节数
boolean 1
byte 1
char 2
short 2
int 4
float 4
long 8
double 8
变量相加和常量相加的区别
- 面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。
byte b1 = 3;
byte b2 = 4;
byte b3 = b1 + b2;
从两方面去回答这个题
- b1和b2是两个变量,变量里面存储的值都是变化的,所以在程序运行中JVM是无法判断里面具体的值
- byte类型的变量在进行运算的时候,会自动类型提升为int类型
byte b4 = 3 + 4;
- 3和4都是常量,java有常量优化机制,就是在编译的的时候直接把3和4的结果赋值给b4了
数据类型
Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间
分类
-
基本数据类型
-
引用数据类型
-
其他
基本数据类型分类(4类8种)
-
整数型
- byte 占一个字节 -128到127
- short 占两个字 -215~215-1
- int 占四个字节 -231~231-1
- long 占八个字节 -263~263-1
-
浮点型
- float 占四个字节 -3.403E38~3.403E38 单精度(输入浮点型数值末尾需要加上f/F)
- double 占八个字节-1.798E308~1.798E308 双精度（小数类型默认为double）
-
字符型
- char 占两个字节 0~65535（char类型数据参与运算会自动提升为int）
-
布尔型
-
boolean
boolean理论上是占八分之一个字节,因为一个开关就可以决定是true和false了,但是java中boolean类型没有明确指定他的大小
不参与运算
-
| 类型 | ||||
|---|---|---|---|---|
| 整型 | byte | short | int | long |
| 浮点 | float | double | ||
| 布尔 | boolean | |||
| 字符 | char |
字符和字符串
ASCII输出：System.out.println('a');
字符类型与整数相加为ASCII字符号加整数：System.out.println('a'+1);
ASCII码表，记住三个值：
- ‘0’ 48
- ‘A’ 65
- ‘a’ 97
字符串与其他类型相加等于在字符串后加上字符
System.out.println("hello"+'a'+1);
System.out.println('a'+1+"hello");
在有字符串参与中被称为字符串连接符
System.out.println("5+5="+5+5);
System.out.println(5+5+"=5+5");
char数据类型
char c = 97; 0到65535
Java语言中的字符char可以存储一个中文汉字。因为Java语言采用的是Unicode编码。Unicode编码中的每个字符占用两个字节。中文也是占的两个字节。
占用空间
类型 字节数 数据位 默认值 范围
boolean 1 8 false [true,false]
byte 1 8 0 [-128,127]
char 2 16 '\u0000' [0,2^16]或['\u0000','\uffff']
short 2 16 0 [-2^15,2^15-1]
int 4 32 0 [-2^31,2^31-1]
float 4 32 0.0f [-3.4*10^38,-1.4*10^-45]U[1.4*10^-45,3.4*10^38]
long 8 64 0 [-2^63,2^63-1]
double 8 64 0.0d ...
long与float的取值范围谁大谁小
进行混合运算的时候,byte,short,char不会相互转换,都会自动类型提升为int类型,其他类型进行混合运算的是小的数据类型提升为大的
- byte,short,char（这三个混合运算也是转换为int） – int – long – float – double
- long: 8个字节
- float：4个字节
- IEEE754： 4个字节是32个二进制位，1位是符号位， 8位是指数位，00000000 11111111，0到255，1到254，-126到127，23位是尾数位，每个指数位减去127
结论：
-
它们底层的存储结构不同。
-
float表示的数据范围比long的范围要大
long：2^63-1
float：3.410^38 > 210^38 > 28^38 = 22338 = 2*2^114 > 2^63-1
转义字符
\f 下一页
\b 退格
\r 回车
\n 换行
\t 制表
\uxxxx 十六进制unicode字符
\ddd 八进制unicode字符
自动类型转换
byte-->short-->char-->int-->long-->float-->double
boolean类型不能自动类型转换
字符串与基本类型转换
XXX.parseXXX(String s) //实现将字符串类型转为任意基本类型
小数准确运算
import java.math.BigDecimal;
public class Test {
public static void main(String[] args) {
System.out.println(0.05+0.01); //0.060000000000000005
BigDecimal bd1=new BigDecimal(0.05);
BigDecimal bd2=new BigDecimal(0.01);
System.out.println(bd1.add(bd2)); //0.06000000000000000298372437868010820238851010799407958984375
BigDecimal bd3=new BigDecimal("0.05");
BigDecimal bd4=new BigDecimal("0.01");
System.out.println(bd3.add(bd4)); //0.06
}
}
注意事项
- 作用域问题：同一个区域不能使用相同的变量名
- 初始化值问题：局部变量在使用之前必须赋值（方法内）
- 一条语句可以定义几个变量：int a,b,c…;
隐式转换
- int + int 结果为int
- byte + int 结果为int
Java中的默认转换规则：取值范围小的数据类型与取值范围大的数据类型进行运算,会先将小的数据类型提升为大的,再运算
强制转换
强制转换问题
- int a = 10;
- byte b = 20;
- b = a + b;
强制转换的格式，括号不能省略
- b = (byte)(a + b); (强转后的二进制都是按照补码来计算)
强制转换的注意事项：如果超出了被赋值的数据类型的取值范围得到的结果会与你期望的结果不同（环形数值圈）而强转相当于截取，两种是不同
算术运算符
算术运算符，赋值运算符，比较(关系或条件)运算符，逻辑运算符，位运算符，三目(元)运算符
- +,-,*,/,%,++,–
注意事项：
- +号在java中有三种作用,代表正号,做加法运算,字符串的连接符
- 整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型
- /获取的是除法操作的商，%获取的是除法操作的余数
- %运算符
- 当左边的绝对值小于右边绝对值时,结果是左边
- 当左边的绝对值等于右边或是右边的倍数时,结果是0
- 当左边的绝对值大于右边绝对值时,结果是余数
- %运算符结果的符号只和左边有关系,与右边无关
- 任何一个正整数%2结果不是0就是1可以用来当作切换条件
算术运算符++和–
- ++,–运算符的作用
- 自加（++）自减（–）运算
- ++:自加。对原有的数据进行+1
- –:自减。对原有的数据进行-1
eg:
int a = 10;
int b = 10;
int c = 10;
a = b++; //a=10,b=11
c = --a; //c=9,a=9
b = ++a; //b=10,a=10
a = c--; //a=9,c=8
eg:
int x = 4;
int y = (x++)+(++x)+(x*10);
//x=6,y=70
eg:
byte b = 10;
b++; //有机制
b = b + 1; //报错，b是byte不能接收int
赋值运算符
-
基本的赋值运算符：=
- 把=右边的数据赋值给左边。
-
扩展的赋值运算符：+=,-=,*=,/=,%=
- += 把左边和右边做加法，然后赋值给左边。
eg:
short s=1;s = s+1; //int赋值给short，溢出错误
short s=1;s+=1; //有机质
关系运算符
==,!=,>,>=,<,<=
注意事项：
-
无论你的操作是简单还是复杂，结果是boolean类型。
-
“==“不能写成”=”。
逻辑运算符
- & | ^ !
- && || （短路运算符）
注意事项：
- 逻辑运算符一般用于连接boolean类型的表达式或者值。
- 表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
- 算术表达式：a + b
- 比较表达式：a == b(条件表达式)
&逻辑与:有false则false。
|逻辑或:有true则true。
^逻辑异或:相同为false，不同为true。
!逻辑非:非false则true，非true则false。特点：偶数个不改变本身。
短路运算区别
最终结果一样。&&具有短路效果。左边是false，右边不执行。&是无论左边是false还是true,右边都会执行，同理||和|的区别同上。开发中使用短路运算比较好，但是还是要看情况而定。
位运算符
& | ^ ~ >> >>> <<
- &:有0则0
- |:有1则1
- ^:相同则0，不同则1
- :按位取反（求一个数x的相反数格式：X+1）
位异或运算符的特点
一个数据对另一个数据位异或两次，该数本身不变。
逻辑运算符：运算布尔量
位运算符：运算数值量
可以用来实现两个数的交换
int x,y;
x=x^y;
y=x^y;
x=x^y;
<<：左移 左边最高位丢弃，右边补齐0，相当于×2
>>：右移 最高位是0，左边补齐0;最高为是1，左边补齐1，相当于÷2
>>>：无符号右移 无论最高位是0还是1，左边补齐0
eg：最有效率的算出2 * 8的结果（2<<3）
三元运算符
三元运算符的格式：(关系表达式) ? 表达式1 : 表达式2;
max=a>b?b;
Boolean x=a==b?trufalse;
max=a>b?(a>c?c):(b>c?c);
键盘录入
键盘录入练习：键盘录入两个数据，获取这两个数据中的最大值03.10_Java语言基础(键盘录入的练习2)(掌握)
03.11_Java语言基础(顺序结构语句)(了解)
import java.util.Scanner;
class LuRuDemo1
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("请分别输入两个整数!");
int x=sc.nextInt();
int y=sc.nextInt();
int max;
max=(x>y)? x:y;
System.out.println("最大的数是"+max);
}
}
流程控制语句：可以控制程序的执行流程。
流程控制语句的分类
- 顺序结构
- 选择结构
- 循环结构
执行流程：
- 从上往下，依次执行。
选择结构
if语句。。。balabala我就不介绍了
import java.util.Scanner;
class If_Else {
public static void main(String[] args) {
int x;
Scanner sc=new Scanner(System.in);
System.out.println("输入一个一百以内数字");
x=sc.nextInt();
if (x>100|x<0) {
System.out.println("成绩输入错误");
}else if (x>=90) {
System.out.println("优");
}else if (x>=80) {
System.out.println("良");
}else if (x>=70) {
System.out.println("中");
}else if (x>=60) {
System.out.println("及");
}else
System.out.println("差");
}
}
switch语句：
switch表达式：能自动类型提升为int的都可以作为其表达式内容，long不可以，String可以。
default一定是最后执行。
import java.util.Scanner;
class Day {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入1-7的一个数字");
int x=sc.nextInt();
switch(x){
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("格式错误");
}
}
}
注意：
- case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
- default可以省略，但是不建议
- break漏写会出现一个现象：case穿透。（case 穿透和default穿透）
- default可以在任意位置。但是建议在最后。依然是最后执行。
- switch语句的结束条件
- 遇到break就结束了
- 执行到switch的右大括号就结束了
循环结构
for,while,do…while
输出10次helloworld
class HelloWorld {
public static void main(String[] args){
for(int i=1;i<=10;i++) {
System.out.println(“helloworld”);
}
}
}
需求：在控制台输出所有的”水仙花数”，所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。举例：153就是一个水仙花数。153 = 111 + 555 + 333 = 1 + 125 + 27 = 153
class Flower {
public static void main(String[] args) {
int a1,a2,a3,count=0;
for (int i=100;i<1000 ;i++ ) {
a1=i%10; //个
a2=i/10%10; //十
a3=i/100; //百
if (i==a1*a1*a1+a2*a2*a2+a3*a3*a3) {
System.out.println(i);
count++;
}
}
System.out.println(count);
}
}
初始化语句;
while(判断条件语句) { // 条件满足执行循环体，不满足退出
循环体语句;
控制条件语句;
}
do { // 先执行循环体，再判断条件，满足继续执行
循环体语句;
控制条件语句;
}while(判断条件语句);
死循环：
while(true){...}
for(;;){...}
循环控制语句：
break：退出循环
continue：退出本次循环
for(int x=1;x<=10;x++){
if(x%3==0){
//在此处填写代码
}
System.out.println("Java基础班");
}
// 我想在控制台输出2次:"Java基础班" break;
// 我想在控制台输出7次:"Java基础班" continue;
// 我想在控制台输出13次:"Java基础班" System.out.pintln(“Java基础班”);
注意：System.out.println("*");和System.out.print("*");的区别
需求：请输出下列的形状
// *
// **
// ***
// ****
// *****
class Day04_7 {
public static void main(String[] args) {
for (int i=5;i>0 ;i-- ) {
for (int j=i;j>0 ;j-- ) {
System.out.print("*");
}
System.out.println();
}
}
}
需求：在控制台输出九九乘法表。
class JiuJiuBiao
{
public static void main(String[] args)
{
for (int i=1;i<=9 ;i++ )
{
for (int j=1;j<=i ;j++ )
{
System.out.print(j+"x"+i+"="+i*j+' ');
}
System.out.println();
}
System.out.println("by pp");
}
}
转义字符
写在字符串中的字符
'\t' tab键的位置
'\r' 回车
'\n' 换行
'\"' 转意字符”
'\'' 转意字符’
return的作用
- 返回
- 其实它的作用不是结束循环的，而是结束方法的。
return和break以及continue的区别：
- return是结束方法（写在主方法里面时候，结束主方法，程序停止运行）
- break是跳出循环
- continue是终止本次循环继续下次循环
标号：break a；跳到a这个标号处。标号也必须是合法标识符。
方法
提高代码的复用性，完成特定功能的代码块。
方法的格式(写在主方法外，类中方法外)
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
方法体语句;
return 返回值;
}
- 修饰符：
- 返回值类型：就是功能结果的数据类型。
- 方法名：符合命名规则即可。方便我们的调用。
- 参数：
- 实际参数：就是实际参与运算的。
- 形式参数；就是方法定义上的，用于接收实际参数的。
- 参数类型：就是参数的数据类型
- 参数名：就是变量名
- 方法体语句：就是完成功能的代码。
- return：结束方法的。
- 返回值：就是功能的结果，由return带给调用者。
需求：求两个数据之和的案例
public static int add(int a,int b){
return a+b;
}
注意：
- 方法不调用不执行
- 方法与方法是平级关系，不能嵌套定义
- 方法定义的时候参数之间用逗号隔开
- 方法调用的时候不用再传递数据类型
- 如果方法有明确的返回值，一定要有return带回一个值
方法重载概述和基本使用)
方法重载
在同一个类中，方法名相同，参数列表不同。与返回值类型无关。
参数列表不同：
- 参数个数不同
- 参数类型不同
- 参数的顺序不同(算重载,但是在开发中不用)
数组
数组(容器)：为了存储同种数据类型的多个值
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。数组既可以存储基本数据类型，也可以存储引用数据类型。
数组定义格式:
数据类型[] 数组名 = new 数据类型[数组的长度];
数组动态初始化
动态初始化 只指定长度，由系统给出初始化值int[] arr = new int[5];
静态初始化 给出初始化值，由系统决定长度
- 动态初始化的格式：
数据类型[] 数组名 = new 数据类型[数组长度];
初始化：整数类型：byte,short,int,long都是0；
浮点：float,double都是0.0；
布尔：false
字符：’\u0000’
静态初始化的格式：（不允许动静结合，有元素就不写个数）
- 格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…}; - 简化格式：
数据类型[] 数组名 = {元素1,元素2,…};
区别：上一种可以先声明，再赋值。简写形式只能声明赋值在同一行。
输出数组名称和数组元素
打印数组名：[I@19bba45a：前面[代表一维数组（[[二维），I代表int类型，后面@符号代表地址值。
注意：两个异常
- ArrayIndexOutOfBoundsException:数组索引越界异常
- 原因：你访问了不存在的索引。
- NullPointerException:空指针异常
- 原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。
- int[] arr = {1,2,3};
- arr = null;
- System.out.println(arr[0]);
数组遍历
public static void print(int[] arr) {
for (int i = 0;i < arr.length ;i++ ) {
System.out.print(arr[i] + " ");
}
}
eg：求最大值
public static int getMax(int[] arr) {
int max = arr[0];
for (int i = 1;i < arr.length ;i++ ) { //从数组的第二个元素开始遍历
if (max < arr[i]) { //如果max记录的值小于的数组中的元素
max = arr[i]; //max记录住较大的
}
}
return max;
}
二维数组概述
-
二维数组格式：
int[][] arr = new int[3][2];注意事项：
以下格式也可以表示二维数组
-
1：
数据类型 数组名[][] = new 数据类型[m][n]; -
2：
数据类型[] 数组名[] = new 数据类型[m][n]; -
注意下面定义的区别
int x; int y; int x,y; int[] x; int[] y[]; int[] x,y[]; x是一维数组,y是二维数组
-
{% raw %}
-
二维数组格式：
int[][] arr = new int[3][]; -
二维数组格式：
int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
{% endraw %}
需求：二维数组遍历
-
外循环控制的是二维数组的长度，其实就是一维数组的个数。
-
内循环控制的是一维数组的长度。
int[][] arr = {{1,2,3},{4,5},{6,7,8,9}}; for (int i = 0;i < arr.length ;i++ ) { //获取到每个二维数组中的一维数组 for (int j = 0;j < arr[i].length ;j++ ) { //获取每个一维数组中的元素 System.out.print(arr[i][j] + " "); } System.out.println(); }
数据类型参数传递
基本数据类型传递过程不改变原值，因为调用完会弹栈，局部变量消失。
引用数据类型传递改变原值，即使方法弹栈，堆内存数组还在，可以通过地址访问
1523
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
