标题太欠扁 改了

啵啵River小帅哥陪陪人家写写
他打呼噜时也陪陪
吃肉肉时也陪陪
打篮球时也陪陪
变聪明时也陪陪
鸽鸽的努力激励惹人家呢
嘻嘻 用River鸽鸽的爱浇灌的～～
小猪归属权：River鸽鸽

关键字的特点

关键字是有特殊含义的/被保留的/不能随意使用的字符

1. 完全小写的字母，没有大写和数字；
2. 有特殊颜色（紫色）

关键字内容

1. 访问控制（private protected public default默认）
2. 类/方法/变量修饰符（class static静态）
3. 基本类型（）
4. 变量引用：void无返回值

标识符的特点

标识符是我们在程序中自己定义的内容，比如类/方法/变量的名字，举例（age/$salary/_value/__1value）(非法：123abc/-salary)
命名规则：

1. 英文字母26个，区分大小写/0-9数字/$/_;
2. 不能用数字开头
3. 不能是关键字
4. 类名规范：首字母大写，后面每个首字母都大写（HelloWorld）【类是什么】
5. 变量名规范：首字母小写，后面每个单词首字母大写
6. 方法名规范：同上
7. 源文件名规范：必须和类名相同。保存文件时用类名作为文件名保存。（HelloWorld.java）
8. 主方法入口：由public static void main(String []args)方法（程序执行的起点）开始执行，代表main方法
9. 输出语句：System.out.println("")

修饰符【是什么】

变量

可以在方法中被替换的数据；int i = 1
数据类型 变量名称；//创建一个变量
局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
类变量（static）：类变量也声明在类中，方法体之外，但必须声明为static类型。
成员变量

变量使用不能超过作用域的范围。作用域是指从定义变量的那一行开始，一直到所属的大括号为止。

常量

常量是在程序运行期间，固定不变的量。
常量的分类：

1. 字符串常量： 用双引号引起来的部分（public class Demo01Const【类】）"123"“abc”
2. 整数常量：直接写上数字，没有小数点
3. 浮点数常量：直接写上书数字，有小数点（2.5/-3.4）
4. 字符常量Char：单引号引起来的单个字符（‘9’/‘A’/‘中’）
5. 布尔常量：只有两种取值（true/false）
6. 空常量：null，代表没有任何数字

演示：
public class Demo01Const{
public static void main(String[] args) {
//字符串常量
System.out.println("");//注意：两个单引号间必须有且仅有一个字符（‘a’），不能空（“”），不能（null）
}
}
int num3;
num3 = 30;

常量基本数据类型

四类八种
整数型 byte字符(取值范围：-128~+127)1 short短整2 int整4 long长整8 long num1 = 100L
浮点型 float<比long取值范围大>单精度4 double双精度8「Double是两倍,float比long长 38/19」
字符型 char2 ‘Q’/‘中’
布尔型 boolean1（true/false）

引用数据类型（今后学习）
字符串、数组、类、接口、Lambda

在eclipse中使用

创建一个java project，取名和类的名字相同，在src中右击new-class，再点一下主程序puclic static…，删除module-.java<或者点击next，直接不选择module>，如果要在终端运行：找到文件的位置（File,property,Location<src的位置>）
把java转成class：pwd
cd /…
javac Yu.java
java Yu
直接运行class：cd /…
java Yu

注意事项：

1. 字符串不是基本类型，是引用类型；
2. 整数默认int型，如果要表示long型要在后面加L
3. 浮点数默认double，如果要表示float，要加上一个F

数据类型转换

方法调用：都是int的 看数据范围，而不是字节；
byte short int longL Float double 左边大 自动 左边小 强制
看原本的类型范围，要往左边的，前面补上（类型），往右边的，不用。
System.out.println(same((short)10,(short)20))
System.out.println(10L,20L))

在进行加法的时候要特别注意转换问题；int = int+ int；
数据类型不一样时，先变成一样的；
直接输出时zufu1 + 0 这个不用转换，但要对照ASC表格。

自动数据类型转换：
数据类型从小到大，把右侧的数值交给左边。
左边大 = 右边小

强制代码转换：
左边小 = （左边）右边大，但是右边的数值没有超过左边的范围；
int num = (int)100L
double a ;
double b;
return (int)(a+b);
范围小的类型 范围小的变量名 = （范围小的类型）原本范围大的数据；

1.强制的特殊：
数据溢出：int num2 = (int) 6000000000L<int范围只有10【？】位>，输出很少；
2.数据损失
int num3 = (int) 3.99 输出3
char zifu1 = ‘A’;
A是用65代替。
3.byte/short/char 会被提升成int类型，然后进行计算，用计算方法，如加法“+”。
byte/short/char如果没有超过左侧的范围，那么编译器会自动补上强转(byte)(short)(char)。
int result1= a + b //不能用=byte
但是：short a = 5
short b =6
//short result = a+ b //这个是错误的！
short result = 5+8 //13正确！如果右侧表达式中全是常量，那么编译后达到的直接是结果。
short result2 = (short)(num4 +num6)
double result2 = x + 2.5<int + double = double>
对于字符串String来说，
字符串类型的变量使用：数据类型 变量类型 = 数据值
String str1 = “Hello”
输出（“Hello” + “World”）
优先级：字符串String 和任何数据类型链接都是字符串
（str2 + 20 + 30）=Java2030
(str2 +(20+30))=Java50
4.boolean不能当数据类型转换
ASC表格 48=0 65=A 97=a
Unicode码表

算术运算符

Demo01Operator
乘：* ，不能写2x，要把它变成2*x
除：/<被除数/除数 = 商。。。余数>
取模%： 取余数<没有余数就 (num %20)是0>；仅针对整数除以整数；（x % y）<用来判断是奇数还是偶数if>
等于：
不等于：!=
自增运算符++：让一个变量涨一个数字
自减运算符–：让一个变量减一个数字
单独使用*++num1;*单独成一行，再println(nmu1)
混合使用时：前++，直接加一，然后开始运算
后加加，则先一步赋值，最后一步再+1
int num2 = 20；
println(num2++);//20，是赋值的运算，先把num赋值20
println(num2);//21，是最后一步
常量（20+30），常量不能做自增自减运算；
（20 *a）

2.2赋值运算符

常量不能进行赋值！
基本赋值运算符 =
复合赋值运算符
+= (a+= 1) -->a=a+1
-= b -= 4 -->b= b-4
先把右边算出来再往左边赋值
int a = 10
a +=5
println(15)

2.3比较运算符

常量、变量都能用；运行结果一定是个boolean值，成立是true,不成立是false；
相等==
不相等!=
println(10 >5);//true

2.4逻辑运算符

与（并且）&& 全都是true，才是true
或（或者）|| 至少一个true,则是true
非（取反）！ 在前面加一个感叹号，本来是true，变成false
<inta= 10
println(3>4 && ++a<100);//f
println(a)//没有运行后半部分，所以++a不会先变成11，再做比较>

1. println(3<4 && 10>5); T
   如果第一个条件已经是f,则第二个条件不会再运行
2. t||f–>t t||t–>t f||f–>f
   同理，在||中，第一个是t，第二个也不会再执行。
3. println(!true);//false ；取反只要有一个布尔值即可；
4. 多个条件：条件a && b&& c 对于1<x<3, int x =2, 1<x && x<3

三元运算符(也能用来条件判断)

一元运算符，只需要一个数据就能处理，e.g.取反，自增自减
二元运算符，需要两个数据才能处理，加法、赋值
三元运算符，需要三个数据才可以操作的运算符

先要满足数据要求和数据性质 3>4?2.5:10不满足性质要求

格式：数据类型 变量名称 = 条件判断 ？ 表达式A：表达式B
根据条件判断，如果这个条件是t,则赋值A 到等号左边的变量；
例如，求最大值max时，输出变量是max，int是输入变量；
int a = 10;int b = 20; int max = a>b ? a : b;println(“最大值：”+ max

65方法

方法能让我们的作品更直观
方法好比一个工厂，参数是原料<进入方法的数据>，返回值是产出物<从方法中出来的数据>；
用来显示的就用void；

1. 固定格式：
   修饰符 返回值类型 方法名称(参数类型 参数名称，…){
   方法体<变量>
   return返回值；
   }

2. 定义一个两个数字相加的方法，三要素：
   返回值类型：int
   方法名称:sumNumber小驼峰
   参数列表: int a, int b

3. 修饰符public static 现阶段固定写法
   返回值类型：也就是最终产生的数据结果是什么类型
   方法名称：命名和变量一样，是小驼峰
   参数类型：进入的数据的类型
   参数名称：进入的数据对应的变量名称<参数如果有多个，用逗号连接>
   方法体：需要做的事情，若干行代码
   return：停止当前方法并把后面的返回值还给调用处<回到调用这个方法，想得到的结果的那边 方法(参数)>
   返回值：方法最后产生的数据结果

4. 示例：
   public static int sumNumber( int a, int b){
   System.out.println(“方法执行啦”);
   int result = a+b;
   return result;
   }

5. public static void 方法名称<小驼峰取名farmerMethod>() {
   方法体,可以是任意语句
   }
   方法定义要挨着，不能在定义中嵌套定义；
   方法的调用：public static void main(String[] args){
   方法名称farmer();
   cook();
   me();
   }

6. 具体调用自定义方法的代码示例：
   public static void main(String[] args){
   farmerMethod();
   }
   public static void farmermethod(){ /这是对创建的方法的定义/
   for(int j = 0; j<5;j++){
   System.out.println(“pigpig”)
   }
   }

三种调用格式

void方法调用只能用单独调用，不能用其他两种；

1. 单独调用：方法名称(参数数值);
   public static void main(String[] args){
   sumNumber(10, 20);
   }
2. 打印调用：System.out.println(方法名称(参数));
   public static void main(String[] args){
   System.out.println(sumNumber(10, 20));
   }
3. 赋值调用：数据类型 变量名称 = 方法名称(参数);
   public static void main(String[] args){
   int result = sumNumber(10, 20);
   System.out.println(“变量的值”+ result);
   }

有参数和无参数

有参数：小括号中有内容，需要数据才可以完成，否则方法不能完成
无参数：小括号中没有内容

有返回值和无返回值

有返回值：求两个数字之和，告诉我结果的答案；我是main方法，我来调用你，你帮我算完以后把结果告诉我的num变量；
无返回值：<是void方法>定义一个方法用来打印两个数字之和，这个方法负责打印，算完你自己负责显示结果，不用告诉我；此时不需要return 返回值<变量>；只需要在方法中打印输出即可；main方法空着收回到调用处；

方法题目1

1. 只要保持return后面是boolean即可，
2. 题目中有“是否”，就用布尔值；
   定义一个方法 用来判别两个数字 是否相同
   三要素：返回值类型boolean
   方法名称isSame
   参数列表int a , int b
   再要想方法中的变量
   public static boolean isSame(int a , int b){
   boolean same; 变量是小驼峰
   if（a == b）{
   same = true;
   } else {
   same = false;
   }
   // boolean same = ab ? true : false;
   // boolean same = ab ;<ab本身就是一个boolean值>
   return same;
   // return ab;<a==b本身表达值等于布尔值；返回值也可以是表达式>
   }

方法题目2

如果有“求出”/“得到”等字眼，则一定有返回值；
定义一个方法，用来求出1-100所有数字的和。
三要素：返回值类型int 方法名称 sum 参数列表 int a<数据类型固定，这个要素的改变不会影响结果，所以不需自己代入 自己设定的数据/参数，因此不需要参数>
public static int sum( ){
int sum;
for(int a = 1; a <=100; a++){
sum = sum + a;//sum +=i;
return sum;
}<啥时候是print:调用的时候println>
}

方法题目3

定义一个方法，用来打印指定次数的HelloWorld
返回值类型：打印 不需要,那么就是 void，可以不写return
方法名称：print
参数列表：到底打印多少次？必须告诉这个方法，否则没法打印==（调用的时候要不要这个要素，这个要素的改变是否会影响结果）==
public static print(int a ){
for (int i= 0; i <= a; i++){
System.out.println(“HelloWorld”)
}
}

Overload方法重载

新建一个package ，新建一个class；
定义一个方法的名称

1. 参数数量：当方法一样，只有参数数量不同时，可以用overload，在方法中：不用改名字，名字可以一模一样，方法一模一样，
2. 参数类型：或者参数的类型不同，
3. 参数的顺序：不同，但是不同参数个数都要写上，
4. 输出内容“里面”可以不同；在调用中：调用的方法名字相同，参数不同。

方法格式： 修饰符 返回值类型 方法名称(参数类型 参数名称，…){
方法体<变量>
public static void myPtint(String str){
System.out.println(str);
}

但是

1. 参数名称要相同：参数的名称的改变和重载无关，int a , int x,这两个不能放在同一个重载；（int a ,int b）(int g,int j)看看有没有相同的参数类型，还有没有两个int的
2. 返回值要相同：返回值的不同也是错误的，不能把返回值不同的放在同一个重载
3. public static这些修饰符有或没有都没关系,方法名称不同，不是重载

方法题目4

比较两个数据是否相等 两个byte short int long类型
参数 int a, int b;
方法名称 same;
返回值 int
public static boolean same(byte a, byte b){
return a==b;
}

数组Array

newe出现时就能创造一个变量；
直接用调用的方法，在里面放数组；
基本类型和引用类型array都能做数组中的部分；

1. 类型统一，是一种引用数据类型
2. 在程序运行中不能改变

数组初始化：在内存中创建一个数组，赋予一些默认值；
两种常见初始化方式：动态初始化（指定长度）<只有个数>；静态初始化（指定内容）<更为详细，但也自动推算长度>

静态自动由默认值变为具体内容；

数组动态初始化格式：

数据类型[] 数组名称 = new 数据类型[数组长度]；
标准格式下的二步化：数据类型[] 数组名称;
数组名称 = new 数据类型[]{};
[]：代表这是一个数组，用以和变量进行区分；
数据长度：int变量，数组中可以保存多少个数据，就写几；

数组为null空：int[] array = null;
array = new int[3]
动态举例：public static void main(String[] args){
int[] array = new int[300];
}
打印：System.out.println(array[0]);
元素会自动有默认值；
赋值：
array[0] = 123;
System.out.println(array[0]);

84数组静态初始化格式：

数据类型[] 数组名称= new 数据类型 []{内容1， 内容2…}

省略型格式：数据类型[] 数组名称array= {内容1， 内容2};

标准格式下的二步化：数据类型[] 数组名称;
数组名称 = new 数据类型[]{内容1，内容2};

静态举例： public static void main(String[] args){
int[] array01 = new int[]{5, 15, 25};
}
//int[] array = {10,20,30};
打印：
System.out.println(array[0]);这个是第1号元素；
/int num = array[0];
System.out.println(num);/
直接打印数组，所得到的一串代码：[I<代表int类型>@+十六进制0123456789abcdef f=15 逢16进0；内存地址哈希值，数组创建在内存中；
访问数组元素的格式：数组名称[索引值]
索引值：是一个int数字，代表数组中的元素编号；从0号元素开始；

如何获得数组长度

格式：数组名称.Length;
int len = array01.length;

public static void main(String[] args){
int[] array = new int[3];
int[] array01 = new int[]{1,2,3,4}
}
数组本身的长度不会有任何的变化，变化的是赋值后的第二个数组的变量

数组打印方法

<快捷方式.length>array.length.fori
for(int i = 0;i<array.length; i++){
System.out.println(array[i]);
}

int len = array.length;
for(int i = 0;i<len; i++){
System.out.println(array[i]);
}

void方法打印：返回值类型 只是打印而已 不需要进行计算 也没有结果
方法名称：printArray
参数列表：给不同的数组打印出的内容不一样
具体内容：
public static void printArray(int[] array){
for(int i = 0 ; i< array.length; i++){
System.out.println(array[i]);
}
}

在main里面运用数组：
int[] array = { 10, 20, 30, 40, 50};
printArray(array);//代入的内容是地址值

在main里面返回多个返回值（结果）：

1. 在方法的后部加上
   int[] array = new int[2];【为什么不用具体内容{} 可以用{sum, avg}？】
   array[0]=sum;
   array[1]=avg;
   return array;
2. 再在main 里面：
   int[] result = calculate (10 , 20, 30);
   System.out.println(“总和”+result[0]);
   System.out.println(“平均数”+result[1]);

求最大值：冒泡排序

直接在main方法里面 不需要设置新的方法 设置新的方法是属于如果题目要求“设置一个新的方法”，可以让整个分块看的更加清晰。所以一般都是用main直接去做，
int[] array = {5, 20,20,30,100000};
int max = array[0];
for(i = 1; i < array.length; i++){
if (max < array[i]){
max = array[i];
}
}
System.out.println(“最小”+max);

数组元素交换

1. 是对称元素的交换
2. 两个箭头索引：int min = 0//int max =array.length-1;
3. 数组交换int a = 10; int b = 20 ;int temp = a ; a = b; b = temp;
4. 交换的时间：min < max
   main里面：
   int[] array = {1,2,3,4,5}
   int min = 0;
   int max =array.length-1;
   for(int min = 0, int max =array.length-1; min < max; min++, max–){
   int temp = array[min];
   array[min] = array[max];
   array[max] = temp;
   }
   for(int i = 0;i<array.length; i++){
   System.out.println(array[i]);
   }

85内存

1. 栈(Stack): 存放局部变量（方法内部变量名称），方法的参数；方法的运行都在栈中进行；
2. 堆(Heap)：new出来的东西都在堆中，16进制，有默认值，规则 整数0，浮点数0.0 字符’\u0000’ 布尔值false 引用类型null；
3. 方法区（Method Area）: 储存.class 相关的信息，包含方法的信息； <你的方法是啥>
4. 本地方法栈（Native Method Stack）: 与操作系统相关
5. 寄存器（pc Register）：与CPU相关

jshell脚本

针对非常简单的代码，无需保存一个class
直接在终端的users里面打jshell
System.out.println(“HelloWorld”)
int a = 10;
int b = 20;
int result = a *b
System.out.println(“结果是”+result)
退出剧本 /exit，回到cmd

注释与空行

/* 嘻嘻嘻我是小猪*/
//这是我啦
空行不会看

继承/接口

对象/类

类是java中所有源代码的基本组织单位
「在public class 后代表一个类的名称，可以随便取」
对象是类（男孩/女孩）中单独的个体（某个男孩/女孩）；
对象的状态（名字/品种/颜色）是属性；
对象的行为（叫/摇尾巴/跑）通过方法体现；
方法操作对象内部属性改变，…

顺序结构

圆框：开始结尾
方框：步骤

判断语句

1. 单if语句----最简单好用；
   if(关系条件判断 得到boolean的结果，如果正确，则执行语句体){语句体：代码，方框表示}
   菱形代表条件判断
   方框表示代码
   int age = 16；
   if(age >= 18){
   System.out.println(“进入网吧”)；
   }//这里就是结束了
   /这句话可以没有/System.out.println(“回家”)；
2. if（关系判断）如果true，语句体运行;
   }else{如果错，语句体运行;
   }
   只选择其中一个语句体执行
3. 循环if…else…《分段函数的题目解法》
   if (条件){
   }else if() {
   }…else{
   }
   int x= 10;
   int y;
   if (x>=3){
   y= 2 x +1;
   }else if (x>-1 && x<3){y= 2x
   }else{
   y=2*x-1;
   }
   System.out.println(“结果是”+y);
   注意
4. 要考虑到“你的成绩是错误的”这个情况，此时是||或者的关系，或者直接用else 用来考虑不合理的结果的情况；
5. 不要忘记打出分号；
6. 可以打出int num；进行变量设置；

选择语句

1. 常量值1/常量值2 不能够重复
2. 被测量值：基本数据类型（byte/short/char/int）引用数据类型（String字符串/enum枚举）
3. default不一定要放在最后
   switch(被检测的量<变量/等式>){
   case 常量值1<如果被检测的量等于这个常量>:
   语句体1;
   break;
   case 常量体2: 语句体2; break;…
   default: 语句体;break;
   }
   今天是星期几：
   int num =1
   switch (num){
   case1: System.out.println(“星期一”)；
   break;…
   default: prinntln(“数据错误”); break;
   }

循环语句

如果去除println中的ln，则循环中不会再换行；
Syetem.out.println()是单纯的换行

for(1 初始化表达式<只会执行一次，之后再也不会执行>;2 布尔表达式<判断对错，对就继续此循环，错就结束循环>; 4 步进表达式){
3 循环体<循环要做啥就写啥>也可以在里面镶嵌循环
}
1–>2->-3>-4->234234–>24

1. for(int i = 1; i <=100;i++<打印完了，循环结束了，再继续这个东西>){println(“小猪真美丽”+i)；
   }
   println(“程序停止”)；

int num=1;num<=20;…—>循环20次
int num=0;num<20;…—>循环20次
IDEA中：5.fori自动循环5次
这里的i只能在大括号for(){}内部使用，在这个大括号后面再用i 就无意义了
2. while(条件判断){循环体}；
扩展格式：
初始化语句；
while(条件判断 布尔表达式){
循环体；步进语句;
}
3. do-while
do{
循环体
}while(条件判断);
扩展：
初始化语句
do{
1.循环体<println("")>;
2.步进语句i++;
}3.while(条件判断)

【int = 1;
do{
System.out.println(“world”);
i++;
}while(i<0);】这个是i在while判断之后还是之前？【看do-while流程图】【分号和空格的做法】
三种循环的区别：

1. 如果条件从来没有满足过，for和while循环执行0次，但是do-while循环执行至少一次；
2. for循环i在里面；while和do-while中i在外面
3. 次数已知=for；次数未知=while

53循环控制break

后面全部都没了
for(int i = 1 ; i <= 10 ; i++){
if (i==4){
break;
}
System.out.println(“Hello”+i);
}

54循环控制continue

只要一次停止
同一层逻辑的对齐，每一段不是分号就是括号；
for(i = 1; i<=10; i++){
if (i == 4){
continue;
}
System.out.println(“这一层是”+i)；
}

55Demo01DeadLoop死循环

停止：control+C
次数不限：while循环
while(true){
循环体System.out.println（“break”）；
}

56循环镶嵌

for (int hour = 0; hour<24;hour++){
for(int minute = 0; minute<60; minute++){
System.out.println(“现在时间是”+hour+“时”+minute+“分”)；
}
}

57IDEA集成开发环境系统

project 项目—>module模块—>package包
src是源代码的内容，所有代码在里面
External Libraries是jdk java安装包
Package名字：只能小写 字母 数字 英语句点 cn.littlepig
类名字要大写，其他都可以小写，package需要对齐之前的格式 cn.pig.day04.demo01/cn.pig.day04.demo02

create a new project; project structure> +号 >new module>java>jdk如果红色 找一下java目录位置>module名字随便取>右击src>new>package命名注意>右击package>new>java class新建一个java类> psvm方法>Sout输出>右击 run

导入module: File>project structure>+号>import module>next next next>finish
class在out文件夹中

设置字体：File>settings>editor>Front>size
找出快捷健：File>settings>keymap>设置 duplicate>Default copy>main menu>code>completion>basic>双击 remove删除 add重设>有重复的快捷键就把之前的删除
单行注释可以用来保存代码 随便选 整行的
多行注释可以用来保存一小段 或者句子里一块代码