Java基础语法-数据类型-类型转换-变量常量-运算符

前言

什么是字节

为了防止一些小伙伴不清楚计算机存储单位, 我贴心的帮大家"科普"一下

如果知道的小伙伴, 可以直接去看数据类型

• 位(bit) : 是计算机内部数据储存的最小单位, 11001100是一个八位二进制数
• 字节(byte) : 是计算机中数据处理的基本单位, 习惯上用大写B来表示
• 字符: 是指计算机中使用的字母、数字、字和符号

---

• 1bit表示1位
• 1Byte表示一个字节， 1B = 8b
• 1024B = 1KB
• 1024KB = 1M
• 1024M = 1G

1.数据类型

语言分为: 强类型语言和弱类型语言, Java属于强类型语言

• 强类型语言: 要求变量的使用严格符合规定, 所有变量必须先定义后才能使用
• 弱类型语言: 也称为弱类型定义语言。与强类型定义相反。像vb，php等就属于弱类型语言

Java的数据类型分为两大类:

• 基本类型
• 引用类型

---

基本数据类型分为三大类：数值类型、字符类型、boolean类型

1.数值类型

数值类型又分为两类：整数类型和浮点类型

1.1整数类型

• byte: 占1个字节, 范围：-128 -> 127

• short: 占2个字节, 范围: -32768 -> 32767

• int: 占4个字节, 范围: -2147483848 -> 2147483847

• long: 占8个字节, 范围: -9223372036854775808 -> -9223372036854775807

  byte num1 = 10;
  short num2 = 20;
  int num3 = 30; // int最常用
  long num4 = 40L; // long类型需要在数字后面加上L便于区分
  1
  2
  3
  4

1.2浮点类型

• float: 占4个字节

• double: 占8个字节

  float num5 = 40.1f;// float类型要在数字后面加上f
  double num6 = 3.1415926;
  1
  2

2.字符类型

• char: 占2个字节

  // char类型只能存放一个单独的字符
  char name1 = 'A'; // 错误写法: char name1 = 'Aa';
  char name2 = '陈'; // 错误写法: char name1 = '小陈';
  1
  2
  3

3.boolean类型

• boolean类型: 占1位, 且值只有true和false两个

  // boolean类型只有两个值, 一个为true一个为false
  boolean flag1 = true;
  boolean flag2 = false;
  1
  2
  3

总结: 共有八大基本数据类型, 4个整数类型+2个浮点类型+1个字符类型+1个boolean类型

(引用数据类型后面讲)

2.类型转换

2.1 类型转换介绍

由于Java是强类型语言，所以要进行有些运算的时候的，需要用到类型转换。

• 运算中，不同类型的数据先转化为同一类型，然后进行运算。

• 转换从低级到高级(根据容量来看, 且浮点型高于整型)

  低 --------------------------------------------> 高
  byte, short, char -> int -> long -> float -> double
  1
  2

类型转换分为:

• 自动类型转换: 从低级转到高级可以使用自动类型转换
• 强制类型转换: 从高级转到低级必须使用强制类型转换

2.2 自动类型转换

自动类型转换：容量小的数据类型可以自动转换为容量大的数据类型。

【比如】

• short数据类型的位数为16位，就可以自动转换位数为32的int类型；
• float数据类型的位数为32，可以自动转换为64位的double类型。

【演示】

char name = 'a';
int num1 = name;
System.out.println(num1); // 97

int num2 = 1024;
double num3 = num2;
System.out.println(num3); // 1024.0
1
2
3
4
5
6
7

【解析：由于小写字母a，查它对应的ASCII 码表可知对应的 int 类型值为 97，所以转换完成后是97】

2.3 强制类型转换

强制类型转换，又被称为造型，用于显式的转换一个数值的类型，容量大的类型转换容量小的类型，必须使用强制转换

• 在有可能丢失信息的情况下进行的转换是通过造型来完成的，但可能造成精度降低或溢出。
• 强制类型转换的语法格式： (type)var ，运算符“()”中的type表示将值var想要转换成的目标数据类型。 条件是转换的数据类型必须是兼容的。

【演示】

int num1 = 120;
byte num2 = (byte) num1;
System.out.println(num2); // 120

double num3 = 120.67;
float num4 = (float) num3;
System.out.println(num4); // 120.67
1
2
3
4
5
6
7

2.4 类型转换规则

数据类型转换必须满足如下规则：

• 不能对boolean类型进行类型转换。

• 不能把对象类型转换成不相关类的对象。

• 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

• 转换过程中可能导致溢出或损失精度，例如：

  int a = 128;
  // 强制转换a为byte类型
  byte b = (byte) a;
  System.out.println(a); // 128
  System.out.println(b); // -128
  1
  2
  3
  4
  5

  因为 byte 类型是 8 位，最大值为127，所以当 int 类型强制转换为 byte 类型时，值 128 时候就会导致溢出, 从而导致结果出现错误。

• 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：

  float c = 23.9f;
  int d = (int) c;
  System.out.println(d); // 23
  1
  2
  3

2.5 JKD7扩展

JDK7新特性：下划线分隔符

• 在实际开发和学习中，如果遇到特别长的数字，读懂它令人头疼！JDK7为我们提供了下划线分隔符，可以按照自己的习惯进行分割, 方便我们阅读。

  // 随意按照自己的习惯分隔
  int money1 = 100_000_000
  int money2 = 1_0000_0000
    
  // 对结果没有任何影响
  System.out.println(money1); // 100000000
  System.out.println(money2); // 100000000
  1
  2
  3
  4
  5
  6
  7

JDK7新特性: 二进制整数

• 我们在开发中也经常使用二进制整数，因此JDK7为我们直接提供了二进制整数的类型, 我们只要以：0b开头即。

  int num = 0b0101;
  1

3.变量和常量

3.1 变量的介绍

变量是什么：就是可以变化的量！

我们通过变量来操纵存储空间中的数据，变量就是指代这个存储空间！空间位置是确定的，但是里面放置什么值不确定！ 打个比方：

这就好像我们家里有一个大衣柜，里面有十分多的小格子，我们给格子上贴上标签，放衣服，放鞋子，放手表等等，此时我们知道了哪里该放什么，而这个标签就相当于我们的变量，我们给他起了个名字，但是里面要放什么需要我们自己去放。

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

• Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

• 变量在使用前必须对其声明, 只有在变量声明以后，才能为其分配相应长度的存储单元，声明格式为：

  //数据类型  变量名    =值;    后面可以使用逗号隔开来声明多个同类型变量
       type varName [=value] [{, varName [=value]}]  
  1
  2

【注意事项】

• 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
• 变量名必须是合法的标识符。
• 变量声明是一条完整的语句，因此每一个声明都必须以分号结束

【演示】

int a, b, c; // 同时声明三个int类型整数: a b c
// 声明完可以单独对变量进行赋值
a = 10;
b = 20;
c = 30;

byte d = 40, e = 50, f = 60; // 同时声明三个byte变量并赋值
        
System.out.println(a); // 10
System.out.println(b); // 20
System.out.println(c); // 30
System.out.println(d); // 40
System.out.println(e); // 50
System.out.println(f); // 60
1
2
3
4
5
6
7
8
9
10
11
12
13
14

【编码规范】

• 虽然可以在一行声明多个变量，但是不提倡这个风格，逐一声明每一个变量可以提高程序可读性。

3.2 变量作用域

变量根据作用域可划分为三种：

• 类变量（静态变量： static variable）：独立于方法之外的变量，用 static 修饰。
• 实例变量（成员变量：member variable）：独立于方法之外的变量，不过没有 static 修饰。
• 局部变量（lacal variable）：类的方法中的变量。

【示例】: 看不懂没关系, 我们先了解一下类变量, 实例变量, 局部变量分别写在什么位置

public class Test {
    // 类变量
    static int num = 10;
    // 实例变量
    String str = "Hello World";
    
    public void method() {
        // 局部变量: 定义在方法中
        String name = "小陈";
    }
}
1
2
3
4
5
6
7
8
9
10
11

局部变量 :

• 方法或语句块内部定义的变量, 生命周期是从声明位置开始到”}”为止。
• 在使用前必须先声明并且初始化(赋初值)。
• 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

【示例】

public static void main(String[] args) {
    int i = 10; // 错误写法: int i;
    int j = i + 10;
    System.out.println(j); // 20
}
1
2
3
4
5

实例变量 :

• 方法的外部、类的内部定义的变量。
• 从属于对象，生命周期伴随对象始终。
• 如果不自行初始化，他会自动初始化成该类型的默认初始值（数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false）

【示例】

public class Test {
    // 实例变量: 定义在类的内部，方法的外部
    int num = 100;
    String str = "Hello World";

    public static void main(String[] args) {
      	// 需要创建实例才能使用
        Test test = new Test();
        System.out.println(test.num); // 100
        System.out.println(test.str); // Hello World
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

静态变量 :

• 使用static定义。
• 从属于类，生命周期伴随类始终，从类加载到卸载。(注：讲完内存分析后我们再深入！先放一放这个概念！)
• 如果不自行初始化，他会自动初始化成该类型的默认初始值（数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false）

【示例】

public class Test {
    // 静态变量
    static double money = 2000;
    
    public static void main(String[] args) {
        // 可以直接在方法中使用
        System.out.println(money); // 2000.0
    }
}
1
2
3
4
5
6
7
8
9

3.3 常量的介绍

常量(Constant)：初始化(initialize)后不能再改变值！不会变动的值。

• 所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中就不允许再被改变。

• 语法如下

  // final 数据类型 变量名 = 值;
  final double PI = 3.1415926;
  final String NAME = "小陈";
  1
  2
  3

【注意事项】

• 常量名一般使用大写字符。
• 程序中使用常量可以提高代码的可维护性。

3.4 变量命名规范

1. 所有变量、方法、类名：要做到见名知意
2. 类成员变量：首字母小写和驼峰原则 : monthSalary
3. 局部变量：首字母小写和驼峰原则 : monthSalary
4. 常量：大写字母和下划线：MAX_VALUE
5. 类名：首字母大写和驼峰原则: Man, GoodMan
6. 方法名：首字母小写和驼峰原则: run(), runRun()

4.运算符

运算符operator

Java 语言支持如下运算符：

• 算术运算符: +，-，*，/，%，++，–
• 赋值运算符 =
• 关系运算符: >，<，>=，<=，==，!= instanceof
• 逻辑运算符: &&，||，!
• 位运算符: &，|，^，~ ， >>，<<，>>> (了解！！！)
• 条件运算符 ？：
• 扩展赋值运算符:+=，-=，*=，/=

4.1 算术运算符

4.1.1 二元运算符

+、-、*、/

两个操作数，来看看我们小时候的数学运算, 其实都属于二元运算符；

public static void main(String[] args) {
    int a = 20;
    int b = 10;
    System.out.println("a + b =" + (a + b)); // a + b =30
    System.out.println("a - b =" + (a - b)); // a - b =10
    System.out.println("a * b =" + (a * b)); // a * b =200
    System.out.println("a / b =" + (a / b)); // a / b =2
}
1
2
3
4
5
6
7
8

整数运算 :

• 如果两个操作数有一个为Long, 则结果也为long
• 没有long时，结果为int。即使操作数全为shot,byte，结果也是int.

【示例】

public static void main(String[] args) {
    int a = 10;
    long b = 100L;
    short c = 20;
    byte d = 30;
    // 运算有long类型, 运算结果就是long类型
    System.out.println((a + b + c + d));
    // 运算没有long类型, 那么就是int类型, 哪怕操作数中全是short和byte类型
    System.out.println((a + c + d)); // int类型 + short类型 + byte类型 结果是 int类型
    System.out.println((c + d)); // short类型 + byte类型 结果依然是 int类型
}
1
2
3
4
5
6
7
8
9
10
11

浮点运算 ：

• 如果两个操作数有一个为double, 则结果为double.
• 只有两个操作数都是float, 则结果才为float.

【示例】

public static void main(String[] args) {
    float a = 12.34F;
    float b = 56.78F;
    double c = 3.14159;

    // 有一个为double, 结果为double类型
    System.out.println((a + c)); // double类型
    // 全为float才是float类型
    System.out.println((a + b)); // float类型
}
1
2
3
4
5
6
7
8
9
10

4.1.2 取模运算

%

取模运算:

• 其实就是我们小学的取余运算, 得到余数

• 其操作数可以为浮点数,一般使用整数。如：5.9%3.9=2.000000004

要点：

• 负数%负数＝负数；
• 负数%正数＝负数；
• 正数%负数＝正数；

public static void main(String[] args) {
    System.out.println((9 % 2)); // 1
    System.out.println((-9 % -2)); // -1
    System.out.println((-9 % 2)); // -1
    System.out.println((9 % -2)); // 1
}
1
2
3
4
5
6

【注：一般都是正整数运算，进行结果的判断！】

4.1.3 一元运算符

++、--

自增（++）自减（–）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，

• 比如: a++, 其实相当于 a = a + 1
• 比如: a–, 就相当于 a = a - 1

【示例】

public static void main(String[] args) {
    int a = 1;
    a++;
    System.out.println(a); // 2
    ++a;
    System.out.println(a); // 3
    a--;
    System.out.println(a); // 2
    --a;
    System.out.println(a); // 1
}
1
2
3
4
5
6
7
8
9
10
11

而自增自减运算符是一个操作数，分为前缀和后缀两种。

• a++, 是先参加运算, 再自增,
• ++a, 是先自增, 再参加运算

【示例】

public static void main(String[] args) {
    int a = 1;
    int b = a++;
    int c = ++a;
    int d = a--;
    int e = --a;
    System.out.println(b); // 执行结果: 1; a先赋值给b, 然后自增加1, 此时a = 2
    System.out.println(c); // 执行结果: 3; a先自增加1, 然后赋值给b, 此时a = 3
    System.out.println(d); // 执行结果: 3; a先赋值给d, 然后自身减1, 此时a = 2
    System.out.println(e); // 执行结果: 1; a先自身减1, 然后赋值给b, 此时a = 1
}
1
2
3
4
5
6
7
8
9
10
11

java中的乘幂的处理: 需要使用Math类, Math类提供了很多科学和工程计算需要的方法和常数。特殊的运算都需要运用到方法!

public static void main(String[] args) {
    double a = Math.pow(3, 2); // 错误写法: int a = 3 ^ 2;
    System.out.println(a); // 9.0
}
1
2
3
4

4.2 赋值运算符

=

赋值运算符顾名思义是用来给变量赋值的, 将=右边的值赋值给=左边的变量

public static void main(String[] args) {
    // 将80赋值给num这个变量
    int num = 80;
    // 将"小陈"赋值给name
    String name = "小陈";

    System.out.println(num); // 80
    System.out.println(name); // 小陈
}
1
2
3
4
5
6
7
8
9

4.3 关系运算符

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

关系运算符返回一个布尔值(boolean)

【示例】

public static void main(String[] args) {
    int a = 10;
    int b = 20;
    System.out.println((10 == 20)); // false
    System.out.println((10 != 20)); // true
    System.out.println((10 > 20)); // false
    System.out.println((10 < 20)); // true
    System.out.println((10 >= 20)); // false
    System.out.println((10 <= 20)); // true
}
1
2
3
4
5
6
7
8
9
10

4.4 逻辑运算符

&&、||、!

逻辑运算符: 包含逻辑与, 逻辑或, 逻辑非

逻辑与和逻辑或采用短路的方式。从左到右计算，如果确定值则不会再计算下去。

• 逻辑与只要有一个为false, 则直接返回false.
• 逻辑或只要有一个为true, 则直接返回true;

【示例】

public static void main(String[] args) {
    boolean a = false;
    boolean b = true;
    System.out.println((a || b)); // 执行结果: true; 逻辑或运算符, 一个为真则为真
    System.out.println((a && b)); // 执行结果: false; 逻辑与运算符, 一个为假则为假
    System.out.println(!a); // 执行结果: true; 逻辑非运算符取反, 对a取反为true
    System.out.println(!b); // 执行结果: false; 逻辑非运算符取反, 对b取反为false
}
1
2
3
4
5
6
7
8

4.5 位运算符

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型
(byte)等类型。位运算符作用在所有的位上，并且按位运算。

【示例】

/*
	int num1 = 00111100;
	int num2 = 00001101;
	
	num1 & num2 = 00001100
	num1 | num2 = 00111101
	num1 ^ num2 = 00110001
	~num1 = 11000011
 */
1
2
3
4
5
6
7
8
9

public static void main(String[] args) {
    int num1 = 2;
    // 左移 相当于乘2; 左移几位, 就乘几个2
    System.out.println(num1 << 2); // 8; 相当于2 * 2 * 2

    int num2 = 16;
    // 右移 相当于除2; 右移几位, 就除几个2
    System.out.println(num2 >> 3); // 2; 相当于16 / 2 / 2 / 2
}
1
2
3
4
5
6
7
8
9

4.6 三目条件运算符

？ ：

三目条件运算符，语法格式：

x ? y : z
1

• 其中x为结果是boolean类型表达式，先计算x的值
• 若x的值为true，则整个三目运算的结果为表达式y的值
• 若x的值为false, 则整个运算结果为表达式z的值

【演示】

public static void main(String[] args) {
    int score1 = 80;
    int score2 = 52;
    String result1 = score1 >= 60 ? "及格了" : "不及格";
    String result2 = score2 >= 60 ? "及格了" : "不及格";
    System.out.println(result1); // 及格了
    System.out.println(result2); // 不及格
}
1
2
3
4
5
6
7
8

三元运算符在真实开发中十分的常见，大家可以多练习使用，之后我们会讲解分支语句，可以利用三元
运算符做到更加精简代码！便于理解！

4.7 字符串连接符

+

加号还有一个作用就是连接字符串

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

【示例】

public static void main(String[] args) {
    String str = "Hello Java";
    int num = 100;
    // 会自动将num转为字符串类型再进行拼接
    System.out.println((str + num)); // Hello Java100
}
1
2
3
4
5
6

4.8 扩展赋值运算符

以上运算符就相当于是一种简写的方式, 这种写法非常常用

【示例】

public static void main(String[] args) {
    int a = 10;
    int b = 3;
    System.out.println((a += b)); // 13; 等效于 a = 10 + 3
    System.out.println((a -= b)); // 10; 等效于 a = 13 -10
    System.out.println((a *= b)); // 30; 等效于 a = 10 * 3
    System.out.println((a /= b)); // 10; 等效于 a = 30 / 3
    System.out.println((a %= b)); // 1; 等效于 a = 10 % 3
}
1
2
3
4
5
6
7
8
9

4.9 运算符的优先级

我们小学都学过：先加减，后乘除，所以优先级这个概念我们并不陌生。

当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。

在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。

下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部

大家不需要去刻意的记住，表达式里面优先使用小括号来组织！！方便理解和使用，不建议写非常冗余
的代码运算！
表的底部**

大家不需要去刻意的记住，表达式里面优先使用小括号来组织！！方便理解和使用，不建议写非常冗余
的代码运算！