JavaSe基础-基础语法

已于 2022-08-27 19:23:29 修改
阅读量223 收藏
点赞数
分类专栏： javaSE基础 文章标签： java jvm 数据结构
于 2022-08-26 18:32:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47893939/article/details/126548683
版权

JavaSE_第2章【Java基础语法】

学习目标

  • 会使用单行注释和多行注释
  • 能够辨识关键字
  • 理解标识符的含义
  • 理解Java中的基本数据类型分类
  • 能够理解常量的概念
  • 能够定义8种基本数据类型的变量
  • 能够分清楚两种输出语句的区别
  • 了解进制
  • 理解基本数据类型的自动类型转换
  • 理解基本数据类型的强制类型转换
  • 了解ASCII编码表和Unicode编码表
  • 理解int类型和char类型的运算原理
  • 理解运算符++ --的运算方式
  • 理解+符号在字符串中的作用
  • 掌握算术运算符
  • 掌握赋值运算符
  • 掌握比较运算符
  • 理解逻辑运算符
  • 掌握三元运算符的格式和计算结果
  • 了解位运算符

2.1 注释（Comment）

  • 注释：就是对代码的解释和说明。其目的是让人们能够更加轻松地了解代码。为代码添加注释，是十分必须要的，它不影响程序的编译和运行。
  • Java中有单行注释、多行注释和文档注释

    • 单行注释以 //开头，以换行结束，格式如下：

      // 注释内容

    • 多行注释以 /*开头，以*/结束，格式如下：

      /*
	注释内容
	注释内容
*/

    • 文档注释以/**开头，以*/结束

      /**
	注释内容
	@author   可指定 java java程序的作者
	@version  可指定源文件的版本
*/

      文档注释可以被JDK提供的javadoc工具解析生成一套网页形式的说明文档，操作入下：

      D:\>javadoc -d mydoc -author -version Hello.java

2.2 关键字（Keyword）

  • 什么是关键字：被java语言赋予了特殊含义的字符串（单词）。

    例如HelloWorld案例中，出现的关键字有 public 、class 、 static 、 void 等，这些单词已经被Java定义，具有明确的含义。

  • 关键字的特点：全部都是小写字母。

  • Java有哪些关键字：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1J4px4iX-1661509889199)(imgs/关键字表.png)]

关键字一共50个，其中const和goto是保留字。

true,false,null看起来像关键字，但从技术角度，它们是特殊的布尔值和空值。

建议：关键字比较多，不需要死记硬背，学到哪里记到哪里即可。

2.3 标识符( Identifier)

  • **标识符概念：**即给类、变量、方法、包等命名的字符序列，称为标识符。

    简单的说，凡是程序员自己命名的部分都可以称为标识符。

  • 标识符的命名规则（必须遵守）

    （1）组成：英文大小写字母，数字，下划线_，美元符号$

    （2）数字不能开头

    （3）严格区分大小写

    （4）不能使用Java的关键字（包含保留字）和特殊值

  • 标识符的命名规范（遭受鄙视）

    （1）见名知意

    （2）类名、接口名等：每个单词的首字母都大写（大驼峰法则），形式：XxxYyyZzz，

    例如：HelloWorld，String，System等

    （3）变量、方法名等：从第二个单词开始首字母大写（小驼峰法则），其余字母小写，形式：xxxYyyZzz，

    例如：age,name,bookName,main

    （4）包名等：每一个单词都小写，单词之间使用点.分割，形式：xxx.yyy.zzz，

    例如：java.lang

    （5）常量名等：每一个单词都大写，单词之间使用下划线_分割，形式：XXX_YYY_ZZZ，

    例如：MAX_VALUE,PI

**练习：**以下合法的标识符是？

flag_3
my code
discount%
234rate
$name
println
main

2.4 常量（Constant）

  • **常量概念：**在程序执行的过程中，其值不可以发生改变的量。

  • 常量的分类：

    • 自定义常量：通过final关键字定义（后面在面向对象部分讲解）

    • 字面值、字面量（literal）：

      字面量分类举例
      字符串字面量“HelloWorld”
      整数字面量12，-23
      浮点字面量12.34
      字符字面量‘a’，‘A’，‘0’，‘好’
      布尔字面量true，false
      空值字面量null
      public class ConstantDemo {
	public static void main(String[] args) {
		//字符串常量
		System.out.println("HelloWorld");
		
		//整数常量
		System.out.println(12);
		System.out.println(-23);
		
		//小数常量
		System.out.println(12.34);
		
		//字符常量
		System.out.println('a');
		System.out.println('A');
        System.out.println('0');
		
		//布尔常量
		System.out.println(true);
		System.out.println(false);
	}
}

      注意事项：

      ​ 字符字面量，单引号里面有且仅有一个字符。

      ​ 字符串字面量，使用双引号表示，可以包含多个字符。

      ​ 空值字面量，是一种特殊值，不可以在输出语句中直接打印

2.5 输出语句

  • 换行输出语句：输出内容，完毕后进行换行，格式如下：

    System.out.println(输出内容);

  • 直接输出语句：输出内容，完毕后不做任何处理，格式如下

    System.out.print(输出内容);

示例代码：

对比如下两组代码：
System.out.println("tom");
System.out.println(18);

System.out.print("jack");
System.out.print(19);
//--------------------------
System.out.println("jack"+19);//jack19
System.out.println(100+19+"jack");//119jack

注意事项：

​ 换行输出语句，括号内可以什么都不写，只做换行处理

​ 直接输出语句，括号内什么都不写的话，编译报错

​ 只能输出一个数据，不能同时输出多个数据，如果要输出多个数据可以使用 + 把多个数据连接起来，变成为一个数据进行输出。

2.6 变量（Variable）

  • 变量的概念:

在程序执行的过程中，其值可以发生改变的量

  • 变量的作用:

    用来存储数据，代表内存的一块存储区域，这块内存中的值是可以改变的。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fDhTPsA4-1661509889201)(imgs\变量内存.png)]

  • 定义格式：

    1. 声明变量，并同时赋值

      数据类型 变量名=初始化值；

      //声明并同时赋值，存储一个整数的年龄
int age = 18;
//打印输出变量值
System.out.println("age = " + age);//+号表示连接符，把""中的字符串与变量age中的数据连接进行输出

    2. 先声明，再赋值

      数据类型 变量名;

      变量名=初始值；

      //先声明，再赋值
int age;
age=18;
//打印输出变量值
System.out.println("age = " + age);//18

      //变量可以重新赋值
age=19;
System.out.println("age = " + age);//19

    3. 同时声明多个变量

      数据类型 变量名1=初始值，变量名2=初始值；

      //声明多个变量并同时赋值
int a=11,b=22;
//或者先声明再赋值
int c,d;
c=33;
d=44;

  • 变量的使用注意事项

    • 先声明后使用

      ​ 如果没有声明，会报“找不到符号”错误

    • 在使用之前必须初始化

      ​ 如果没有初始化，会报“未初始化”错误

    • 变量有作用域

      ​ 作用域为变量直接所属的{}范围内，如果超过作用域，也会报“找不到符号”错误

    • 在同一个作用域中不能重名

      ​ 同一个{}，不能同时声明两个同名变量

2.7 计算机如何存储数据

计算机世界中只有二进制。那么在计算机中存储和运算的所有数据都要转为二进制。包括数字、字符、图片、声音、视频等。

2.7.1 进制（了解）

  1. 进制分类与表示方式

    （1）十进制：
    数字组成：0-9
    进位规则：逢十进一

    System.out.println(10);//10表示十进制的10，输出十进制结果10

    （2）二进制：
    数字组成：0-1
    进位规则：逢二进一

    表示方式：以0b或0B开头

    System.out.println(0B10);//0B10表示二进制的10，输出十进制结果2

    十进制的256，二进制：100000000，为了缩短二进制的表示，又要贴近二进制，在程序中引入八进制和十六进制

    （3）八进制：很少使用
    数字组成：0-7
    进位规则：逢八进一

    表示方式：以0开头

    System.out.println(010);//010表示八进制的10，输出十进制结果8

    与二进制换算规则：每三位二进制是一位八进制值

    （4）十六进制
    数字组成：0-9，a-f或A-F
    进位规则：逢十六进一

    表示方式：以0x或0X开头

    System.out.println(0X10);//0x10表示十六进制的10，输出十进制结果16

    与二进制换算规则：每四位二进制是一位十六进制值

  2. 进制的转换

    十进制二进制八进制十六进制
    0000
    1111
    21022
    31133
    410044
    510155
    611066
    711177
    81000108
    91001119
    10101012a或A
    11101113b或B
    12110014c或C
    13110115d或D
    14111016e或E
    15111117f或F
    16100002010

  • 任意进制转十进制

    十进制的本质：123=1*102+2*101+3*10^0

    系数：就是每一个位上的数值。上例中的1,2,3
    基数：x进制的基数就是x。上例中的10
    权：对每一个位上的数据，从右到左，并且从0开始编号，对应的编号就是该数据的权。上例中的0,1,2

    任意进制转十进制：系数*基数^权次幂之和。

  • 十进制转任意进制：

    十进制数除以基数取余，直到商为0，余数反转。

    十进制转二进制：十进制整数6除以基数2，倒序取余数，结果为二进制数110
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BLuIrpKR-1661509889202)(imgs/十进制转二进制.jpg)]

  • 快速转换方法：

    • 二进制转十进制：

      **8421码：**从右边开始依次是2的0次，2的1次，2的2次。。。。

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mv394sbi-1661509889202)(imgs/二进制转十进制.jpg)]

    • 二进制数据转八进制数据

      从右边开始，3位二进制对应1位八进制

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uAZIznxm-1661509889203)(imgs/2、二进制与八进制转换.png)]

    • 二进制数据转十六进制数据

      从右边开始，4位二进制对应1位十六进制

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-derZETsT-1661509889203)(imgs/3、二进制与十六进制转换.png)]

2.7.2 计算机存储单位

  • **位（bit）：**是数据存储的最小单位，也就是一个二进制位。其中8 bit 就称为1个字节(Byte)。
  • **字节（Byte）：**是计算机信息技术用于计量存储容量的一种计量单位，1字节等于8bit。
  • 转换关系：
    • 8 bit = 1 Byte
    • 1024 Byte = 1 KB
    • 1024 KB = 1 MB
    • 1024 MB = 1 GB
    • 1024 GB = 1 TB

2.7.3 二进制数据存储(理解)

计算机底层都是使用二进制进行数据的存储的。不同类型的数据，存储方式也有不同。

  1. 整数存储

    计算机底层存储整数并不是把整数转换为二进制直接存储，而是以二进制的补码形式进行存储。要了解补码还要知道原码和反码：

    原码：把十进制转为二进制，然后最高位设置为符号位，1表示负数，0表示正数。

    正整数的原码、反码和补码都一样，称为三码合一。

    负整数的反码和补码表示为：

    反码：负整数的反码在其原码的基础上，符号位不变，其余位取反（0变1,1变0）

    补码：负整数的补码为其反码基础上+1

    例如：用1个字节的二进制表示一个数

25 ==> 原码  0001 1001 ==> 反码  0001 1001 -->补码  0001 1001
-25 ==>原码  1001 1001 ==> 反码  1110 0110 ==>补码  1110 0111

    一个字节可以存储的整数范围

    分为两种情况：

    （1）无符号：不考虑正负数

    0000 0000 ~ 1111 1111 ==> 0~255

    （2）有符号：-128~127

    0000 0000 ~ 0111 1111 ==> 0~127

1000 0001 ~ 1111 1111 ==> -127 ~ -1 （补码形式存储）

1000 0000  ==> -128     特殊值，最高位既是符号位，又是数值位

  2. 如何存储小数（了解）

    • 为什么float（4个字节）比long（8个字节）的存储范围大？
    • 为什么double（8个字节）比float（4个字节）精度范围大？
    • 为什么float和double不精确

    因为float、double底层也是二进制，先把小数转为二进制，然后把二进制表示为科学记数法，然后只保存：

    ①符号位②指数位③尾数位

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7jli373p-1661509889204)(imgs\小数二进制存储.png)]

    详见《float型和double型数据的存储方式.docx》

  3. 如何存储字符

    在计算机的内部都是二进制的0、1数据，如何让计算机可以直接识别人类文字的问题呢？就产生出了编码表的概念。

    • 编码表

      就是将人类的文字和一个十进制数进行对应起来组成一张表格。例如：

      字符十进制数值二进制数值
      ‘0’480011 0000
      ‘A’650100 0001
      ‘a’970110 0001

      将所有的英文字母，数字，符号都和十进制进行了对应，因此产生了世界上第一张编码表ASCII（American Standard Code for Information Interchange 美国标准信息交换码）。

      Unicode(统一码、万国码、单一码)是计算机科学领域里的一项业界标准，包括字符集、编码方案等。Unicode 是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求。

      Java中使用的字符集：Unicode编码集

      unicode使用2个字节存储一个字符，对于大量的英文字符（1个字节可以存储），无疑是浪费空间的，所以出现了UTF-8、UTF-16编码规则，UTF-8是以8位为一个编码单位的可变长编码规则。这时：

      英文字符：还是按照ASCII码表对应的数字进行存储（1个字节）

      中文字符：通常需要3个字节来存储

    • Java中字符常量的几种表示方式

      （1）‘一个字符’

      ​ 例如：‘A’，‘0’，‘尚’

      （2）转义字符

      \n：换行
\r：回车
\t：Tab键
\\：\
\"："
\'：'
\b：删除键Backspace
    
System.out.println('\\');
System.out.println("hello\tworld\njava");

      （3）\u字符的Unicode编码值的十六进制型

      ​ 例如：‘\u5C1A’代表’尚’

      char c = '\u5C1A';
char c = '尚';
String s = '尚';//错误的，哪怕是一个字符，也要使用双引号

char c2 = '';//错误，单引号中有且只能有一个字符
String s2 = "";//可以，双引号中可以没有其他字符，表示是空字符串

      （4）直接给char类型变量赋值十进制的0~65535之间的Unicode编码值

      例如：‘尚’ 的编码值是23578

      'a’的编码值是97

      char c1 = 23578;
System.out.println(c1);//尚

char c2 = 97;
System.out.println(c2);//a

2.8 数据类型(Data Type)

2.8.1 数据类型分类

Java是一种强类型的语言，针对每一种数据都定义了数据类型，不同类型的数据二进制表示方式或分配的空间大小有所不同，java数据类型主要分为两大类：（定义变量需要确定数据类型，即确定数据使用的空间大小和二进制表示形式）

  • 基本数据类型：包括 整数、浮点数、字符、布尔。
  • 引用数据类型：包括 类、数组、接口等。

2.8.2 基本数据类型

四类八种基本数据类型：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FDH1TLiD-1661509889204)(imgs/基本数据类型范围.jpg)]

Java中的默认类型：整数类型是int 、浮点类型是double 。

  • 常量整数值都是int类型，占用4个字节空间。

    程序运行期间byte、short、char、boolean实际都是占用4个字节内存空间，
    但在逻辑上：
    ​ byte只有低8位有效空间。
    ​ short只有低16位有效空间。
    ​ 所以，可以直接把一个byte范围内的整数常量值直接赋给byte类型变量。short同理。byte b=10;
    赋值给int，只要在int范围即可。
    赋值给long，在int范围内的，可以加也可以不用加L，会自动升级为long，如果数字超过int范围，必须加L。

  • 小数常量值，无论多少，不加F，就是double类型。

2.8.3 基本数据类型的存储范围

  1. 整型系列

（1）byte：字节类型

​ 占内存：1个字节

​ 存储范围：-128~127

byte b=10;
byte b1=128//编译失败: 不兼容的类型: 从int转换到byte可能会有损失

（2）short：短整型类型

​ 占内存：2个字节

​ 存储范围：-32768~32767

short s=10;
short s1=32768//编译失败: 不兼容的类型: 从int转换到short可能会有损失

（3）int：整型

​ 占内存：4个字节

​ 存储范围：-2的31次方 ~ 2的31次方-1

int i=10;
int i1=12345678900;//编译错误: 过大的整数: 12345678900

（4）long：整型

​ 占内存：8个字节

​ 存储范围：-2的63次方 ~ 2的63次方-1

long j=10;
long j1=12345678900L;

注意：如果要表示某个超过int范围的常量整数它是long类型，那么需要在数字后面加L

  1. 浮点型系列（小数）

    （1）float：单精度浮点型

    占内存：4个字节

    精度：科学记数法的小数点后6~7位

    注意：如果要表示某个常量小数是float类型，那么需要在数字后面加F或f，否则就是double类型

    （2）double：双精度浮点型

    占内存：8个字节

    精度：科学记数法的小数点后15~16位

    float f = 12.3F;//右边如果赋值小数常量值，那么必须加F或f
double d = 12.3;
  2. 单字符类型：char

    占内存：2个字节

    char ch='a';

    char类型：使用单引号’’

  3. 布尔类型

    boolean：只能存储true或false

    虽然计算机底层使用0和1表示false和true，但是在代码中不能给boolean类型的变量赋值0和1，只能赋值false和true

2.9 基本数据类型转换（Conversion）

在Java程序中，不同的基本数据类型的值经常需要进行相互转换。Java语言所提供的七种数值类型之间可以相互转换，基本数据类型转换有两种转换方式：自动类型转换和强制类型转换。

2.9.1 自动类型转换

将取值范围小的类型自动提升为取值范围大的类型 。

基本数据类型按照取值范围从小到大的关系，如图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RRR0z2cO-1661509889204)(imgs/自动类型转换图1.jpg)]

以下情况会发生自动类型转换（隐式类型转换）：

  1. 当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时
int i = 'A';//char自动升级为int
double d = 10;//int自动升级为double
  1. 当存储范围小的数据类型与存储范围大的数据类型一起混合运算时，会按照其中最大的类型运算
int i = 1;
byte b = 1;
double d = 1.0;

double sum = i + b + d;//混合运算，升级为double
  1. 当byte,short,char数据类型进行算术运算时，按照int类型处理
byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//编译报错，b1 + b2自动升级为int

char c1 = '0';
char c2 = 'A';
System.out.println(c1 + c2);//113

boolean类型不参与

2.9.2 强制类型转换

通常将取值范围大的类型转换成取值范围小的类型时需要进行强制（显示）类型转换。

例如：将小数1.5 赋值到int 类型变量会发生什么？产生编译失败，肯定无法赋值。

int i = 1.5; // 错误

想要赋值成功，只有通过强制类型转换，将double 类型强制转换成int 类型才能赋值。

转换格式：

数据类型 变量名 = （数据类型）被强转数据值；

（1）当把存储范围大的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围小的变量时，需要强制类型转换，提示：有风险，可能会损失精度或溢出

int i = (int)3.14;//强制类型转换，损失精度

double d = 1.2;
int num = (int)d;//损失精度

int i = 200;
byte b = (byte)i;//溢出

（2）当某个值想要提升数据类型时，也可以使用强制类型转换

int i = 1;
int j = 2;
double shang = (double)i/j;

提示：这个情况的强制类型转换是没有风险的。

2.9.3 特殊的数据类型转换

任意数据类型的数据与String类型进行“+”运算时，结果一定是String类型

System.out.println("" + 1 + 2);//12

练习

1、练习题：判断如下代码是否编译通过，如果能，结果是多少？
short s1 = 120;
short s2 = 8;
short s3 = s1 + s2;

2、练习题：判断如下代码是否编译通过，如果能，结果是多少？
short s1 = 120;
short s2 = 8;
byte s3 = (byte)(s1 + s2);

3、练习题：判断如下代码是否编译通过，如果能，结果是多少？
char c1 = '0';
char c2 = '1';
char c3 = c1 + c2;

4、练习题：判断如下代码是否编译通过，如果能，结果是多少？
char c1 = '0';
char c2 = '1';
System.out.println(c1 + c2);

5、练习题：判断如下代码是否编译通过，如果能，结果是多少？
int i = 4;
long j = 120; //因为右边120默认是int类型，int的值赋值给long类型是可以的，会自动类型转换，但是要求这个int值不能超过int的存储范围，如果超过int的存储范围必须加L.
double d = 34;
float f = 1.2f;//因为右边1.2默认是double类型，double的值是不能直接赋值给float的，要么加F要么使用强制类型转换。
System.out.println(i + j + d + f);//最后是double

6、练习题：判断如下代码是否编译通过，如果能，结果是多少？
int i = 1;
int j = 2;
double d = i/j;
System.out.println(d);

2.10 运算符（Operator）与标点符号（Separators）

  • **运算符：**是一种特殊的符号，用以表示数据的运算、赋值和比较等。
  • **表达式：**用运算符连接起来的式子

在Java中，一共有38个运算符。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vet7sOGv-1661509889205)(imgs/image-20210701164724830.png)]

2.10.1 运算符的分类

  • 按照功能划分：

    分类运算符
    算术运算符+、-、*、/、%、++、--
    赋值运算符=、+=、-=、*=、/=、%=等
    关系运算符>、>=、<、<=、==、!=
    逻辑运算符&、`
    条件运算符(条件表达式)?结果1:结果2；
    位运算符（了解）&、`

  • 按照操作数个数划分：

    分类运算符例子
    一元（单目）运算符++、–、！i++、–i
    二元（双目）运算符+、-、*、/、%、>、<=等a+b、10>=9
    三元（三目）运算符表达式1?表达式2:表达式3age>=18?“成年”:“未成年”

2.10.2 算术运算符

算术运算符符号解释
+加法运算，字符串连接运算，正号
-减法运算，负号
*乘法运算
/除法运算，整数/整数结果还是整数
%求余运算，余数的符号只看被除数
++ 、 --自增自减运算

  1. 加、减、乘、除、模

    public class OperatorDemo01 {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
		
		System.out.println(a + b);// 7
		System.out.println(a - b);// -1
		System.out.println(a * b);// 12
		System.out.println(a / b);// 计算机结果是0，为什么不是0.75呢？
		System.out.println(a % b);// 3
        
        System.out.println(5%2);//1
		System.out.println(5%-2);//1
		System.out.println(-5%2);//-1
		System.out.println(-5%-2);//-1		
		//商*除数 + 余数 = 被除数
		//5%-2  ==>商是-2，余数时1    (-2)*(-2)+1 = 5
		//-5%2  ==>商是-2，余数是-1   (-2)*2+(-1) = -4-1=-5
	}
}

  2. “+”号的两种用法

    • 第一种：对于+两边都是数值的话，+就是加法的意思

    • 第二种：对于+两边至少有一边是字符串得话，+就是拼接的意思

      public class OperatorDemo02 {
	public static void main(String[] args) {
		// 字符串类型的变量基本使用
		// 数据类型 变量名称 = 数据值;
		String str1 = "Hello";
		System.out.println(str1); // Hello
		
		System.out.println("Hello" + "World"); // HelloWorld
		
		String str2 = "Java";
		// String + int --> String
		System.out.println(str2 + 520); // Java520
		// String + int + int
		// String		+ int
		// String
		System.out.println(str2 + 5 + 20); // Java520
	}
}

  3. 自加自减运算

理解：++ 运算，变量自己的值加1。反之，-- 运算，变量自己的值减少1，用法与++ 一致。

  • 单独使用

    • 变量在单独运算的时候，变量前++和变量后++，变量的是一样的；

    • 变量前++ ：例如 ++a 。

    • 变量后++ ：例如 a++ 。

      public class OperatorDemo3 {
	public static void main(String[] args) {
		// 定义一个int类型的变量a
		int a = 3;
		//++a;
		a++;
        // 无论是变量前++还是变量后++，结果都是4
		System.out.println(a);
	}
}

  • 复合使用

    • 和其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同。

    • 变量前++ ：变量先自身加1，然后再取值。

    • 变量后++ ：变量先取值，然后再自身加1。

      public class OperatorDemo03 {
	public static void main(String[] args) {
		// 其他变量放在一起使用
		int x = 3;
		//int y = ++x; // y的值是4，x的值是4，
		int y = x++; // y的值是3，x的值是4
		
		System.out.println(x);
		System.out.println(y);
		System.out.println("==========");
        
		// 和输出语句一起
		int z = 5;
		//System.out.println(++z);// 输出结果是6，z的值也是6
		System.out.println(z++);// 输出结果是5，z的值是6
		System.out.println(z);
        
        int a = 1;
        a = a++;//(1)先取a的值“1”放操作数栈(2)a再自增,a=2(3)再把操作数栈中的"1"赋值给a,a=1

        int i = 1;
        int j = i++ + ++i * i++;
        /*
        从左往右加载
        (1)先算i++
        ①取i的值“1”放操作数栈
        ②i再自增 i=2
        （2）再算++i
        ①i先自增 i=3
        ②再取i的值“3”放操作数栈
        （3）再算i++
        ①取i的值“3”放操作数栈
        ②i再自增 i=4
        （4）先算乘法
        用操作数栈中3 * 3 = 9，并把9压会操作数栈
        （5）再算求和
        用操作数栈中的 1 + 9 = 10
        （6）最后算赋值
        j = 10
        */
	} 
}

  • 小结：

    • ++在前，先自加，后使用；
    • ++在后，先使用，后自加。

  1. 练习

    • （1）获取一个四位数的个位，十位，百位，千位

      public class Test01 {
	public static void main (String [] args) {
		//1.定义一个四位数，例如1234
		int num = 1234;
        
		//2.通过运算操作求出个位，十位，百位，千位
		int ge = ？
		int shi = ？
		int bai = ？
		int qian = ？
		
		System.out.println(num + "这个四位数个位上的数字是：" + ge);
		System.out.println(num + "这个四位数十位上的数字是：" + shi);
		System.out.println(num + "这个四位数百位上的数字是：" + bai);
		System.out.println(num + "这个四位数千位上的数字是：" + qian);
	}
}

    • （2）自增自减练习

      判断如下代码的运行结果

      	public static void main(String[] args){
		int i = 1;
		int j = i++;
		int k = i++ * ++j + ++i * j++;
		
		System.out.println("i = " + i);
		System.out.println("j = " + j);
		System.out.println("k = " + k);
	}

      	public static void main(String[] args){
		int i = 1;
		int j = i++;
		int k = i++ * ++j + --i * j--;
		
		System.out.println("i = " + i);
		System.out.println("j = " + j);
		System.out.println("k = " + k);
	}

      	public static void main(String[] args){
		int i = 1;
		int j = ++i + i++ * ++i + i++;
		
		System.out.println("i = " + i);
		System.out.println("j = " + j);
	}

      public static void main(String[] args){
	int i = 0;
	int result = ++i/--i;
	System.out.println("result="+result);
}

2.10.3 赋值运算符

注意：所有的赋值运算符的=左边一定是一个变量

赋值运算符符号解释
=将符号右边的值，赋值给左边的变量
+=将符号**左边的值和右边的值进行相加操作，最后将结果赋值给左边的变量**
-=将符号**左边的值和右边的值进行相减操作，最后将结果赋值给左边的变量**
*=将符号**左边的值和右边的值进行相乘操作，最后将结果赋值给左边的变量**
/=将符号**左边的值和右边的值进行相除操作，最后将结果赋值给左边的变量**
%=将符号**左边的值和右边的值进行取余操作，最后将结果赋值给左边的变量**

  1. 基本赋值运算符课堂案例

    public class OperatorDemo04 {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
		a = a + b; 
		System.out.println(a); // 7
		System.out.println(b); // 4	
	}
}

  2. 扩展赋值运算符课堂案例

    public class OperatorDemo04 {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
		b += a;// 相当于 b = b + a ; 
		System.out.println(a); // 3
		System.out.println(b); // 7	
		
		short s = 3;
		// s = s + 4; 代码编译报错，因为将int类型的结果赋值给short类型的变量s时，可能损失精度
		s += 4; // 代码没有报错
        //因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型强转成short
		System.out.println(s);
        
        int j = 1;
		j += ++j * j++;//相当于  j = j + (++j * j++);
		System.out.println(j);//5
	}
}

    扩展赋值运算符在将最后的结果赋值给左边的变量前，都做了一步强制类型转换。

  3. 练习

    交换两个变量的值
    int m = 1;
    int n = 2;

    int temp=m;
m=n;
n=temp;

2.10.4 关系运算符/比较运算符

比较运算符，是两个数据之间进行比较的运算，运算结果一定是boolean值true或者false 。

关系运算符符号解释
<比较符号左边的数据是否小于右边的数据，如果小于结果是true。
>比较符号左边的数据是否大于右边的数据，如果大于结果是true。
<=比较符号左边的数据是否小于或者等于右边的数据，如果大于结果是false。
>=比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是false。
==比较符号两边数据是否相等，相等结果是true。
!=不等于符号 ，如果符号两边的数据不相等，结果是true。

  • 课堂案例

    public class OperatorDemo05 {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;

		System.out.println(a < b); // true
		System.out.println(a > b); // false
		System.out.println(a <= b); // true
		System.out.println(a >= b); // false
		System.out.println(a == b); // false
		System.out.println(a != b); // true
	}
}

  • ​ 练习：判断如下程序的运行结果

    public static void main(String[] args){
	int a = 1;
	int b = 2;
	int c = 0;
	boolean flag = false;
	if(flag=true){
		c = a++ + b;
	}

	if(flag=false){
		c = ++a - b;
	}
	System.out.println("a = " + a);
	System.out.println("b = " + b);
	System.out.println("c = " + c);
}

2.10.5 逻辑运算符

逻辑运算符，是用来连接两个布尔类型结果的运算符（!除外），运算结果一定是boolean值true或者false

逻辑运算符符号解释符号特点
&与，且有false则false
``或
^异或相同为false，不同为true
!非非false则true，非true则false
&&双与，短路与左边为false，则右边就不看
``

  1. 课堂案例

    public class OperatorDemo06 {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
		int c = 5;

		// & 与，且；有false则false
		System.out.println((a > b) & (a > c)); 
		System.out.println((a > b) & (a < c)); 
		System.out.println((a < b) & (a > c)); 
		System.out.println((a < b) & (a < c)); 
		System.out.println("===============");
		// | 或；有true则true
		System.out.println((a > b) | (a > c)); 
		System.out.println((a > b) | (a < c)); 
		System.out.println((a < b) | (a > c));
		System.out.println((a < b) | (a < c));
		System.out.println("===============");
		// ^ 异或；相同为false，不同为true
		System.out.println((a > b) ^ (a > c));
		System.out.println((a > b) ^ (a < c)); 
		System.out.println((a < b) ^ (a > c)); 
		System.out.println((a < b) ^ (a < c)); 
		System.out.println("===============");
		// ! 非；非false则true，非true则false
		System.out.println(!false);
		System.out.println(!true);
	}
}

  2. &&和&区别，||和|区别

    短路与，短路或运算符左边表达式结果可以确定最终结果，则运算符右边表达式不再进行运算，效率高

    • **&&和&**区别：

      &&和&结果一样，&&有短路效果，左边为false，右边不执行；&左边无论是什么，右边都会执行。

    • **||和|**区别：

      ||和|结果一样，||有短路效果，左边为true，右边不执行；|左边无论是什么，右边都会执行。

  3. 面试题1

在这里插入图片描述

public class LogicExer1{
	public static void main(String[] args){
		int x = 1;
		int y = 1;

		//x==2 ,x++  false  x = 2 左边为false
		//右边继续
		//++y  y==2  y=2  y==2成立  右边为true
		//false & true 结果false
		if(x++==2 & ++y==2){
			x =7;
		}
		System.out.println("x="+x+",y="+y);//x=2,y=2
	}
}

public class LogicExer2{
	public static void main(String[] args){
		int x = 1,y = 1;

		//x==2,x++  左边条件为false，x=2
		//因为短路与，右边不算
		//false && ? 结果是false
		if(x++==2 && ++y==2){
			x =7;
		}
		System.out.println("x="+x+",y="+y);//x=2,y=1
	}
}

public class LogicExer3{
	public static void main(String[] args){
		int x = 1,y = 1;

		//x==1,x++  左边为true，x=2
		//因为是逻辑与,右边继续  
		//++y, y==1  y=2 右边为false
		//条件true | false，最终为true
		if(x++==1 | ++y==1){
			x =7;
		}
		System.out.println("x="+x+",y="+y);//x=7,y=2
	}
}	

public class LogicExer4{
	public static void main(String[] args){
		int x = 1,y = 1;

		//x==1,x++  左边为true，x=2
		//因为是短路或，左边为true，右边就不看了
		//整个条件为true
		if(x++==1 || ++y==1){
			x =7;
		}
		System.out.println("x="+x+",y="+y);//x=7,y=1

	}
}

  1. 面试题2
    在这里插入图片描述

    public class LogicExer5{
	public static void main (String []  args)  {
		boolean x = true;
		boolean y = false;
		short z = 42;
		
		//如果if((z++==42)&&(y==true))条件成立，执行z++，不成立，就不执行z++
		//左边的条件：z==42,z++  z==42成立,z++变成43
		//中间虽然是短路与，因为左边现在是true,右边还要看
		//右边 y==true   不成立
		//true && false 结果为false
		if((z++==42)&&(y==true))	z++;
	
		//左边为x=false,赋值  结果就为false
		//中间虽然为短路或，因为左边是false,右边继续看
		//++z,z==45  ++z变成44，z==45是否成立，不成立
		//false || false  结果为false
		if((x=false) || (++z==45))  z++;

		System. out.println("z="+z);//44
	}
}

    class  Test4_2  {
	public static void main (String []  args)  {
		boolean x = true;
		boolean y = false;
		short z = 42;
		
		//如果if(y=true)条件成立，接着判断if((z++==42)&&(y==true))	z++;	
		//如果不成立，if((z++==42)&&(y==true))	z++;	不看的
		/*
		if(y = true)
				
		if((z++==42)&&(y==true))	z++;	
		
		if((x=false) || (++z==45))  z++;
		*/
		
		//标准
		//y=true赋值，y就被修改为true,if(true)成立
		if(y=true){
			//左边：z==42,z++  成立,z变成43
			//&&短路与，不满足短路的情况，右边继续
			//y==true 成立
			//true && true，结果为true
			if((z++==42)&&(y==true)){
				//z++变成44
				z++;
			}
		}
		//左边：x=false不成立
		//中间虽然是短路或，但是没满足短路的情况，右边继续
		//++z,z==45  ++z变成45，z==45成立
		if((x=false) || (++z==45)){
			//z++，变成46
			z++;
		}
		System. out.println("z="+z);//46
	}
}

2.10.6 条件运算符

  • 条件运算符格式：
条件表达式？结果1：结果2
  • 条件运算符计算方式：
    • 条件判断的结果是true，条件运算符整体结果为结果1，赋值给变量。
    • 判断条件的结果是false，条件运算符整体结果为结果2，赋值给变量。
public static void main(String[] args) {
    int i = (1==2 ? 100 : 200);
    System.out.println(i);//200
    int j = (3<=4 ? 500 : 600);
    System.out.println(j);//500
}
练习

1、声明三个整型的变量,a,b,c,要求找出最大值
2、声明一个整型的变量，判断它是正数还是负数，还是0

2.10.7 位运算符（了解）

位运算符符号解释
&按位与，当两位相同时为1时才返回1
``
~按位非，将操作数的每个位（包括符号位）全部取反
^按位异或。当两位相同时返回0，不同时返回1
<<左移运算符
>>右移运算符
>>>无符号右移运算符
  • 位运算符的运算过程都是基于补码运算，但是看结果，我们得换成原码，再换成十进制看结果
  • 从二进制到十进制都是基于原码
  • byte,short,char在计算时按照int类型处理
  • 位运算直接对二进制进行位移操作实现数值运算，所以运算效率高

如何区分&,|,^是逻辑运算符还是位运算符？

如果操作数是boolean类型，就是逻辑运算符，如果操作数是整数，那么就位运算符。

  1. 左移：<<

    运算规则：左移几位就相当于乘以2的几次方

    **注意：**当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位

    byte,short,char在计算时按照int类型处理

    3<<4  类似于  3*2的4次= 3*16 = 48

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RmByVj0d-1661509889206)(imgs/image-20200225113651675.png)]

-3<<4  类似于  -3*2的4次= -3*16 = -48

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XWVuSR9r-1661509889206)(imgs/image-20200225114707524.png)]

  1. 右移：>>

    快速运算：类似于除以2的n次幂，如果不能整除，向下取整

    69>>4  类似于  69/2的4次 = 69/16 =4

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AotbRl5A-1661509889207)(imgs/image-20200225115636844.png)]

    -69>>4  类似于  -69/2的4次 = -69/16 = -5

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ur2ln7ri-1661509889207)(imgs/image-20200225120112188.png)]

  2. 无符号右移：>>>

    运算规则：往右移动后，左边空出来的位直接补0，不看符号位

    正数：和右移一样

    负数：右边移出去几位，左边补几个0，结果变为正数

    69>>>4  类似于  69/2的4次 = 69/16 =4

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AgWWpeDp-1661509889208)(imgs/image-20200225121104734.png)]

    -69>>>4   结果：268435451

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T6y0wpnQ-1661509889208)(imgs/image-20200225121244290.png)]

  3. 按位与：&

    运算规则：对应位都是1才为1

    1 & 1 结果为1

    1 & 0 结果为0

    0 & 1 结果为0

    0 & 0 结果为0

    9&7 = 1

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YOE0VUT8-1661509889208)(imgs/image-20200225122440953.png)]

    -9&7 = 7

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HkoSjXB2-1661509889209)(imgs/image-20200225122221616.png)]

  4. 按位或：|

    运算规则：对应位只要有1即为1

    1 | 1 结果为1

    1 | 0 结果为1

    0 | 1 结果为1

    0 & 0 结果为0

    9|7  结果： 15

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-13gTRTkU-1661509889209)(imgs/image-20200225122758851.png)]

    -9|7 结果： -9

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XMYw8xvM-1661509889209)(imgs/image-20200225123409130.png)]

  5. 按位异或：^

    运算规则：对应位一个为1一个为0，才为1

    1 ^ 1 结果为0

    0 ^ 1 结果为1

    0 ^ 0 结果为0

    9^7  结果为14

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4iqZWB5w-1661509889210)(imgs/image-20200225123445305.png)]

    -9^7 结果为-16

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RKWrFUPy-1661509889210)(imgs/image-20200225133145727.png)]

  6. 按位取反

    运算规则：

    ​ ~0就是1

    ​ ~1就是0

    ~9  结果：-10

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YPs3GhIY-1661509889210)(imgs/image-20200225124112662.png)]

    ~-9  结果：8

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8Wmp8yT5-1661509889211)(imgs/image-20200225124156862.png)]

2.10.8 运算符优先级

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-udkhdvuH-1661509889211)(imgs/1553858424335.png)]

提示说明：

（1）表达式不要太复杂

（2）先算的使用()

  1. 大体的排序：算术 > 位 > 比较 > 逻辑 > 三元 > 赋值

2.10.9 标点符号

在Java中一共有12个标点符号。（后面再一一学习）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PMaLepno-1661509889211)(imgs/image-20210701170438577.png)]

  • 小括号()用于强制类型转换、表示优先运算表达式、方法参数列表
  • 大括号{}用于数组元素列表、类体、方法体、复合语句代码块边界符
  • 中括号[]用于数组
  • 分号;用于结束语句
  • 逗号,用于多个赋值表达式的分隔符和方法参数列表分隔符
  • 英文句号.用于成员访问和包目录结构分隔符
  • 英文省略号…用于可变参数
  • @用于注解
  • 双冒号::用于方法引用

各个标点符号的使用在后续章节中一一揭晓。

特拉斯托
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java自学视频教程-JavaSE基础-Java基础语法-02、Java语言概述.mp4
08-23
Java是一种编程语言，被特意设计用于互联网的分布式环境。Java具有类似于C++语言的“形式和感觉”，但它要比C++语言更易于使用，而且在编程时彻底采用了一种“以对象为导向”的方式。 使用Java编写的应用程序，既...
1-JavaSE 基础语法
weixin_52221977的博客
05-23 85
JavaSE的基础语法，建议从头开始学Java的同学先了解一下这些内容。
Java自学视频教程-JavaSE基础-Java基础语法-04、Java入门HelloWorld.mp4
08-23
Java是一种编程语言，被特意设计用于互联网的分布式环境。Java具有类似于C++语言的“形式和感觉”，但它要比C++语言更易于使用，而且在编程时彻底采用了一种“以对象为导向”的方式。 使用Java编写的应用程序，既...
Java自学视频教程-JavaSE基础-Java基础语法-05、Java入门程序：常见问题.mp4
08-23
Java是一种编程语言，被特意设计用于互联网的分布式环境。Java具有类似于C++语言的“形式和感觉”，但它要比C++语言更易于使用，而且在编程时彻底采用了一种“以对象为导向”的方式。 使用Java编写的应用程序，既...
Java自学视频教程-JavaSE基础-Java基础语法-03、Java环境搭建：JDK安装、常用命令.mp4
08-23
Java是一种编程语言，被特意设计用于互联网的分布式环境。Java具有类似于C++语言的“形式和感觉”，但它要比C++语言更易于使用，而且在编程时彻底采用了一种“以对象为导向”的方式。 使用Java编写的应用程序，既...
javase-java的基础语法一
05-03
javase-java的基础语法一
进阶2 探索图形化编程：扩展图形组件与切片开发的魅力
优树搭的博客
05-30 1497
当这些切片成功地通过图形程序串联起来后，在后续进行程序升级或维护时，大家会惊喜地发现，图形程序就如同清晰的路标一般，可以非常便捷地通过图形程序准确地定位到相关切片，并对这些切片进行在线查看、编辑和执行等操作。而且，这些切片的代码长度通常不会太长，相比传统开发的代码，阅读起来要容易得多，这无疑会给系统后续的工作带来极大的便利。
JAVAEE之多线程进阶（2）_ CAS概念、实现原理、ABA问题及解决方案
2301_80653026的博客
05-29 1531
CAS全称Compare and swap，字面意思:”比较并交换“，它是一条 CPU 并发原语，用于判断内存中某个值是否为预期值，如果是则更改为新的值，这个过程是原子的。全称 Compare and swap, 即 “比较并交换”. 相当于通过一个原子的操作, 同时完成 “读取内存, 比较是否相等, 修改内存” 这三个步骤. 本质上需要 CPU 指令的支撑。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 1062
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
Itmastergo的博客
05-31 898
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 363
【代码】Java手动启动jar包。
java调用cmd执行命令
weixin_45210565的博客
05-28 319
3、exec(String command, String[] envp) ，在调用外部程序之前设置系统环境变量，该变量仅供command入参使用，envp每个元素为一个系统环境变量，并且字符串格式为“环境变量名=环境变量值”。2、exec(String[] cmdArray) ，调用外部程序，入参cmdArray的元素将组合成为一条完整的外部可执行程序的启动路径或命令。1、exec(String command) ，调用外部程序，入参command为外部可执行程序的启动路径或命令。
Java面向数据编程1.1版本
极道Jdon的技术博客
05-28 520
虽然将所有这些方法都集中在 Item 上似乎是合理的，因为它们都与购买流程交互，但增加了 predictLowStock（与基于机器学习的预购系统交互）、registerForRecommendations（另一个 ML 系统，这次是物品建议）和 reportPurchase（登记潜在危险物品的购买），让我们怀疑所有这些操作是否真的属于同一个接口。：这是不同上下文场景的方式，放在Item一个类或接口中肯定不对，如同学生借书，将借书这个动作建模在学生这个类或接口一样，借书时一种具体场景。
java多线程创建方式
weixin_57763462的博客
05-28 1123
这种方式是通过创建一个实现了Runnable接口的类，并实现run()方法来创建线程。然后将这个类的对象作为参数传递给Thread类的构造器，并调用Thread对象的start()方法来启动线程。这种方式是通过创建一个实现了Callable接口的类，实现call()方法，并使用FutureTask或者ExecutorService来创建线程。这种方式的优点在于，由于Java不支持多重继承，如果你的类需要继承其他类，那么实现Runnable接口将是唯一的选择。// 在这里定义线程的执行逻辑。
Redis学习笔记【基础篇】
qq_42192253的博客
05-30 1053
这样以来，我们就可以把不同类型的数据区分开了。从而避免了key的冲突问题。HSET key field value：添加或者修改hash类型key的field的值。获取sorted set 中的指定元素的排名：ZRANK key member。HGET key field：获取一个hash类型key的field的值。通过给key添加前缀加以区分，不过这个前缀不是随便加的，有一定的规范。HMSET：批量添加多个hash类型key的field的值。HMGET：批量获取多个hash类型key的field的值。
C语言基础——数组
2302_80177460的博客
05-27 1081
C语言基础——字符串与数组及部分操作符-CSDN博客），这里再简单说明一下吧。我们都知道，如果我们在C语言中想要创建很多个变量，如果是一个一个创建的话那效率太低下了，这个时候或许会有人想到用循环来搞定，但是我们再细想想，如果用循环来表示的话我们应该把这组数据储存在哪里呢，如果只是创建一个变量的话那么后一次循环会覆盖掉前一次循环，但是如果创建很多个变量的话又不好在循环之中插入，这个时候我们便可以使用我们心心念念的数组啦。我们这一章节就来具体看看数组到底是什么吧。
【JAVA |String类】JAVA中的String类常见用法详解
YKX0000的博客
05-30 918
在JAVA中的字符串存储是可以直接使用String这个引用数据类型，不像C语言表示字符串只能使用字符数组或者字符指针，使我们操作起来更方便，更符合不符合面相对象的思想。
继承与无参构造器
2301_79842503的博客
05-30 237
在Java中，当你创建一个子类的实例时，如果子类构造函数没有显式地调用父类的构造函数，那么编译器会自动插入一个对父类无参构造函数的调用（如果父类中存在这样的构造函数）。这是Java中构造函数链式调用的一个基本规则，确保父类在子类之前被正确初始化。这个过程是Java中对象初始化的一个重要部分，确保在子类访问或修改从父类继承的任何状态之前，父类已经完成了其自己的初始化。的构造函数内部，你输出了"Student()无参构造器后执行了"，这是在。的构造函数执行之后发生的。的构造函数执行之前，编译器会自动先调用。
java如何实现请求
最新发布
m0_75032658的博客
06-03 103
如果你想要向数据库发送请求（如查询、更新等），你可以使用Java的JDBC（Java Database Connectivity）API。在Java中，实现请求通常指的是通过网络发送HTTP请求到服务器，或者通过其他协议（如JDBC）向数据库发送请求。注意：在使用Apache HttpClient之前，你需要将其添加到你的项目中。是Java标准库中的一个类，它允许你发送HTTP请求并接收响应。以下是一个简单的示例，展示如何使用。请注意，对于数据库连接，你需要添加相应的JDBC驱动依赖到你的项目中。
javaSE基础项目实战
06-01
1. 基础语法练习：包括JavaSE中的基本数据类型、流程控制语句、数组、字符串等语法知识的练习。 2. 面向对象编程练习：包括JavaSE中的面向对象编程特性，如类、对象、继承、多态、封装等的练习。 3. 异常处理练习...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值