Java基础知识

于 2022-01-18 12:16:10 发布
阅读量646 收藏 2
点赞数 1
分类专栏： 笔记 文章标签： java java-ee 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42008211/article/details/122557289
版权

一、java概述

1.1 Java 语言概述

Java 是一种高级编程语言，而且是面向对象的编程语言。Java 语言是美国 Sun 公司(Stanford University Network)，在 1995 年推出的高级的编程语言。Java 语言共同创始人之一：詹姆斯·高斯林 (James Gosling)，被称为 Java之父。Java 语言的版本：1.0-1.4，5.0…8.0…16.0，本文笔记用的 jdk 版本为 8.0。

在这里插入图片描述

1.2 Java 语言平台版本

JavaSE(Java Platform Standard Edition)标准版

是为开发普通桌面和商务应用程序提供的解决方案
该技术体系是其他，可以完成一些桌面应用程序的开发两者的基础

JavaME(Java Platform Micro Edition)小型版

是为开发电子消费产品和嵌入式设备提供的解决方案，已经被安卓 IOS

JavaEE(Java Platform Enterprise Edition)企业版

是为开发企业环境下的应用程序提供的一套解决方案

1.3 Java 语言的特点

简单性面向对象分布式
跨平台性多线程动态性
健壮性安全性

1.4 Java 语言的跨平台实现原理

(1) JVM: Java 虚拟机，是专门用来运行 Java 程序的。
(2) 平台：指的就是操作系统，比如 Windows、linux、MacOS 等。
(3) 跨平台: 我们编写的一个 Java 程序，可以做多个操作系统上运行一次编译，到处运行。

在这里插入图片描述

1.5 JDK、JRE、JVM 的组成和作用

1.JVM: Java 虚拟机，是专门用来运行 Java 程序的，但是不能单独安装。
2.JRE: Java 运行环境，包含 JVM(Java 虚拟机，是专门用来运行 Java 程序的)和核心类库。
3.JDK: Java 开发工具包，包含 JRE 和开发工具。

三者关系： JDK > JRE > JVM
在这里插入图片描述

二、开发环境搭建

2.1 JDK 安装

注意事项：

1.注意操作系统是 Windows、linux、MacOS
2.注意操作系统的位数是 32 位还是 64 位
3.安装 java 相关软件的时候: 安装路径中不允许出现中文和空格(任何开发软件都最好不要安装在中文路径下)

在这里插入图片描述
默认路径安装一直下一步就行,唯一注意的是8版本安装会安装jdk与jre如果自定义路径需要分别创建文件夹保存

2.2 常用 DOS 命令的使用

打开命令行窗口的方式：

  • win + r 打开运行窗口，输入cmd，回车。

常用dos命令

操作说明
盘符名称:E:回车，表示切换到E盘。
dir查看当前路径下的内容。
cd目录 进入单级目录。cd JavaSE
cd…回退到上一级目录。
cd 目录1\目录2…进入多级目录。cd JavaSE\baiyunshan
cd\回退到盘符目录。
cls清屏。
exit退出命令提示符窗口。

2.3 配置步骤

首先右键【此电脑】—> 选择【属性】—> 点击左侧的【高级系统设置】—> 点击【环境变量】—> 在下方的【系统变量】中点击【新建】
在这里插入图片描述

在这里插入图片描述

新建变量名为【JAVA_HOME】，变量值我们点击【浏览目录】，选择jdk的安装路径jdk文件夹
然后点击【确定】
在这里插入图片描述
找到path路径中写 %JAVA_HOME%\bin; ，放在最前面，不要忘了加英文的分号

在这里插入图片描述

jdk环境配置

JAVA_HOME:用于配置jdk安装路径，用于提供第三方软件支持

CLASSPATH:jdk1.5以后默认配置，无需配置（如果配置不要配错），配置源代码编译后生成位置

PATH:使bin下工具可以在任意路径下使用

注意：在修改环境变量之后需要重新打开cmd窗口

2.4 测试开发环境

通过javac和java命令验证
注意 ：如果提示 < javac不是内部或者外部命令>，原因是path配置错误, 重新按照上一步的步骤进行配置即可！
避免C:\WINDOWS\system32出现所有名字以java开头的文件，有，删之；
注意 ：jdk不要安装在带中文的路径下,最好也是不包含空格字符的英文路径;

在这里插入图片描述
在这里插入图片描述

三、HelloWorld 入门程序

3.1 程序开发的步骤

1.源代码：
程序员写的程序；
程序员在自己可以看得懂得程序；
程序：字母、数字、其他符号；
源程序是程序员编写的，程序员自己可以看得懂得程序，本质就是一个文本文件，但是扩展名不是 .txt，而是 .java。
2.生成JVM可以执行的字节码(.class)文件
JVM：叫做 Java 虚拟机，是专门用来运行 Java 程序的。但是 JVM 是一个二货，只能识别 0 和 1，而存储 0 和 1 的文件叫做 字节码文件(.class文件)
如何把源文件(程序)翻译成JVM能够执行的字节码文件(程序)呢? 使用 javac 命令(编译命令)， 使用格式：javac 文件名.java 例如：编译HelloWorld.java 源文件: javac HelloWorld.java，生成一个字节码文件：HelloWorld.class
3. 把字节码文件交给JVM执行
不管是源文件(程序)还是字节码文件(程序)都存储在硬盘中? 不会自动执行，如何把字节码文件交给 JVM 执行呢? 使用 java 命令(运行命令)。 使用格式: java 文件名 例子：java HelloWorld

在这里插入图片描述

3.2 编写HelloWorld程序

1.编写源文件。 创建一个名称为 HelloWorld.txt 的文本文件，把扩展名修改为 .java，打开 HelloWorld.java 源文件，输入以下内容，并保存(ctrl+s)。

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

2.编译: javac命令。 根据 .java源文件 生产对应的 .class文件(字节码文件)。 使用 javac 命令的格式：javac 文件名.java。javac HelloWorld.java。
注意：
保证当前路径下 javac命令 可以使用。
保证当前路径下有要进行编译的 源(.java)文件。
使用编译javac命令时，文件名后面必须写 扩展名.java。

3.运行: java命令。 把 字节码(.class)文件 交给 jvm 执行。使用 java 命令的格式：java 文件名，java HelloWorld，同样要注意：
保证当前路径下 java 命令 可以使用。
保证当前路径下有要进行运行的 字节码(.class)文件。
使用运行 java 命令 时，文件名后面不能写 扩展名.class。

3.3HelloWorld常见问题

1.大小写问题。Java语言对大小写敏感（区分大小写）
2.非法字符问题。Java中的符号都是英文格式的
3.在系统中显示文件的扩展名，避免出现HelloWorld.java.txt文件
4.编译命令后的java文件名需要带文件后缀.java
5.运行命令后的class文件名（类名）不带文件后缀.class

四、java基本语法

4.1 注释

4.1.1 概念

在代码书写过程中添加书写的解释与说明的文字.

4.1.2 特点

在代码中添加注释可提高代码的可读性。注释中包含了程序的信息，可以帮助程序员更好地阅读和理解程序。在 Java 源程序文件 的任意位置都可以添加注释，且 Java 编译器不编译代码中的注释，也就是说代码中的注释对程序不产生任何影响。所以开发者不仅可以在注释中编写代码的说明文字、设计者的个人信息，还可以使用注释来屏蔽某些不希望执行的代码。

4.1.3 分类

  • 单行注释

单行注释的格式是使用//，从//开始至本行结尾的文字将作为注释文字

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

多行注释的格式是使用/* 和 */将一段较长的注释括起来

/*
这是多行注释文字
这是多行注释文字
这是多行注释文字
*/
// 注意：多行注释不能嵌套使用。
  • 文档注释

文档注释以/**开始，以*/结束,当文档注释出现在声明(如类的声明、类的成员变量声明、类的成员方法声明等)之前时，会被 Javadoc 文档工具 读取作为 Javadoc 文档内容。文档注释的格式与多行注释的格式相同。对于初学者而言，文档注释并不是很重要，了解即可。

/**
   这是文档注释的内容
*/

说明：一定要养成良好的编码习惯。软件编码规范中提到 可读性第一，效率第二，所以程序员必须要在程序中添加适量的注释来提高程序的可读性和可维护性。建议程序中的注释总量要占程序代码总量的 20%~50%。

4.2 关键字

4.2.1 概念

关键字是指被在java中已经被赋予了特殊含义的单词

4.2.2 特点

关键字的字母全部小写
单个单词
常用的代码编辑器对关键字都有高亮显示

4.2.3 关键字列表

常用的关键字51关键字+2个保留字
2个保留字conest goto
在这里插入图片描述

4.3 标识符

4.3.1 概念

标识符可以简单地理解为一个名字，用来标识类名、变量名、方法名、数组名等的有效字符序列。
也可以理解为在java代码书写期间所有由我们命名的都可以称之为标识符

4.3.2 命名规则

由字母、数字、下划线“_”、美元符号“$”组成，第一个字符不能是数字。
不能使用java中的关键字作为标识符。
标识符对大小写敏感（区分大小写）。

4.3.3 命名规范

见名知意:根据名字知道标识符对应功能
驼峰命名法：如果标识符由多个单词组成除首个单词首字母外其余单词首字母大写 passWord

随着java的发展,java程序员在遵循已有规范的基础上对于不同标识符定义了默认的规范(江湖规矩)

类名：通常使用名词，第一个单词字母必须大写，后续单词首字母大写。(大驼峰式)
方法名：通常使用动词，第一个单词首字母小写，后续单词首字母大写。(小驼峰式)
包名:通常采用公司倒置的域名,例如:con.baidu.部门名.功能名
变量：第一个单词首字母小写，后续单词首字母大写。(小驼峰式)
常量：所有字母均大写。
单词的拼接：通常使用 userLastName 方式拼接单词，而不是 user_last_name。

4.4 常量

4.4.1 概念

在程序执行过程中不允许改变的量,称之为常量.

4.4.2 分类

4.4.2.1按照数据类型分

字符串常量

用双引号括起来的多个字符（可以包含0个、一个或多个），例如"a"、“abc”、"中国"等

整数常量

整数，例如：-10、0、88等

小数常量

小数，例如：-5.5、1.0、88.88等

字符常量

用单引号括起来的一个字符，例如：‘a’、‘5’、‘B’、'中’等

布尔常量

布尔值，表示真假，只有两个值true和false

空值常量

一个特殊的值，空值，值为null

4.4.2.2按照书写方式分

默认常量

在程序书写过程中无需定义可直接使用的常量,上面的常量都可以看做默认常量

自定义常量

通过代码定义使用关键字final定义的常量

4.5 数据类型

4.5.1 概念

Java是一个强类型语言，对每一种数据都规定了范围.在代码书写存储数据时必须指定其数据类型

4.5.2 分类

java数据类型分为两大类:基本数据类型与引用数据类
基本数据类型分为四类八种
引用类型主要是面向对象中的类

在这里插入图片描述

4.5.3 取值范围

java中对于取值范围的实际范围只需要知道常用范围即可
整数类型取值范围:-2位数次方-1 ~ 2位数次方-1 -1(位数为内存占用*8)
字符类型取值范围0~65535 (就是0~231)

在这里插入图片描述

4.6 变量

4.6.1 概念

在程序运行过程中可以改变的量,称之为变量.类似于数学中的x,根据运算计算结果,在java中可以使用使用声明变量的形式进行保存.

4.6.2 变量定义的格式

  • 格式一

将变量的声明赋值一同进行
数据类型 变量名(标识符)=值;
int x=1;

  • 格式二

将变量的声明与赋值分开书写
声明: 数据类型 变量名(标识符);
赋值:已经声明的变量名=值;
注意:变量声明时可以不用赋值,但是如果使用变量,那么在使用前必须进行赋值
int x;
x=1;

  • 格式三

同时声明创建多个相同类型变量并进行赋值(也可以只声明不进行赋值)
数据类型 变量名 = 值,变量名 = 值, …;
int a=1,b=2,c=3;

4.6.3 注意事项

  1. 在同一对花括号中，变量名不能重复。
  2. 变量在使用之前，必须初始化（赋值）。
  3. 定义long类型的变量时，需要在整数的后面加L（大小写均可，建议大写）。因为整数默认是int类型，整数太大可能超出int范围。
  4. 定义float类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。因为浮点数的默认类型是double， double的取值范围是大于float的，类型不兼容。
  5. 变量实际存储的是数据的地址，修改的也是地址

在这里插入图片描述

4.7 数据类型转换

4.7.1 概念

java是强类型语言,在声明变量保存数据时需要声明保存数据的类型,以便于jvm开辟对应的大小数据空间进行数据的存储,但是有时可能会出现声明时使用的数据类型与最终使用的类型不匹配(常出现同种类型整数小数之间),这个时候就需要使用类型转换,将数据类型转换为我们需要的类型

4.7.2 分类

  • 自动类型转换(隐式转换)

把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的，直接书写即可,无特殊语法格式

示例

double num1 = 5.5;
int num2 = (int) num1; // 将double类型的num1强制转换为int类型
System.out.println(num2); // 输出5（小数位直接舍弃）
  • 强制类型转换(显式转换)

把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。由于数据类型存储数据的上限,这种类型转换可能造成数据的溢出,所以需要额外定义语法进行书写

在这里插入图片描述
强制类型转换注意事项

char类型的数据转换为int类型是按照码表中对应的int值进行计算的。比如在ASCII码表中，'a’对应97。

int a = 'a';
System.out.println(a); // 将输出97

整数默认是int类型，byte、short和char类型数据参与运算均会自动转换为int类型。

byte b1 = 10;
byte b2 = 20;
byte b3 = b1 + b2; 
// 第三行代码会报错，b1和b2会自动转换为int类型，计算结果为int，int赋值给byte需要强制类型转换。
// 修改为:
int num = b1 + b2;
// 或者：
byte b3 = (byte) (b1 + b2);

boolean类型不能与其他基本数据类型相互转换。

4.8 运算符

4.8.1 概念

  • 运算符

对常量或者变量进行操作的符号

  • 表达式

用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。 不同运算符连接的表达式体现的是不同类型的表达式。

4.8.2 分类

4.8.2.1 算术运算符
符号作用说明
+加将数据类型变量相加,如果是字符串变为连接符
-减将数据类型变量相减
*乘将数据类型变量相乘
/除将数据类型变量相除
%取余获取的是两个数据做除法的余数

注意事项
/和%的区别：两个数据做除法，/取结果的商，%取结果的余数。
整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。

示例

int a = 10;
int b = 3;
System.out.println(a / b); // 输出结果3
System.out.println(a % b); // 输出结果1
  • 字符的"+"操作

char类型参与算术运算

使用的是计算机底层对应的十进制数值。需要我们记住三个字符对应的数值

  • ‘a’ – 97 a-z是连续的，所以’b’对应的数值是98，'c’是99，依次递加
  • ‘A’ – 65 A-Z是连续的，所以’B’对应的数值是66，'C’是67，依次递加
  • ‘0’ – 48 0-9是连续的，所以’1’对应的数值是49，'2’是50，依次递加
// 可以通过使用字符与整数做算术运算，得出字符对应的数值是多少
char ch1 = 'a';
System.out.println(ch1 + 1); // 输出98，97 + 1 = 98

char ch2 = 'A';
System.out.println(ch2 + 1); // 输出66，65 + 1 = 66

char ch3 = '0';
System.out.println(ch3 + 1); // 输出49，48 + 1 = 49
  • 算术表达式

算术表达式中包含不同的基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。

提升规则

byte类型，short类型和char类型将被提升到int类型，不管是否有其他类型参与运算。
整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型

等级顺序：byte,short,char --> int --> long --> float --> double

示例

byte b1 = 10;
byte b2 = 20;
// byte b3 = b1 + b2; // 该行报错，因为byte类型参与算术运算会自动提示为int，int赋值给byte可能损失精度
int i3 = b1 + b2; // 应该使用int接收
byte b3 = (byte) (b1 + b2); // 或者将结果强制转换为byte类型
-------------------------------
int num1 = 10;
double num2 = 20.0;
double num3 = num1 + num2; // 使用double接收，因为num1会自动提升为double类型

正是由于上述原因，所以在程序开发中我们很少使用byte或者short类型定义整数。也很少会使用char类型定义字符，而使用字符串类型，更不会使用char类型做算术运算。

  • 字符串的"+"操作

当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算。

System.out.println("Amour恋空"+ 666); // 输出：Amour恋空666

在”+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“+”操作时，从左到右逐个执行。

System.out.println(1 + 99 + "Amour恋空"); // 输出：100Amour恋空
System.out.println(1 + 2 + "Amour恋空" + 3 + 4); // 输出：3Amour恋空34
// 可以使用小括号改变运算的优先级 
System.out.println(1 + 2 + "yunhe" + (3 + 4)); // 输出：3Amour恋空7
4.8.2.2 赋值运算符
符号作用示例等价
+=相加结果赋予左侧a += b;a = a + b;
-=相减结果赋予左侧a -= b;a = a - b;
*=相乘结果赋予左侧a *= b;a = a * b;
/=相除结果赋予左侧a /= b;a = a / b;
%=取余结果赋予左侧a %= b;a = a % b;
&=与结果赋予左侧a &= b;a = a & b;
|=或结果赋予左侧a |= b;a = a
^=异或结果赋予左侧a ^= b;a = a ^ b;
<<=左移结果赋予左侧a <<= b;a = a << b;
>>=右移结果赋予左侧a >>= b;a = a >> b;
>>>=无符号右移结果赋予左侧a >>>= b;a = a >>> b;

注意
扩展的赋值运算符隐含了强制类型转换。

示例

short s = 10;
s = s + 10; // 此行代码报出，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度
s += 10; // 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 10);
4.8.2.3 自增自减运算符

自增、自减运算符是单目运算符，可以放在变量之前，也可以放在变量之后。自增、自减运算符的作用是使变量的值加1或减1。

符号作用说明
++自增变量的值加1
–自减变量的值减1

注意事项

++和-- 既可以放在变量的后边，也可以放在变量的前边。
单独使用的时候， ++和-- 无论是放在变量的前边还是后边，结果是一样的。
参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者–。
参与操作的时候，如果放在变量的前边，先拿变量做++或者–，后拿变量参与操作。
最常见的用法：单独使用。

在运算中使用如下:
在这里插入图片描述
示例

int i = 10;
i++; // 单独使用
System.out.println("i:" + i); // i:11

int j = 10;
++j; // 单独使用
System.out.println("j:" + j); // j:11

int x = 10;
int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1
System.out.println("x:" + x + ", y:" + y); // x:11，y:10

int m = 10;
int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1
System.out.println("m:" + m + ", m:" + m); // m:11，m:11
4.8.2.4 关系运算符

关系运算符有6种关系，分别为小于、小于等于、大于、等于、大于等于、不等于。

符号说明
==a==b，判断a和b的值是否相等，成立为true，不成立为false
!=a!=b，判断a和b的值是否不相等，成立为true，不成立为false
>a>b，判断a是否大于b，成立为true，不成立为false
>=a>=b，判断a是否大于等于b，成立为true，不成立为false
<a<b，判断a是否小于b，成立为true，不成立为false
<=a<=b，判断a是否小于等于b，成立为true，不成立为false

注意事项

关系运算符的结果都是boolean类型，要么是true，要么是false。
千万不要把"=="误写成"="，"=="是判断是否相等的关系，"="是赋值。

int a = 10;
int b = 20;
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
System.out.println(a <= b); // true

// 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量
boolean flag = a > b;
System.out.println(flag); // 输出false
4.8.2.5 逻辑运算符

逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。

符号作用说明
&逻辑与a&b，a和b都是true，结果为true，否则为false
|逻辑或a|b，a和b都是false，结果为false，否则为true
^逻辑异或a^b，a和b结果不同为true，相同为false
!逻辑非!a，结果和a的结果正好相反

示例

//定义变量
int i = 10;
int j = 20;
int k = 30;

//& “与”，并且的关系，只要表达式中有一个值为false，结果即为false
System.out.println((i > j) & (i > k)); //false & false,输出false
System.out.println((i < j) & (i > k)); //true & false,输出false
System.out.println((i > j) & (i < k)); //false & true,输出false
System.out.println((i < j) & (i < k)); //true & true,输出true
System.out.println("--------");

//| “或”，或者的关系，只要表达式中有一个值为true，结果即为true
System.out.println((i > j) | (i > k)); //false | false,输出false
System.out.println((i < j) | (i > k)); //true | false,输出true
System.out.println((i > j) | (i < k)); //false | true,输出true
System.out.println((i < j) | (i < k)); //true | true,输出true
System.out.println("--------");

//^ “异或”，相同为false，不同为true
System.out.println((i > j) ^ (i > k)); //false ^ false,输出false
System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
System.out.println((i > j) ^ (i < k)); //false ^ true,输出true
System.out.println((i < j) ^ (i < k)); //true ^ true,输出false
System.out.println("--------");

//! “非”，取反
System.out.println((i > j)); //false
System.out.println(!(i > j)); //!false，,输出true
  • 短路逻辑运算符
符号作用说明
&&短路与作用和&相同，但是有短路效果
||短路或作用和|相同，但是有短路效果

在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。

逻辑与&，无论左边真假，右边都要执行。

短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。(存假便为假)

逻辑或|，无论左边真假，右边都要执行。

短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。(存真便为真)

int x = 3;
int y = 4;
System.out.println((x++ > 4) & (y++ > 5)); // 两个表达都会运算
System.out.println(x); // 4
System.out.println(y); // 5

System.out.println((x++ > 4) && (y++ > 5)); // 左边已经可以确定结果为false，右边不参与运算
System.out.println(x); // 4
System.out.println(y); // 4
4.8.2.6 位运算符

用于按位进行数据计算的运算符（与逻辑运算符相似）

符号说明
&a&b， 将a与b的值按位进行与运算
|a|b， 将a与b的值按位进行或运算
~~a， 将a值按位进行取反运算
^a^b， 将a与b的值按位进行异或运算
//位运算符
//将十进制数据转换为二进制之后  逐位进行对应的运算
public class Test5 {
	public static void main(String[] args) {
		//结果的二进制会自动再转换为十进制输出
		// 6->0110
		// 3->0011
		//0代表false  1代表true
		
		//6&3 0010->2
		System.out.println(6&3);
		
		//6|3 0111->7
		System.out.println(6|3);
		
		//6^3 0101->5
		System.out.println(6^3);
		
		//~6 实际计算机存储数据为63位 1位符号位
		System.out.println(~6);
		
		//右移
		System.out.println(6>>2);
		//左移
		System.out.println(6<<2);
	}
}
4.8.2.7 三目运算符

也称之为三元表达式,通过语法书写可以进行简单的逻辑判断

  • 书写格式
关系表达式 ? 表达式1 : 表达式2;

问号前面的位置是判断的条件，判断结果为boolean型，为true时调用表达式1，为false时调用表达式2。其逻辑为：如果条件表达式成立或者满足则执行表达式1，否则执行第二个。

示例

int a = 10;
int b = 20;
int c = a > b ? a : b; // 判断 a>b 是否为真，如果为真取a的值，如果为假，取b的值

图解
在这里插入图片描述

4.8.2.8运算符优先级

Java 中的表达式就是使用运算符连接起来并且符合 Java 规则的式子。运算符的优先级决定了表达式中运算的先后顺序。通常优先级由高到低的顺序依次是：自增和自减运算、算术运算、位运算、逻辑运算、赋值运算。如果两个运算有相同的优先级，会以从左到右的方式进行运算。下表显示 Java 中的运算符的优先级。

优先级描 述运 算 符说 明
1圆括号()优先计算圆括号里代码
2自增，自减，逻辑非，正号，负号，取反++ – ！ + - ~优先计算导致变量自身改变的运算符
3乘，除，取余* / %算术优先乘除法，同级从左到右
4加，减+ -乘除之后计算加减法，同级从左到右
5左移位，右移位，无符号右移位<< >> >>>同级从左到右
6小于，小于等于，大于，大于等于，判断继承关系< <= > >= instanceof同级从左到右
7等于，不等于== !=同级从左到右
8与&同级从左到右
9异或^同级从左到右
10或|同级从左到右
11逻辑与&&同级从左到右
12逻辑或||同级从左到右
13赋值= += -= *= /= %= <<= >>= &= ^= |= >>>=最后赋值

4.9 数据输入

在初期学习中,由于没有前后台的 数据交互,所以我们只能声明变量的形式进行数据操作,但是变量值固定不能做到随时输入,所以可以使用java API提供的Scanner工具类来实现数据的输入操作

  • 使用步骤

1.导包

Scanner 类在java.util包下，所以需要将该类导入。导包的语句需要定义在类的上面。

import java.util.Scanner;

2.创建Scanner对象

Scanner sc = new Scanner(System.in);// 创建Scanner对象，sc表示变量名，其他均不可变

3.调用方法接收数据

int i = sc.nextInt(); // 表示将键盘录入的值作为int数返回。
//也可以调用nextLine();方法获取输入的字符串
//但是注意 nextLine()不能与nextInt()连用

示例

import java.util.Scanner;
public class ScannerDemo {
	public static void main(String[] args) {
		//创建对象
		Scanner sc = new Scanner(System.in);
		//接收数据
		int x = sc.nextInt();
		//输出数据
		System.out.println("x:" + x);
	}
}

4.10 流程控制语句

通过特定的语法,像控制运算符优先级一样,控制java代码语句的执行顺序的方式

4.10.1 顺序流程控制语句

顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

  • 顺序结构执行流程图
    在这里插入图片描述

4.10.2 选择流程控制语句

也叫做分支流程控制语句.在程序执行过程中根据表达式判断的结果选择执行对应的分支(类似于三目运算符)

  • if分支语句

语法一

//if单分支语法
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("结束");
	}
}

语法二

//if双分支语法
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;
		b = 5;	
		//需求：判断a是否大于b，如果是，在控制台输出：a的值大于b，否则，在控制台输出：a的值不大于b
		if(a > b) {
			System.out.println("a的值大于b");
		} else {
			System.out.println("a的值不大于b");
		}		
		System.out.println("结束");
	}
}

语法三

//if多分支语法
if (关系表达式1) {
    语句体1;	
} else if (关系表达式2) {
    语句体2;	
} 
…
else {
    语句体n+1;
}

执行流程

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

在这里插入图片描述

示例

import java.util.Scanner;
public class IfDemo03 {
	//键盘录入一个星期数(1,2,...7)，输出对应的星期一，星期二，...星期日
	public static void main(String[] args) {
		System.out.println("开始");
		// 需求：键盘录入一个星期数(1,2,...7)，输出对应的星期一，星期二，...星期日
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个星期数(1-7)：");
		int week = sc.nextInt();
		if(week == 1) {
			System.out.println("星期一");
		} else if(week == 2) {
			System.out.println("星期二");
		} else if(week == 3) {
			System.out.println("星期三");
		} else if(week == 4) {
			System.out.println("星期四");
		} else if(week == 5) {
			System.out.println("星期五");
		} else if(week == 6) {
			System.out.println("星期六");
		} else {
			System.out.println("星期日");
		}	
		System.out.println("结束");
	}
}

三目运算符与if语句区别

1、语法上的区别
三目运算符是运算符，分支语句是流程控制语句
2、返回结果的区别
三目运算符执行结束后必须创建变量保存结果，分支语句可以直接执行代码块
3、使用的区别
进行简单判断且返回常量数据时，使用三目运算符
进行复杂条件判断时，使用分支语句

  • switch分支语句

语法

switch (表达式) {
	case 值1:
		语句体1;
		break;
	case 值2:
		语句体2;
		break;
	...
	default:
		语句体n+1;
		break;
}

执行流程

①首先计算出表达式的值
②其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结 束。
③最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
注意：switch中表达式的结果可以为byte short int char String 枚举

在这里插入图片描述
示例1

public class SwitchDemo01{
	//键盘录入一个月份输出季节
    public static void main(String[] args) {
        //键盘录入月份数据，使用变量接收
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个月份：");
        int month = sc.nextInt();
        //case穿透
        switch(month) {
            case 1:
            case 2:
            case 12:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            default:
                System.out.println("你输入的月份有误");
        }
    }
}

注意：如果switch中得case，没有对应break的话，则会出现case穿透的现象。
示例2

public class SwitchDemo02{
	public static void main(String[] args) {
		//根据输入年月日输入当年已过天数
		Scanner scanner=new Scanner(System.in);
		System.out.println("请输入年份");
		int year=scanner.nextInt();
		System.out.println("请输入月份");
		int month=scanner.nextInt();
		System.out.println("请输入日期");
		int day=scanner.nextInt();
		//思考：2021年 5月9日已过天数
		//1月份天数+2月+3月+4月+9日期
		
		//声明变量保存已过天数
		int sumDay=0;
		//根据年份计算二月天数
		//二月天数
		int twoDay=28;
		if(year%4==0){
			twoDay=29;
		}
		switch (month-1) {
		case 11:
			sumDay+=30;
		case 10:
			sumDay+=31;
		case 9:
			sumDay+=30;
		case 8:
			sumDay+=31;
		case 7:
			sumDay+=31;
		case 6:
			sumDay+=30;
		case 5:
			sumDay+=31;
		case 4:
			sumDay+=30;
		case 3:
			sumDay+=31;
		case 2:
			sumDay+=twoDay;
		case 1:
			sumDay+=31;
		default:
			sumDay+=day;
		}
		System.out.println("已过"+sumDay+"天");
	}
}

4.10.3 循环流程控制语句

  • while循环

语法

初始化语句;
while (条件判断语句) {
	循环体语句;
    条件控制语句;
}

执行流程

①执行初始化语句
②执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
③执行循环体语句
④执行条件控制语句
⑤回到②继续

在这里插入图片描述

示例1

public class WhileDemo {
    public static void main(String[] args) {
        //需求：在控制台输出5次"HelloWorld"
		//while循环实现
		int j = 1;
		while(j<=5) {
			System.out.println("HelloWorld");
			j++;
		}
    }
}

示例2

世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度?

public class WhileTest {
    public static void main(String[] args) {
		//定义一个计数器，初始值为0
		int count = 0;
		//定义纸张厚度
		double paper = 0.1;
		//定义珠穆朗玛峰的高度
		int zf = 8844430;
		//因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环
		//折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度
		while(paper <= zf) {
			//循环的执行过程中每次纸张折叠，纸张的厚度要加倍
			paper *= 2;
			//在循环中执行累加，对应折叠了多少次
			count++;
		}
		//打印计数器的值
		System.out.println("需要折叠：" + count + "次");
    }
}
  • do…while循环

语法

初始化语句;
do {
	循环体语句;
	条件控制语句;
}while(条件判断语句);

执行流程

① 执行初始化语句
② 执行循环体语句
③ 执行条件控制语句
④ 执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
⑤ 回到②继续

在这里插入图片描述

示例

public class DoWhileDemo {
    public static void main(String[] args) {
        //需求：在控制台输出5次"HelloWorld"
		//for循环实现
		for(int i=1; i<=5; i++) {
			System.out.println("HelloWorld");
		}
		System.out.println("--------");
		//do...while循环实现
		int j = 1;
		do {
			System.out.println("HelloWorld");
			j++;
		}while(j<=5);
    }
}
  • for循环

语法

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

for循环可以看做是while一定结构的简化书写

执行流程

①执行初始化语句
②执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
③执行循环体语句
④执行条件控制语句
⑤回到②继续

在这里插入图片描述
示例1

public class ForTest01 {
    public static void main(String[] args) {
		//需求：输出数据1-5
        for(int i=1; i<=5; i++) {
			System.out.println(i);
		}
		System.out.println("--------");
		//需求：输出数据5-1
		for(int i=5; i>=1; i--) {
			System.out.println(i);
		}
    }
}

示例2

public class ForTest02 {
    public static void main(String[] args) {
		//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
		int sum = 0;
		//从1开始到5结束的数据，使用循环结构完成
		for(int i=1; i<=5; i++) {
			//将反复进行的事情写入循环结构内部
             // 此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 sum 中
			sum += i;
			/*
				sum += i;	sum = sum + i;
				第一次：sum = sum + i = 0 + 1 = 1;
				第二次：sum = sum + i = 1 + 2 = 3;
				第三次：sum = sum + i = 3 + 3 = 6;
				第四次：sum = sum + i = 6 + 4 = 10;
				第五次：sum = sum + i = 10 + 5 = 15;
			*/
		}
		//当循环执行完毕时，将最终数据打印出来
		System.out.println("1-5之间的数据和是：" + sum);
    }
}

示例3

public class ForTest03 {
    public static void main(String[] args) {
		//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
		int sum = 0;
		//对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同
		for(int i=1; i<=100; i++) {
			//对1-100的偶数求和，需要对求和操作添加限制条件，判断是否是偶数
			if(i%2 == 0) {
				sum += i;
			}
		}
		//当循环执行完毕时，将最终数据打印出来
		System.out.println("1-100之间的偶数和是：" + sum);
    }
}

示例4

public class ForTest04 {
    public static void main(String[] args) {
		//输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
		for(int i=100; i<1000; i++) {
			//在计算之前获取三位数中每个位上的值
			int ge = i%10;
			int shi = i/10%10;
			int bai = i/10/10%10;
			
			//判定条件是将三位数中的每个数值取出来，计算立方和后与原始数字比较是否相等
			if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
				//输出满足条件的数字就是水仙花数
				System.out.println(i);
			}
		}
    }
}

while和do…while区别

  • 语法不同
    while与do…while
  • 执行流程不同
    while先判断循环条件后进行循环体执行，do…while先执行循环体后进行条件判断
  • 循环体执行次数不同
    while循环体可能由于条件不满足一次都不执行，do…while循环体至少执行一次
  • 使用场景不同
    while就是根据条件决定循环体执行，跟循环条件无关必须至少执行

for循环和while的区别

  • 变量作用域不同
    for循环声明的变量再有当前循环可用，while在外声明可以直接使用
  • 使用场景不同
    已知次数的循环使用for循环，未知次数的循环使用while循环

死循环

  1. for( ; ; ){}
  2. while(true){}
  3. do {} while(true)

4.10.4 流程跳转语句

跳转控制语句（break）

跳出循环，结束循环

跳转控制语句（continue）

跳过本次循环，继续下次循环

结束跳转语句（return）

结束当前方法返回数据

//流程跳转语句
//使用关键字操作流程语句的跳转 完成对应的功能
public class Test {
	public static void main(String[] args) {
		//return 方法级别的结束
		//会将当前方法后续代码全部结束 直接方法结束
		for(int i=1;i<=100;i++){
			if(i==5){
				return;
				//System.out.println(11111);
				//return结束级别比break更高
			}
			System.out.print(i+" ");
		}
		System.out.println();
		System.out.println("~~~~~~~~~~~~~~~~~");
		
		//continue跳过本次循环中continue后续的代码
		//继续进行下次循环
		for(int i=1;i<=100;i++){
			if(i==5){
				continue;
			}
			System.out.print(i+" ");
		}
		System.out.println();
		System.out.println("~~~~~~~~~~~~~~~~~~~~~");

		//break 结束当前代码块后续代码(结束当前循环)
				//当前代码块中 break之后的代码不会执行
				for(int i=1;i<=100;i++){
					if(i==5){
						break;
						//在break同级代码中之后不能书写其他代码
						//因为break只要执行就会结束
						//System.out.println(111);
					}
					 
					System.out.print(i+" ");
				}
				System.out.println();
	}

}

4.10.5 嵌套循环

在循环中进行循环流程控制语句以及选择流程控制语句的嵌套,实现复杂执行逻辑功能

示例1

public static void main(String[] args) {
    //外循环控制小时的范围，内循环控制分钟的范围
    for (int hour = 0; hour < 24; hour++) {
        for (int minute = 0; minute < 60; minute++) {
            System.out.println(hour + "时" + minute + "分");
        }
        System.out.println("--------");
    }
}

示例2

	public static void main(String[] args){
	//打印九九乘法表
		for(int i = 1 ; i <= 9;i ++){
			for(int j = 1 ; j <= i ; j++){
				System.out.print(j + " * " + i + " = " + (i*j) +"\t");
			}
			System.out.println();
		}
	}

在这里插入图片描述

4.11 数据数生成

Random类似Scanner，也是Java提供好的API，内部提供了产生随机数的功能

  • 使用步骤

1.导包

Random类在java.util包下，所以需要将该类导入。导包的语句需要定义在类的上面。

import java.util.Random;

2.创建Random对象

固定创建对象语法

Random r = new Random();

3. 调用方法获取随机数

会生成0~传入数据(不包含)之间的整数,例如:传入10 随机生成0~9 之间的数据
如果没有书写数据name会在int类型取值范围内随机生成

int num = r.nextInt(10);

示例1

import java.util.Random;
public class RandomDemo {
	public static void main(String[] args) {
		//创建对象
		Random r = new Random();
		//用循环获取10个随机数
		for(int i=0; i<10; i++) {
			//获取随机数
			int number = r.nextInt(10);
			System.out.println("number:" + number);
		}
		//需求：获取一个1-100之间的随机数
		int x = r.nextInt(100) + 1;
		System.out.println(x);
	}
}

示例2

程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？

import java.util.Random;
import java.util.Scanner;

public class RandomTest {
	public static void main(String[] args) {
		//要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
		Random r = new Random();
		int number = r.nextInt(100) + 1;
		
		while(true) {
			//使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入你要猜的数字：");
			int guessNumber = sc.nextInt();
			
			//比较输入的数字和系统产生的数据，需要使用分支语句。
             //这里使用if..else..if..格式，根据不同情况进行猜测结果显示
			if(guessNumber > number) {
				System.out.println("你猜的数字" + guessNumber + "大了");
			} else if(guessNumber < number) {
				System.out.println("你猜的数字" + guessNumber + "小了");
			} else {
				System.out.println("恭喜你猜中了");
				break;
			}
		}
	}
}

4.12 数组

4.12.1 概念

数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。
用于存储具有相同数据类型的容器称之为数组

4.12.2 特点

只能用于存储相同数据类型的数据
数组中既可以存储基本数据类型数据,还可以存储引用类型数据(数组可以存储任意类型数据)
在创建时必须指定长度与存储数据的类型
数组一旦创建,数组存储的数据类型与长度不允许更改.

4.12.3 语法

  • 数组声明

    数据类型[] 数组名;
//声明一个存储指定[数据类型]的数组,名为[数组名]
数据类型 数组名 [];
//声明一个存储指定[数据类型]名为[数组名]的数组

  • 数组初始化创建

    1.动态创建

    数组动态创建也称为数组的动态初始化,就是在创建时只给定数组类型与长度，由系统给出默认初始化值

    数据类型[] 数组名 = new 数据类型[数组长度];

    int[] arr = new int[3];

    等号左边

    • int:数组的数据类型

    • []:代表这是一个数组

    • arr:代表数组的名称

    等号右边

    • new:为数组开辟内存空间

    • int:数组的数据类型

    • []:代表这是一个数组

    • 3:代表数组的长度

    2.静态创建

    数组静态创建也称为数组的静态初始化在创建数组时，直接将元素确定,由系统计算出数组的长度

    简化版语法

    数据类型[] 数组名 = {元素1,元素2,...};

    完整版语法

    数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};

    示例

      public class ArrayDemo {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {1, 2, 3};
        //输出数组名
        System.out.println(arr);
        //输出数组中的元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

  • 数组访问

    语法

    数组名[索引];

    示例

    public class ArrayDemo {
  public static void main(String[] args) {
      int[] arr = new int[3];

      //输出数组名
      System.out.println(arr); //[I@880ec60
      //输出数组中的元素
      System.out.println(arr[0]);
      System.out.println(arr[1]);
      System.out.println(arr[2]);
  }
}

4.12.4 数组内存分配

  • 单个数组变量指向数组的内存图
    在这里插入图片描述
  • 多个数组变量指向不同数组的内存图

在这里插入图片描述

  • 多个数组变量指向相同数组内存图
    在这里插入图片描述

示例

使用数组保存斐波那契额数列

public class ArrayFBNQ {
	public static void main(String[] args) {
		//**1、使用数组保存斐波那契数列**
		//（头两个数为1 之后为前两项数据之和）
		//1  1  2 3  5  8  13  21  34  55 89
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入数列个数");
		//获取数列个数
		int nextInt = sc.nextInt();
		//创建对应长度的数组
		int [] arr=new int[nextInt];
		//遍历数组存入数据
		for(int i=0;i<arr.length;i++){
			if(i==0||i==1){
				arr[i]=1;
			}else{
				arr[i]=arr[i-1]+arr[i-2];
			}
		}
		
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+"\t");
		}	
	}
}

数组常用排序算法

4.13 二维数组

4.13.1 概念

java中本质不存在多维数组,多维数组的概念就是依据与数组可以存储任意类型数据,二维数组其实就是一个元素为一维数组的数组

4.13.2 语法

  • 数组声明
数据类型[][] 变量名;
数据类型 变量名[][];
数据类型[] 变量名[];
//本质就是声明数组存储数组
  • 数组初始化创建
    动态初始化
    数据类型[][] 变量名 = new 数据类型[m][n];
//m表示这个二维数组有多少个一维数组
//n表示每一个一维数组的元素个数
    静态初始化
    标准版：
  数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化版：
  数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

示例1

某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99

public class ArrayCase {
    public static void main(String[] args) {
        // 定义二维数组
        int[][] arr = {{22, 66, 44}, {77, 33, 88}, {25, 45, 65}, {11, 66, 99}};

        // 求总和
        int he = 0;

        for (int i = 0; i < arr.length; i++) {
            // 求每一季度的总销售额
            int sum = 0;
            for (int j = 0; j < arr[i].length; j++) {
                sum += arr[i][j];
            }

            // 将每一季度的总销售额累加到总和
            he += sum;
            System.out.println("第" + (i + 1) + "季度的销售额是：" + sum);
        }

        System.out.println("总销售额: " + he);
    }
}

示例2

1
1 1
1 2 1
1 3 3 1
使用二维数组完成杨辉三角的保存

public class ArrayYHSJ{
	public static void main(String[] args) {
		//**2、使用二维数组完成杨辉三角的保存**
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入行数");
		int [][] arr=new int [sc.nextInt()][];
		for(int i=0;i<arr.length;i++){
			arr[i]=new int[i+1];
			for(int j=0;j<arr[i].length;j++){
				if(j==0||j==arr[i].length-1){
					arr[i][j]=1;
				}else{
					arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
					
				}
			}
		}
		for(int i=0;i<arr.length;i++){
			for(int j=0;j<arr[i].length;j++){
				System.out.print(arr[i][j]+" ");
			}
			System.out.println();
		}
	}
}

4.14 方法

4.14.1 概念

方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集
不同的语言还会称之为函数、过程

4.14.2 语法

修饰符 返回值类型 方法名(参数列表){
    //代码省略... 
    return 结果; 
}

修饰符 public static固定写法(初期学习)
返回值类型： 表示方法运行的结果的数据类型，方法执行后将结果返回到调用者
参数列表： 方法在运算过程中的未知数据，调用者调用方法时传递
return： 将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束

小贴士：return 结果; 这里的"结果"在开发中，我们正确的叫法成为方法的返回值

示例

将打怪物发射炮弹重复的代码，抽取到方法中并使用

public static void fire() {
    System.out.println("准备发射5发炮弹");
    System.out.println("发射第1发炮弹* * * *");
    System.out.println("发射第2发炮弹* * * *");
    System.out.println("发射第3发炮弹* * * *");
    System.out.println("发射第4发炮弹* * * *");
    System.out.println("发射第5发炮弹* * * *");
    System.out.println("发射5发炮弹结束");
}

在main方法中调用

public static void main(String[] args) {
    System.out.println("游戏开始...");
    System.out.println("看到了一个怪物...血牙野猪...");
    //调用方法,发射炮弹
    fire();
    System.out.println("...血牙野猪被打倒...");
}

4.14.3 调用

  • 语法
方法名(参数...);

方法必须先创建才可以使用，该过程成为方法定义
方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用

  • 方法调用过程图解
    在这里插入图片描述

  • 调用方法三种形式
    直接调用：直接写方法名调用

    public static void main(String[] args) {    
    print();
}
public static void print() {
    System.out.println("方法被调用");
}

    赋值调用：调用方法，在方法前面定义变量，接收方法返回值

    public static void main(String[] args) {    
    int sum = getSum(5,6);
    System.out.println(sum);
}
public static int getSum(int a,int b) {
    return a + b;
}

    输出语句调用：在输出语句中调用方法

    public static void main(String[] args) {    
    System.out.println(getSum(5,6));
}
public static int getSum(int a,int b) {
    return a + b;
}

    注意:不能用输出语句调用void无返回值类型的方法。因为方法执行后没有结果，也就打印不出任何内容

    public static void main(String[] args) {
    // 错误，不能输出语句调用void类型方法
    System.out.println(printHello());
}
    public static void printHello() {
        System.out.println("Hello");
    }

4.14.4 方法的重载

指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。
参数列表：个数不同，数据类型不同，顺序不同。
重载方法调用：JVM通过方法的参数列表，调用不同的方法。

注意事项
重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

	//计算两个数据的和
	public static int sum(int a,int b){
		return a+b;
	}
	 
	//方法的重载
	//在同一个类中 方法名相同  参数列表不同 称之为发生了方法的重载
	//有时在进行方法定义时 同一个功能由于参数传递不同可能需要书写多个方法
	//需要定义多个方法名 但是功能相似 这个时候就可以使用方法的重载定义名称相同的不同方法
	
	//参数列表不同——参数个数不同
	public static int sum(int a,int b,int c){
		return a+b+c;
	} 
	
	//参数类型不同——参数个数相同  参数类型不同
	public static double sum(double a,double b,double c){
		return a+b+c;
	}
	
	//参数顺序不同——参数个数相同类型相同（两个以上）
	//顺序不同不是参数变量顺不同 而是数据类型的顺序不同
	
	public static double sum(int a,double b) {
		return a+b;
	}
	public static double sum(double a,int b) {
		return a+b;
	}
	
	//方法重载jvm调用过程
	//顺序执行 执行对应方法时 会到方法栈中查找对应的方法名
	//如果对应方法不存在则报错
	//如果存在则进行判断 是否唯一
	//如果存在多个同名方法 根据调用方法传入的参数个数进行匹配
	//如果个数存在相同 依次根据参数的数据类型进行匹配
	//在依次匹配时进行方法的选择

4.14.5 方法的参数传递

  • 方法参数传递基本类型
    测试代码

    public class ArgsDemo01 {
  public static void main(String[] args) {
      int number = 100;
      System.out.println("调用change方法前：" + number);
      change(number);
      System.out.println("调用change方法后：" + number);
  }

  public static void change(int number) {
      number = 200;
  }
}

结论

基本数据类型的参数，形式参数的改变，不影响实际参数

在这里插入图片描述

  • 方法参数传递引用类型
    测试代码

    public class ArgsDemo02 {
  public static void main(String[] args) {
      int[] arr = {10, 20, 30};
      System.out.println("调用change方法前：" + arr[1]);
      change(arr);
      System.out.println("调用change方法后：" + arr[1]);
  }

  public static void change(int[] arr) {
      arr[1] = 200;
  }
}

结论

对于引用类型的参数，形式参数的改变，影响实际参数的值
在这里插入图片描述

qq_42008211
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java—web知识汇总
03-07
该思维导图是JavaWEB的知识汇总，主要包括：css、html、bootstrap、js、jsp、filter、数据库、ajax、三层模型、maven等基础知识，适用于Java初学者做技术汇总复习。
java 小常识
fanjaing的博客
07-23 796
有关一些运算符的小知识                   short  b=2；                   b=（short）（b+3）； // 进行两次运算，第一次是相加，二是将值赋给b                    b+=3；                        // 进行一次运算，只做赋值运算，会自动转型 关系运算符：>,=,            
java需要掌握的知识
xinge2016的博客
12-14 265
1、语法：Java程序员必须比较熟悉语法，在写代码的时候IDE的编辑器对某一行报错应该能够根据报错信息 知道是什么样的语法错误并且知道任何修正。 2、命令：必须熟悉JDK带的一些常用命令及其常用选项，命令至少需要熟 悉：appletviewer、 HtmlConverter、jar、 java、 javac、javadoc、javap、javaw、native2ascii、serialv
【java基础核心大总结(一)】
hub666的博客
11-27 151
ava 概述 什么是 Java？ Java 是 Sun Microsystems 于1995 年首次发布的一种编程语言和计算平台。编程语言还比较好理解，那么什么是 计算平台 呢？ 计算平台是在电脑中运行应用程序（软件）的环境，包括硬件环境和软件环境。一般系统平台包括一台电脑的硬件体系结构、操作系统、运行时库。 Java 是快速，安全和可靠的。 从笔记本电脑到数据中心，从游戏机到科学超级计算机，从手机到互联网，Java 无处不在！Java 主要分为三个版本： JavaSE(J2SE)(Java2 Pl
java的基础知识_Java基础知识总结
weixin_42298424的博客
02-21 100
1、java语言的特点：简单易用，开源，跨平台，面向对象，可移植性，安全。多线程。2、JDK、JRE、JVM的作用及关系：作用： JVM：保证Java语言跨平台JRE：Java程序的运行环境JDK：Java程序的开发环境关系：JDK：JRE+工具JRE：JVM+类库3、关键字定义：被java语言赋予特定含义的单词特点：全部小写注意:goto和const作为保留字存在4、标志符定义：就是给类、...
Java基础知识点总结.docx
04-03
Java是一种广泛使用的面向对象的编程语言，其基础知识涵盖了多个方面，包括语法、面向对象特性、异常处理、多线程...以上只是Java基础知识的一个概述，每个话题都值得深入探讨和实践，不断学习和总结是提升技能的关键。
java基础知识总结
07-23
Java 基础知识总结 Java 是一种广泛使用的编程语言，由 Sun 公司的 James Gosling 等人于 1991 年开始开发。Java 有三种技术架构：JavaEE、JavaSE 和 JavaME。JavaSE 是桌面应用程序的开发基础，JavaEE 是企业环境...
java基础知识
11-28
java基础知识，涵盖了面向对象，I/O，反射，多线程等，众多java基础知识，适合java初学者夯实基础或者不明白如何学java的朋友
java 基础知识
01-02
java 基础知识 java 基础知识 java 基础知识 java 基础知识
java基础知识大全(必看经典)
03-22
Java 基础知识大全 本资源摘要信息是 Java 基础知识大全的总结，涵盖了 Java 语言的基本概念、特点、历史发展等方面的知识点。以下是本资源摘要信息的详细内容： 一、 Java 语言的特点 * 面向对象：Java 语言是...
java基础知识总结(经典)
04-26
Java 基础知识总结是 Java 程序员不可或缺的一部分，本总结将涵盖 Java 的基础知识，包括 Java 概述、Java 语法基础、变量、数据类型、运算符、控制语句、方法、数组、继承、多态、接口、异常、IO 流等。 一、Java ...
java基础知识.md
04-13
java的基础知识总结，对基本的知识点，容易错的知识点进行总结。文档中写有很多的案例。
java知识体系整理(一)基础知识
wthfeng的专栏
04-01 6182
基础知识 基础知识主要涉及java语法及常见知识点。包括IO、类加载，反射、注解、异常，集合类等。下面以这几个大类分别做汇总，并引出其中若干小问题。 知识梳理 java的集合体系及继承关系，以及主要类的用法及原理。 java类加载机制 BIO与NIO、AIO区别及联系，什么是Reactor模型。 异常类继承关系，受检异常和非受检异常。 反射知识梳理。 其他java特性（枚举，注解，synchro...
Java知识——精华总结
weixin_43239868的博客
10-13 604
一、Java的基本语法 Java程序的基本结构大体分为包、类、main()方法、标识符、关键字、语句、注释等。 Java代码的基本格式： Package 包名; Import package1[.package2…].类名; 修饰符 class 类名{ 类体; } 包、import：Java语言中的一个package（包）就是一个库类单元。 类：Java程序是由类（class）组成的。 Main(...
java面试1：常见java数据类型
至臻至善
04-27 1098
第一部分：必背易漏知识点： 1.变量命名规则 字、下、美、人、数、骆驼；变量名首字母小写；有意义；不能使用关键字； 2.默认类型 在java中，整型默认是int类型，浮点型默认是double类型 3.常量 在声明前加final；常量名通常大写；不同字符使用下划线分隔（驼峰命名）；只能被赋值一次，通常定义时即对其初始化 4.类型转换（重点） 4.1简单数据类型之间的转换 在java中，整型、浮点型、字符型被视为简单数据类型，这些类型由低到高分别为(byte.short,char)——int——long——fl
java 不允许默认构造_Java错误：默认的构造函数不能处理异常类型FileNotFound异常...
weixin_30746795的博客
02-13 222
无论是在你的子类抛出FileNotFoundException声明一个显式构造：public MySubClass() throws FileNotFoundException {}或环绕有try-catch块在基类中的代码，而不是抛出一个FileNotFoundException异常：public MyBaseClass() {FileInputStream fstream = null;try...
Java基础知识入门与学习指南
"本资源主要涵盖Java基础知识，包括从环境变量配置到基础语法的讲解，适合Java初学者，提供免费的在线学习资源，通过QQ群可以参与直播课程。内容涉及到Java的起源、技术架构，以及JDK和JRE的介绍，并简要说明了如何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值