02_数据类型和变量

清疚 2021-10-29 11:32 456阅读 0赞

# 1 **数据类型****和变量** #

## 1.1 **内存****如何存储数据** ##

数据是各式各样的，开发者要根据**数据的****类型**为其在内存中申请一块合适空间。

## 1.2 **数据****类型****(****A****)** ##

Java是一门强类型语言，任何数据都需要数据类型。

Java分为基本数据类型和引用数据类型。

byte、short、int、long、float、double、char、boolean 统称为java八大基本数据类类型。

## 1.3 **字符集(****A****)** ##

计算机只认识0或者1,计算机把8个二级制位称为一个**字节**，把1024字节称为1KB,把1024KB称为1MB，1024MB 称为1GB

0000 0000

键盘上的常用字符可以用1个字节

ASCII码

ISO8859-1 西欧字符集

GB2312 简体中文

GBK 简体中文\+繁体

Unicode 万国码

总结：

\[1\]以什么编码存文件，一定要以对应编码解码文件。

\[2\]存储二进制文件不需要编码

思考:unicode和utf8有什么关系？

## 1.4 **进制****转换****(****B****)** ##

### 1.4.1 **二进制转换** ###

二进制->十进制

= 0x20\+1x21\+0x22\+1x23\+0x24\+0x25\+0x26\+1x27

=> 138

十进制->二进制

八进制->十进制(C)

java中八进制表示法用数字0开头，例如017

015 => 5x80\+1x81

=> 13

十六进制\->十进制(C)

java中十六进制表示用0x开头，例如0x15,

10=a 11=b …15=f

0x15 => 5x160\+1x161 => 12

十六进制和八进制的出现是为了更方便的表述二进制而已。

## 1.5 **数据****类型** ##

### 1.5.1 **整形** ###

整形根据其所占用的长度分为4种

byte 1字节

short 2字节

int 4字节

long 8字节

byte 占一个字节，表示的数据范围是0000 0000 – 1111 1111 => 0-28\-1

总结：

开发中，一定要根据数据选择合适的数据类型。

可以通过十进制、八进制、十六进制给变量赋值。但初学还是建议十进制赋值。

<table> 
 <tbody> 
 <tr> 
 <td> public class Test01{ public static void main(String[] args){ // byte a = 257; &nbsp; // short a = 257; &nbsp; //short a = 015; //short a = 0x15; &nbsp; short a = 0x0; System.out.println(a); } } </td> 
 </tr> 
 </tbody> 
</table>

整形默认是int类型，如果要声明一个long类型的量，在量的后面加l或者L，建议大写。

### 1.5.2 **浮点型** ###

浮点型在计算机中表示小数，根据其精确的位置有可以分为两类。

float类型单精度，可以精确6-7位有效数字。

double类型 双进度，可以精确到15-16位有效数字。

浮点型数据的声明方式

十进制

3.14 314.0

科学计数法(C)

314e2 314E2 314E-2

**double** f = 314e2; //314\*10^2-->31400.0

**double** f2 = 314e-2; //314\*10^(-2)-->3.14

当**声明一个浮点型的数据时，默认是double类型****，****如果要声明成float需要加f****/F.加d****/D****表示****double类型。**

浮点型数据有舍入误差，避免在金融计算时使用浮点数而渲染BigDecimal类来处理。

避免使用浮点数进行比较！

1/10 ó 0.1 在**计算机中不相等**，在现实世界相等。

### 1.5.3 **字符型** ###

在java中，用单引号(‘’)引起来的数据表示字符型数据。‘A’、‘a’、‘2’、‘中’。用char表示。

用“”引起来的数据是字符串 “abc”、“中国”、“好”。字符串就是字符连成串。

字符和字符串是完全不同的数据类型。

char 类型用来表示在**Unicode**编码表中的字符。

转义字符

### 1.5.4 **boolean** ###

布尔类型，有两个值true或者false。用一个二进制位存储。一般用在逻辑判断。

## 1.6 **变量(****A****)** ##

### 1.6.1 **什么****是变量？** ###

在程序开发过程中，值可以发生变化的量就是变量。变量的本质是一块内存，这个内存有一个名字，这个名字就是变量名，该内存中的数据可以变化。

<table> 
 <tbody> 
 <tr> 
 <td> public class Test03{ public static void main(String[] args){ // 【1】声明变量 =&gt; 申请2个字节的内存空间 short money; // 【2】赋值 money = 1000; &nbsp; &nbsp; // 声明变量 声明和赋值合二为一 double rate = 0.05; double allMoney = 0.0; &nbsp; // 【3】使用变量 allMoney = money + money * rate; System.out.println(allMoney); } } </td> 
 </tr> 
 <tr> 
 <td> &nbsp;<img src="https://img2018.cnblogs.com/blog/1734439/201907/1734439-20190715182430256-444440261.png" alt=""> &nbsp; </td> 
 </tr> 
 </tbody> 
</table>

### 1.6.2 **声明****变量** ###

\[1\]声明变量 => 向内存申请空间

**数据类型 变量名；**

数据类型能省略吗？\-> 数据类型决定了申请多个空间。

变量名能省略吗？ \-> 不能

\[2\]变量赋值 => 给内存空间赋值

\[3\]使用变量 => 修改内存空间的值

注意:声明变量和赋值变量可合二为一。

### 1.6.3 **变量****命名规则** ###

\[1\]可以是字母、数字、\_、$

\[2\]数字不能开头

\[3\]不能是java关键字或者保留字

命名规范

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

\[2\]见名知意

### 1.6.4 **局部****变量和****成员变量** ###

局部变量

在方法内或者语句块内定义的变量，局部变量必须先声明后赋值才能使用。

<table> 
 <tbody> 
 <tr> 
 <td> public class Test08{ &nbsp; &nbsp; public static void main(String[] args){ &nbsp; // 方法中的局部变量 int count = 0; System.out.println("count="+count); &nbsp; // 语句块中的局部变量 { int price = 998; System.out.println("price="+price); } &nbsp; System.out.println("price="+price); System.out.println("count="+count); } } </td> 
 </tr> 
 </tbody> 
</table>

总结：

局部变量有其作用域，在其作用域中都可见。在java中\{\}就表示作用域。

成员变量

在类的内部，方法的外部定义的变量。

成员变量如果没有初始化，jvm自动给成员变量初始化成默认值。

数值型默认值是0/0.0

字符型默认值是0x00 \\u0000

布尔值默认值false

<table> 
 <tbody> 
 <tr> 
 <td> public class Test09{ &nbsp; // 成员变量 int age; &nbsp; public void test(){ System.out.println("age="+age); } &nbsp; public static void main(String[] args){ &nbsp; Test09 t = new Test09(); t.test(); } } </td> 
 </tr> 
 </tbody> 
</table>

## 1.7 **常量** ##

在开发过程中，值不能发生变化的量称之为**常量****，****用Final****表示****。**

<table> 
 <tbody> 
 <tr> 
 <td> public class Test10{ public static void main(String[] args){ &nbsp; // 求半径为10的圆的面积 //final float PI = 3.14f; // PI = 3.14159f; &nbsp; final float PI; PI = 3.14f; &nbsp; int r = 10; float area = PI * r * r; System.out.println("area="+area); &nbsp; } } </td> 
 </tr> 
 </tbody> 
</table>

总结：

Final类型的常量只能被赋值一次。

## 1.8 **标识符****命名规范** ##

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

变量、方法名：

首字母小写和驼峰原则

run(), runRun(), age ageNew monthSalary

**常量：**

大写字母和下划线：MAX\_VALUE

类名：

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

## 1.9 **运算符和****表达式** ##

### 1.9.1 **赋值****运算符** ###

int var = value

赋值运算符，用于把右边的量value赋值给左边的变量var

### 1.9.2 **算术****运算符** ###

\+ - \* / %

/ 表示整除。两个整数相除结果为整；两个浮点数相除结果为小数

<table> 
 <tbody> 
 <tr> 
 <td> int a = 15; double b = 3.0; double c = a / b; System.out.println("c="+c); </td> 
 </tr> 
 </tbody> 
</table>

% 表示取余数，也叫求模

<table> 
 <tbody> 
 <tr> 
 <td> // % a = 1; int d = 3; int e = a % d; System.out.println("e="+e); &nbsp; // 案例:把12356转化成时分秒 int ts = 12356; int h = ts / 3600; //int m = (ts-h*3600)/60; int m = (ts % 3600) / 60; int s = ts % 60; </td> 
 </tr> 
 </tbody> 
</table>

总结

%a结果就不会超过a

i++/i—-

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

<table> 
 <tbody> 
 <tr> 
 <td> public class Test12{ public static void main(String[] args){ &nbsp; // 【1】 int i = 10; i++; &nbsp; // 【2】 i = 10; int j = 0; j = i++; // i=? j=? &nbsp; // 【3】 i = 10; j = i++ + i++; // i=? j=? System.out.println("i="+i); System.out.println("j="+j); } } </td> 
 </tr> 
 </tbody> 
</table>

\++i/--i

\++i:i在参与运算前就自加1.

<table> 
 <tbody> 
 <tr> 
 <td> public class Test13{ public static void main(String[] args){ &nbsp; // 【1】 int i = 10; ++i; &nbsp; // 【2】 i = 10; int j = 0; j = ++i; // i=? j=? &nbsp; // 【3】 i = 10; j = ++i + ++i; // i=? j=? System.out.println("i="+i); System.out.println("j="+j); } } </td> 
 </tr> 
 </tbody> 
</table>

### 1.9.3 **拓展****运算符** ###

\+= -= \*= /= %=

<table> 
 <tbody> 
 <tr> 
 <td> public class Test14{ public static void main(String[] args){ &nbsp; // += 步增 int a = 10; a += 2; //=&gt; a=a+2 System.out.println("a="+a); &nbsp; // -= 步减 a = 10; a -= 2; System.out.println("a="+a); &nbsp; // *= 倍增 a = 10; a *= 2; //=&gt; a=a*2; &nbsp; // *= 倍减 a = 10; a /= 2; &nbsp; } } </td> 
 </tr> 
 </tbody> 
</table>

### 1.9.4 **关系****运算符** ###

>、<、>=、 <=、 ==、 !=

关系运算符的结果是布尔类型。

<table> 
 <tbody> 
 <tr> 
 <td> int a = 10; int b = 11; boolean r = b != a; System.out.println("r="+r); </td> 
 </tr> 
 </tbody> 
</table>

### 1.9.5 **逻辑****运算符** ###

逻辑运算符 &&(与)、||(或)、非(!)

逻辑运算符两边的表达式一定是布尔值，结果也是布尔值。

**逻辑****与****&& =>** **表示并且、且**  
**true && true = true**

**true && false = false**

**false && true = false**

**false && false = false**

**逻辑****&&****两边****的表达式只要有一个为false，结果就为false**

**常见****错误**

<table> 
 <tbody> 
 <tr> 
 <td> int a = 10; int b = 4; r = (a&gt;b) &amp;&amp; (++b); System.out.println("r="+r); System.out.println("b="+b); </td> 
 </tr> 
 <tr> 
 <td> &nbsp;<img src="https://img2018.cnblogs.com/blog/1734439/201907/1734439-20190715182513876-884254992.png" alt=""> &nbsp; </td> 
 </tr> 
 </tbody> 
</table>

**逻辑****&&的短路运算**

**当****逻辑&&左边的表达式结果为false时，第二个****表达式将****不进行任何运算。**

<table> 
 <tbody> 
 <tr> 
 <td> int a = 10; int b = 4; r = (a&lt;b) &amp;&amp; (a&lt;++b); System.out.println("r="+r); System.out.println("b="+b); </td> 
 </tr> 
 </tbody> 
</table>

**逻辑****或****|| =****> 表示****或者、或**

**运算****规则**

**true || true = true**

**true || false = true**

**false || true = true**

**false || false = false**

**逻辑****||两边的表达式只要有一个为true****，****结果为true**

**逻辑****||****的****短路运算**

**逻辑****||左边的表达式如果为true，第二个表达式将不进行任何****运算****。**

**逻辑****非**

**!true = false**

**!false = true**

### 1.9.6 **位****运算符****(****C****)** ###

~ -- 取反

~0000 0000 = 1111 1111

& -- 按位与

0000 1010

& 0000 0000

\-------------

0000 0000

| -- 按位或

0000 1010

| 0000 0000

\-------------

0000 1010

^ -- 按位异或:相同为0，不同为1

0000 1010

^ 0000 1000

\-------------

0000 0010

<<：左移运算符

0000 1010 << 2 => 0010 1000

左移n位，相当于乘以2n

>>：右移运算符

右移n位，相当于除以2n

查资料了解 <<<、>>>

### 1.9.7 **三****目运算符** ###

(布尔表达式) ? r1 : r2

布尔表达式为true，这个运算的结果取r1，否则取r2。

<table> 
 <tbody> 
 <tr> 
 <td> public class Test19{ public static void main(String[] args){ &nbsp; int a = 2; int b = 10; int r = (a&gt;b)? 1:2; System.out.println("r="+r); &nbsp; // 案例：求两个数的最大值 int m = 10; int n = 4; int max = 0; max = (m&gt;n) ? m : n; System.out.println("max="+max); } } </td> 
 </tr> 
 </tbody> 
</table>

### 1.9.8 **字符串****连接符\+** ###

“\+”运算符两侧的操作数中**只要有一个是字符串(String)类型**，系统会自动将另一个操作数转换为字符串然后再进行连接

<table> 
 <tbody> 
 <tr> 
 <td> int e = 10; int f = 20; System.out.println(e+f);//加法运算 System.out.println("e="+e);// 字符串连接 </td> 
 </tr> 
 </tbody> 
</table>

#     #

转载于:https://www.cnblogs.com/meizhoulqp/p/11190581.html