这是一篇技术贴。。。
唔.......
我是菜鸟，没啥技术
所以。。。。
班主任女神说的----->
我就把自己搞的笔记传一下咯
================华丽的分割线==============================


类名、方法名----大驼峰、小驼峰
字符类型
int short byte char
double float
long
boolean

类型自动转换
小-->大
类型强制转换
大-->小
强制转换，数据过大会造成数据溢出或精度丢失
ASCII码表
48---0
65---A
97---a

算术运算
+ - * / %...
++ --
赋值 =
比较 >  <  =  <=  >= !=
逻辑 &&  ||  ！
三元运算 a == b ? a : b

顺序结构：
System.out.println(1);
System.out.println(2);
System.out.println(3);

选择结构：
单if
int a = 2;
if(a >= 2){
System.out.println(...);
}
标准 if-else
if(a > 2){
System.out.println(...1);
}else{
System.out.println(...2);
}
扩展 if-else
if(a > 2){
System.out.println(...1);
}else if(a < 2){
System.out.println(...2);
}else{
System.out.println(...3);
}

标准 switch  
int a = 1;//给a赋值什么，就从哪个case开始执行，遇到break停止。
switch(a){//小括号中只能是int、shrot、byte、char,或者是引用类型的string、enum枚举
case 1://每一个case不可以重复
System.out.println(...a);
break;
case 2://case没有顺序要求，可以颠倒
System.out.println(...b);
break;
.
.
.
default:
System.out.println(...收尾)；
break: //这一行可以省略，但最好保留。
}

穿透 switch
int a = 1;  //没有遇到break，会直接继续执行下一个case，不会停止，直到遇到break。
switch(a){
case 1:
System.out.println(...1);
case 2:
System.out.println(...2);
case 3:
System.out.println(...3);
break
}

循环
for 循环
for(初始表达式 1 ;循环条件 2 ;步进表达式 4 ){
循环体 3
}
// 1 仅执行一次
执行流程： 1.2.3.4 --> 2.3.4循环 --> 当 2 不再满足时，停止
while 循环
初始化表达式 1
while(循环条件 2 ){
循环体 3
步进表达式 4
}
执行流程：同上： 初始、条件、循环、步进，当不满足循环条件时，循环停止

do while 循环
初始表达式 1
do {
循环体 3
步进表达式 4
}while(循环条件 2)；
执行流程： 1.3.4 --> 2.3.4 -->  当 2 不再满足时，停止
通俗的讲，先执行一次程序，然后进入循环，当布不再满足循环条件时，跳出循环。

continue
结束本次循环，进入下一次的循环
例如：
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
//需求:不打印第三次HelloWorld
if(i == 3){
continue;
}
System.out.println("HelloWorld"+i);
}
}

死循环
永远不会结束的循环，条件永远为 true
例如： while(true){}


嵌套循环
for(初始化表达式 1 ;循环条件 2 ;步进表达式 7){
for(初始 3 ;条件 4 ;步进 6){
  循环体 5 ;
}
}
执行流程： 1.2.3.4.5.6 --> 4.5.6 --> 当 4 不满足时 进入 7.2 --> 然后继续 3.4.5.6
直到条件不再满足 2  , 则不再进入内循环
通俗的讲，外循环一次，内循环多次，当外循环的的循环条件不再满足，整个循环结束。


方法
主方法： public static void main(){
方法名(参数类型 参数名,...);
//上面这玩意就是下面那个方法写的作业，把这玩意放过来的行为叫做调用。
}
定义方法
修饰符 返回值类型 方法名(参数类型 参数名,...){
方法体
return 返回值;  
}
// 现阶段，修饰符就是 public static
// 返回值类型  方法最终的数据是什么类型，这里就写什么类型
// 方法名用小驼峰
// 参数类型 进入方法的数据的类型
// 参数名 进入方法的数据对应的名字
// 方法体 想让这个方法干嘛，就在这里敲上相应的代码
// return 告诉这个方法下班了，然后把这个方法工作时写的作业交给调用他的老板
// 返回值 这玩意就是方法要交的作业

方法的三种调用格式：
单独
打印
赋值
单独调用：方法名(参数);
//这个东西很鸡贼，悄咪咪自己玩不让人看见
打印调用：System.out.println(方法名(参数));
//这玩意简单来说就是让悄咪咪被执行了调用的方法可以被看见
赋值调用：数据类型 变量名 = 方法名(参数);
//先悄咪咪调用，然后把版权卖给某个变量，相当于重新包装一下再卖出去露脸

关于有参数无参数、有返回值无返回值 -->  -->  
不是很难但是要打好多字啊...所以如果不懂自己看视频吧哈哈哈
(视屏大概在day4 12 13 )
==============================
算了还是随便写一点吧-。-
有参数就是方法名后面的小括号里有东西 --> 某个不省心的方法  需要告诉他一点条件 他才知道该怎么写作业
无参数就是方法名后面的小括号里没东西 --> 方法里的乖孩子 给个任务，自己就能把作业写完
有返回值就是会把结果告诉调用者 --> 写了作业不给任何人看,但是谁问他要他就给谁
//调用者可以接收值
无返回值就是不会把结果告诉调用者，而是自己打印输出
//需要被单独调用
<--  <--   以上，总的来说，有返回值的什么调用都能用，无返回值的只能用单独调用
方法的注意事项：
1.都是【类】旗下的艺人，级别相同，不存在阶级斗争（不能嵌套，简单来说一个方法里面不可以有另一个方法）
2.大家都是同事，先后顺序无所谓啦
3.没有收到调用通知的方法只能乖乖待在家里，不可以跑通告
4.作为拥有返回值的方法，必须佩带return标志
5.作为一家人，return后面的数据类型和方法的返回值类型要一样
6.已经有了void的、也就是没有返回值的方法，可以偷偷佩带return标志表示方法结束，但return后面不可以有小尾巴返回值
7.void方法的return可以不写
8.一个方法可以有多个return，但只能用一个（如果连这种常识性注意事项都会犯的话，自己去买豆腐吧...）

重载
功能类似的方法太多了会嫌麻烦→_→
所以，引入方法重载（overlo 这玩意是重载的英文）
简单来说，就是方法名字一个样，但是参数列表不一样。
这玩意有个好处，一个名字，可以实现多个类似的功能
关于重载
记住下面这些东西：
1.参数个数不同
2.参数类型不同
3.参数类型一样，但是顺序不一样
//官宣：重载就和上面那三点有关系


数组
怎么理解呢
这玩意就相当于是一个容器，就把它当做冰箱，只不过冰箱放吃的，它放数据
来讲讲数组的特点
1.这玩意的数据类型属于引用类型
2.这玩意里面虽然可以放很多个数据，但是数据们的类型必须要一样
3.如果程序跑起来了，这玩意的长度就改不了了
数组常见的有两种初始化方式
1.动态//给它指定了长度
2.静态//给它指定了内容
格式
1.动态的格式
数据类型[] 数组名 = new 数据类型[长度];
2.静态的格式
数据类型[] 数组名 = new 数据类型[]{这里放数据，有几个放几个，中间用英文的逗号隔开};
来分析一下：（这是动态数组的分析）
/*
左边数据类型：数组里面的数据类型要一样，大家都是一家人
左边的中括号：告诉你这玩意是数组身份
数组名：（这也需要解释？？？）
右边的new： 这玩意是数组被创建的象征
右边的数据类型：不多说了，和左边写一样的就行
右边的中括号：里面写几，就表示这个数组可以放几个数据，但是这个【几】必须是int类型
*/
那么静态数组的分析呢？
/*
和动态的差不多，稍微有些不一样
中括号里面不需要写东西，想放什么，直接扔到中括号后面的大括号里就好了
理论上，你写几个，就能放几个
那么静态数组的长度怎么办...它自己会算
要是想知道长度，给个指令让他告诉你呗
*/
//静态和动态数组可以拆分 差不多是下面这个样子
动态的：
int[] array1 = new int[5];
-->
int[] array1;
array1 = new int[5];
静态的：
int[] array2 = new int[]{1,2,3,4,5};
-->
int[] array2;
array2 = new int[]{1,2,3,4,5};
//然鹅！！！
静态数据有个省略格式，这玩意不能拆分
省略格式如下：
int[] array3 = {1,2,5};

创建好的数组会被放在内存里，直接打印数组，输出的是一个哈希值，这玩意是数组的地址码。
想要访问数组里某个具体的数据，光有地址码还不够，
还需要一个索引，这玩意其实就是一个int数字，代表数组里面每一个数据的编号
数组里面的编号是从0开始的（吐槽一下老美的奇葩脑回路）
也就是说，在一个数组里，编号，也就是索引值，从0开始，一直到（数组长度- 1 ）结束
想要打印数组，输出  【数组名[编号]】
比如：
System.out.println(array1[0]); //这玩意输出的是数组array1里面编号为0，实际为1的数据
动态初始化数组，里面的元素会自动拥有默认值，差不多有下面这些
/*
整数类型：默认为0
浮点类型：默认为0.0
字符类型：默认为'\u0000'
布尔类型：默认为false
引用类型：默认为null
*/

内存：
栈：方法必须在这里运行
堆：new的东西都在这里
方法区：存储 .class 的相关信息，包含方法的信息
本地方法栈   //现在不重要
寄存器       //现在不重要
//理解性的东西，不想写了→_→(其实是我自己也懵懵懂懂....)
如果忘记了，自己看视频（视频在day5，具体位置自己慢慢找 ）

还有一些  
索引越界异常(索引编号不存在)
控制针异常(只赋值了null，没有进行初始化new)
什么的...
//自己稍微注意一下就好了
获取数组长度：
int 一个变量 = 数组名.length
然后输出这个变量就好了-。-
直接输出也可以-。-
数组的遍历输出
//这玩意通俗来讲就是把数组里面的数据每一个都处理一遍。一般默认的处理方式就是打印出来....
public static void main(String[] args){
int[] array = {1,2,3,4,5,6}
for(int i = 0; i < array.length; i++){
  System.out.println(array[i]);
}
}

还有数组的最值、反转什么的（用比较、冒泡等方法进行相应的操作）
另外，数组可以作为方法参数使用，也可以作为方法返回值
。
。
。
。
（后面的没完全学会，笔记先到这里好了，待续吧...）

这是一篇技术贴。。。
唔.......
我是菜鸟，没啥技术
所以。。。。
班主任女神说的----->
我就把自己搞的笔记传一下咯
================华丽的分割线==============================


类名、方法名----大驼峰、小驼峰
字符类型
int short byte char
double float
long
boolean

类型自动转换
小-->大
类型强制转换
大-->小
强制转换，数据过大会造成数据溢出或精度丢失
ASCII码表
48---0
65---A
97---a

算术运算
+ - * / %...
++ --
赋值 =
比较 >  <  =  <=  >= !=
逻辑 &&  ||  ！
三元运算 a == b ? a : b

顺序结构：
System.out.println(1);
System.out.println(2);
System.out.println(3);

选择结构：
单if
int a = 2;
if(a >= 2){
System.out.println(...);
}
标准 if-else
if(a > 2){
System.out.println(...1);
}else{
System.out.println(...2);
}
扩展 if-else
if(a > 2){
System.out.println(...1);
}else if(a < 2){
System.out.println(...2);
}else{
System.out.println(...3);
}

标准 switch  
int a = 1;//给a赋值什么，就从哪个case开始执行，遇到break停止。
switch(a){//小括号中只能是int、shrot、byte、char,或者是引用类型的string、enum枚举
case 1://每一个case不可以重复
System.out.println(...a);
break;
case 2://case没有顺序要求，可以颠倒
System.out.println(...b);
break;
.
.
.
default:
System.out.println(...收尾)；
break: //这一行可以省略，但最好保留。
}

穿透 switch
int a = 1;  //没有遇到break，会直接继续执行下一个case，不会停止，直到遇到break。
switch(a){
case 1:
System.out.println(...1);
case 2:
System.out.println(...2);
case 3:
System.out.println(...3);
break
}

循环
for 循环
for(初始表达式 1 ;循环条件 2 ;步进表达式 4 ){
循环体 3
}
// 1 仅执行一次
执行流程： 1.2.3.4 --> 2.3.4循环 --> 当 2 不再满足时，停止
while 循环
初始化表达式 1
while(循环条件 2 ){
循环体 3
步进表达式 4
}
执行流程：同上： 初始、条件、循环、步进，当不满足循环条件时，循环停止

do while 循环
初始表达式 1
do {
循环体 3
步进表达式 4
}while(循环条件 2)；
执行流程： 1.3.4 --> 2.3.4 -->  当 2 不再满足时，停止
通俗的讲，先执行一次程序，然后进入循环，当布不再满足循环条件时，跳出循环。

continue
结束本次循环，进入下一次的循环
例如：
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
//需求:不打印第三次HelloWorld
if(i == 3){
continue;
}
System.out.println("HelloWorld"+i);
}
}

死循环
永远不会结束的循环，条件永远为 true
例如： while(true){}


嵌套循环
for(初始化表达式 1 ;循环条件 2 ;步进表达式 7){
for(初始 3 ;条件 4 ;步进 6){
  循环体 5 ;
}
}
执行流程： 1.2.3.4.5.6 --> 4.5.6 --> 当 4 不满足时 进入 7.2 --> 然后继续 3.4.5.6
直到条件不再满足 2  , 则不再进入内循环
通俗的讲，外循环一次，内循环多次，当外循环的的循环条件不再满足，整个循环结束。


方法
主方法： public static void main(){
方法名(参数类型 参数名,...);
//上面这玩意就是下面那个方法写的作业，把这玩意放过来的行为叫做调用。
}
定义方法
修饰符 返回值类型 方法名(参数类型 参数名,...){
方法体
return 返回值;  
}
// 现阶段，修饰符就是 public static
// 返回值类型  方法最终的数据是什么类型，这里就写什么类型
// 方法名用小驼峰
// 参数类型 进入方法的数据的类型
// 参数名 进入方法的数据对应的名字
// 方法体 想让这个方法干嘛，就在这里敲上相应的代码
// return 告诉这个方法下班了，然后把这个方法工作时写的作业交给调用他的老板
// 返回值 这玩意就是方法要交的作业

方法的三种调用格式：
单独
打印
赋值
单独调用：方法名(参数);
//这个东西很鸡贼，悄咪咪自己玩不让人看见
打印调用：System.out.println(方法名(参数));
//这玩意简单来说就是让悄咪咪被执行了调用的方法可以被看见
赋值调用：数据类型 变量名 = 方法名(参数);
//先悄咪咪调用，然后把版权卖给某个变量，相当于重新包装一下再卖出去露脸

关于有参数无参数、有返回值无返回值 -->  -->  
不是很难但是要打好多字啊...所以如果不懂自己看视频吧哈哈哈
(视屏大概在day4 12 13 )
==============================
算了还是随便写一点吧-。-
有参数就是方法名后面的小括号里有东西 --> 某个不省心的方法  需要告诉他一点条件 他才知道该怎么写作业
无参数就是方法名后面的小括号里没东西 --> 方法里的乖孩子 给个任务，自己就能把作业写完
有返回值就是会把结果告诉调用者 --> 写了作业不给任何人看,但是谁问他要他就给谁
//调用者可以接收值
无返回值就是不会把结果告诉调用者，而是自己打印输出
//需要被单独调用
<--  <--   以上，总的来说，有返回值的什么调用都能用，无返回值的只能用单独调用
方法的注意事项：
1.都是【类】旗下的艺人，级别相同，不存在阶级斗争（不能嵌套，简单来说一个方法里面不可以有另一个方法）
2.大家都是同事，先后顺序无所谓啦
3.没有收到调用通知的方法只能乖乖待在家里，不可以跑通告
4.作为拥有返回值的方法，必须佩带return标志
5.作为一家人，return后面的数据类型和方法的返回值类型要一样
6.已经有了void的、也就是没有返回值的方法，可以偷偷佩带return标志表示方法结束，但return后面不可以有小尾巴返回值
7.void方法的return可以不写
8.一个方法可以有多个return，但只能用一个（如果连这种常识性注意事项都会犯的话，自己去买豆腐吧...）

重载
功能类似的方法太多了会嫌麻烦→_→
所以，引入方法重载（overlo 这玩意是重载的英文）
简单来说，就是方法名字一个样，但是参数列表不一样。
这玩意有个好处，一个名字，可以实现多个类似的功能
关于重载
记住下面这些东西：
1.参数个数不同
2.参数类型不同
3.参数类型一样，但是顺序不一样
//官宣：重载就和上面那三点有关系


数组
怎么理解呢
这玩意就相当于是一个容器，就把它当做冰箱，只不过冰箱放吃的，它放数据
来讲讲数组的特点
1.这玩意的数据类型属于引用类型
2.这玩意里面虽然可以放很多个数据，但是数据们的类型必须要一样
3.如果程序跑起来了，这玩意的长度就改不了了
数组常见的有两种初始化方式
1.动态//给它指定了长度
2.静态//给它指定了内容
格式
1.动态的格式
数据类型[] 数组名 = new 数据类型[长度];
2.静态的格式
数据类型[] 数组名 = new 数据类型[]{这里放数据，有几个放几个，中间用英文的逗号隔开};
来分析一下：（这是动态数组的分析）
/*
左边数据类型：数组里面的数据类型要一样，大家都是一家人
左边的中括号：告诉你这玩意是数组身份
数组名：（这也需要解释？？？）
右边的new： 这玩意是数组被创建的象征
右边的数据类型：不多说了，和左边写一样的就行
右边的中括号：里面写几，就表示这个数组可以放几个数据，但是这个【几】必须是int类型
*/
那么静态数组的分析呢？
/*
和动态的差不多，稍微有些不一样
中括号里面不需要写东西，想放什么，直接扔到中括号后面的大括号里就好了
理论上，你写几个，就能放几个
那么静态数组的长度怎么办...它自己会算
要是想知道长度，给个指令让他告诉你呗
*/
//静态和动态数组可以拆分 差不多是下面这个样子
动态的：
int[] array1 = new int[5];
-->
int[] array1;
array1 = new int[5];
静态的：
int[] array2 = new int[]{1,2,3,4,5};
-->
int[] array2;
array2 = new int[]{1,2,3,4,5};
//然鹅！！！
静态数据有个省略格式，这玩意不能拆分
省略格式如下：
int[] array3 = {1,2,5};

创建好的数组会被放在内存里，直接打印数组，输出的是一个哈希值，这玩意是数组的地址码。
想要访问数组里某个具体的数据，光有地址码还不够，
还需要一个索引，这玩意其实就是一个int数字，代表数组里面每一个数据的编号
数组里面的编号是从0开始的（吐槽一下老美的奇葩脑回路）
也就是说，在一个数组里，编号，也就是索引值，从0开始，一直到（数组长度- 1 ）结束
想要打印数组，输出  【数组名[编号]】
比如：
System.out.println(array1[0]); //这玩意输出的是数组array1里面编号为0，实际为1的数据
动态初始化数组，里面的元素会自动拥有默认值，差不多有下面这些
/*
整数类型：默认为0
浮点类型：默认为0.0
字符类型：默认为'\u0000'
布尔类型：默认为false
引用类型：默认为null
*/

内存：
栈：方法必须在这里运行
堆：new的东西都在这里
方法区：存储 .class 的相关信息，包含方法的信息
本地方法栈   //现在不重要
寄存器       //现在不重要
//理解性的东西，不想写了→_→(其实是我自己也懵懵懂懂....)
如果忘记了，自己看视频（视频在day5，具体位置自己慢慢找 ）

还有一些  
索引越界异常(索引编号不存在)
控制针异常(只赋值了null，没有进行初始化new)
什么的...
//自己稍微注意一下就好了
获取数组长度：
int 一个变量 = 数组名.length
然后输出这个变量就好了-。-
直接输出也可以-。-
数组的遍历输出
//这玩意通俗来讲就是把数组里面的数据每一个都处理一遍。一般默认的处理方式就是打印出来....
public static void main(String[] args){
int[] array = {1,2,3,4,5,6}
for(int i = 0; i < array.length; i++){
  System.out.println(array[i]);
}
}

还有数组的最值、反转什么的（用比较、冒泡等方法进行相应的操作）
另外，数组可以作为方法参数使用，也可以作为方法返回值
。
。
。
。
（后面的没完全学会，笔记先到这里好了，待续吧...）