后续内容在《Java SE基础学习笔记2》，还没写完
内容有点乱，可能还有错误，会经常修改的
推荐黑马的Java教程B站链接
文章目录
Java
特点
面试可能会问
面向对象跨平台 最重要
面向对象三大基本特征：封装，继承，多态
Java语言跨平台原理
平台：指的是操作系统
即 Windows、Mac、Linux
跨平台：Java程序可以在任意操作系统上运行
前提：程序中有Java的运行环境
JRE 和 JDK
JRE
是Java程序的运行时环境，包含JVM和运行时所需要的核心类库
想要运行一个已有的Java程序，那么只需安装 JRE 即可
JDK
是Java程序开发工具包，包含JRE和开发人员使用的工具
其中的开发工具:编译工具(javac.exe)和运行工具(java.exe)。我们想要开发一个全新的Java程序，那么必须安装JDK。
JDK、JRE和JVM的关系
JDK：开发用的，包含开发工具和JRE
JRE：运行Java程序用的，Java运行时环境，包含类加载器
JVM：java程序真正运行的地方，在不同的操作系统上，需要提供具有相同功能的JVM
JDK的下载和安装
卸载JDK，不卸载的没法安装新的
这两个都要卸载
jdk 目录里面的重要文件
| 目录名称 | 说明 |
|---|---|
| bin | 该路径下存放了 JDK 的各种工具命令 javac 和 java 就放在这个目录 |
常用DOS命令
| 操作 | 说明 |
|---|---|
| 盘符名称: | 盘符切换 E:回车，表示切换到E盘 |
| dir | 查看当前路径下的内容 包括子文件和子文件夹 |
| cd目录 | 进入单级目录 cd itheima |
| cd … | 回退到上—级目录 |
| cd 目录1 目录2 … | 进入多级目录 cd itheimaavaSE |
| cd \ | 回退到盘符目录 |
| cls | 清屏 |
| exit | 退出命令提示符窗口 |
命令提示符窗口中 Ctrl + C 可以结束 死循环
配置Path环境变量
开发 Java 程序，需要使用 JDK 提供的开发工具，而这些工具在 JDK 的安装目录的 bin 目录下
为了在开发 Java 程序的时候，能够方便的使用 java 和 javac 这些命令，需要配置 Path环境变量
-
JAVA_ HOME 新建
？:\ …\jdk-11 -
Path 编辑
%JAVA_HOME%\bin
别忘了移到最上面
Java程序开发运行流程
开发Java程序，需要三个步骤：①编写程序 ②编译程序 ③运行程序
HelloWorld案例的编写
- 新建文本文档文件，修改名称为HelloWorld.java
- 用记事本打开HelloWorld.java文件，编写程序内容
pub1ic c1ass He11oor1d {
pub1ic static void main(String[]args){
System out.println("Heiioworid");
}
)
-
先 javac 编译这个文件
通过编译器编译成字节码文件.class -
再 java 执行文件
在 Window 操作系统中 文件名 不 区分大小写
- 快捷键
按 Tab 自动补齐文件名
运行Java程序时计算机发生的操作
面试时经常考 JVM Java 虚拟机 和 JDK 、 JRE
BUG的解决
- 具备识别BUG的能力
多看，增加知识储备 - 具备分析BUG的能力
多思考，多查阅资料 - 具备解决BUG的能力
多尝试，多总结
基础语法
注释
概述
- 注释是在程序 指定位置 添加的 说明性信息
- 注释 不参与程序运行，仅起到 说明作用
分类
| 注释 | 格式 |
|---|---|
| 单行注释 | // 注释信息 |
| 多行注释 | / * * 注释信息 */ |
| 文档注释 | /** * 注释信息 */ |
文档注释：
- 类,方法,属性的前面
- 可以生成Javadoc
案例
/*
Java程序中最基本的组成单位是 类
类的定义格式：
public class 类名 {
)
*/
// 这是我定义的 Helloworld 类
public class Helloworld {
/*
这是 main 方法
main 方法是程序的入口方法
代码的执行是从main方法开始的
*/
public static void main (String[] args){
System.out.println ("HelloWorld");
}
}
关键字
概述
关键字 就是被 Java语言 赋予了 特定含义 的单词
特点
- 关键字的字母 全部小写
- 常用的代码编辑器，针对关键字有特殊的 颜色标记 ，非常直观
48 个关键字
数据类型: void, byte, short, int, long, float, double, char,boolean
权限修饰符: public, protected, private类型定义: class, interface, enum
类的修饰符: static, abstract, final,
流程控制: if, else, for, while, do, switch, case, default, break,continue, return, try, catch, finally
3 个常量值 true false null
2 个保留字 const goto
标识符
标识符就是给 类 ， 方法 ，变量 等起名字的符号
定义规则
- 由 数字 、 字母 、 下划线（_） 和 美元符($) 组成
- 不能以 数字 开头
- 不能是关键字
- 严格区分 大小写
规范
命名约定
小驼峰命名法：方法、变量
- 标识符 是一个单词的时候，首字母 小写
例如：name - 标识符 由多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写
例如：firstName
大驼峰命名法：类
- 标识符是一个单词的时候，首字母大写
例如：Student - 标识符由多个单词组成的时候，每个单词的首字母大写
例如：GoodStudent
常量
概述
常量 是在程序运行过程中，其值 不发生改变 的量
分类
- 注意
空常量 null
空常量 是不能直接输出的
System.out.println (null); // 报错
数据类型
数据类型，页内跳转
Java语言是 ==强类型语言== ，对于每一种数据都给出了明确的数据类型，不同的 ==数据类型== 也分配了不同的 ==内存空间==，所以它们表示的 ==数据大小== 也是不一样的数据类型内存占用和取值范围
很重要
E+38 表示是乘以10的38次方
E-45 表示乘以10的负45次方
科学计数法
156700
前面的数超过6位会造成精度的丢失 ↓
近似值 产生的 精度误差
所有 浮点数 都有这种情况
弱类型语言和强类型语言
强类型语言 是一种强制类型定义的语言，一旦某一个变量被定义类型，如果不经过强制转换，则它 永远 就是该数据类型了
强类型语言包括 Java 、 Python 、 C++ 等
弱类型语言 是一种弱类型定义的语言，某一个变量被定义类型，该变量可以根据环境变化 自动进行转换 ，不需要经过显性强制转换
弱类型语言有 JavaScript 、PHP 等
变量
概述
变量 是在程序运行过程中，其值可以发生改变的量
从 本质 上讲，变量是 内存 中—小块区域
变量的命名
格式：数据类型变量名 = 变量值
范例：
inta = 10;
// 下面这两种都对
int i, j;
int m = 5, n = 10;
i = j = 10;
// i = ( j = 10 )
int x = y = 10; // 报错，y 没定义
int a, b = a = 10; // 这个是可以的
变量 变 常量
语法：final 数据类型 常量名;
范例：
final f1oat PI = 3.14;
注意
常量 赋值 过了就不能再 赋值了
PI = 3.1415; // 报错
变量的使用
-
取值格式：变量名
例如：a -
修改值格式：变量名 = 变量值;
例如：a = 20;
使用注意事项
- 名字不能重复
- 变量未赋值,不能使用
- 定义 long 类型的变量
long l = 10000000000; // 报错 long l = 10000000000L; // 输出 10000000000 System.out.println(l);
整数 默认的是 int 类型
long类型的变量定义的时候，为了防止整数过大，后面要加 （ L ）
- 定义float类型的变量
float f = 13.14; // 报错
float f = 13.14F; // 13.14
system.out.println(f) ;
浮点数 默认的是 double 类型
float 类型的变量定义的时候，为了防止类型不兼容，后面要加 （F）
类型转换
数据类型类型转换 分为 自动类型转换 和 强制类型转换
boolean 不能与其它类型进行转换
自动（隐式）类型转换
把一个表示 数据范围小 的 数值 或者 变量 赋值给另一个表示 数据范围大 的变量
例如：
doubled = 10;
转换顺序
byte => short => int => long => float =>double
short s = 'a'; // 好像是 char 自动转换成short类型
char c = 'a';
s = c; // 报错，说明 char 是不能自动转换成short类型的
其实是 s 的数据类型 是 int
案例：
正确
double d = l0 ; // int → double
system.out.println (d) ; // 输出 10.0
// 定义byte类型的变量
byte b = 10 ;
short s = b ; // byte → short
int i = b ; // byte → int
char c = b ; // 报错 byte → char 无法转换
自动转换的坑
强制类型转换
把一个表示 数据范围大 的 数值 或者 变量 赋值给另一个表示 数据范围小 的 变量
格式：目标数据类型 变量名 = (目标数据类型)值 或者 变量;
这个 值 或者 变量 的 数据范围 一定要比 目标数据类型 的数据范围要大
注意： 数据可能会丢失 / 数据溢出
long l = 2200000000L;
Float f1 = 1.5f;
byte b1 = 10;
char c1 = (char)b1;
System.out.println(c1);
short s1 = 128;
//十进制如何转换成二
byte b2 = (byte)s1; // -128
System.out.println(compare(1,2));
compare(1,2) // int
compare((byte)1,(byte)2) // byte
compare((short)1,(short)2) // short
compare(1L,2L) // long
特殊情况：
int k = (int)88.88; // 88.88 是浮点数
System.out.println(k); // 88
- 由上面的案例可见 强制类型转换 可以做，但有数据的 丢失，不建议做
作用域
位置很重要
运算符
面试题
当遇到复杂的运算时可以加 括号 括起来
int a = 1;
int b = 1;
--a++; // 报错
a +++ b; // a++ + b
a ++++ b; // 报错
a ++-++ b; // a++ - ++b
// 中间的 +- 可以放无限个
a ++-+-+-+-++ b;
// (a++) - (+ - + - + - (++b))
// 1 - (- - - 2) = 3
运算符 和 表达式
- 运算符：对 常量 或者 变量 进行操作的 符号
- 表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式
不同 运算符 连接的 表达式 体现的是不同类型的 表达式
- 案例
int a = 10;
int b = 20;
int c = a + b;
+：是 运算符 ，并且是 算术运算符
a + b：是 表达式 ，由于+是 算术运算符，所以这个表达式叫 算术表达式
算术运算符
算术运算符 和 数据类型 的 坑
数据类型
在运算时 低 数据类型向 高 数据类型
1.在运算中, char、byte 和 short 类型，会自动转换成 int计算
short s1 = b1 +10; // 报错，s1 是 int类型
byte b1 = 10;
byte b2 = 20;
short s1 = b1; // 不报错，s1 没进行运算，所以是 short型
short s2 = b1 + b2; // 报错，s2 是 int类型
2.当表达式中，是两个常量值运算，在编译时将两个值直接运算
short s4 = 'a' + 'b'; // √
// 97 + 98 = 195
// short s4 = 195 符合语法
char c1 = 'a';
char c2 = 'b';
short s5 = c1 + c2; // 报错
整数 相除 （ % ） 只能得到 整数 ，要想得到 小数 ，必须有 浮点数 的参与
System.out.println (6 / 4); // 1
System.out.println (6.0 / 4); // 1.5
System.out.println( 10.5 % 3.3 );
// 10.5/ 3.3 = 3 ..... 0.6
// 实际上为 0.6000000000000005
// 被转换成 double
System.out.println(-11 % 3); // -2
System.out.println(11 % -3); // 2
System.out.println(-11 % -3); // -2
数据类型 不同
算术表达式 中包含多个 基本数据类型 的值的时候，整个 算术表达式 的类型会自动进行提升
提升规则
- byte类型，short类型和char类型将被提升到 int 类型
- 整个表达式的类型自动提升到 表达式 中 最高等级 操作数 同样的类型 等级顺序 ↓
byte,short,char → int → long → float → double
案例
//定义两个变量
int i = 10;
char c ='A'; // 'A'的值是65
char ch= i + c; // 报错 char 类型会被自动提升为 int 类型
int j = i + c;
System.out.println(i) ; // 75
int k = 10 + 13.14; // 报错
double d = l0 + 13.l4; // √
字符串的“+”操作
- 当“+”操作中出现 字符串 时，这个”+”是 字符串连接符 ，而不是 算术运算
“abc"+ 123 // abc123 - 在”+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“+”操作时，从左到右逐个执行
“abc"+ 12 + 3 // abc123 1 + 2 +"abc” // 3abc
复合运算符
+= 注意事项
( + - * / % ) = 的操作隐含了 强制类型转换
short s = 10;
1
s += 20; // 30 建议这样写
2
s = s + 20; // 类型不匹配：不能从 int 转换为 short
3
s = (short)(s + 20); // 强转 为 short 类型
System.out.println(s);
自增自减运算符
++ –
位置很关键
- 单独使用的时候，++和–无论是放在变量的前边还是后边，结果是一样的
- 参与运算，如果放在变量的 后边，先拿变量参与运算，后拿变量做++或者–
- 参与运算，如果放在变量的 前边，先拿变量做++或者–，后拿变量参与运算
案例
1
int a = 10;
int b = a++; // 先把 a 赋值给 b，然后 a 再 ++
System.out.println(a); // 11
System.out.println(b); // 10
2
int b = ++a; // 11
关系运算符
值一定为 布尔类型(boolean) true false
逻辑运算符
// ^ 相同为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
! 可以放多个，就是取反取反再取反
短路逻辑运算符
| 逻辑与 & | 短路与 && |
|---|---|
| 无论左边真假，右边都要执行 | 如果左边为真，右边执行 如果左边为假，右边不执行 |
| 逻辑或 l | 短路或 ll |
|---|---|
| 无论左边真假，右边都要执行 | 如果左边为假，右边执行 如果左边为真，右边不执行 |
位运算符
面试题
如何以最快的速度实现 num * 2^n
-用左移位
二进制：
0 000000
-1 111111
-2 111110
-3 111101
负数的二进制等于正数的二进制 取反 +1
三元运算符
| 格式 | 范例 |
|---|---|
| 关系表达式 ? 表达式1 : 表达式2; | a > b ? a : b |
- 首先计算关系表达式的值
- 如果值为 true ，表达式1 的值就是运算结果
如果值为 false，表达式2 的值就是运算结果
//获取两个数据中的较大值
int max = a > b ? a : b; // 别忘了在最前面 定义 数据类型（int）
三元运算符是 从右向左 的
运算符的结合性
面试题
输出 System
输入 Scanner
在按下回车以后会被扫描到信息
使用步骤
-
导包：引入 Scanner 类
import java.uti1.Scanner ;导包 的动作必须出现在 类定义 （ public class ） 的上面
-
定义(创建)对象
Scanner sc = new Scanner (System.in);上面这个格式里面，sc 是 变量名
-
接收数据
sc.nextXxx(); Xxx 数据类型//姓名 string name; System.out.println("请输入您的姓名:"); name = sc.next(); // 返回字符串的输入 //年龄 int age; System.out.println("请输入您的年龄:"); age = sc.nextInt(); //性别 System.out.println("请输入您的性别:"); String sex = sc.next(); // next方法没有 char 类型 //电话号码 System.out.println("请输入您的手机号:"); String phone = sc.next(;
补全 快捷键 Ctrl + Alt + V
sc.nextInt();
next() 和 nextLine()
Scanner类 中的方法 next() 和 nextLine() 都是吸取输入台输入的字符
区别：
next() 不会吸取字符前/后的空格/Tab键，只吸取字符，开始吸取字符（字符前后不算）直到遇到空格/Tab键/回车截止吸取
nextLine() 吸取字符前后的空格/Tab键，回车键截止
详解
分支语句
流程控制语句分类：
- 顺序结构：按照代码的先后顺序依欠执行
- 分支结构( if 、switch )
- 循环结构( for 、while 、do…while )
if
执行流程
- 首先计算关系表达式1的值
- 值为 true 就执行语句体1，值为 false 就计算关系表达式2的值
- 如果没有任何关系表达式为 true ，就执行语句体n+1
switch
- case：后面跟的是要和 表达式 进行比较的值
- default：表示所有情况 都不匹配 的时候，就执行该处的内容
case穿透
在switch语句中，如果case控制的语句体后面不写break，将出现 穿透 现象，在不判断下一个case值的情况下，向下运行，直到遇到 break ，或者整体 switch 语句结束
switch (month) {
case l:
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 ll:
System.out.println("秋季");
break;
default:
System.out.println("你输入的月份有误");
}
循环语句
| 语句 | 说明 |
|---|---|
| 初始化语句 | 用于表示循环开启时的起始状态 即循环开始的时候什么样 |
| 条件判断语句 | 用于表示循环反复执行的条件 即判断循环是否能一直执行下去 |
| 循环体语句 | 用于表示循环反复执行的内容 即循环反复执行的事情 |
| 条件控制语句 | 用于表示循环执行中每次变化的内容 即控制循环是否能执行下去 ++ – |
表格的从上往下的顺序也是 循环 执行的顺序，初始化语句 只执行一次
for
多个初始化变量，实在不行可以放到上面啊
for (int start = 0,end = 5;...;...)
变量 的 作用域
-
for 条件控制语句 所控制的 自增变量
因为归属 for 循环的语法结构中，在 for 循环结束后，就不能再次被访问到了 -
while 条件控制语句 所控制的 自增变量
对于 while 循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用for(int i = l; i<3; i++){ System.out.println ("abc") ; } System.out.println(i) ; // 报错
水仙花数
int a;
int b;
int c;
int j = 0;
for (int i = 100;i < 1000; i++) {
a = i / 100;
b = i / 10 % 10;
c = i % 10;
if (i == a * a * a + b * b * b + c * c * c) {
j++;
System.out.println(i);
}
}
System.out.println(j);
j = 0;
兔生兔
有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少?
while
珠穆朗玛峰 & 折纸
珠穆朗玛峰：8844430毫米 ，纸：0.1毫米 ，折叠多少次
int a = 8844430;
double b = 0.1;
int i = 0;
while (b < a) {
b *= 2;
i++;
}
System.out.println(i + "次"); // 27
do…while
因为先 执行 后 判断 ，所以无论如何都会 执行 一次
int k = 3;
do {
System.out.println("abc"); // 输出一次 abc
k++;
}while (k<3) ;
跳转控制语句
continue 和 break JavaScript 里的使用
Java 中的 exit
System.exit(0);
0 表示正常程序的关闭，非0表示异常关闭，也可放在循环体里面，和 break 差不多
产生一个随机数 Random
使用步骤 与 Scanner 相同
-
导包
import java.util.Random;导包 的动作必须出现在 类定义 （ public class ） 的上面
-
创建对象
Random r = new Random();r 是 变量名，可以改变，其他的都不能改变
-
获取随机数
int a = r.nextInt(10); // 获取数据的范围：[0,10) 包括 0 不包括 10a 是 变量名 和 取值范围 的 10 都可以 改变，其他的都不能改变
获取 1 - 100 之间的 随机数
方案： [0,100) → [1,101)
int a = r.nextInt(100) + 1;
IDEA 和 eclipse
IDEA
是用于Java语言开发的 集成环境
集成环境：把代码 编写 、 编译 、 执行 、 调试 等多种功能综合到一起的 开发工具
eclipse
编码格式：
快捷键
ctrl + + 放大
ctrl + - 缩小
HelloWorld
可分为两大部分
第一部分
- 创建一个 项目 ( Project0109 )
- 创建一个 模块 ( idea_test )
第二部分
- 在 模块 下的 src 下创建一个 包 ( com.practice )
不能叫 com.package ，无法创建 - 在 包 下新建一个 类 ( HelloWorld )
- 在 类 中编写代码
- 执行程序
-
注意
写内容之前别忘了先 声明main方法声明 定义 没有分配 内存 分配了 内存 声明 和 定义 的区别
与 .java 文件相对应的 .class 文件在另外的位置
项目结构
模块 → 包 → 类 → 方法
内容辅助键
- 快速生成
效果 按键 快速生成main()方法 psvm + 回车 快速生成输出语句 sout + 回车 - 内容辅助键
效果 按键 内容提示，代码补全等 Alt + /
快捷键
| 效果 | 按键 |
|---|---|
| 单行注释 | Ctrl + / |
| 多行注释 | Ctrl + Shift + / |
| 格式化代码 | Ctrl+Alt+L |
IDEA 中 模块操作
1. 新建模块
2. 删除模块
| 效果 | 操作 |
|---|---|
| 在 程序 中 移除 | 在对应 模块 右键 点 Remove Module |
| 在 文件 中 完全 删除 | Show in Explorer 打开文件删除 ↓ |
3. 导入模块 重点
把别处的 模块 导入 项目 中
报错的话 安装SDK 就行
数组
数组(array)：一种用于存储 多个相同类型 数据的 存储模型
目的：一次性 声明 大量的用于存储数据的 变量
例如：学号、成绩
定义格式
| 第一种 | 第二种 | |
|---|---|---|
| 格式 | 数据类型[] 变量名 | 数据类型 变量名[] |
| 范例 | int[ ] arr | int arr[ ] |
| 读法 | 定义了一个 int类型 的数组 数组名 是 arr |
定义了一个 int类型 的变量 变量名 是 arr数组 |
推荐使用第一种
数组初始化
Java 中的 数组 必须先 初始化 ，然后才能使用
初始化：为 数组 中的数组元素 分配内存空间 ，并为每个 数组元素 赋值
数组初始化方式：动态初始化、静态初始化
| 动态初始化 | 静态初始化 | |
|---|---|---|
| 效果 | 初始化 时只指定 数组长度 由 系统 为数组分配 初始值 |
初始化 时指定每个数组元素的初始值 由 系统 决定 数组长度 |
| 格式 | 数据类型[] 变量名= new 数据类型[数组长度]; | 数据类型[] 变量名 = new 数据类型[]{数据1,数据2,…}; 简化格式：数据类型[] 变量名 = {数据1,数据2,…}; |
| 规范 | int[ ] arr = new int[3]; | int[ ] arr = new int[ ]{1,2,3}; int[ ]arr = { 1，2,3}; |
结构说明
int[] arr = new int[3];
- 左边:
关键词 说明 int 说明数组中的元素类型是int类型 [ ] 说明这是一个数组 arr 数组的名称 - 右边:
关键词 说明 new 为数组申请内存空间 int 说明数组中的元素类型是int类型 [ ] 说明这是一个数组 3 数组长度，即数组中的元素个数
数组元素访问
| 访问 | 格式 |
|---|---|
| 数组变量访问 | 数组名 |
| 数组内部保存的数据的访问 | 数组名[索引] |
索引：数组 中数据的编号方式
作用：索引 用于访问 数组 中的数据使用，数组名[索引] 等同于 变量名 ，是一种特殊的 变量名
注意：在实际开发中，如果对应的索引不存在，一般都是返回一个负数，通常用 -1 来表示
内存分配
| 空间名 | 作用 | 使用完毕 |
|---|---|---|
| 栈内存 | 存储 局部变量 即定义在方法中的变量，例如: arr |
立即消失 |
| 堆内存 | 存储new出来的内容(实体、对象) 每一个new出来的东西都有一个地址值，例如：001 |
会在垃圾回收器空闲时被回收 |
默认值
数组在 初始化 时，会为 存储空间 添加 默认值
| 数据类型 | 默认值 |
|---|---|
| 整数 | 0 |
| 浮点数 | 0.0 |
| 布尔值 boolean | false |
| 字符 char | 空字符 |
| 引用数据类型 | null |
多个 数组 指向 相同
把第一个数组的 地址 赋值给第二个数组
int[] arr2 = arr; // 两数组 地址 将相同
输出 ↓
数组总结
Debug
Debug调试，又被称为断点调试，是供程序员使用的 程序调试工具
断点 其实是一个标记，告诉我们从哪里开始查看
Debug的功能：
- 查看 程序的执行流程
- 追踪程序执行过程来 调试 程序
Debug 操作流程
-
如何加断点
-
如何运行加了断点的程序
-
看哪里
- 看 Debugger 窗口
- 看 控制台
- 看 Debugger 窗口
-
点哪里
-
继续运行
注意： 如果数据来自于键盘输入，一定要记住输入数据，不然就不能继续往下查看了
-
结束
-
-
如何删除断点
有多个断点，可以一个个的点，也可以一次性全部删除
方法
方法(method)：是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的 代码集
方法可以提高代码的 复用性
方法定义
方法必须先创建才可以使用，该过程称为 方法定义
格式：
public static void 方法名(){
//方法体
}
范例：
public static void method() {
//方法体
}
我可能正是个傻逼才会在main方法里写别的方法吧
方法调用
方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为 方法调用
格式：
方法名();
范例：
method();
public static void main(String[] args) {
method(); // 1
}
public static void method() {
int a = 1;
if (a > 0) {
System.out.println(a);
}
}
注意事项
- 方法调用 的语句要写在 main方法 里，因为 main方法 程序的 入口方法
- 方法必须先 定义 后 调用，否则程序将报错，但是千万别忘了最后要 调用
不过程序是先执行 方法调用 的语句，再执行 方法定义 的语句
带 参数 的方法
定义方法
| 单个参数 | 多个参数 | |
|---|---|---|
| 格式 | public static void 方法名(数据类型 变量名) {…} | public static void方法名(数据类型 变量名1,…) {…} |
| 规范 | public static void method(int number) {…} | public static void getMax(int a,int b,…) {…} |
调用方法
| 单个参数 | 多个参数 | |
|---|---|---|
| 格式 | 方法名(参数); | 方法名(变量名1/常量值1,变量名2/常量值2); |
| 规范 | method(3); | getMax (a,5,…) ; |
- 方法调用时，参数 的 数量 与 类型 必须与方法定义中的设置相匹配，否则程序将报错
案例
基本数据类型
public static void main(String[] args) {
int a = 2;
// 这里不用写 数据类型
method(a); // 2
}
// 这里的 int b 和上面没有关系，写 int a 也一样
// 注意，这不是 JavaScript ，别忘了你的数据类型，int！
public static void method(int a) {
if (a > 0) {
System.out.println(a);
}
}
数组
public static void main(String[]args) {
// 定义一个数组，用静态初始化完成数组元素初始化
int[] arr = {1,2,3};
// 调用方法
printArray(arr);
}
// 定义一个方法，用数组遍历通用格式对数组进行遍历/*
/*
两个明确:
返回值类型: void
参数: int[] arr
*/
public static void printArray(int[] arr) {
for(int x = 0;x<arr.length;x++) {
System.out.println(arr[x]);
}
}
形参 和 实参
带 返回值 的方法
格式：
public static 数据类型 方法名(参数){
return 数据;
}
范例：
// boolean
public static boolean method(int number){
return true;
}
// int
public static int getMax(int a,int b) {
return 100;
}
注意事项
- 方法的 返回值 通常会使用 变量 接收，否则该返回值将无意义
- void表示无返回值，可以省略return，也可以单独的书写return，后面不加据
案例：
public static void main(String[] args) {
int a = 2;
boolean b = method(a);
System.out.println(b);
}
public static boolean method(int a) {
if (a > 0) {
return true;
} else {
return false;
}
}
方法的 通用格式
格式：
public static 返回值类型 方法名(参数){
方法体;
return 数据;
}
| 关键词 | 说明 |
|---|---|
| public static | 修饰符 |
| 返回值类型 | 方法操作完毕之后返回的数据的数据类型 如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写 return |
| 方法名 | 调用方法时候使用的标识 |
| 参数 | 由数据类型和变量名组成，多个参数之间用逗号隔开 |
| 方法体 | 完成功能的代码块 |
| return | 如果方法操作完毕，有数据返回，用于把数据返回给调用者 |
注意事项
定义方法 时，要做到两个明确
- 明确 返回值类型
主要是明确方法操作完毕之后是否有数据返回- 没有，写 void
- 有，写对应的 数据类型
- 明确 参数
主要是明确参数的 类型 和 数量
调用方法时
- void类型 的方法，直接调用 即可
- 非void类型 的方法，用 变量 接收调用
方法重载
方法重载：同一个类中定义的多个方法之间的关系，满足
① 多个方法在 相同的类 中
② 多个方法具有 相同的方法名
③ 多个方法的 参数 不相同， 类型 不同或者 数量 不同，这三点有不相同的就行
的多个方法相互构成重载
方法重载特点
- 重载 仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
- 重载仅针对同一个类中方法的 名称 与 参数 进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载
| 参数 int a 相同 与返回值无关 |
参数个数不同 |
| 参数类型相同 | MethodDemo01 和 MethodDemo02 是两个类 |
案例：
在调用的时候，Java虚拟机 会通过 参数的不同 来区分 同名的方法
public static void main(String[] args) {
//调用方法
int result = sum(1,2);
System.out. println(result); // 3
double result2 = sum(1.0,2.0);
System.out.println(result2); // 3.0
int result3 = sum(1,2,3);
System.out.println(result3); // 6
}
//需求1:求 两个 int类型数据 和的方法
public static int sum(int a,int b) {
return a + b;
}
// 需求2:求 两个 double类型数据 和的方法
public static double sum(double a,double b) {
return a + b;
}
// 需求3:求 三个 int类型数据 和的方法
public static int sum(int a,int b,int c) {
return a + b + c;
}
方法参数传递
基本类型
对于 基本数据类型 的参数， 形参 的改变，不影响 实参 的值
引用类型
对于 引用类型 的参数，形参 的改变，影响 实参 的值
杂物堆
报错
语法错误 显示 红色波浪线
导包
有三种方式导包
- 手动导包
Scanner示例 - 快捷键导包 Alt + Enter
- 自动导包 （推荐使用）