02 数据类型_变量_运算符_表达式

1.1 数据是如何存储的？

计算机只认识0/1,二进制。

现实世界包含很多数据类型 10、3.14、hello world、二狗

数据在计算机中通过内存来存储和运算的。

数据各式各样，要先根据数据的需求（即类型）为它申请一块合适的空间

1.2 八大基本数据类型

Java是一种强类型语言，每个变量都必须声明其类型。

为什么存在字符集？什么是字符编码？

计算机只认识0/1 => 请问字符‘h’如何存在到计算机中。

比如 0110 0001=> ‘a’

ascii表 => 把英文 <=> 二进制代码

1010 => 中

gbk字符集,包含了简体、繁体中文，目前的主流win7/win10都是gbk编码。

1.3 进制转换

【1】二进制->十进制
1 0 1 0 => 0*2⁰+1*2¹+0*2²+1*2³

6 1 2 0 => 0*8⁰+2*8¹+1*8²+6*8³

【2】十进制->二进制

1.4 八大数据类型

1.4.1 整型

三种表示法

十进制 99、0

八进制以0开头的数字 015、017

十六进制以0x开头的数字 0x15、0x0

整形根据其内存的长度又细分为byte、short、int、long

byte 占用内存8个二进制位(bit),即一个字节

一个字节最小的数是 0000 0000 => 0

一个字节最大的数是 1111 1111 => 255

ð 一个字节表示的数据分为是[0,255]，可以表示256个状态。

short 占内存中的2字节 => [0,2¹⁶-1] => [0,65535] =>[-32768-32767]

Java语言的整型常数默认为int型，声明long型常量可以后加L。

1.4.2 浮点型

浮点型表示小数。浮点型根据其精度分为单精度（float）和双精度类型(double).

单精度可以精确到6-7位

双精度可以精确到15-16位。

两种表示法(C)

浮点数值默认为double类型。要将其变为float类型，需要在后面增加F/f. 如： 3.14F(As)

浮点型注意(A)

[1]浮点数存在舍入误差 1.0在计算机中可能0.99999999999999898..

[2]浮点型不能用于比较 1.0 不一定等于 1.0 、0.1f 不一定等于 1.0/10

1.4.3 字符型

[1]通过单引号(’’)引起来的单个字符，用char表示;通过双引号(“ ”)引起来的单个或者多个字符称为字符串,用String表示。

[2] char 类型用来表示在Unicode编码表中的字符，占2个字节。

问题:搞清楚字符集和字符编码的关系？

char类型也可以用于存储转义字符

\n 和 \r的区别？

\n 换行

\r 把光标调至行首

1.4.4 Boolean 布尔类型

Boolean类型表示两种状态，一种是true表示真，一种是false表示假，主要用于逻辑判断。

Boolean类型用一个二进制位存储就可以。

1.5 变量

1.5.1 变量概念和内存表现

在程序运行过程中，值可以发生变化的量。变量本质上是一块内存空间。

public class Test02{

public static void main(String[] args){

// 需求：求一年后的收入

int money;

money = 1000;

 

 

// 利率 声明和赋值合二为一。

double rate = 0.05;

double result = 0.0;

 

// 表达式的计算

result = money + money * rate;

System.out.println(result);

 

}

}

1.5.2 变量的声明

[1]声明变量

[2]赋值。声明和赋值可合二为一

[3]使用变量

public class Test03{

public static void main(String[] args){

 

float score = 98.5f;

String name = "张三";

char gender = '男';

 

System.out.println(score);

System.out.println(name);

System.out.println(gender);

 

}

}

标识符的命名规则:

[1]变量名可以由字符、数字、_、$组成。

[2]首字母不能是数字。

[3]不能是java的关键字

变量命名的规范:

[1] 驼峰命名法。首字母小写，后续具有单个意义的单词首字母大写。

[2] 见名知意。

1.6 局部变量和实例变量

1.6.1 局部变量

局部变量：在方法或者在语句块({})内声明的变量统称为局部变量

java是强类型语言，存在作用域(scope)的概念，

[1]作用域用{}表示。一个{}就是一个独立的作用域。作用域可以嵌套。

[2]如果要访问一个变量，首先在该变量所在的作用域查找，如果找不到，查找该作用域的父作用域，依次类推，直到找到为止。在查找的过程中形成了一个链，这个链称为作用域链(scope chain)。

局部变量一定要先声明后初始化！

1.6.2 实例变量

实例变量: 方法外部、类的内部定义的变量

实例变量如果不自行初始化，他会自动初始化成该类型的默认初始值。

八大基本数据类型的默认值

数值型变量初始化成0或0.0；

字符型变量的初始化值是16位的0；

布尔型默认是false

1.7 常量

在程序运行过程中，值不可以发生变化的量。常量本质上是一块内存空间。常量用final修饰。

只能被初始化一次！

public class Test07{

public static void main(String[] args){

// 常量的声明

//final int count = 53; // 只能在此初始化一次。

//count = 60;

 

final int count;

count = 53;

 

System.out.println(count);

}

}

什么时候使用常量呢？

常量用于声明一个些固定的值。final float pi = 3.14;

需求:求半径为5的圆的面积？

public class Test08{

public static void main(String[] args){

int r = 10;

final double PI = 3.14;

 

double area = 0.0;

area = PI * r * r;

System.out.println(area);

}

}

标识符命名规范

所有变量、常量、方法、类名：见名知意

变量、方法名：

首字母小写和驼峰原则

run(), runRun(), age ageNew monthSalary

常量：

大写字母和下划线：MAX_VALUE

类名：

首字母大写和驼峰原则: Man, GoodMan

1.8 运算符

1.8.1 赋值运算符

变量 = 值 => 把右边的值赋值给变量表示的内存空间。

int count = 10;

1.8.2 算术运算符

+、-、*

/ 整除。如果/运算符两边的表达式是整数，结果一定是整数。如果/两边的表达式有一个为浮点数，结果就是浮点数。

% 求模/取余 a % b 表示求a/b的余数。

public class Test10{

public static void main(String[] args){

 

int a = 3;

int b = 10;

int c = a % b; //

 

// 需求:

int ts = 12764; // 单位是s => _时_分_秒

/*

int h = ts / 3600;

int m = (ts - h * 3600) / 60;

int s = ts - h*3600 - m*60;

System.out.println(h);

System.out.println(m);

System.out.println(s);

*/

 

int h = ts / 3600;

int m = ts % 3600 / 60;

int s = ts % 60;

System.out.println(h);

System.out.println(m);

System.out.println(s);

 

// %谁就一定不会超过谁

}

}

++、--:

a++/a--:a先参与运算，运算完成后自加/减1

public class Test11{

public static void main(String[] args){

 

int a = 10;

// a++;

 

// int b = a++;

 

int b = a++ + a++;

 

System.out.println(a);

System.out.println(b);

}

}

++a/--a:a在参与运算前就自加/减1

public class Test12{

public static void main(String[] args){

 

int a = 10;

//++a;

 

// int b = ++a;

 

// int b = ++a + ++a;

 

System.out.println(a);

System.out.println(b);

}

}

1.8.3 关系运算符

> >= < <= == !=

关系运算符的结果是true或者false

1.8.4 逻辑运算符

&&(与) 并且

两边的表达式必须为boolean值,表达式运算结果也是boolean值。

运算法则

t && t => t

t && f => f

f && t => f

f && f => f

总结:&& 两边的表达式只要有一个为false，结果为false

&& 是短路运算，如果第一个表达式为false，第二个表达式不做任何运算。

public class Test14{

public static void main(String[] args){

 

int a = 20;

int b = 10;

 

boolean r1 = (a<b) && (++a == 21);

System.out.println(a);

}

}

||(或) 或者

两边的表达式必须为boolean值,表达式运算结果也是boolean值。

运算法则

t || t => t

t || f => t

f || t => t

f || f => f

总结：|| 两边的表达式只要有一个为true，结果为true

||是短路运算，如果第一个表达式为true，第二个表达式不做任何运算。

!(非) 取反

!t = f

!f = t

1.8.5 位运算符(C)

&，|，^，~ ， >>，<<，>>> 运算符都应用于二进制位的运算

& 位与

1 & 1 = 1

1 & 0 = 0

0 & 1 = 0

0 & 0 = 0

1011

& 1001

-----------

1001

| 位或

1 | 1 = 1

1 | 0 = 1

0 | 1 = 1

0 | 0 = 0

1011

| 1001

-----------

1011

>> n 右移n位，左边0填充

<< 左移n位，右边0填充

10 => 0000 1010 >> 2 => 000000 10 => 2

10 => 0000 1010 << 2 => 0010 1000 => 40

右移1位相对于除以2

左移1位相对于乘以2

1.8.6 三目条件运算符

public class Test16{

public static void main(String[] args){

 

// 求两个数大小

// (boolean)? m : n

int max = 0;

int a = 10;

int b = 20;

 

max = (a>b)?a:b;

System.out.println(max);

}

}

1.8.7 拓展运算符

+= -= *= /= %=
a += n => a=a+n; => 步增

a -= n => a=a-n; => 步减

a *= n => a=a*n; => 倍增

a /= n => a=a/n; => 倍减

a %= n => a=a%n;

1.8.8 字符串连接符

+ 有两层含义

如果表达式都是数值类型，进行加法运算。

如果表达式有一个为字符串，进行字符串连接运算。

1.8.9 运算符优先级

当多个运算符组合运算时，一定搞清楚谁先进行运算？

总结

[1] ()优先级最高

[2] 赋值运算符优先级最低

[3] 只要想让谁先计算，加().

[4] 运算符有运算方向，赋值运算符从R to L.

1.9 控制台输入（A）

// 【1】导包

import java.util.Scanner;

public class Test02{

public static void main(String[] args){

// 【2】创建一个控制台输入对象

Scanner sc = new Scanner(System.in);

System.out.println("请输入java成绩:");

// 【3】接收用户输入的整数

int javaScore = sc.nextInt();

System.out.println("java score:"+javaScore);

}

}

1.10 类型转换

1.10.1 自动类型转换

在程序中，存在

[1] 容量小的数据类型可以自动转换为容量大的数据类型.

[2] 类型相兼容(数值型,char和整形相兼容) => 字符本质上是整形。

 

public class Test05{

public static void main(String[] args){

// 可以编译

double a = 10.0f;

System.out.println("a="+a);

 

byte b = 10;

int c = b;

System.out.println("c="+c);

 

// 特殊情况1:尽量规避

int d = 20;

float e = d;

System.out.println("e = " + e);

 

// 特殊情况2:整数-> 自动转化成char类型

char f = 'a';

System.out.println(f);

 

// 不能发生自动类型转换

int i = "aaaa";

}

}

jvm对类型转化的优化

可以将整型常量直接赋值给byte, short, char等类型变量，而不需要进行强制类型转换，只要不超出其表数范围

byte a = 200;

表达式计算结果类型自动转换(偏移)

1.10.2 强制类型转换

java中可以把一个数据类型强制转换成另外一个数据类型。在转换的过程中，可能存在精度丢失、丢失信息。

public class Test06{

public static void main(String[] args){

 

// 丢失精度

float pi = 3.14f;

int a = (int)pi;

System.out.println("a = " + a);

 

 

char c = 'a';

char d = (char)(c + 1);

System.out.println("d = " + d);

 

// 丢失信息

int e = 300;

byte f = (byte)e;

System.out.println("f = "+f);

}

}

注意:

在强制类型转换使用过程中，一定要规避丢失信息的情况