后续内容在《Java SE基础学习笔记2》，还没写完
内容有点乱，可能还有错误，会经常修改的
推荐黑马的Java教程B站链接

文章目录

• Java
• • 特点
  • Java语言跨平台原理
  • JRE 和 JDK
  • JDK的下载和安装
  • 常用DOS命令
  • 配置Path环境变量
  • Java程序开发运行流程
  • • HelloWorld案例的编写
    • 运行Java程序时计算机发生的操作
  • BUG的解决
• 基础语法
• • 注释
  • 关键字
  • 标识符
  • • 定义规则
    • 规范
    • 命名约定
    • • 小驼峰命名法：方法、变量
      • 大驼峰命名法：类
  • 常量
  • 数据类型
  • • 数据类型内存占用和取值范围
    • 弱类型语言和强类型语言
  • 变量
  • • 变量的命名
    • • 变量 变 常量
    • 变量的使用
  • 类型转换
  • • 自动（隐式）类型转换
    • • 自动转换的坑
    • 强制类型转换
  • 作用域
• 运算符
• • 面试题
  • 运算符 和 表达式
  • 算术运算符
  • • 算术运算符 和 数据类型 的 坑
    • 数据类型 不同
    • • 提升规则
  • 复合运算符
  • 自增自减运算符
  • 关系运算符
  • 逻辑运算符
  • • 短路逻辑运算符
  • 位运算符
  • • 面试题
  • 三元运算符
  • 运算符的结合性
• 输出 System
• 输入 Scanner
• • next() 和 nextLine()
• 分支语句
• • if
  • switch
  • • case穿透
• 循环语句
• • for
  • • 变量 的 作用域
    • 水仙花数
    • 兔生兔
  • while
  • • 珠穆朗玛峰 & 折纸
  • do...while
  • 跳转控制语句
• 产生一个随机数 Random
• IDEA 和 eclipse
• • IDEA
  • eclipse
  • HelloWorld
  • 项目结构
  • 内容辅助键
  • 快捷键
  • IDEA 中 模块操作
• 数组
• • 定义格式
  • 数组初始化
  • • 结构说明
  • 数组元素访问
  • 内存分配
  • • 默认值
    • 多个 数组 指向 相同
  • 数组总结
• Debug
• • Debug 操作流程
• 方法
• • 方法定义
  • 方法调用
  • • 注意事项
  • 带 参数 的方法
  • • 定义方法
    • 调用方法
    • 案例
    • 形参 和 实参
  • 带 返回值 的方法
  • 方法的 通用格式
  • 方法重载
  • • 方法重载特点
  • 方法参数传递
  • • 基本类型
    • 引用类型
• 杂物堆
• • 报错
  • 导包

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环境变量

1. JAVA_ HOME 新建
   ？:\ …\jdk-11

2. Path 编辑
   %JAVA_HOME%\bin
   别忘了移到最上面

Java程序开发运行流程

开发Java程序，需要三个步骤：①编写程序 ②编译程序 ③运行程序

HelloWorld案例的编写

1. 新建文本文档文件，修改名称为HelloWorld.java
2. 用记事本打开HelloWorld.java文件，编写程序内容

pub1ic c1ass He11oor1d {
	pub1ic static void main(String[]args){
		System out.println("Heiioworid");
	}
)

3. 先 javac 编译这个文件
   通过编译器编译成字节码文件.class

4. 再 java 执行文件
   
   在 Window 操作系统中 文件名 不 区分大小写

• 快捷键
  按 Tab 自动补齐文件名
  

运行Java程序时计算机发生的操作

面试时经常考 JVM Java 虚拟机 和 JDK 、 JRE

BUG的解决

1. 具备识别BUG的能力
   多看，增加知识储备
2. 具备分析BUG的能力
   多思考，多查阅资料
3. 具备解决BUG的能力
   多尝试，多总结

基础语法

注释

概述

1. 注释是在程序 指定位置 添加的 说明性信息
2. 注释 不参与程序运行，仅起到 说明作用

分类

注释	格式
单行注释	// 注释信息
多行注释	/ * * 注释信息 */
文档注释	/** * 注释信息 */

文档注释：

1. 类,方法,属性的前面
2. 可以生成Javadoc
   

案例

/* 
	Java程序中最基本的组成单位是 类
	
	类的定义格式：
		public class 类名 {
		)
*/

// 这是我定义的 Helloworld 类
public class Helloworld {

	/* 
		这是 main 方法
		main 方法是程序的入口方法
		代码的执行是从main方法开始的
	*/

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

关键字

概述
关键字 就是被 Java语言 赋予了 特定含义 的单词
特点

1. 关键字的字母 全部小写
2. 常用的代码编辑器，针对关键字有特殊的 颜色标记 ，非常直观
   

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

标识符

标识符就是给 类 ， 方法 ，变量 等起名字的符号

定义规则

1. 由 数字 、 字母 、 下划线（_） 和 美元符($) 组成
2. 不能以 数字 开头
3. 不能是 关键字
4. 严格区分 大小写

规范

命名约定

小驼峰命名法：方法、变量

1. 标识符 是一个单词的时候，首字母 小写
   例如：name
2. 标识符 由多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写
   例如：firstName

大驼峰命名法：类

1. 标识符是一个单词的时候，首字母大写
   例如：Student
2. 标识符由多个单词组成的时候，每个单词的首字母大写
   例如：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;	// 报错

变量的使用

1. 取值格式：变量名
   例如：

   a
   

2. 修改值格式：变量名 = 变量值;
   例如：

   a = 20;
   

使用注意事项

1. 名字不能重复
2. 变量未赋值,不能使用
3. 定义 long 类型的变量

   long l = 10000000000;		// 报错
   long l = 10000000000L;		// 输出 10000000000
   
   System.out.println(l);
   

整数 默认的是 int 类型
long类型的变量定义的时候，为了防止整数过大，后面要加 （ L ）

默认值

4. 定义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

数据类型 不同

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

提升规则

1. byte类型，short类型和char类型将被提升到 int 类型
2. 整个表达式的类型自动提升到 表达式 中 最高等级 操作数 同样的类型 等级顺序 ↓
   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;	// √

字符串的“+”操作

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

   “abc"+ 123			// abc123
   

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

   “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. 单独使用的时候，++和–无论是放在变量的前边还是后边，结果是一样的
2. 参与运算，如果放在变量的 后边，先拿变量参与运算，后拿变量做++或者–
3. 参与运算，如果放在变量的 前边，先拿变量做++或者–，后拿变量参与运算

案例

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

1. 首先计算关系表达式的值
2. 如果值为 true ，表达式1 的值就是运算结果
   如果值为 false，表达式2 的值就是运算结果

//获取两个数据中的较大值
int max = a > b ? a : b;	// 别忘了在最前面 定义 数据类型（int）

三元运算符是 从右向左 的

运算符的结合性

面试题

输出 System

输入 Scanner

在按下回车以后会被扫描到信息

使用步骤

1. 导包：引入 Scanner 类

   import java.uti1.Scanner ;
   

   导包 的动作必须出现在 类定义 （ public class ） 的上面

2. 定义(创建)对象

   Scanner sc = new Scanner (System.in);
   

   上面这个格式里面，sc 是 变量名

3. 接收数据
   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键，回车键截止
详解

分支语句

流程控制语句分类：

1. 顺序结构：按照代码的先后顺序依欠执行
2. 分支结构( if 、switch )
3. 循环结构( for 、while 、do…while )

if

执行流程

1. 首先计算关系表达式1的值
2. 值为 true 就执行语句体1，值为 false 就计算关系表达式2的值
3. 如果没有任何关系表达式为 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;...;...)

变量 的 作用域

1. for 条件控制语句 所控制的 自增变量
   因为归属 for 循环的语法结构中，在 for 循环结束后，就不能再次被访问到了

2. 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 相同

1. 导包

   import java.util.Random;
   

   导包 的动作必须出现在 类定义 （ public class ） 的上面

2. 创建对象

   Random r = new Random();
   

   r 是 变量名，可以改变，其他的都不能改变

3. 获取随机数

   int a = r.nextInt(10);
   // 获取数据的范围：[0,10) 包括 0 不包括 10
   

   a 是 变量名 和 取值范围 的 10 都可以 改变，其他的都不能改变

获取 1 - 100 之间的 随机数

方案： [0,100) → [1,101)

int a = r.nextInt(100) + 1;

IDEA 和 eclipse

IDEA

是用于Java语言开发的 集成环境
集成环境：把代码 编写 、 编译 、 执行 、 调试 等多种功能综合到一起的 开发工具

傻瓜安装

30天试用无限刷新

eclipse

傻瓜 汉化 和 英化

创建项目 的基本操作

编码格式：

快捷键
ctrl + + 放大
ctrl + - 缩小

HelloWorld

可分为两大部分
第一部分

1. 创建一个 项目 ( Project0109 )
2. 创建一个 模块 ( idea_test )

第二部分

3. 在 模块 下的 src 下创建一个 包 ( com.practice )
   不能叫 com.package ，无法创建
4. 在 包 下新建一个 类 ( HelloWorld )
5. 在 类 中编写代码
6. 执行程序

视频教程

• 注意
  写内容之前别忘了先 声明 main方法

  声明	定义
  没有分配 内存	分配了 内存

  声明 和 定义 的区别
  与 .java 文件相对应的 .class 文件在另外的位置

项目结构

模块 → 包 → 类 → 方法

内容辅助键

1. 快速生成

   效果	按键
   快速生成main()方法	psvm + 回车
   快速生成输出语句	sout + 回车

2. 内容辅助键

   效果	按键
   内容提示，代码补全等	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	会在垃圾回收器空闲时被回收

视频
javaScript 中的内存分配

默认值

数组在 初始化 时，会为 存储空间 添加 默认值

数据类型	默认值
整数	0
浮点数	0.0
布尔值 boolean	false
字符 char	空字符
引用数据类型	null

多个 数组 指向 相同

把第一个数组的 地址 赋值给第二个数组

int[] arr2 = arr;		// 两数组 地址 将相同

输出 ↓

数组总结

Debug

Debug调试，又被称为断点调试，是供程序员使用的 程序调试工具
断点 其实是一个标记，告诉我们从哪里开始查看

Debug的功能：

1. 查看 程序的执行流程
2. 追踪程序执行过程来 调试 程序

Debug 操作流程

1. 如何加断点
   

2. 如何运行加了断点的程序
   

3. 看哪里

   1. 看 Debugger 窗口
      
   2. 看 控制台
      

4. 点哪里

   1. 继续运行
      

      注意： 如果数据来自于键盘输入，一定要记住输入数据，不然就不能继续往下查看了

   2. 结束

5. 如何删除断点
   有多个断点，可以一个个的点，也可以一次性全部删除
   

方法

方法(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);
	}
}

注意事项

1. 方法调用 的语句要写在 main方法 里，因为 main方法 程序的 入口方法
2. 方法必须先 定义 后 调用，否则程序将报错，但是千万别忘了最后要 调用
   不过程序是先执行 方法调用 的语句，再执行 方法定义 的语句

带 参数 的方法

定义方法

	单个参数	多个参数
格式	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;
}

注意事项

1. 方法的 返回值 通常会使用 变量 接收，否则该返回值将无意义
2. 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	如果方法操作完毕，有数据返回，用于把数据返回给调用者

注意事项

定义方法 时，要做到两个明确

1. 明确 返回值类型
   主要是明确方法操作完毕之后是否有数据返回
   1. 没有，写 void
   2. 有，写对应的 数据类型
2. 明确 参数
   主要是明确参数的 类型 和 数量

调用方法时

1. void类型 的方法，直接调用 即可
2. 非void类型 的方法，用 变量 接收调用

方法重载

方法重载：同一个类中定义的多个方法之间的关系，满足

① 多个方法在 相同的类 中
② 多个方法具有 相同的方法名
③ 多个方法的 参数 不相同， 类型 不同或者 数量 不同，这三点有不相同的就行

的多个方法相互构成重载

方法重载特点

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

参数 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;
}

方法参数传递

基本类型

对于 基本数据类型 的参数， 形参 的改变，不影响 实参 的值

引用类型

对于 引用类型 的参数，形参 的改变，影响 实参 的值

杂物堆

报错

语法错误 显示 红色波浪线

导包

有三种方式导包

1. 手动导包
   Scanner示例
2. 快捷键导包 Alt + Enter
   
3. 自动导包 （推荐使用）