截至6.14的一点笔记 java

10:40 16/05/2022

classpath

类名第一个字母要大写

ctrl d 连续复制出改行代码

sout
psvm

10:40 17/05/2022
标识符是自己取的名字
关键字不能当标识符

java大小写严格区分

java命名有约定熟成的规范
包名：都小写
类名接口名：驼峰法
变量函数名：驼峰法但第一个单词的首字母小写
常量名：所有单词大写且用_连接 // final int NUMBER = 100；

变量名也可以用中文，但只能在本地跑，在伺服器跑不了

声明变量有变量名和类型就可以
再赋值

byte 字节
kb killo byte 1024个byte
mb mega byte 1024个kb
gb giga byte
tb tera
bit二进制单位 比特

在方法体种声明的变量，生效域是该方法

代码块
1、修饰符可以选，要写的话也只能写 static
2、代码块分为两类，使用static的叫静态代码块，没有static的叫做普通代码块
3、代码中可以为任意逻辑语句例如：输入，输出，方法调用，循环，判断
4、 ; 号可以写上也可以省略

用long的类型后面最好加个大写的L
float也一样 F
float数据类型不建议使用：float对于点数的精度处理比double差，float只能处理点数后7个位，double可以处理点数后14个位

int + float = float
byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。

= 赋值
== 比较运算符
swift中 ：= 赋值

当把任何基本类型的值和字符串值进行连接运算时(+)，基本类型的值将自动转化为字符串类型。 
在存在字符串string数据时，+表示连接符

字符串是个类
string不是基本数据类型，属于引用数据类型

强制类型转换 ()

基本数据类型的引用数据类型（除char外）
引用数据类型本质上是类，类里面有方法供使用
基本数据类型byte 引用数据类型Byte
为什么还要用基本数据类型：节省空间，不容易出现编译错误的问题

08:36 18/05/2022
世界上有10 种人，懂和不懂二进制的

二进制
定义的int以0b开头
十进制256转二进制为1 0000 0000：十进制整数转换为二进制整数采用"除2取余，逆序排列"法。具体做法是：如图，用2整除十进制整数，商写在下面，对应余数写在右边；接着再用2去除商，又会得到一个商和余数，一直继续，直到商为0，把得到的余数最底下的作为高位，最上面的做低位排列，得到对应二进制数。 

bit是计算机最少的存储单位
byte...基本....
byte和bit的区别是容量大小不同、存储数据类型不同

18%7___3 
%取余

对浮点数取模或除法时注意精度

用容量较小的数据类型可以直接赋值给容量较大的数据类型
反过来就不行，要用强制转换()

number += 10; // number = number + 10;

number = 40;
number %= 11; // number = 7

& 逻辑与：左边无论真假右都运算
&& 短路与 （常用）：左边真右运算，左边假右不运算
或|，短路或||

^ 逻辑异或
System.out.println(true ^ true); //false
System.out.println(true ^ false); //true
System.out.println(false ^ false); //false
如果2边boolean一样就都是假，两边不一样就都是真
异或追求的是异

三元运算 
条件表达式 ? 表达式1 ： 表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；

运算符优先级：

GOTO是跳转语句，意思是中断当前某程序的执行，跳转到程序的其他位置继续执行。
常见的跳转语句有：break、continue、goto
Java中没有goto
goto是条件跳转指令，可以使程序的执行跳转到另一个位置，因此它会破坏其它的控制流机制（如FOR,IF SWITCH)所提供的有用结构。goto语句常常导致程序需要不断进行修补，而通过goto语句对原来的代码进行修改，程序很快就会变得难以理解。

" ":字符串
' ':字符
不一样

System.out.println('x'); //x
System.out.println("x"); //x
System.out.println('x' + 1); //121 要经过计算
System.out.println("x" + 1); //x1

public static void main(String[] args){}
这是java程序的入口地址,java虚拟机运行程序的时候首先找的就是main方法.跟C语言里面的main()函数的作用是一样的.只有有main()方法的java程序才能够被java虚拟机欲行,可理解为规定的格式
对于里面的参数及修饰符
public:表示的这个程序的访问权限,表示的是任何的场合可以被引用,这样java虚拟机就可以找到main()方法,从而来运行javac程序
static:表明方法是静态的,不依赖类的对象的,是属于类的,在类加载的时候main()方法也随着加载到内存中去
void:main()方法是不需要返回值的
main:约定俗成,规定的
String[] args:从控制台接收参数

src: source code
cmd界面: command line interface
javac: java compile编译

Java se 标准版 standard
Java ee 企业版

08:39 19/05/2022
System.out.println("输入：");
Scanner sc = new Scanner(System.in);
int number = sc.nextInt();

变量：
局部变量和成员变量的区别：
定义的位置不一样【重点】
局部变量：在方法的内部
成员变量：在方法的外部，直接写在类当中
作用范围不一样【重点】
局部变量：只有在方法当中才可以使用，出了方法就不能再用了
成员变量：整个类全都可以通用
默认值不一样【重点】
局部变量：没有默认值，如果要想使用，必须手动进行赋值
成员变量：如果没有赋值，会有默认值，规则和数组一样
内存的位置不一样（了解）
局部变量：位于栈（Stack）内存
成员变量：位于堆（Teap）内存
生命周期不一样（了解）
局部变量：随着方法进栈而诞生，随着方法出栈而消失
成员变量：随着创建而诞生，随着对象被垃圾回收而消失

Java中定义成员变量时采用合法的前向引用

if(...){...;}
就算执行代码块只有一句也建议加{}

switch 开关
switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断。

case(99 <= score || score >= 80): 是错误的
只能
switch (score / 10) {
case 9:
case 8:

int number = 0;
number += number; // = number = number + 0

for(1; 2; 3){4; }
1 2 4 3 2 4 3 2....
第一次循环的时候3不会执行 // 3是迭代部分，第二次循环才执行

idea格式化代码快捷键: Ctrl+Alt+L

while( 布尔表达式 ) {  //循环内容}
只要布尔表达式为 true，循环就会一直执行下去。

for和while循环可以相互转化

如果f2和音量-冲突：Fn + f2

for (; ; ) {}
相当于无限循环，下面的东西就不会运行，但不显示打印的东西，= 卡住了
死循环

对于 while 语句而言，如果不满足条件，则不能进入循环。
do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

断电测试：
红色的点
点debug
一般循环的时候会用

break可以和标签一起用
outter_loop
inner_loop

08:37 20/05/2022
字符串用 .equal 比较

Java中声明数组不能指定长度 String[] strArray = new String[5];
数组一旦初始化其长度是不可变的
数组是引用类型
int数组没赋值打印就打印默认值0，如果是char什么其他的就是其他的，boolea则默认为false, String就默认为null
基本数据类型的初始值各有不同，引用的则都是null

栈stack
堆heap

在类外面不能做操作
类class里 main外 是成员变量
class里main里也是局部变量

17:33 22/05/2022
如果ax=N（a>0，且a≠1），那么数x叫做以a为底N的对数，记作x=logaN，读作以a为底N的对数，其中a叫做对数的底数，N叫做真数。

10:25 23/05/2022
do也是关键字，do while

ctrl + 鼠标左 点main调用的方法可以直接跳到方法

实例化一个狗的对象，标识符为d：
//栈内存中产生Dog d
//堆内存中产生new Dog()
Dog d = new Dog(); //这一句里产生了2个对象
现在创建一个叫 dog的对象，后面又new一个，把新的对象赋予到叫d的对象之中

1.对象放在哪个位置？
堆内存中
2. Car c = new Car(); c变量名中存储的是什么？
存储的是对象在堆内存中的地址。
3. 成员变量（name、price）的数据放在哪里，存在于哪个位置？
对象中，存在于堆内存中。

面向对象：
3特征：封装 继承 多态
面向对象：Object Oriented Programming 强调的是功能行为，以函数为最小单位，考虑怎么做。
面向过程：Procedure Oriented Programming 将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

类(Class)和对象(Object)是面向对象的核心概念。
类 = 抽象概念的人；对象 = 实实在在的某个人
类是对一类事物的描述，是抽象的、概念上的定义
对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。

常见的类的成员有：
属性：对应类中的成员变量
行为：对应类中的成员方法

Field = 属性 = 成员变量，Method = (成员) 方法 = 函数

创建对象语法： 类名 对象名 = new 类名();
使用“对象名. 对象成员 ”的方式访问对象成员（包括属性和方法 ）
public class Zoo{
public static void main(String args[]){
// 创建对象
Animal xb=new Animal();
xb.legs=4;// 访问属性
System.out.println(xb.legs);
xb.eat();// 访问方法
xb.move();// 访问方法
}
}

10:17 24/05/2022
public
protected 
private

src 源代码
在src里面建文件夹再写类
软件包：全是小写，单词用.分割（文件路径会成为嵌套的文件夹

在同一个包下的类不需要import；引入某个包下所有的类 import com.tty2.*; 

按ctrl + 鼠标左键 点方法进入

子类可以继承父类的属性和行为，但子类不可以用父类私有化属性和方法
父类不可以使用子类的属性和方法
java是单继承模式：一个类只能继承一个直接父类
java不支持多继承，但支持多层继承
java中所有类都是object的子类

继承。。。idea提示中粗体的是自己的方法，细一点的是父类的、

看源码详细之类的 ctrl + 鼠标左

shift + 左右 ： 左右选择

面向对象的特征：
1、“抽象”，把现实世界中的某一类东西，提取出来，用程序代码表示；
2、“封装”，把过程和数据包围起来，对数据的访问只能通过已定义的界面；
3、“继承”，一种联结类的层次模型；
4、“多态”，允许不同类的对象对同一消息做出响应。

super()：
1）super()只能用在子类的构造方法中，且必须在第一行
2）在子类的普通方法中可以调用super.属性，super.方法等
3）super()和this()不能同时调用，会导致重复创建对象
this()：表示本身类的构造方法
 
5.方法重写
1）只有方法可以重写，和属性无关
2）子类重写父类的方法：方法名、参数列表必须相同，只有方法体可以不同（否则会变成重载）
3）子类的修饰符可以扩大，但不能缩小：public>protected>default<private
4）子类抛出的异常范围可以缩小但不能扩大：ClassNotFoundException<Exception

10:40 25/05/2022
static 静态的 属于类的方法 即访问它不需要实例对象就能访问
void 即这个方法没有返回值

ctrl 新标签
shift 新窗口

静态方法与非静态方法的区别
1，写法不同，静态方法有修饰词static
2，静态方法是与类同时加载的，而使用非静态方法时，需要实例化（即new）才能存在
3，如果非静态方法未被实例化，静态方法中不可以使用非静态方法

方法签名
方法体 {}内的东西
一个方法要不有方法体要不定义为抽象的方法，但抽象的方法又必须在抽象类里。且抽象方法不能直接创建对象。
抽象类里也能写普通方法，抽象类里没抽象方法也不会报错。

抽象类
含有抽象方法的类就叫抽象类。而抽象方法就是被abstract修饰的方法，这个方法可以没有具体的实现。
在抽象类的子类中必须对抽象方法进行重写，当其子类为抽象类时，可以不重写抽象方法，但在其子类中一旦有普通类，则必须重写父类继承的所有抽象方法。
抽象类不可以实例化。抽象类的构造方法作用为初始化子类对象。
抽象类存在的意义就是为了被继承。
抽象类中的普通属性和普通方法都需要用子类的对象去调用。
普通类
普通类可以实例化，实例化后可以调用自己类中的属性和方法或父类的方法和属性。
普通类的构造方法中必须要调用父类的构造方法
如果普通类继承了抽象类，那么必须要重写所有父类的抽象方法
普通类存在的意义就是实例化。
普通类和抽象类的区别总结
1、抽象类的存在时为了被继承，不能实例化，而普通类存在是为了实例化一个对象
2、抽象类的子类必须重写抽象类中的抽象方法，而普通类可以选择重写父类的方法，也可以直接调用父类的方法
3、抽象类必须用abstract来修饰，普通类则不用
4、普通类和抽象类都可以含有普通成员属性和普通方法
5、普通类和抽象类都可以继承别的类或者被别的类继承
6、普通类和抽象类的属性和方法都可以通过子类对象来调用

编程错误：语法，逻辑

09:58 26/05/2022
ctrl n idea中的搜索

字符型和字符串型的区别：
1.字符串型是由一对双引号括起来的字符序列如"abc"；
2.字符常量使用单引号括起来；
3.字符常量只能是单个字符，而字符串常量包含一个或者多个字符；
4.字符常量赋予一个字符变量，但是不能将一个字符串常量赋予一个字符变量，在C语言中没有  相应的字符串变量，但是可以用一个字符数组来存放一个字符串常量：如：char [] s = "abcde";
5.字符常量栈一个字节的内存空间，字符串常量的内存字节数等于字符串字节数加1，增加的一  个自己中存放字符"\0",这是字符串结束符；注意字符'a',与字符串"a"在内存中存储的情况不同。

java进行转义的方法:在需要转义的字符前加上“\”即可进行转义,使得该字符具有不同于该字符单独出现时的语义;例如:“\0”表示空字符,“\t”表示水平制表,“\n”表示换行,“\r”表示回车、“\b”表示退格等等。

==:
基本类型：比较的是数据值是否相同
引用类型：比较的是地址值是否相同

通过new创建的字符串对象：每次new都会申请一个新内存空间，虽然内容相同但地址不同
String str2 = new String();
以""给出的字符串，只要内容相同，无论在代码中出现几次，jvm都是只建立一个string对象，并在字符串池中维护
String str = "";

函数可以有返回值，也可以没有返回值。
（1）没有返回值的函数：功能只是完成一个操作，应将返回值类型定义为void，函数体内可没有return语句。
（2）有返回值的函数：函数的最后会有一个返回值return，可以用来获取该函数执行结果返回给该函数，让外部调用该函数的。

有些软件安装了，快捷方式也放在了桌面，但是win处Cortana搜索不到这个应用。
解决方法：
进入开始菜单文件夹C:\ProgramData\Microsoft\Windows\Start Menu\Programs，将桌面上的快捷方式复制过来。

选中发发 CTRL b 跟进
选中直接按ctrl f可搜索关键字
idea界面CTRL n 看方法源码

08:43 31/05/2022

java基础复习：

java编译器：javac
class后缀在jvm上运行
类名要和java文件名相同，一个java文件可以写多个类，但只能有一个有main方法的类

/* */
//
/** 再按回车

jvm：虚拟机
jre：运行环境（包含jvm ；除了.class的运行环境jvm还包含java的一些类库
jdk：开发包 （包含jvm和jre

java变量：指向一个值或对象；一个数据存储空间的表示

java语言层面没指针，

变量命名：首字母可以字母 $ _ 开头，不能以数字开头

String是引用数据类型

不能把double赋值给float，但反过来可以
目标类型要大于源类型
float score = 58.9； 报错
float score = 58.9f； 可以
float score = (float)58.9； 可以

sout((int) a);  97
sout(10 + a); 107
char可以和整数int相加

常量：final
常量名通常大写
不同字符使用下划线分割
初始化(赋值)后不能改变，一般定义后就初始化

导入scanner类
import java.util.*;
创建scanner对象
Scanner input = new Scanner(System.in);
获得键盘输入的数据
姓名：String name = input.next();
电话：int num = input.nextInt();

不引入3方变量temp实现2数交换：加减
int num1 = 5;
int num2 = 6;
num1 = num1 + num2; //11
num2 = num1 - num2; //5
num1 = num1 - num2; //6

计算器： ctrl r ：calc
用programmierer的可以算不同的进制

sout(++i);
先给i加1再打印

| 或
& 与

产生随机数
Math.random():[0,1)

运算符优先级：
！> 算数 > 关系 > 逻辑
& > |
() 优先级最高
= 优先级最低

选择结构：

if （条件：boolean） {
    代码块;
}

字符串比较： .equals()

ctrl shift enter ： 代码自动补全，比如补{}

switch（常量表达式）{
case 常量1：
语句；
break；
....
default：
语句;
}
条件是等值判断
直到碰到break结束，或者自然结束
default顺序可以变，比如放在case1的前面

switch（day）{
case 1：
case 2：
case 3：
sout("work");
break;
}

while
do...while

for（初始化；判断；迭代）{
 语句；
}

while("y".equalsIgnoreCase(answer))
忽略大小写

打印图形：
for循环
如：矩形2层for循环：控制每行个数和行数
如：平行四边形3层：控制行数，打印空格，控制*个数

break
continue

数组：
一个变量，储存相同数据类型的一组数据
在内存空间划出一串连续的空间

标识符，数组元素，元素下标0开始，元素类型

数组长度固定不变，避免数组越界

[]可以写在类型后也可写在变量后

声明数组
int[] a; 或 int a[]; //数据类型 数组名 // int[] a; c#  // int a[]; c
分配空间 //调用数组的构造函数
a = new int[5]; //int 4字节 分配了20字节 //没赋值前都是0
赋值
a [0] = 8;
处理数据
a [0] = a[0] * 10;

边声明边赋值
int[] scores = {4,5,6};
int[] scores = new int[] {4,5,6}; //不能指定数组长度！

iter迭代

for(int score:scores){//第一个定义一个变量，第二个是要遍历的数组
//定义的变量必须和遍历的数组类型一致。
System.out.println(score);
}

lambda表达式

语法上java支持多维数组
内存分配原理来说只有一维数组

二维数组：
int[][] scores;
scores = new int[5] [50]
或
int[][] scores = new int[5] [50]
或
int [] [] scores = new int [5] [];  //但 int [] [] scores = new int [] []; 是错误的 // 二维数组是以一维数组做元素的数组

多重循环时：循环少的放在外层

09:09 01/06/2022
oop：
类和对象：类模板class，模板new出一个一个的对象

结构化开发和面向对象开发

类图
+ public（访问修饰符
- private

School center = new School();
栈stack :center
堆heap :schoolName=北京中心
方法区 ：class School

copy代码可能没编译就运行报错，在out里看看有没有，再编译一下就能运行了

idea改名：shift f6

新建平行的包：不用复制名字，直接在下面新建然后把.删掉

注释： /* 或  /**再回车是有区别的

没加static方法叫实例方法
在同个类下的main也不能直接调用另一个实例方法
得new实例化

/*这样把注释写在代码里*/

形参 实参
调用方法实参不用加参数类型

javadoc 
写注释帮助生成帮助文档

值的副本（参数为原始类型
基本数据类型和引用数据类型数据在传参的区别
c#可以ref引用传递，java不行

一个java文件里只能有一个public class 且同名

java只存在一种传递：值传递
只是传的内容不一样，原始类型传值的副本，引用类型传地址的副本

构造方法和普通方法不同，
构造方法没有返回值，名字和类名相同，可以指定参数
参数本质是一个局部变量

方法重载：
参数项不同：如无参构造方法和有参构造方法
方法的重载和返回值类型无关：方法的调用者可以忽略返回值（在调用点并没有任何其他的变量接收这个返回值，虽然它就返回了，但调用点返回了以后就被“丢弃”了。
但方法的参数无法忽略

idea快捷键
alt+insert：generate

this（name）代表调用另外一个构造函数，必须是第一句

变量声明的位置决定变量作用域
变量作用域确定可在程序中按变量名访问该变量的区域
在同一个方法中，不允许有同名局部变量
在不同的方法中，可以有同名局部变量
Java会给成员变量一个初始值
Java不会给局部变量赋予初始值
在同一个类中，成员变量和局部变量同名时，局部变量具有更高的优先级

09:14 02/06/2022
作为java源代码第一条语句：用package声明包，；结尾
包名都是小写。。。

import java.util.*;      //导入java.util包中所有类(*对效率性能没影响
import cn.jtest.classandobject.School;    //导入指定包中指定类
1. 系统包：java.util
2. 自定义包：cn.jtest.classandobject

一个类同时引用了两个来自不同包的同名类
必须通过完整类名来区分

每个包都是独立的，顶层包不会包含子包的类

package和import的顺序是固定的
package必须位于第一行（忽略注释行）
只允许有一个package语句
其次是import
接着是类的声明

Java_package和 import
package和 import都是Java关键字
package语句作为Java源文件的第一条语句，指明该文件中定义的类所在
的包。(若缺省该语句，则指定为无名包)。
package的语法格式:package 顶层包名.子包名 ;
package对应于文件系统的目录，package语句中，用 “.” 来指明包(目录)的层次；
package通常用小写单词标识。通常使用所在公司域名的倒置com.atguigu.xxx

Java_import关键字
为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)。
import语句告诉编译器到哪里去寻找类。
import语法格式：import 包名. 类名;
//import pack1.*;表示引入pack1.pack2包中的所有结构

Java_import关键字重点
在源文件中使用import显式的导入指定包下的类或接口
声明在包的声明和类的声明之间。
如果需要导入多个类或接口，那么就并列显式多个import语句即可
可以使用java.util.*的方式，一次性导入util包下所有的类或接口。
如果导入的类或接口是java.lang包下的，或者是当前包下的可以省略import语句。
如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。
如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
import static组合的使用：调用指定类或接口下的静态的属性或方法

类的访问修饰符：
default默认就是包级别的访问

在有参构造函数中，对于要保护的参数，不要this.name=name;赋值，调用setName（name）;赋值

构造函数new的时候调用

静态属性属于类，不属于对象，访问应最好通过类名而不是对象；在方法区且只有一份
静态方法不能有this super，因为静态和对象没关系
类名首字母大写，对象instance的小写
实例属性是对象
静态方法只执行一次，实例的构造函数每new一次构造方法执行一次
静态初始化比实例的要早，所以静态方法不能访问实例成员
方法里不能定义static变量，static和类相关

Java中实例变量和静态变量的区别（类变量）
（1）语法定义上的区别
静态变量用static修饰
实例变量没有static修饰
（2）运行区别，实例区别
静态变量在类中，不属于实例对象，属于类所有，只要程序加载了字节码，不用创建实例对象静态变量就会被分配空间，已经可以使用。
实例变量是某个对象的属性，只有实例化对象后，才会被分配空间，才能使用。
类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；
而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象；
实例变量必须创建对象后，才可以通过这个对象来使用；静态变量则可以直接使用类名来引用（如果实例对象存在，也可以通过实例对象来引用），其实这也可以解释，为什么static修饰的方法不用在实例对象创建后，可以调用。而没有static修饰的方法必须要与对象关联在一起，必须创建一个对象后，才可以在该对象上进行方法调！

static变量的作用：
（1）能被类的所有实例共享，可作为实例之间进行交流的共享数据
（2）如果类的所有实例都包含一个相同的常量属性，可把这个属性定义为静态常量类型，从而节省内存空间

c++ 菱形继承

java 单根继承，但可以多接口
构造函数不能被继承

当父类只有带参构造函数，又无法修改父类代码时，在子类创造带参构造函数匹配父类
一般没源码，给的是jar包
public pen(String name,int health,String strain){ 
//假如strain是子类私有的，name health是父类的
super(name,health); //不写super默认调用父类无参，但此时父类没无参，所以得写
this.strain=strain;
}

多态
可以用重写实现多态
instanceof

重载发生在一个同类的内部
override
重写（覆盖）是子类，重写父类的方法
overload

（1）Object类的equals()方法与==没区别
（2）当有特殊需求，如认为属性相同即为同一对象时，需要重写equals()
@Override
public boolean equals(Object obj){
//1.obj和当前对象比较
if(this == obj){return true;}
//2.判断比较对象obj的类型  instanceof
if(!(obj instanceof Student)){return false;}
//3.比较对象的属性
Student s=(Student)obj;
if(s.sid==this.sid&&name.equals(this.name)){return true;}
return false
}
//一旦重写了equals就要重写hashCode
//object对象 objects工具类
（3）Java.lang.String重写了equals()方法，把equals()方法的判断变为了判断其值

父类引用，子类对象

09:14 06/06/2022
instanceof是运算符

接口 has a

一个接口不能实现另一个接口，但可以继承多个其他接口

实现接口的快捷键：alt enter

接口里有默认实现 default 可以选择重写也可以不

swing：java gui

09:14 07/06/2022
堆栈调用轨迹

out标准输出流
err错误流
所以有时输出顺序会错开，2个流

在try-catch块后加入finally块
是否发生异常都执行
不执行的唯一情况：catch里写了System.exit(1)

finally块：主要用来释放资源

09:23 08/06/2022
native 本地方法

Parent child = new Son();//child只能用son里继承parent的方法，相当于只能调用父类的（差不多）。但子类重写的父类方法会将父类方法覆盖，此时调用的父类父类方法是被子类重写的

Son child = new Son();//child能用son里所有的的方法

普通for循环：可以没有遍历的目标，因为一般用索引
增强for（foreach）：要有遍历目标，不用索引

 int[] arr = {5,11,2,4,9,18};
      for(int item :arr){
        System.out.println("元素："+ item);
    }//增强for循环括号里写两个参数，第一个是声明一个变量，变量类型必须是数组元素的类型。第二个就是需要迭代的容器

08:48 13/06/2022
class interface enum

static main方法不能调用实例方法，得先实例化：
public class Demo{
public void dowhat(int day){
....
sout();
return;
...}
psvm{
Demo demo = new Demo();//实例化
demo.dowhat(8);//调用方法
}}

枚举enum常和switch，if else一起用

8大原始类型不是object，没有方法，在栈里
byte,shor,int,long,char,boolean,float,double

character '' 字符
String "" 字符串
Java严格区分单双引号，js不区分

基本数据类型和包装类转换可以自动转换：装箱拆箱
原始类转包装类：Boolean b = new Boolean(true);
字符串转包装类：Boolean b = Boolean.valueOf("true");
Boolean b = Boolean.parseBoolean("tRue");
Boolean类构造方法参数为String类型时，若该字符串内容为true(不考虑大小写)，则该Boolean对象表示true，否则表示false
当Number包装类构造方法参数为String 类型时，字符串不能为null，且该字符串必须可解析为相应的基本数据类型的数据，否则编译不通过

包装类型不能++，那是原始类型的，得+1

正则表达式 .代表任意字符
得转义 \\.

用+进行字符串连接效率低，会生成很多stringbuilder对象
因为字符串一旦初始化是不可改变的

javap是 Java class文件分解器，可以反编译，也可以查看java编译器生成的字节码。用于分解class文件。

9:03 AM 6/14/2022
测试 main方法或maven junit？？

文件后缀名是为了打开文件好关联软件
文件也可以没后缀名

栈：先进后出
队列：先进先出 stream

stream：字节方式
reader wirter：字符方式