• 重修之Java-基础篇-数据类型和运算符

    基础篇之数据类型和运算符


    为什么要从头开始学习Java呢？一是因为总觉得自己之前学习的时候没有很好的把最简单的知识点打扎实，想要重修一下基础，毕竟万丈高楼从地起，要想成为高超的技术boy，就要走好每一步；二是记录一下自己学习的历程，也好监督一下自己有没有毅力完成。

    1. 注释

      在计算机流传这么一句话：‘‘我生平最讨厌两种人：一种是没有写注释的人，另一种是让我写注释的人’’。可见注释在代码中是多么的重要。‘‘注释’’，首先解释一下什么是注释：是一种向代码中添加说明、解释的文本。其实就是给看代码的人讲清楚，这一段代码为什么要这样写。在对于日后来维护代码的时候起着十分关键的作用，毕竟谁也不知道自己当初为什么要这么写代码，为什么这块功能就莫名其妙的跑起来了。

    1.1 单行注释

      很容易懂得，就是对某一行代码进行的一行注释，在Java语言中用双斜线（//）表示。注释是不会被电脑运行的，他是拿给人看的。下面是一个单行注释的示例：

    public class Demo{
	public static void main(String[] args){
		//瞧，这是对下面一行输出代码的注释
		System.out.println("Hello World");//嘿，我们也可以在代码后面进行注释
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    1.2 多行注释

      有单行注释，那么肯定会有多行注释。就是对某一段代码进行多行的注释。在Java中就需要用"/* 注释内容*/"来表示。下面是一个多行注释的示例：

    public class Demo{
	/*
	被包括的内容就是多行注释的
	可以写多行
	多行注释一般是对某函数或者某类进行注释，后面将会对函数和类进行复盘
	*/
	public static void main(String[] args){
		System.out.println("Hello World");
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    2. 标识符和关键字

      这两个概念平时是不会在意的，但是确一直在伴随着我们。

    2.1 分隔符

      分隔符，就是将A和B分割开，起到很明显的分隔作用。在Java中有以下几种：

    1. 分号（;）：将两个不同语句的代码分隔开；
    2. 花括号（{}）：把某一段代码包裹起来；
    3. 方括号（[]）：同理，也是把某些语句包括起来，一般用于数组中；
    4. 圆括号（()）：圆括号用途较多。一是用来强制转换时使用，二是将表达式中的某一部分括起来优先计算，还有就是方法定义时的参数定义，调用函数时也需要使用。
    5. 空格：一般使用空格来合理缩进代码，使得代码更具可读性；
    6. 圆点（.）：一般用于类或者对象的，访问其成员时使用。
        以下是一些示例
    public class Demo{//这里用到了花括号
	public static void main(String[] args){//这里使用到了中括号、花括号和圆括号，以及空格
		System.out.println("Hello World");//这里使用到了圆点和分号
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5

    2.2 关键字

      认识关键字之前要先介绍什么是标识符，就是用于给程序中变量、类和方法命名的符号（说白话一点就是给东西取名字，但是取名字要有标准，不能乱取，需要遵循一定的准则），下面是命名标识符的一些准则。

    1. 可以有数字，字母，下划线以及美元符号（$）组成，其中不能以数字开头（别问为什么可以有美元符号，因为Java这玩意是漂亮国发明的）；
    2. 不能是Java中的关键字和保留字，但是可以包含关键字和保留字；
    3. 不可以包含空格；
    4. 只能包含美元符号，不能包含@，#这样的符号；

       注意 : \color{red}{注意:} 注意:这在Java语法中并没有明确规定要这样做，但是在行业中确实必须存在的，就是给程序中变量、类和方法命名的时候，必须要符合规定：

    1. 包名：所有字母小写；
    2. 类名、接口名：所有单词的首字母大写；
    3. 变量名、方法名：第一个单词首字母小写，第二个单词开始，每个单词首字母大写（也叫驼峰命名法）；
    4. 常量名：所有字母大写；
    //变量命名示例
int myAge;//定义我的年龄
String myFavouritePerson;//我最喜欢的人

    • 1
    • 2
    • 3

      解释完这么多，终于来到了关键字，顾名思义，就是十分关键的字，在Java中，由于需要使用到一些常用的标识符，这些标识符不需要用户去命名，它们用着特殊的用途，将这样的标识符称为关键字。比如，在Java中需要使用for来表示循环，if来表示选择，class来表示类，还有private，public，protected等等。
      还有一个保留字，就是被保留的标识符，在Java中有两个，goto和const，表示它们两个还未使用，将来可以会使用到。

    3. 数据类型分类

      什么是数据类型？首先要了解什么是数据，数据就是描述和记录信息的集合。我们要对现实生活中的某一事物进行描述，记录一个班级中学生的姓名，学号，成绩等，这些都是数据。在excel表格中，我们可以采取以下方式来记录：

    姓名学号成绩
    张三202021000451628

      以上就是数据在表格中的表现形式。那么在Java中如何展示呢？

    public class Student{//定义一个student类
	String name;//姓名
	int studentNumber;//学号（驼峰命名法）
	int score;//成绩
}

    • 1
    • 2
    • 3
    • 4
    • 5

      从上面可以看出，我们分别使用name，studentNumer，score来表示学生的姓名，学号，成绩等信息，这些我们称为数据。那么String，int这些就是描述这些信息的类型，我们知道，学号和成绩都是数字，在Java中这样的数据称为整型数据，姓名是不能用数字来描述的，我们可以用字符型数据来描述，我们就称为字符型。在Java中，将诸如此的数据分为以下几种类型:

    1. 整型数据类型
    2. 字符数据类型
    3. 浮点数据类型
    4. 布尔数据类型
         注意 : \color{red}{注意:} 注意:以上4中类型在Java中被归类于基本数据类型，那么还有不基本的数据类型，称为引用类型。本章节先复习基本数据类型，先简单说一下， 引用类型包括类，接口和数组，其中最先接触的会是数组，后面的章节会一一介绍。

    3.1 整型

      整型，也就是数据是一个整体，例如1224，9587此类的。在Java中，用以下4中类型来描述整型数据：

    1. byte：在内存中占8位，表示的数据范围（-128( − 2 7 -2^7 −27)~127( 2 7 − 1 2^7-1 27−1)）
    2. short：在内存中占16位，表示的数据范围（-32768( − 2 1 5 -2^15 −215)~32767 2 1 5 − 1 2^15-1 215−1）
    3. int：在内存中占32位，表示的数据范围（-2147483648( − 2 31 -2^{31} −231)~2146483647( 2 31 − 1 2^{31}-1 231−1)）
    4. long：在内存中占64位，表示的数据范围（ − 2 63 -2^{63} −263)~( 2 63 − 1 2^{63}-1 263−1）
         疑问 1 : \color{red}{疑问1:} 疑问1:最开始学习的时候有个小疑问，为什么int它们在数据中占32位，数值范围是（ − 2 31 -2^{31} −231)~( 2 31 − 1 2^{31}-1 231−1）呢？当时没想明白，是因为数值除了正数，还会出现负数，这样正负结合才是( 2 32 2^{32} 232)个数。
         疑问 2 : \color{red}{疑问2:} 疑问2:为什么要将整型数据分这么多类呢？在JavaScript中，只使用了Number来表示数字类型，为什么Java不这样干呢？Java是一门高级语言，需要考虑的问题很多，拿一个很容易考虑到的来讲，就是为了节约内存。比如我们需要用到的数据在（-128( − 2 7 -2^7 −27)~127( 2 7 − 1 2^7-1 27−1)）之间，内存只占8位，如果使用占32位的int类型来描述，岂不是浪费了内存开销。（内存可是很贵的）
        换言之，在编写程序的时候，要用合适的数据类型来描述数据，要节省内存开销。
    public class IntegerTest{
	byte a = 56;
	short b = 23455;
	int c = 234412341;
	long bigValue1 = 99999999999;//这行代码是错误的，在Java中，比较大的数据需要在结尾后加一个L，来表示其是一个非常长的数据，L就是Long单词的首字母。
	long bigValue2 = 99999999999L;                                         
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    3.2 字符型

      什么是字符型数据呢？在Java中，字符型数据是用来表示单个的字符，例如a，b，c此类的。如下所示：

    public class CharTest{
	char a = 'A';
	char b = 'B';
}

    • 1
    • 2
    • 3
    • 4

      单个字符必须使用单引号包含起来，这样才能表示其为一个字符。除了通过单个字符来指定值，还可以通过转义字符表示特殊的字符值，例如’\n’表示换行、‘\t’表示制表符等；也可以直接使用Unicode值直接表示字符型值，例如，’\n’可以用’\u000a’表示等。
    在前面我们用到的String，它并不是字符型，它是Java封装的一个类，专门用来表示字符串数据的。这一章节简单说一下，什么是字符串。字符串就是有多个字符组成的一串数据，例如，我们常用到的邮箱，就需要使用字符串来存储。

    public class Demo{
	String myMail = "zwx971206@163.com";//字符串里面可以是合法的任意数据
}

    • 1
    • 2
    • 3

    3.3 浮点型

      什么又是浮点型数据呢？和前面提到的整型数据其实差不多，整型数据是一块整体的数据，它并不包含小数，浮点型数据就是来描述小数的，在Java中分为单精度浮点数（float）和双精度浮点数（double）两种。于整型数据一样，它们也有范围。double的数值占8个字节，64位；float占4个字节，32位。

    public class Demo{
	float fNum = 5.234;
	double dNum = 5.2345566;//double类型存的小数点后面的位数比float更多
}

    • 1
    • 2
    • 3
    • 4

      因此，如果需要用到比较高精度的数据的时候，就用double类型，不需要使用太高的精度，就用float类型。

    3.4 布尔型

      那么，什么又是布尔型数据呢？布尔型只有一个boolean类型，且只有true和false两个。用来判断真或假的状态。常常用在控制语句中。

    public class Demo{
	boolean isGo = true;
	if(isGo){
		System.out.println("走，出去玩");
	}
	boolean isWork = false;
	if(!isWork){//!表示非，就是于isWork相反的状态
		System.out.println("耶，不去上班");
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    4. 类型转换

      在Java中不同类型的值常常需要相互转换。就是将int类型转换位long类型。有两种转换方式，自动类型转换和强制类型转换。

    4.1 自动类型转换

      下图展示了7中基本数据类型的自动转换。从左往右可以依次转换，char可以往int转换，int可以转换为long型
    在这里插入图片描述

    public class Demo{
	public static void main(String[] args){
		char ch = 'A';
		byte numB = 10;
		int numA = ch;
		int numC= numB;
		//ch和numB都自动的转换为int型的numA和numC了，
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

      为什么不能自动的从int转换为short呢？这就是下面要将的强制类型转换。

    4.2 强制类型转换

      强制转换也就是意味着人为干涉，我们将上图中右边的类型转换为左边的类型就需要用到强制转换。在进行强制转换的时候，类似于将大瓶子里的水倒进小瓶子里面，如果大瓶子装的水比小瓶子的容量要大，则会溢出，反之，则会顺利转换。强制转换方式如下：

    public class Demo{
	public static void main(String[] args){
		int numA = 233;
		byte numB = (byte)numA;//在需要强制转换的前面用圆括号((需要强制转换的类型))
		System.out.println(numB);//将会输出-23，这是因为byte存储最高的数只有127，所以溢出了，多得数则从-128往前面数，直到刚刚满233，则为-23
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    5. 运算符

      受过9年义务教育的同学都知道，运算符无非就是加减乘除。在Java中可分为以下几种：

    1. 算术运算符：加减乘除求余
    2. 赋值运算符：=
    3. 比较运算符：大于小于
    4. 逻辑运算符：与或非
    5. 位运算符：按位与等
    6. 类型相关运算符：三目运算符

    5.1 算术运算符

      就是平时提到的加减乘除求余，其中还有自加（++）和自减（–）

    public class Demo{
	public static void main(String[] args){
		int numA = 2 + 7;//加
		int numB = numA - 3;//减
		int numC = numB * 10;//乘
		int numD = 63 / 10;//除，在Java则是取整,numD则为6
		int numE = 63 % 10;//取余，就是取余数，numE为3；
		int numF = numA++;//先将numA赋值给numF，numF为9，然后numA自加1，numA等于10;
		int numG = ++numA;//numA先自加1，numA由10变为11，然后才将numA赋值给numG,numG为11；
		int numH = numA--;//先将numA赋值给numH，numH为9，然后numA自减1，numA等于10;
		int numI = --numA;//numA先自减1，numA由10变为9，然后才将numA赋值给numG,numI为9;
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    5.2 赋值运算符

       则是将等于右边的值赋给左边的变量；

    public class Demo{
	public static void main(String[] args){
		int numA = 9;//将数字9赋值给变量numA;
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5

    5.3 比较运算符

       判断是否满足条件时使用；

    public class Demo{
	public static void main(String[] args){
		boolean num1 = 9 > 8;//9大于8，则将true赋值给num1;返回的boolean型的true或者false
		boolean num2 = 7 > 8;//7不大于8，则将false赋值给num2;
		boolean num3 = 8 >= 8;//8大于或者等于8，则将true赋值给num3;
		boolean num4 = 9 < 8;//9不大于8，则将false赋值给num;
		boolean num5 = 6 > 8;//6小于8，则将true赋值给num5;
		boolean num6 = 6 != 8;//6不等于8，则将true赋值给num6;
		boolean num7 = 8 == 8;//8等于8，则将true赋值给num6;
		boolean num8 = 9.8 > 8;//不同数据类型的数据是不能比较的
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    5.4 逻辑运算符

       逻辑运算符用于操作两个布尔型的变量和常量，主要有以下六个：

    1. &&：与，前后两个操作符必须都是true才返回true，否则返回false；
    2. &：不短路与，和&&一样，但是不会短路（什么是短路？）
    3. ||：或。只要其中一个是true，就可以返回true，两个都是假才返回false；
    4. |：不短路或，和||一样，但是不会短路（什么是短路）；
    5. !：非，就是取相反的状态；
    6. ^：异或，和&&相反，必须两个同时为false才返回true；
         疑问 3 : \color{red}{疑问3:} 疑问3:什么是短路？拿&&和&举例，假设A和B是两个表达式，int result = A&&B；只有当Atrue时，才会去计算B是否为true，只有A和B同时为true，result才为true；当A为false时，就不会计算B表达式的值了（这样就称为短路）。而&就不会这样，当A为false时，依然为继续计算B是否为true，这样就成为不短路。同理||和|也是如此。下面的代码简单的叙述了&&和&的不同
    public class Demo{
	public static void main(String[] args){
		int numA = 2;
		int numB = 3;
		boolean result1 = numA == 2 && numB == 3;//先判断numA是否等于2，其等于，然后计算numB等于3，所以result1为true
		boolean result2 = numA == 1 && ++numB == 3;//先判断numA是否等于2，不等于，就不会计算++numB是否等于3，且此时numB的值为3，所以result2为false
		boolean result3 = numA == 2 & numB == 3;//先判断numA是否等于2，其等于，然后计算numB等于3，所以result3为true
		boolean result4 = numA == 2 & ++numB == 3;//先判断numA是否等于2，不等于，但还是会计算++numB是否等于3，且此时numB的值为4，所以result4为false
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    5.5 位运算符

       位运算符主要是计算两位数值通过位运算得到的结果，主要有以下7个：

    1. &：按位与。当两位同时为1时才为1；
    2. |：按位或。只要有一位为1，就为1；
    3. ~：按位非，将数的每一位都取反；
    4. ^：按位异或，当两位相同时为0，不同时为1；
    5. <<：左移运算符
    6. >>：右移运算符
    7. >>>：无符号右移运算符
         用int num = 5&9举例，5的二进制是0101，9的二进制是1001，最后一位都是1，则num的二进制的最后一位为1，同理，num的二进制则为0001，所以num等于1；左移运算符int num = 5<<2；0101往左移动2位，变成010100，所以num为20。

    5.6 扩展后的赋值运算符

       前面学习了算术运算符、赋值运算符和位运算符，可以将其扩展为更强大的运算符：

    public class Demo{
	public static void main(String[] args){
		int num = 10;
		num += 1;//即num=num+1,num的值为11
        System.out.println(num);
        num -= 1;//即num=num-1,num的值为10
        System.out.println(num);
        num *= 1;//即num=num*1,num的值为10
        System.out.println(num);
        num /= 1;//即num=num/1,num的值为10
        System.out.println(num);
        num &= 8;//即num=num&8,num的值为8
        System.out.println(num);
        num |= 3;//即num=num|3,num的值为11
        System.out.println(num);
        num ^= 4;//即num=num^4,num的值为15
        System.out.println(num);
        num <<= 2;//即num=num<<2,num的值为60
        System.out.println(num);
        num >>= 3;//即num=num>>3,num的值为7
        System.out.println(num);
        num >>>= 2;//即num=num>>>2,num的值为1
        System.out.println(num);
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    5.7 三目运算符

       直接举例：

    public class Demo{
	public static void main(String[] args){
		String str = 5 > 3?"5大于3":"5不大于3";//判断5是否大于3，如果大于，则输出5大于3，如果不大于，则输出5不大于3；
		//总结一个公式   A?B:C，A表达式如果为true，则执行B；反之，则执行C。
        System.out.println(str);//5大于3
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    番外篇

       突然想到一个知识点，什么是字面量，什么是变量，它们有什么区别？
       1. 字面量（Literal）是指在代码中直接使用的固定值，它可以表示不同的数据类型。换句话说，看见什么，就是什么，浮点数字面量可以是 3.14，布尔值字面量可以是 true 或 false，字符字面量可以是 ‘A’。但是在Java中如果直接使用字面量的话，则十分复杂（不知道该字面量是拿来干啥的，比如3.14，我们人类可以一眼看出它是 π \pi π，但是电脑不行，它很笨，需要人为的给他解释），这个时候就需要使用变量来储存该字面量（double pi = 3.14）。pi就是变量。
      变量则是标识符的一种，标识符（Identifier）是用于标识变量、函数、类或其他程序实体的名称，前面的章节介绍过。变量通常由三个组成部分构成：

    1. 变量名（Variable Name）：变量名是用来标识和引用变量的唯一名称。它遵循一定的命名规则和语法，可以包含字母、数字和下划线，并且通常具有描述性，以便更好地理解变量的用途和含义。
    2. 数据类型（Data Type）：变量具有特定的数据类型，用于定义变量可以存储的数据的种类和规则。常见的数据类型包括整数、浮点数、字符串、布尔值等。数据类型决定了变量可进行的操作和支持的值范围。
    3. 值（Value）：变量存储的具体数据值就是其值。通过将值赋给变量，可以将数据存储在变量所代表的内存位置中，以便在程序中使用和操作。
    public class Demo{

	public void test(){
		System.out.println(18);//18是可以直接看见的，但是就这样写是不知道18是什么含义，因此我们使用myAge来表示咱们的年龄，是18岁。
		// int位数据类型，myAge则为变量名，18则是值；
		int myAge = 18;
		myAge = 26;//可以修改变量的值，呀，突然变老了呢
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
  • 相关阅读:
    遗传力缺失的案例
    adb and 软件架构笔记
    【Helm三部曲】安装 chartmuseum 可视化界面 chartmuseumUi 【官方推荐安装方法】
    架构师范文（AI写作）两篇
    Qt HTTP下载数据
    直播回顾｜多云时代，如何建设企业级云管理平台？
    STM32H743IIT6学习笔记03——使用第三方组件FreeRTOS
    数据结构-作业3
    机器人冗余自由度优化过程中的零空间概念
    小龙虾算法优化极限学习机实现乳腺癌诊断,(COA-ELM)数据分类
  • 原文地址：https://blog.csdn.net/qq_39443703/article/details/134008037