Java基础从入门到精通系列（一）

后端技术那点事
380 阅读29分钟

1、Java简介

Java语言是一种高级、并发、面向对象的计算机编程语言，由Sun Microsystems公司于1995年推出。Java广泛应用于Web应用程序开发、移动应用程序开发以及大型企业级应用程序的开发中。Java语言具有跨平台、安全性好、可移植性强、易学易用等优点，在业界得到了广泛的应用和认可。

1.1、Java发展史

  • 1991年Green项目，开发语言最初命名为Oak (橡树)
  • 1994年，开发组意识到Oak 非常适合于互联网
  • 1996年，发布JDK 1.0，约8.3万个网页应用Java技术来制作
  • 1997年，发布JDK 1.1，JavaOne会议召开，创当时全球同类会议规模之最
  • 1998年，发布JDK 1.2，同年发布企业平台J2EE
  • 1999年，Java分成J2SE、J2EE和J2ME，JSP/Servlet技术诞生
  • 2004年，发布里程碑式版本：JDK 1.5，为突出此版本的重要性，更名为JDK 5.0
  • 2005年，J2SE -> JavaSE，J2EE -> JavaEE，J2ME -> JavaME
  • 2009年，Oracle公司收购SUN，交易价格74亿美元
  • 2011年，发布JDK 7.0
  • 2014年，发布JDK 8.0，是继JDK 5.0以来变化最大的版本
  • 2017年，发布JDK 9.0，最大限度实现模块化
  • 2018年3月，发布JDK 10.0，版本号也称为18.3
  • 2018年9月，发布JDK 11.0，版本号也称为18.9
  • 2019年3月20日，Java SE 12 发布。Java 12是短期支持版本。
  • 2019年9月23日，Java SE 13发布，此版本中添加了“文本块”，文本块是一个多行字符串文字，避免对大多数转义序列的需要，以可预测的方式自动格式化字符串，并在需要时让开发人员控制格式。

1.2、Java三大平台

1.2.1、JavaSE(Java Standard Edition)标准版

支持面向桌面级应用（如Windows下的应用程序）的Java平台，提供了完整的Java核心API，此版本以前称为J2SE

1.2.2、JavaEE(Java Enterprise Edition)企业版

是为开发企业环境下的应用程序提供的一套解决方案。该技术体系中包含的技术如:Servlet 、Jsp等，主要针对于Web应用程序开发。版本以前称为J2EE

1.2.3、Java ME(Java Micro Edition)小型版

支持Java程序运行在移动终端（手机、PDA）上的平台，对Java API有所精简，并加入了针对移动终端的支持，此版本以前称为J2ME

1.3、Java语言的特点

1.3.1、特点一：面向对象

  • 两个基本概念：

    • 类
    • 对象

  • 三大特性：

    • 封装
    • 继承
    • 多态

1.3.2、特点二：健壮性

  • 去除了C语言中的指针，吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分（如指针、内存的申请与释放等），提供了一个相对安全的内存管理和访问机制。
  • 自动的垃圾回收机制，但是仍然会出现内存溢出、内存泄漏的可能性。

1.3.3、特点三：跨平台性

  • 跨平台性：通过Java语言编写的应用程序在不同的系统平台上都可以运行。“Write once , Run nywhere”
  • 其原理：通过编译后生成的字节码文件实现跨平台的，只要在需要运行java 应用程序的操作系统上，先安装一个对应版本的Java虚拟机(JVM Java Virtual Machine) 即可。由Java虚拟机来运行字节码文件实现其跨平台的特性。

1.4、Java语言的环境搭建

1.4.1、什么是JVM,JDK, JRE

  • JVM（Java Virtual Machine）：Java虚拟机
  • JDK(Java Development Kit Java开发工具包)：JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE。 所以安装了JDK，就不用在单独安装JRE了。其中的开发工具：编译工具(javac.exe) 打包工具(jar.exe)等。
  • JRE(Java Runtime Environment Java运行环境)：包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等，如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。

2、Java基础语法

2.1、注释

Java中的注释分为三种：

  • 单行注释：
// 这是单行注释文字
  • 多行注释：
/*
这是多行注释文字
这是多行注释文字
这是多行注释文字
*/

注意：多行注释不能嵌套使用。
  • 文档注释：
/**
 * @author  指定java程序的作者**
 * @version  指定源文件的版本**
 */
  • 使用的技巧以及注意点
如果我们要对代码进行解释，那么就可以使用注释，当注释的内容比较少，一行就写完了，可以用单行注释。
如果注释的内容比较多，需要写在多行，那么可以使用多行注释。
​
注释的内容不会参与编译和运行的，仅仅是对代码的解释说明而已。
所以，不管在注释当中写什么内容，都不会影响代码运行的结果。

2.2、关键字

2.1 概念

被Java赋予了特定含义的英文单词。我们在代码中写了关键字之后，程序在运行的时候，就知道要做什么事情了。

abstractassertbooleanbreakbyte
casecatchcharclassconst
continuedefaultdodoubleelse
enumextendsfinalfinallyfloat
forgotoifimplementsimport
instanceofintinterfacelongnative
newpackageprivateprotectedpublic
returnstrictfpshortstaticsuper
switchsynchronizedthisthrowthrows
transienttryvoidvolatilewhile

2.2、字面量

作用：告诉程序员，数据在程序中的书写格式。

字面量类型说明程序中的写法
整数不带小数的数字666，-88
小数带小数的数字13.14，-5.21
字符必须使用单引号，有且仅能一个字符‘A’，‘0’， ‘我’
字符串必须使用双引号，内容可有可无“HelloWorld”，“黑马程序员”
布尔值布尔值，表示真假，只有两个值：true，falsetrue 、false
空值一个特殊的值，空值值是：null
public class Demo {
    public static void main(String[] args) {
        System.out.println(10); // 输出一个整数
        System.out.println(5.5); // 输出一个小数
        System.out.println('a'); // 输出一个字符
        System.out.println(true); // 输出boolean值true
        System.out.println("欢迎来到黑马程序员"); // 输出字符串
    }
}

区分技巧

  1. 不带小数点的数字都是整数类型的字面量。
  2. 只要带了小数点，那么就是小数类型的字面量。
  3. 只要用双引号引起来的，不管里面的内容是什么，不管里面有没有内容，都是字符串类型的字面量。
  4. 字符类型的字面量必须用单引号引起来，不管内容是什么，但是个数有且只能有一个。
  5. 字符类型的字面量只有两个值，true、false。
  6. 空类型的字面量只有一个值，null。

2.3、变量

变量就在程序中临时存储数据的容器。但是这个容器中只能存一个值。

2.3.1、变量的定义格式

数据类型 变量名 = 数据值；

  • 数据类型：限定了变量当中能存储什么类型的数据。

    • 如果要存10，那么数据类型就需要写整数类型。
    • 如果要存10.0，那么数据类型就需要写小数类型。

  • 变量名：其实就是这个容器的名字。

    • 当以后想要使用变量里面的数据时，直接使用变量名就可以了。

  • 数据值：真正存储在容器中的数据。

  • 分号：表示语句的结束，就跟以前写作文时候的句号是一样的。

public class VariableDemo{
    public static void main(String[] args){
        //定义一个整数类型的变量
        //数据类型 变量名 = 数据值;
        int a = 16;
        System.out.println(a);//16
        
        //定义一个小数类型的变量
        double b = 10.1;
        System.out.println(b);//10.1
    }
}

2.4、数据类型

2.4.1、Java语言数据类型的分类

  • 基本数据类型

    • 整型：byte \ short \ int \ long
    • 浮点型：float \ double
    • 字符型：char
    • 布尔型：boolean

  • 引用数据类型

    • 类：class
    • 接口：interface
    • 数组：array

2.4.2、基本数据类型的四类八种

数据类型关键字内存占用取值范围
整数byte1负的2的7次方 ~ 2的7次方-1(-128~127)
short2负的2的15次方 ~ 2的15次方-1(-32768~32767)
int4负的2的31次方 ~ 2的31次方-1
long8负的2的63次方 ~ 2的63次方-1
浮点数float41.401298e-45 ~ 3.402823e+38
double84.9000000e-324 ~ 1.797693e+308
字符char20-65535
布尔boolean1true，false

2.4.2.1、案例一
public class VariableDemo3{
    public static void main(String[] args){
        //1.定义byte类型的变量
        //数据类型 变量名 = 数据值;
        byte a = 10;
        System.out.println(a);
​
        //2.定义short类型的变量
        short b = 20;
        System.out.println(b);
​
        //3.定义int类型的变量
        int c = 30;
        System.out.println(c);
​
        //4.定义long类型的变量
        long d = 123456789123456789L;
        System.out.println(d);
​
        //5.定义float类型的变量
        float e = 10.1F;
        System.out.println(e);
​
        //6.定义double类型的变量
        double f = 20.3;
        System.out.println(f);
​
        //7.定义char类型的变量
        char g = 'a';
        System.out.println(g);
​
        //8.定义boolean类型的变量
        boolean h = true;
        System.out.println(h);
​
    }
}
2.4.2.2、案例二
/*
Java定义的数据类型
​
*/
class VariableTest1{
    public static void main(String[] args) {
    //1. 整型：byte(1字节=8bit) short(2字节） \ int (4字节）\ long(8字节)
        //① byte范围：-128 ~ 127
​
        byte b1 = 12;
        byte b2 = -128;
    //  b2 = 128; //编译不通过
        System.out.println(b1);
        System.out.println(b2);
​
        // ② 声明long型变量，必须以“1”或“L”结尾
        short s1 = 128;
        int i1 = 12345;
        long l1 = 345678586;
        System.out.println(l1);
        //2. 浮点型：float(4字节) \ double(8字节)
        //① 浮点型，表示带小数点的数值
        //② float表示数值的范围比long还大
​
        double d1 = 12.3;
        System.out.println(d1 +1);
        
        //定义float类型变量时，变量要以"f" 或"F"结尾
        float f1 = 12.3F;
        System.out.println(f1);
​
        //② 通常，定义浮点型变量时，使用double变量
​
        //3. 字符型：char(1字符=2字节)
        //① 定义char型变量，通常使用一对'' 
        char c1 = 'a';
        //编译不通过
        //c1 = 'AB';
        System.out.println(c1);
​
        char c2 = '1';
        char c3 = '中';
        char c4 = '&';
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
​
        //② 表示方式：1.声明一个字符；2.转义字符；3.直接使用Unicode值来表示字符型常量
        char c5 = '\n'; //换行符
        c5 = '\t';  //制表符
        System.out.print("hello" + c5);
        System.out.println("world");
​
        char c6 = '\u0123';
        System.out.println(c6);
        
        char c7 = '\u0043';
        System.out.println(c7);
    }
}

2.4.3、ASCII 码

ASCII码（American Standard Code for Information Interchange，美国信息交换标准代码）是一套基于拉丁字母的字符编码系统，共收录了128个字符，用一个7位二进制数（即一个字节的最高位为0）就可以表示。ASCII码最早于1963年制定，而后经过多次修改和更新，最后一次更新是在1986年。ASCII码被广泛应用于计算机、通讯和其他设备中，用于表示文本字符和控制字符。由于当时计算机系统技术的局限性，ASCII码只有128个字符编码点，其中只有95个是可打印字符，严重限制了其功能的使用范围。

即ASCII 码特点如下所示：

  • 在计算机内部，所有数据都使用二进制表示。每一个二进制位（bit）有0 和1 两种状态，因此8个二进制位就可以组合出256 种状态，这被称为一个字节（byte）。一个字节一共可以用来表示256 种不同的状态，每一个状态对应一个符号，就是256 个符号，从0000000 到11111111。

  • ASCII码：上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个字符的编码，比如空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）。这128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前面的1位统一规定为0。

  • 缺点：

    • 不能表示所有字符。
    • 相同的编码表示的字符不一样：比如，130在法语编码中代表了é，在希伯来语编码中却代表了字母Gimel(ג)

2.4.4、Unicode 编码

Unicode编码是一种国际编码标准，用于为全世界各种语言、符号、符号系统中的所有字符分配一个独特的数字编号和名称。Unicode编码允许计算机处理和表示多种语言的文本字符，包括亚洲文字、古典希腊语、古老的符号和图表等。

相比较ASCII编码，Unicode编码可以支持更多的字符集和编码方式，因此在现代的计算机系统中被广泛应用。例如，在使用不同的语言进行编程、进行国际化文本处理时，使用Unicode编码能够更加方便和简单。同时，由于Unicode编码已成为国际标准，它也解决了不同计算机系统间交换文本文件时由于编码问题造成的混乱、错乱、丢失等问题。

即Unicode 编码特点如下所示：

  • Unicode：一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，使用Unicode 没有乱码的问题。
  • Unicode 的缺点：Unicode 只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储：无法区别Unicode 和ASCII：计算机无法区分三个字节表示一个符号还是分别表示三个符号。另外，我们知道，英文字母只用一个字节表示就够了，如果unicode统一规定，每个符号用三个或四个字节表示，那么每个英文字母前都必然有二到三个字节是0，这对于存储空间来说是极大的浪费。

2.4.5、UTF-8

UTF-8是一种可变长度的字符编码标准，用于电子通讯。它是由Unicode标准定义的，名称来源于 Unicode (或通用字符集) 转换格式 - 8位 。UTF-8 可以使用1到4个字节(8位)的代码单元来编码Unicode中的1,112,064个有效字符代码点。UTF-8能够表示Unicode标准中的任何字符，并且具有与ASCII的向后兼容性。

即Unicode 编码特点如下所示：

  • UTF-8 是在互联网上使用最广的一种Unicode 的实现方式。

  • UTF-8 是一种变长的编码方式。它可以使用1-4 个字节表示一个符号，根据不同的符号而变化字节长度。

  • UTF-8的编码规则：

    • 对于单字节的UTF-8编码，该字节的最高位为0，其余7位用来对字符进行编码（等同于ASCII码）。
    • 对于多字节的UTF-8编码，如果编码包含n 个字节，那么第一个字节的前n位为1，第一个字节的第n+1 位为0，该字节的剩余各位用来对字符进行编码。在第一个字节之后的所有的字节，都是最高两位为"10"，其余6位用来对字符进行编码。

2.5、基本数据类型转换

2.5.1、自动类型转换

自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：

  • 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
  • byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
  • boolean类型不能与其它数据类型运算。
  • 当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类型的值将自动转化为字符串(String)类型。
/*
基本数据类型之间的运算规则：
​
前提：这里讨论只是7中基本数据类型变量的运算。不包含boolean类型的。
1. 自动类型提升：
    当容量小的数据类型的变量和容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
    char、byte、short-->int-->long-->float-->double
​
    特别的：当byte、char、short三种类型的变量做运算时，结果为int类型
​
2. 强制类型转换：
    
说明：此时容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量
*/
class VariableTest2{
    public static void main(String[] args) {
        byte b1 = 2;
        int i1 = 129;
​
//      编译不通过
//      byte b2 = b1 + i1;
        int i2 = b1 + i1;
        long l1 = b1 + i1;
        System.out.println(i2);
        System.out.println(l1);
​
        float f = b1 + i1;
        System.out.println(f);
        //***************特别的**************************
        char c1 = 'a';  //97
        int i3 = 10;
        int i4 = c1 + i3;
        System.out.println(i4);
​
        short s2 = 10;
//      编译错误
//      char c3 = c1 + s2;
        
        byte b2 = 10;
//      char c3 = c1 + b2;  //编译不通过
//      short s3 = b2 + s2; //编译不通过 
//      short s4 = b1 + b2; //编译不通过
    }
}
class VariableTest4{
    public static void main(String[] args){
        //1. 编码情况
        long l = 123456;
        System.out.println(l);
        //编译失败：过大的整数
        //long l1 = 452367894586235;
        long l1 = 452367894586235L;
​
        //**************************
        //编译失败
//      float f1 = 12.3;
        
        //2. 编码情况2:
        //整型变量，默认类型为int型
        //浮点型变量，默认类型为double型
        byte b = 12;
    //  byte b1 = b + 1;    //编译失败
        
    //  float f1 = b + 12.3;    //编译失败
    }
}
​

2.5.2、强制类型转换

  • 自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符：()，但可能造成精度降低或溢出,格外要注意。
  • 通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。如：String a = “43”; inti= Integer.parseInt(a);
  • boolean类型不可以转换为其它的数据类型。

2.6、进制转换

2.6.1、二进制

二进制是一种使用数字0和1表示数值和信息的计数系统和信息处理方法。它在数学和计算机科学中广泛使用。在二进制系统中，每个数字位都只能为0或1。它是一种基于2的数字系统，与我们通常使用的十进制数字系统不同。二进制被广泛用于计算机科学，因为现代计算机将所有数据都存储在二进制形式下，并使用二进制代码来处理和传输数据。二进制可以通过简单的移位和逻辑运算进行处理，因此在计算机中表现出色。

  • Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位；当是long类型时，二进制默认占64位，第64位是符号位

  • 二进制的整数有如下三种形式：

    • 原码：直接将一个数值换成二进制数。最高位是符号位
    • 负数的反码：是对原码按位取反，只是最高位（符号位）确定为1。
    • 负数的补码：其反码加1。计算机以二进制补码的形式保存所有的整数。

  • 正数的原码、反码、补码都相同，负数的补码是其反码+1

2.6.2、为什么要使用原码、反码、补码表示形式呢？

  • 计算机中使用原码、反码、补码来表示整数是因为这种表示形式可以避免计算机在进行加减法等运算时出现溢出的情况。
  • 对于有符号整数，如果采用原码表示，则在进行加减法运算时需要分别考虑正数和负数，并且可能会出现进位或借位，从而导致运算结果不准确。而采用反码和补码表示形式可以将加减法运算统一为只考虑数值的加减法，避免了这些问题。
  • 具体来说，使用反码表示负数，可以有效地解决原码表示下的进位问题。但是，反码的表示形式存在两个零，即+0和-0，这样导致计算机无法区分+0和-0，因此就引出了补码表示方式，它没有+0，只有一个-0，可以消除符号位对计算的影响。

因此，采用原码、反码、补码表示形式，可以使计算机的运算更加高效和准确，也便于理解和处理整数的计算。

两个数相加，其实就是两个整数的补码相加，原码与反码是帮助推导出补码而存在的，计算机底层都是使用的数值的补码保存数据的。在两个整数相加的本质都是在计算它们的补码之和。在补码表示法中，一个数的反码就是对其取反（0变1，1变0），补码等于其反码加1。所以，计算机加法运算中不需要区分正负数，而是将参与运算的两个数的补码按位相加，并且需要最后将结果的补码转换回原码得到正确的结果。

2.6.3、二进制到十进制间的转换

二进制转成十进制乘以2的幂数

例如，二进制数 1011 转换为十进制数的步骤如下：

  • 将二进制数从右向左，按位赋予权值，第一位权值为1，第二位权值为2，第三位权值为4，以此类推。因此，第一位的权值为1，第二位的权值为2，第三位的权值为4，第四位的权值为8。
  • 将每一位的值与对应权值相乘，得到该位的十进制值。因此，第一位的值为1，乘以1得到1；第二位的值为1，乘以2得到2；第三位的值为0，乘以4得到0；第四位的值为1，乘以8得到8。
  • 将所有位的十进制值相加，即可得到最终的十进制结果。因此，1 + 2 + 0 + 8 = 11，所以二进制数 1011 转换为十进制数为 11。

2.6.4、十进制到二进制间的转换

十进制转成二进制除以2取余数，余数倒序排列

一个简单的例子是将十进制数13转换为二进制数。步骤如下：

  • 将数字13除以2，得到商6和余数1。
  • 将商继续除以2，得到商3和余数0。
  • 将商继续除以2，得到商1和余数1。
  • 将商继续除以2，得到商0和余数1。
  • 将余数倒序排列，得到二进制数字1101。

因此，十进制数13转换为二进制数为1101。

2.7、标识符

Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符

2.7.1、定义合法标识符规则

  • 必须由数字、字母、下划线_、美元符号$组成。
  • 数字不能开头
  • 不能是关键字
  • 区分大小写的。

2.7.2、Java 中的名称命名规范

  • 包名：多单词组成时所有字母都小写：xxxyyyzzz
  • 类名、接口名：多单词组成时，** 所有单词的首字母大写：** XxxYyyZzz
  • 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
  • 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
  • 在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
  • java 采用 unicode 字符集，因此标识符也可以使用汉字声明，但是不建议使用。

2.8、IDEA中层级结构介绍

2.8.1、结构分类

  • project（项目、工程）
  • module（模块）
  • package（包）
  • class（类）

层级关系 ：project - module - package - class

2.8.1、结构详解

  • project（项目、工程）：淘宝、京东都属于一个个项目，IDEA中就是一个个的Project。
  • module（模块）：在一个项目中，可以存放多个模块，不同的模块可以存放项目中不同的业务功能代码。例如商品模块、用户模块。为了更好的管理代码，我们会把代码分别放在两个模块中存放。package（包）： 一个模块中又有很多的业务，以用户网站的论坛模块为例，至少包含了以下不同的业务。例如个人信息、订单信息等。为了把这些业务区分的更加清楚，就会用包来管理这些不同的业务。
  • class（类）：就是真正写代码的地方。

  • 包含数量

    • project中可以创建多个module

      • module中可以创建多个package package中可以创建多个class 这些结构的划分，是为了方便管理类文件的。

2.9、运算符和表达式

  • 运算符：就是对常量或者变量进行操作的符号。比如： + - * /
  • 表达式：用运算符把常量或者变量连接起来的，符合Java语法的式子就是表达式。比如：a + b 这个整体就是表达式。而其中+是算术运算符的一种，所以这个表达式也称之为算术表达式

2.9.1、运算符类型

  • 算术运算符
  • 赋值运算符
  • 比较运算符（关系运算符）
  • 逻辑运算符
  • 位运算符
  • 三元运算符
2.9.1.1、算术运算符

/*
运算符之一：算术运算符
+ - * / % (前)++ (后)++ (前)-- (后)-- 
​
*/
class Day3Test{
    public static void main(String[] args) {
​
        //除号：/
        int num1 = 12;
        int num2 = 5;
        int resule1 = num1 / num2;
        System.out.println(resule1);    //2
​
        int result2 = num1 / num2 * num2;
        System.out.println(result2);
​
        double result3 = num1 / num2;
        System.out.println(result3);    //2.0
​
        double result4 = num1 / num2 + 0.0; //2.0
        double result5 = num1 / (num2 + 0.0);   //2.4
        double result6 = (double)num1 / num2;   //2.4
        double result7 = (double)(num1 / num2); //2.0
        System.out.println(result5);
        System.out.println(result6);
​
        // %：取余运算
        //结果的符号与被模数的符号相同
        int m1 = 12;
        int n1 = 5;
        System.out.println("m1 % n1 = " + m1 % n1);
​
        int m2 = -12;
        int n2 = 5;
        System.out.println("m2 % n2 = " + m2 % n2);
​
        int m3 = 12;
        int n3 = -5;
        System.out.println("m3 % n3 = " + m3 % n3);
​
        int m4 = -12;
        int n4 = -5;
        System.out.println("m4 % n4 = " + m4 % n4);
​
        //(前)++ : 先自增1，后运算
        //(后)++ ：先运算，后自增1
        int a1 = 10;
        int b1 = ++a1;
        System.out.println("a1 = " + a1 + ",b1 = " + b1);
​
        int a2 = 10;
        int b2 = a2++;
        System.out.println("a2 = " + a2 + ",b2 = " + b2);
​
        int a3 = 10;
        a3++;   //a3++;
        int b3 = a3;
​
        //注意点：
        short s1 = 10;
        //s1 = s1 + 1;  //编译失败
//      s1 = (short)(s1 + 1);   //正确的
        s1++;   //自增1不会改变本身变量的数据类型
        System.out.println(s1);
​
        //问题：
        byte bb1 = 127;
        bb1++;
        System.out.println("bb1 = " + bb1);
​
        //(前)-- :先自减1，后运算
        //(后)-- ：先运算，后自减1
​
        int a4 = 10;
        int b4 = a4--;  //int b4 = --a4;
        System.out.println("a4 = " + a4 + ",b4 = " + b4);
    }
}
​
  • 如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。
  • 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。例如：intx=3510;x=x/1000*1000; x的结果是？
  • “+”除字符串相加功能外，还能把非字符串转换成字符串.例如：System.out.println(“5+5=”+5+5); //打印结果是？5+5=55 ?
/*
练习：随意给出一个三位数的整数，打印显是它的个位数，十位数，百位数的值。
例如：
数字153的情况如下：
个位数：3
十位数：5
百位数：1
​
公式：
获取任意一个数上每一位数。
个位：数字 % 10
十位：数字 / 10 % 10
百位：数字 / 100 % 10
千位：数字 / 1000 % 10
。。。以此类推。。。
*/
class AriExer{
    public static void main(String[] args){
        int num = 187;
        System.out.println("百位数：" + num/100);
        System.out.println("十位数：" + num%100/10);
        System.out.println("个位数：" + num%10);
    }
}
2.9.1.2、赋值运算符

运算过程：就是把等号右边的结果赋值给左边的变量

  • 符号：=

    • 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
    • 支持连续赋值。

  • 扩展赋值运算符：+=, -=, *=, /=, %=，扩展的赋值运算符中隐层还包含了一个强制转换。

public class OperatorDemo6 {
    public static void main(String[] args) {
        //1.最为简单的赋值运算符用法
        int a = 10;//就是把10赋值给变量a
        System.out.println(a);
​
        //2.如果等号右边需要进行计算。
        int b = 20;
        int c = a + b;//先计算等号右边的，把计算的结果赋值给左边的变量
        System.out.println(c);
​
        //3.特殊的用法
        a = a + 10;//先计算等号右边的，把计算的结果赋值给左边的变量
        System.out.println(a);//20
​
        //扩展赋值运算符
        int a = 10;
        int b = 20;
        a += b;//把左边和右边相加，再把最终的结果赋值给左边，对右边没有任何影响，a += b ;实际上相当于 a = (byte)(a + b);
        // 相当于 a = a + b;  
        System.out.println(a);//30
        System.out.println(b);//20
​
    }
}
2.9.1.3、关系运算符

又叫比较运算符，其实就是拿着左边跟右边进行了判断而已。

符号解释
==就是判断左边跟右边是否相等，如果成立就是true，如果不成立就是false
!=就是判断左边跟右边是否不相等，如果成立就是true，如果不成立就是false
就是判断左边是否大于右边，如果成立就是true，如果不成立就是false
>=就是判断左边是否大于等于右边，如果成立就是true，如果不成立就是false
<就是判断左边是否小于右边，如果成立就是true，如果不成立就是false
<=就是判断左边是否小于等于右边，如果成立就是true，如果不成立就是false
  • 关系运算符最终的结果一定是布尔类型的。要么是true，要么是false
  • 在写==的时候，千万不要写成=
/*
运算符之三：比较运算符
==  !=  > < >= <= instanceof
​
结论：
1.比较运算符的结果是boolean类型
2.区分 == 和 = 
​
*/
class CompareTest{
    public static void main(String[] args){
        int i = 10;
        int j = 20;
        System.out.println(i==j);   //false
        System.out.println(i = j);  //20
​
        boolean b1 = true;
        boolean b2 = false;
        System.out.println(b2 == b1);   //false
        System.out.println(b2 = b1);    //true
    }
}
​
2.9.1.4、逻辑运算符
  • &—逻辑与
  • |—逻辑或
  • ！—逻辑非
  • && —短路与
  • ||—短路或
  • ^ —逻辑异或

  • 逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。

  • “&”和“&&”的区别：

    • 单&时，左边无论真假，右边都进行运算；
    • 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

  • “|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。

  • 异或(^)与或( | )的不同之处是：当左右都为true时，结果为false。理解：异或，追求的是“异”!

/*
运算符之四：逻辑运算符
& && | || ！ ^
​
说明：
1. 逻辑与运算符操作的都是boolean类型的变量
​
*/
class LogicTest{
    public static void main(String[] args){
        //区分& 与 &&
        //相同点1：& 与 && 的运算结果都相同
        //相同点2：当符号左边是true时，二者都会执行符号右边的运算
        //不同点：当符号左边是false时，&继续执行符号
        //开发中，推荐使用&&
        boolean b1 = false;
        int num1 = 10;
        if(b1 & (num1++ > 0)){
            System.out.println("我现在在南京");
        }else{
            System.out.println("我现在在北京");
        }
        System.out.println("num1 = " + num1);
​
        boolean b2 = false;
        int num2 = 10;
        if(b2 && (num2++ > 0)){
            System.out.println("我现在在南京");
        }else{
            System.out.println("我现在在北京");
        }
        System.out.println("num2 = " + num2);
​
        //区分：| 与 ||
        //相同点1：| 与 || 的运算结果都相同
        //相同点2：当符号左边是false时，二者都会执行符号右边的运算
        //不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
        //开发中，推荐使用||
        boolean b3 = true;
        int num3 = 10;
        if(b3 | (num3++ > 0)){
            System.out.println("我现在在南京");
        }else{
            System.out.println("我现在在北京");
        }
        System.out.println("num3 = " + num3);
​
        boolean b4 = true;
        int num4 = 10;
        if(b4 || (num4++ > 0)){
            System.out.println("我现在在南京");
        }else{
            System.out.println("我现在在北京");
        }
        System.out.println("num4 = " + num4);
    }
}
​
2.9.1.5、位运算符

位运算是直接对整数的二进制进行的运算

/*
运算符之五：位运算符(了解)
​
结论：
1.位运算符操作的都是整型的数据变量
2.<< : 在一定范围内，每向左移一位，相当于 * 2
  >> : 在一定范围内，每向右移一位，相当于 / 2
​
面试题：最高效的计算2 * 8 ？   2 << 3 或 8 << 1
*/
class BitTest{
    public static void main(String[] args){
        int i = 21;
//      i = -21;
        System.out.println("i << 2 :" + (i << 2));
        System.out.println("i << 3 :" + (i << 3));
        System.out.println("i << 20 :" + (i << 20));
        System.out.println("i << 27 :" + (i << 27));
        int m = 12;
        int n = 5;
        System.out.println("m & n :" + (m & n));
        System.out.println("m & n :" + (m | n));
        System.out.println("m & n :" + (m ^ n));
        //练习：交换两个变量的值
        int num1 = 10;
        int num2 = 20;
​
        //方式一：
    //  int tent = num1;
    //  num1 = num2;
    //  num2 = tent;
​
        //方式二：
        //好处：不用定义临时变量
        //弊端：①相加可能超出存储范围 ② 有局限性：只适用于数值类型
//      num1 = num1 + num2;
//      num2 = num1 - num2;
//      num1 = num1 - num2;
​
        //方式三：使用位运算
        num1 = num1 ^ num2;
        num2 = num1 ^ num2;
        num1 = num1 ^ num2;
​
        System.out.println("num1 = " + num1 + ",num2 = " + num2);
    }
}
​
2.9.1.6、三元运算符

又叫做：三元表达式或者问号冒号表达式。

/*
运算符之六：三元运算符
1.结构：(条件表达式)？表达式1 : 表达式2
2. 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假，决定执行表达式1，还是表达式2.
  如果表达式为true,则执行表达式1
  如果表达式为false,则执行表达式2
③ 表达式1 和表达式2要求是一致的。
④ 三元运算符是可以嵌套的
3. 凡是可以使用三元运算的地方，都是可以改写if-else。
   反之，则不一定成立！！！
*/
class SanTest{
    public static void main(String[] args) {
        //获取两个整数的最大值
        int m = 12;
        int n = 5;
        int max = (m > n)? m : n;
        System.out.println(max);
​
        double num = (m > n) ? 2 : 1.0;
        //(m > n) ? 2 : "n大";   //编译错误
​
        //****************************************
        String str = (m > n) ? "m大" : ((m == n)? "m和n相等" : "n大");
        System.out.println(str);
​
        //****************************************
        //获取三个数中的最大值
        int n1 = 12;
        int n2 = 30;
        int n3 = -43;
​
        int max1 = (n1 > n2) ? n1 : n2;
        int max2 = (max1 > n3) ? max1 : n3;
        System.out.println("三个数中的最大值是：" + max2);
​
        //此方法：pass
        int max3 = (((n1 > n2)? n1 : n2) > n3) ?((n1 > n2) ? n1 : n2) : n3;
        System.out.println("三个数中的最大值是：" + max3);
​
        //改写成if-else
        if(m > n){
            System.out.println(m);
        }else{
            System.out.println(n);
        }
    }
}
​

2.9.2、运算符的优先级

2.10、流程控制语句

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：

  • 顺序结构
  • 分支结构(if, switch)
  • 循环结构(for, while, do…while)

2.10.1、顺序结构

程序从上到下逐行地执行，中间没有任何判断和跳转。

2.10.2、分支结构

根据条件，选择性地执行某段代码。有if…else和switch-case两种分支语句。

2.10.2.1、if…else
2.10.2.1.1、格式1
格式：
if (关系表达式) {
    语句体;    
}

执行流程：

  • ①首先计算关系表达式的值
  • ②如果关系表达式的值为true就执行语句体
  • ③如果关系表达式的值为false就不执行语句体
  • ④继续执行后面的语句内容

public class IfDemo {
    public static void main(String[] args) {
        System.out.println("开始");   
        //定义两个变量
        int a = 10;
        int b = 20; 
        //需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
        if(a == b) {
            System.out.println("a等于b");
        }       
        //需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
        int c = 10;
        if(a == c) {
            System.out.println("a等于c");
        }       
        System.out.println("结束");
    }
}
2.10.2.1.2、格式2
格式：
if (关系表达式) {
    语句体1;   
} else {
    语句体2;   
}

执行流程：

  • ①首先计算关系表达式的值
  • ②如果关系表达式的值为true就执行语句体1
  • ③如果关系表达式的值为false就执行语句体2
  • ④继续执行后面的语句内容

public class IfDemo02 {
    public static void main(String[] args) {
        System.out.println("开始");       
        //定义两个变量
        int a = 10;
        int b = 20;
        //需求：判断a是否大于b，如果是，在控制台输出：a的值大于b，否则，在控制台输出：a的值不大于b
        if(a > b) {
            System.out.println("a的值大于b");
        } else {
            System.out.println("a的值不大于b");
        }       
        System.out.println("结束");
    }
}
2.10.2.1.3、格式3
格式：
if (关系表达式1) {
    语句体1;   
} else if (关系表达式2) {
    语句体2;   
} 
…
else {
    语句体n+1;
}

执行流程：

  • ①首先计算关系表达式1的值
  • ②如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
  • ③如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
  • ④…
  • ⑤如果没有任何关系表达式为true，就执行语句体n+1。

//95~100 自行车一辆
//90~94   游乐场玩一天
//80 ~ 89 变形金刚一个
//80 以下  胖揍一顿
​
//1.键盘录入一个值表示小明的分数
Scanner sc = new Scanner(System.in);
System.out.println("请输入小明的成绩");
int score = sc.nextInt();
//2.对分数的有效性进行判断
if(score >= 0 && score <= 100){
    //有效的分数
    //3.对小明的分数进行判断，不同情况执行不同的代码
    if(score >= 95 && score <= 100){
        System.out.println("送自行车一辆");
    }else if(score >= 90 && score <= 94){
        System.out.println("游乐场玩一天");
    }else if(score >= 80 && score <= 89){
        System.out.println("变形金刚一个");
    }else{
        System.out.println("胖揍一顿");
    }
}else{
    //无效的分数
    System.out.println("分数不合法");
}
2.10.2.2、switch-case
switch (表达式) {
    case 1:
        语句体1;
        break;
    case 2:
        语句体2;
        break;
    ...
    default:
        语句体n+1;
        break;
}
  • 首先计算出表达式的值
  • 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结 束。
  • 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
/**
*
    需求：键盘录入星期数，显示今天的减肥活动。
    周一：跑步  
    周二：游泳  
    周三：慢走  
    周四：动感单车
    周五：拳击  
    周六：爬山  
    周日：好好吃一顿
**/
public class SwitchDemo2 {
    public static void main(String[] args) {
        //1.键盘录入一个整数表示星期
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数表示星期");
        int week = sc.nextInt();
​
        //2.书写一个switch语句去跟week进行匹配
        switch (week){
            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("输入错误，没有这个星期");
                break;
        }
    }
}

注意： switch结构中的表达式，只能是如下的六种数据类型之一：byte、short、char、int、枚举类型(JDK5.0)、String类型(JDK7.0) ，不能是：long，float，double，boolean。

  • default可以放在任意位置，也可以省略
  • 不写break会引发case穿透现象

2.10.3、循环结构

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。

2.10.3.1、for循环结构
for (初始化语句;条件判断语句;条件控制语句) {
    循环体语句;
}
  • 初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
  • 条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
  • 循环体语句： 用于表示循环反复执行的内容，简单说就是循环反复执行的事情
  • 条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去

执行流程：

  • ①执行初始化语句

  • ②执行条件判断语句，看其结果是true还是false

    • 如果是false，循环结束
    • 如果是true，继续执行

  • ③执行循环体语句

  • ④执行条件控制语句

  • ⑤回到②继续

//需求：打印5次HelloWorld
//开始条件：1
//结束条件：5
//重复代码：打印语句
​
for (int i = 1; i <= 5; i++) {
    System.out.println("HelloWorld");
}
2.10.3.2、while循环
初始化语句;
while(条件判断语句){
    循环体;
    条件控制语句;
}

/*
While循环结构的使用
一、循环结构的四个要素
① 初始化条件
② 循环条件
③ 循环体
④ 迭代条件
​
二、while循环的结构
①初始化部分
while(②循环条件部分)｛
    ③循环体部分;
    ④迭代部分;
}
​
执行过程： ① - ② - ③ - ④ - ② -  ③ - ④ - ... - ② 
​
说明：
1.写while循环千万要小心不要丢了迭代条件。一旦丢了，就可能导致死循环！
2.写程序要避免死循环。
3.能用while循环的，可以用for循环，反之亦然。二者可以相互转换。
区别：for循环和while循环的初始化条件部分的作用范围不同。
​
算法：有限性。
*/
class WhileTest{
    public static void main(String[] args){
        //遍历100以内的所有偶数
        int i = 1;
        while(i <= 100){
            if(i % 2 == 0){
                System.out.println(i);
            }
            i++;
        }
    }
}
​
2.10.3.3、 do...while循环
do-while循环结构的使用
一、循环结构的四个要素
① 初始化条件
② 循环条件 --->是boolean类型
③ 循环体
④ 迭代条件
​
二、do-while循环的结构
①
do{
    ③;
    ④;
}while(②);
​
执行过程：① - ③ - ④ - ② - ① - ③ - ④ - ... - ②
 
说明：do-while循环至少执行一次循环体。
​

class DoWhileTest{
    public static void main(String[] args){
        //遍历100以内的所有偶数,并计算所有偶数的和和偶数的个数
        int number = 1;
        int sum = 0;    //记录总和
        int count = 0;  //记录个数
        do{
            if(number % 2 == 0){
                System.out.println(number);
                sum += number;
                count++;
            }
            number++;
        }while(number <= 100);
​
        System.out.println("总和为：" + sum);
        System.out.println("个数为：" + count);
​
        //*********************************
        int numb = 10;
        while(numb > 10){
            System.out.println("hello:while");
            numb--;
        }
​
        int numb2 = 10;
        do{
            System.out.println("hello：do-while");
            numb2--;
        }while(numb2 > 10);
    }
}
​

2.11、条件控制语句break、continue的使用

  • break
  • continue

2.11.1、break

break: 不能单独存在的。可以用在switch和循环中，表示结束，跳出的意思。

//1.吃1~5号包子
for (int i = 1; i <= 5; i++) {
    System.out.println("在吃第" + i + "个包子");
    //2.吃完第三个的时候就不吃了
    if(i == 3){
        break;//结束整个循环。
    }
}

2.11.2、continue

continue: 不能单独存在的。只能存在于循环当中，表示：跳过本次循环，继续执行下次循环。

avatar
文章
阅读
粉丝