第一阶段＞＞＞Java基础进阶 OOP/Reflect/注解/IO流/API核心

>>>java基础01—结构以及类型

>>>java基础02—初识数组

>>>java基础03—面向对象OOP

>>>java基础04—构造方法(函数)/构造代码块/this/继承

>>>java基础05—static/final/静态代码块/重载/super

>>>java基础06—多态&异常及解决方案

>>>java基础07—抽象类、接口

>>>java进阶01—StringBuilder StringBuffer (掌握string)

>>>java进阶02—正则表达式包装类自动装箱/自动拆箱

>>>java进阶03—IO流/File/字节流/字符流

>>>java进阶04—collection/E/集合接口实现类(子类)

>>>java进阶05—collection/E/集合接口实现类(set与list map)

>>>java进阶06—java进程、线程与多线程、异步、同步锁

>>>java进阶07—设计模式&注解&反射

>>>java基础01—结构以及类型

一、Java中数据类型有几种？

基本类型八种:byte short int long float double char boolean

二、java中常见的语法结构

1.顺序结构从小至下按照逻辑运行代码

2.判断结构

其中分为单分支结构以及多分支结构还有嵌套判断结构

>>>单分支结构 备注:如果只有一条判断if() 可以不用写大括号直接sout输出

If(){

}

>>>多分支结构

If(){

}else{

}

>>>嵌套分支结构

If(){

}else if{

}else{

}

3.循环结构

>>>单循环for 快捷方式fori+回车键

For(开始条件；判断条件；执行条件)｛

执行语句...

｝

>>>嵌套循环for

For(开始条件；判断条件；执行条件)｛

For(开始条件；判断条件；执行条件) {

}

｝

>>>死循环while

While(true)｛

执行语句

｝

>>>先执行的do...while

Do｛

｝while(true){

执行语句

}

4.选择结构

Switch(a);

Case 1 sout break；

Case 2 sout break;

Default+ sout

默写方法的书写格式

方法修饰符public+返回值类型void+方法名main+参数列表()+方法体{ }

>>>java基础02—初识数组

一、理解什么是数组，书写格式以及应用？

数组理解成存储一组数据的组合；

存放多个相同类型的变量。java程序中的数组必须先进行初始化才可以使用,所谓初始化,就是为数组对象的元素分配内存空间,并为每个数组元素指定初始值,而在Java中,数组是静态的,数组一旦初始化,长度便已经确定,不能再随意更改。”

书写格式分静态数组以及动态数组

静态数组：

Int [] a=new int[]{1,2,3,4,5,6};

Int[]a={1,2,3,4,5,6};

动态数组：

Int[]a=new int[6];

数组的一些特性以及它的一些用法？

数组特性

数组是有个名为下标的东西，理解成数组里面每个元素的名字

a[0]=1; a[1]=2; a[2]=3;a[3]=4;a[4]=5;a[5]=6;

上面就是数组，叫做下标书写格式：首下标a[0]=X;

数组也有长度(length),里面有几个元素长度就是几，其中最大的下标为长度-1(length-1)

数组的用法

如果想要查看数组里面的具体元素，不能直接sout+数组名，需要用工具类(toString+数组名)

System.out.Println(Arrays.toString(数组名)) 备注: char类型特殊可以直接查看

如果数组想要排序，从头到尾逐个“过一遍”依次对每个元素均做一次且仅做一次访问。叫做数组的遍历；备注:遍历是访问每一个，并不是排序数组里面的元素。

遍历数组格写法：

for(int i=0; i<数组名.length; i++){

sout(i)>>>>>>这样写输出的只是数组但下标

sout(数组名[i])>>>>>>这样写输出才是遍历后输出数组写法

}

数组排序的写法

大致分为三步>>>第一步创建数组第二步调排序方法第三步打印

int[] c6=new int[]{45,23,14,2,96,102,35,78};
Arrays.sort(c6);
System.out.println(Arrays.toString(c6));

数组的复制扩容缩容截取范围玩法

分步来：复制

第一步创建一个数组

第二步使用Arrays的方法并且定一个新的数组名字

第三步执行类型名+[]+新数组名=Arrays.copyOf(要复制的数组名，数组长度)；

查看复制好的新数组sout+(Arrays.toSting(新数组名));

分步来：扩容

原理同上：第三步为类型名+[]+新数组名=Arrays.copyOf(要扩容的数组名，新的数组长度)；

分步来：缩容

原理同上：第三步为类型名+[]+新数组名=Arrays.copyOf(要缩容的数组名，缩小的数组长度)；

分步来：截取

原理同上：第三步为类型名+[]+新数组名=Arrays.copyOfRange(要截取的数组名，第一个要截取的下标，第二个截止截取的下标)；

>>>java基础03—面向对象OOP

首先学习第一点面向对象其实就是一种思想

其次类是一类事物的总结出来的特征和行为理解成一个模板

对象

对象是根据类创建出一个个独立具体的实例

对象具有各种特征，并且每个特征都可以有自己特定的值

具有各种行为，一个类可以创建多个对象，通过对象的唯一地址值来区分对象

类与对象的关系

类是对象的抽象，对象是类的实体

面向对象的三大特征：

封装：继承：多态

面向对象特征之封装

封装意思是隐藏对象的属性，仅仅对外提供公共的访问方式

好处：提高安全性&提高重用性

什么是匿名对象？

意思就是没有名字的对象，是创建对象的简化形式

比如：OPPO o=new OPPO(); o.play();

等价于new.OPPO().play();

>>>java基础04—构造方法(函数)/构造代码块/this/继承

一、什么是构造函数？

就是构造方法里面的代码就是构造函数

二、什么是构造方法呢？展开梳理下结构：

构造方法分为三种：

无参构造/含参构造/全参构造

构造方法的作用：

主要功能就是完成对象创建或者初始化
当类创建对象(实例化)时,就会自动调用构造方法
构造方法与普通方法一样也可以重载

书写格式：与类同名,且没有返回值类型,可以含参也可以不含参

无参构造格式：方法修饰符+类名（）{}

含参构造格式：方法修饰符+类名（参数1）{}

全参数构造格式：方法修饰符+类名（参数1，参数2，参数3）{}

三、什么是构造代码块，什么是局部代码块？有什么作用？

构造代码块：

格式：{ 这就是构造代码块 }

位置: 类里方法外

用途:用于抽取构造方法中的共性代码

这个意思比如在构造代码块中下面整些构造方法，方法里面都有共同的一个输出

把这个共同输出的的提取出来就可。

局部代码块：

格式:{ 局部代码块也就是这样}

位置:方法里

用途:控制变量的生效范围，出了{ } 就没有效果了->

意思比如在里面定义了变量，就必须在里面控制台输出，出去{}就没反应

四、关键字this如何使用？应用场景？

this意思代表的是本类引用的一个对象, 一般是有变量名相同的时候使用

格式this.name=name;

用途：成员变量与局部变量同名时，可以使用this指定本类的成员变量，不然会遵循就近原则打印。

笔记：创建对象的流程

Person p = new Person();//短短这行代码发生了很多事情

1.把Person.class(JVM虚拟机负责下载jdk里面自带 )文件加载进内存

2.在栈内存中，开辟空间，存放引用变量p

3.在堆内存中，开辟空间，存放Person对象

4.对成员变量进行默认的初始化（理解成赋值默认一般是空的地址值）

5.对成员变量进行显示初始化。（赋值过程）

6.执行构造方法（如果有构造代码块，就先执行构造代码块再执行构造方法）

7.堆内存完成之后

8.把堆内存的地址值赋值给变量p ，p就是一个引用变量，引用了Person对象的地址值

什么是继承？有什么作用呢？

这个东西字面意思，继承家产之类，这个出生由来主要是因为继承使得复用以前的代码非常容易,能够大大的缩短开发的周期,降低开发费用。

继承的一些特点总结：

1.继承的关键字extends 格式：子类 extends 父类

2.继承相当于子类把父类的功能复制了一份，包括私有资源

3.Java只支持单继承：一个子类只能有一个父类，一个父类可以有多个子类

4.继承具有传递性：爷爷的功能会传给爸爸，爸爸的功能会传给孙子

5.子类只可以使用父类的非私有资源，私有资源不可用的原因是不可见

6.子类可以拥有自己的特有功能

7.继承是is a 强耦合的关系，依赖性非常强。

>>>java基础05—static/final/静态代码块/重载/super

一、老规矩名称解释：

static静态

用途：用来修饰成员变量和成员方法

常见用法的几个静态用法：

1.被static修饰过的方法类名可以直接调用静态方法

2.静态资源可以调用静态资源

3.普通资源可以调用静态资源

4.静态资源不可以调用普通资源

备注知识点1：被static修饰的资源为静态资源随着类的加载而加载（只加载一次），一般用于项目的初始化，最先加载优先于对象进行加载/静态资源只能调用静态资源，静态区域内不允许出现this super

备注知识点2：静态资源在内存中只有一份，而且被全局所有对象所共享 * 所以：当我们通过任意一种方式修改了静态变量的值以后 * 不管用何种方式查看，静态变量的值都是刚刚修改后的值。（啥意思呢？整个类，类里整个属性，static修饰下成为静态资源属性，上面方法中创建两个对象，整2个变量。给static修饰过的属性赋值，然后用类调用这个资源得到一个值，后面变量再调用值不变）

构造代码块：

定义:直接在类中定义且没有加static关键字的代码块称为{}构造代码;

书写格式：{ 构造代码块}

作用:给对象统一初始化数据

备注:构造代码块会在构造函数被调用时执行

构造代码块注意点：
java编译器编译java类时，会先将成员属性的声明放到类的前端

成员变量的初始化工作放到构造函数中

如果类中有构造代码块，java编译器在编译时会先将构造代码块中的代码移到构造函数中执行，构造函数中原有的代码最后执行，成员属性的初始化和构造代码块的执行顺序是根据原码中的位置执行

局部代码块：

定义：在函数中的代码块，写在方法中，构造是在类里

作用：在方法中，如果要缩短变量的寿命，可以使用

方法中，某段代码之后，都不再使用某个变量（这个变量有可能是一个很大的Map集合，很占内存），则可以将其定义到局部代码块中，及时结束其生命周期，释放空间！

void run(){

{局部代码块出了局部代码块就没有任何作用}

}

静态代码块：

定义：在java中使用static关键字声明的代码块。

作用：静态块用于初始化类，为类的属性初始化。每个静态代码块只会执行一次。
由于JVM在加载类时会执行静态代码块，所以静态代码块先于主方法执行。

注意：静态代码块不能存在于任何方法体内。2 静态代码块不能直接访问静态实例变量和实例方法，需要通过类的实例对象来访问。

执行顺序：执行顺序：构造代码块>构造方法>对象创建成功>普通方法>局部代码块

final是啥？？？

概念:final是java提供的一个关键字最终的意思

作用:可以修饰类、方法、字段(属性)

到底干毛的？>>>>java出现继承后，子类可以更改父类的功能，但是当父类功能不许子类改变时,可以利用final关键字修饰父类(属性或者方法)。加了这个子类就继承不了父类里用final修饰的属性或者方法。

final特点：

被final修饰的类，不能被继承

被final修饰的方法，不能被重写

被final修饰的字段是个常量，值不能被修改

常量的定义形式：final 数据类型常量名 = 值

super

super使用须知：

我们可以把super看作是父类的对象：Father super = new Father();

1.当父类的成员变量与子类的变量同名时，使用super指定父类的成员变量

2.使用super在子类构造方法的第一行调用父类构造方法的功能

super();>>>调用的是父类的无参构造

super(参数);>>>调用的是父类对应参数的构造方法

注意:在构造方法里,出现的调用位置必须是第一行

二、什么叫做方法的重写与重载

重写（override）

继承以后,子类就拥有了父类的功能，在子类中,可以添加子类特有的功能,也可以修改父类的原有功能，子类中方法的签名与父类完全一样时,会发生覆盖/复写的现象。

重写要求：遵循两同两小一大
两同:方法名参数列表要完全一致
两小:1.子类返回值类型小于等于父类的返回值类型(注意此处说的是继承关系,不是值大小)
2.子类抛出异常小于等于父类方法抛出异常
一大:子类方法的修饰符权限要大于等于父类被重写方法的修饰符权限

重载:(overload)

在一个类中的现象：同一个类中，存在方法名相同，参数列表不同的方法

重写与重载的意义：

重载的意义：是为了外界调用方法时方便，不管传入什么样的参数，都可以匹配到对应的同名方法
重写的意义：在不修改源码的情况下，进行功能的修改与拓展（OCP原则：面向修改关闭，面向拓展开放）

>>>java基础06—多态&异常及解决方案

一、什么叫做多态？用在什么地方？怎么用？

多态就是面向对象的特征之一，指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。把子类看成是父类。苹果梨香蕉都是水果。

注意：多态对象只能调用父类中定义子类中重写的功能,并不能调用子类的特有功能(意思是封装了的),这样就实现了代码的统一。

什么情况下可以用多态？

多态的两个前提：

第一要有继承关系

第二要有方法的重写

Animal a = new Cat() 编译看左边，运行看右边

多态实际业务应用：

不管对象是什么类型，就可以使用该对象的某些方法，并且提高了程序的扩展性和可维护性

成员变量: 使用的是父类的

成员方法: 由于存在重写现象,所以使用的是子类的

静态成员: 随着类的加载而加载,谁调用就返回谁的

二、静态变量和实例变量的区别

静态变量需要加static关键字，实例的不用加
静态变量属于类也叫做类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。

总结：实例对象需要创建对象才可以通过这个对象来使用，静态变量则使用类名来使用

三、向上转型和向下转型

向上转型：可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。

啥意思呢？子类对象当成父类对象，只能调用父类的功能，如果子类重写了父类中声明过的方法，方法体执行的就是子类重过后的功能。但是此时对象是把自己看做是父类类型的，所以其他资源使用的还是父类型的。(子类不能调用自己的属性)

向下转型：子类的引用的指向子类对象，过程中必须要采取到强制转型。这个是之前向上造型过的子类对象仍然想执行子类的特有功能，所以需要重新恢复成子类对象

Parent p = new Child();//向上转型，此时，p是Parent类型
Child c = (Child)p;//此时，把Parent类型的p转成小类型Child

四、什么是异常？异常一般怎么处理？

定义：异常是一些用来封装错误信息的对象

处理方式：一般是捕获或者是向上抛出两种方式；

>>>捕获方式：try{
需要捕获的代码

}catch(异常类型异常名){

处理方案

}

>>>向上抛出方式：throws Exception

位置：括号与花括号中间

备注：throw与throws区别

throws位置是在方法声明处，后面是异常类的名字

表示此方法会抛出异常，需要由本方法的调用者来处理这些异常
注意：这只是一种可能性，异常不一定会发生

throw位置是在方法的内部，后也是跟着异常对象的名字

表示此处抛出异常，由方法体内的语句处理

>>>java基础07—抽象类、接口

一、什么是抽象类？概念是什么？

Java中可以定义被abstract关键字修饰的方法,这种方法只有声明,没有方法体,叫做抽象方法.

Java中可以定义被abstract关键字修饰的类,被abstract关键字修饰的类叫做抽象类

抽象方法的格式：

权限修饰符 abstra 返回值类型方法名(参数列表) public abstract void main(){}

抽象类的一些特点：

抽象类中可以没有抽象或者半普半抽
如果类中有抽象方法，那么这个类就是第一个抽象类
子类继承了抽象类以后,要么还是一个抽象类,要么就把父类的所有抽象方法都重写

意思就是要么变成一个抽象类，要么就是重写抽象方法

abstr注意事项：

1.private：被私有化后，子类无法重写，与abstract相违背。
2.static：静态优先于对象存在，存在加载顺序问题。
3.final：被final修饰后，无法重写，与abstract相违背。

二、什么是接口，干啥用的，实际业务中怎么应用？？

接口( Interface )在Java中也是一种抽象类型，接口中的内容是抽象形成的需要实现的功能,接口更像是一种规则和一套标准.

拓展理解：

一.为什么要使用接口

假如有一个需求：要求实现防盗门的功能。门有"开"和"关"的功能，锁有"上锁"和"开锁"的功能。

分析：首先防盗门是一个门，门有开门和关门的功能，还有一把锁，锁有开锁和上锁，按照面向对象的编程的思想，我们会将门和锁都作为一个类而单独存在，但是，不能让防盗门继承自门的同时又继承自锁，防盗门不是锁，不符合继承中is a的关系，在java中支持单继承。那么我们如何来解决这一问题，这时就要用到接口。

二.什么是接口

在软件中接口是一种规范和标准，他们可以约束类的行为，是一些方法特征的集合，但是没有方法的实现，接口其实上也可以看做是一个特殊的抽象类，但是采用和抽象类完全不同的方法来表示，两者的设计理念也是不同的，抽象类有利于代码复用，接口利于代码的扩展和维护。

三.抽象类和接口的区别：

01抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法；

02.抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的；

03.接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；

04.一个类只能继承一个抽象类，而一个类却可以实现多个接口。

接口格式: interface 接口名{ 代码 ...}

接口特点：

通过interface关键字来定义接口

通过implements让子类来实现接口

接口突破了java单继承的局限性

接口和类之间可以多实现,接口与接口之间可以多继承

接口是对外暴露的规则,是一套开发规范

接口提高了程序的功能拓展,降低了耦合性

综合总结

总结—接口

我们通过interface关键字定义接口

接口实现类需要通过关键字implements与接口建立实现关系

接口不可以创建对象/实例化

在Java8中，接口中所有的方法都是抽象方法，方法可以简写，会自动拼接public abstract

接口中没有构造方法,接口实现类调用的构造方法是父类的，不是父接口的

注意:如果一个类没有明确指定父类的话，会默认继承顶级父类Object

接口中没有成员变量，都是静态常量，默认会拼接public static final

接口不是类！！！你可以把接口理解成一个特殊的抽象类，特殊在，所有的方法都是抽象方法

如果一个实现类实现了接口，要不变成一个抽象子类【不实现/实现部分】，要不变成一个普通子类【全部实现】

接口是用来制定规则的【有哪些方法，方法有参数吗？有返回值类型吗？】，并不做具体的实现

接口可以多继承【一个接口可以继承多个接口】多实现【一个类可以实现多个接口】

总结—类与类的关系

继承关系，只支持单继承

比如： class A extends B ,A是子类，B是父类，子类具备父类的所有功能

子类不能使用父类的私有资源，原因是私有不可见

继承相当于子类把父类的功能复制了一份，但是构造方法不可继承

子类如果想要在不改变父类功能的前提下，实现功能的修改与拓展，可以重写

重写遵循的原则：两同两小一大

注意：方法名+参数列表称为：方法签名

总结—接口与接口的关系

继承关系，既可以单继承，也可以多继承

比如：interface A extends Inter1{}

比如：interface B extends Inter,inter2{}

A是Inter1的子接口

B是Inter1与inter2共同的子接口

注意：如果是B的普通实现类

就需要实现B接口以及B接口从Inter1与Inter2接口中继承下来的所有抽象方法

总结——类与接口的关系

实现关系，即可以单实现，也可以多实现

比如: class A implements Inter1{ }

比如: class B implements Inter1,Inter2{ }

A是Inter1接口的子实现类

B是Inter1与Inter2接口共同的实现类

注意：B就需要实现Inter1与Inter2接口的所有抽象方法，否则就是一个抽象子类

注意：如果有任何一个抽象方法没有实现，那么这个类一定是一个抽象子类

我们一般创建的都是接口实现类的对象，不用创建多态对象那么麻烦

总结——抽象类与接口的比较

1.抽象类是一个特殊的类，这个类被abstract修饰，并且可以存在抽象方法

2.接口可以看作是一个特殊的抽象类，接口里面所有的方法都是抽象方法

但是注意：接口不是类，接口使用interface关键字来定义

3.抽象类中有构造方法，但接口中没有构造方法

注意：抽象类的子类调用的就是抽象类的构造，但接口的实现类调用的是自己父类的构造方法

抽象类与接口均不可以创建对象

接口可以多继承，抽象类只能单继承

抽象类中可以定义普通的成员变量，但接口中都是静态常量

抽象是后天重构的结果，接口是先天设计的结果

>>>java进阶01—StringBuilder StringBuffer (掌握string)

一、理解string这个东西到底是有什么用处的？

理解String它就是一个封装char[ ]数组的对象,字符串不可变，通过下图中的底层实现可以看出:被final修饰,是常量String str = “abc”; 等价=> char data[] = {‘a’, ‘b’, ‘c’};

String的创建方式

方式一：

char[] values = {‘a’,‘b’,‘c’};
String s1 = new String(value);
注意：每new一次，创建一个String对象，存在堆中

方式二：String s = “abc”;

注意：存在堆中的常量池中，有高效的效果，如果是第二次创建，不会新建

注意：== 比较的如果是引用类型，那么是地址值

注意：String重写了Object中的toString(),所以可以直接打印字符串的具体内容

String重写了Object中的equals(),所以比较的也是两个字符串的具体内容

String的一些常用方法：

String toUpperCase() 所有字符都转换为大写。

String toLowerCase() 所有字符都转换为小写

boolean startsWith(String prefix) 测试此字符串是否以指定的元素开头。

boolean endsWith(String suffix) 测试此字符串是否以指定的字符串结束。

char charAt(int index) 返回指定索引/下标处的 char 值/字符

int indexOf(String str) 返回指定字符在此字符串中第一次出现处的索引。

int lastIndexOf(String str) 返回指定字符在此字符串中最后一次出现处的索引。

String concat(String str) 将指定字符串连接/拼接到此字符串的结尾,注意:不会改变原串

String[] split(String regex) 根据给定元素来分隔此字符串。

三、什么是 StringBuilder？什么意思怎么用？什么是StringBuffer？

在执行效率上，StringBuilder > StringBuffer > String
StringBuffer是线程安全，可以不需要额外的同步用于多线程中;

StringBuilder是非同步,运行于多线程中就需要使用着单独同步处理，但是速度就比StringBuffer快多了;

StringBuffer与StringBuilder两者共同之处:可以通过append、indert进行字符串的操作。

源码体现：本质上都是在调用父类抽象类AbstractStringBuilder来干活，只不过Buffer把代码加了同步关键字，使得程序可以保证线程安全问题。

String：适用于少量的字符串操作的情况

StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况

StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

>>>java进阶02—正则表达式包装类自动装箱/自动拆箱

一、什么是正则表达式？

正则表达就是一个正确的字符串格式规则，常用来判断用户输入的内容是否符合格式的要求，注意是严格区分大小写的。

一般是有速查表可以查看

二、什么是包装?

Java的数据类型只有两大类：8大基本类型与引用类型;

包装类是引用类型中的一种，包装类与基本类型一一对应，也有8种;

基本类型只能存自己类型的值，没有其他额外的功能;

包装类型是对基本类型进行了包装，提供了丰富的功能，包装类型是基本类型的拓展;

包装类型Integer的创建方式

1）Integer i1 = new Integer(5); 没有高效的效果，new一次，创建一个包装类对象

2）Integer i2 = Integer.valueOf(5); 有高效的效果，数据在-128~127的范围内，才有高效的效果

3）Integer i3 = 5; 自动装箱：编译器会把int类型5装箱，变成Integer，底层调用的方法：valueOf(5)

包装类型Double的创建方式

1）Double d1 = new Double(3.4); 没有高效的效果，new一次，创建一个包装类对象
2）Double d2 = Double.valueOf(3.4);这个也没有高效的效果，只有Integer有

Integer的常用方法：i1.parseInt(“80”);将字符串80转成int类型的80
Double的常用方法：d1.parseDouble(“80”);将字符串80转成double类型的80

什么自动装箱与自动拆箱的？

自动装箱概念：

把基本类型包装成对应的包装类型的过程
Integer a = 5;//a是引用类型，引用了包装对象的地址。
编译器会完成对象的自动装箱：Integer a = Integer.valueOf(5);

自动拆箱概念：

从包装类型的值，自动变成基本类型的值
int i = a;//a现在是包装类型，没法给变量赋值，需要把5取出来。
编译器会完成自动拆箱：int i = a.intValue();

>>>java进阶03—IO流/File/字节流/字符流

一、什么是IO流？

字面意思input以及output的流

而根据处理的数据单位不同,可以把流分为字节流和字符流

二、怎么理解字节流处理二进制文件以及字符流处理文本文件

文本文件是基于字符编码的文件—比如ASCII编码UNICODE编码

举列子：01000000_01000001_01000010_01000011 记事本打开字符流就是ABC(ACSII编码)

二进制文件是基于值编码的文件，可以根据具体应用，指定某个值是什么意思（可以看作是自定义编码)

举列子：01000000_01000001_01000010_01000011 记事本字节流就是01000...

常用到的流：

File
字节流:针对二进制文件
InputStream
FileInputStream
BufferedInputStream
ObjectInputStream
OutputStream
FileOutputStream
BufferedOutputStream
ObjectOutputStream
字符流:针对文本文件
Reader
FileReader
BufferedReader
InputStreamReader
Writer
FileWriter
BufferedWriter
OutputStreamWriter
PrintWriter一行行写出

>>>java进阶04—collection/E/集合接口实现类(子类)

首先掌握集合概念泛型概念实际业务当中的怎么使用理解透彻

一、泛型 <type>

泛型优点1 约束类型功能

<>里面规定是放指定的类型一般是引用类型以及封装类型

泛型优点2 高级的通用代码

使用<E>E表示元素的类型是Element类型不管传入什么类型，都可以匹配上

e是形式参数 g h f之类都可以

eg:

private static <E> void print (E[] e){/*这个就是泛型的方法*/

for (E ddd : e) {

System.out.println(ddd);

}

二、高效for循环使用

for(1 2:3){循环体}

1:本轮遍历到的数据的类型2:遍历到的数据的名字3:指的是要遍历的数据/元2的名字随便

三、collection的方法可以查看API直接变量名调用即可

需要记忆几个常用的方法调用；集合本质是数组

四、有疑问的问题？

Object[] array=c.toArray(); 这个转换数组类型之所以前面是Object是源代码底层规定，而且返回值类型也是object

>>>java进阶05—collection/E/集合接口实现类(set与list map)

一、集合的迭代器(和数组遍历其实是一回事)

操作步骤：

1.获取集合的迭代器 c2.iterator();

2.利用迭代器进行判断当前集合中是否有下一个可迭代的元素 it.hasNext()

3.利用迭代器获取当前迭代到的元素it.next()

备注：

想迭代先用这个集合的对象调用iterator方法

比如c.interator alt+回车接下创建对象出来的泛型会默认和对象类型一样的

【Iterator<Integer> it = c2.iterator();】

举例：

第一步Iterator<Integer> it = c2.iterator();//alt+回车变量名随便起

第二步while (it.hasNext()){//循环判断是否有元素可迭代

第三步Integer num=it.next();//根据迭代器获取本轮迭代到的集合中的元素

第四步System.out.println(num);//打印获取到的本轮迭代到的集合中元素

二、理解创建对象意思阐述

1)Collection<Integer> c=new ArrayList();

这是创建一个多态对象，左边的是一个父类的接口collection 右边是一个子实现类ArrayList

2) ArrayList<Integer> list=new ArrayList<>();

这是纯子类的对象

三、Arraylist与colleciton关系

Arraylist 作为子接口，是有顺序的>>>>>list一般都是和下标有关系的

它底层数据结构是数组，内存空间是连续的

特点：

1.可以存放重复的元素原理是索引值不同所以可以重放(索引就是下标意思一样的)

2.元素有下标并且可以存放重复的元素

3.数据量较大情况，增删慢查询快因为是数组那样的连续的所以块链表那样就慢了

四、list的方法

因为继承于colleciton所以也可以用这个样子的调用c.add()方法

几个不好记得方法

>>>>在集合的指定元素引处添加指定元素

list.add(1,"蛇精");

>>>>获取指定下标的元素

System.out.println(list.get(8))

>>>>修改集合元素中指定元素的值

System.out.println(list.set(5,"蝎子精"));

>>>>在list集合的指定元素索引处开始添加list2的所有元素

System.out.println(list.addAll(1,list2));

五、问题与疑问

关于迭代的多种方法

方法一：(循环逻辑从哪开始到哪结束如何变化)

for(int i=0;i<list.size()-1; i++ ){备注：或者i<list.size()

System.out.println(list.get(i));这个是根据索引获取对应元素调用get

}

备注：i代表集合中元素的索引值，size代表的是元素个数哥就是长度，size-1就是最大下标值也就是最后一个元素

>>>>逆序迭代的编写思路

【第一步先写出正序迭代，判断是否走到头了最后一个元素那里，用if判断看是不返回false这个结果，知道迭代器没有下一个元素可以迭代了if(false),然后有元素时候为真就可以进入大括号执行，进入后判断前面是否有元素可以迭代，然后打印获取到的前面的元素。记得加break不然就会从后往前然后前往后循环】

备注：it3.hasNext是判断后续是否有元素可迭/it3.previous判断前面是否有元素可以迭代

ListIterator<String> it3 = list.listIterator();//

while (it3.hasNext()) {//判断后续是否有元素可迭代

System.out.println(it3.next());

if (!it3.hasNext()) {

System.out.println("开始逆序迭代");

while (it3.hasPrevious()) {

System.out.println(it3.previous());

}

break;

}

六、Linkedlist与colleciton关系

Linkedlist特点：底层结构为链表

1.Linkedlist链表是一种新的数据结构，内存不连续，靠地址引用连起来

2.查询很慢增删快因为链表节点随时断连

3.也可以放重复元素

4.元素也有下标，有序

5.linkedlist头节点只有下一个节点的地址，尾节点有上一个节点的地址

七、linkedlist的不好记方法

/**别名：新增系统*/

System.out.println(list2.offer("斗罗大陆"));//添加尾元素

System.out.println(list2.offerFirst("盗墓笔记"));//添加首元素

System.out.println(list2.offerLast("钢铁是怎样炼成的"));//添加尾元素

System.out.println(list2);

八、Map接口(这玩意不是集合的子类)

理解成一种映射关系成对的

比如泛型<K,V>也就是<键，值>理解成一个钥匙开一个门

<9527 白骨精> 等价于<Interger,Strings>

九、set接口与collection(接口子类 collection的接口实现类)

set这个接口实现类玩意主要是为了去重用的，然后方法也可以继承集合用add

特点：

1.集合中的元素的都是没有顺序的

2.set集合里面元素是不重复

3.set可以存null，但也就是存一个

>>>java进阶06—java进程、线程与多线程、异步、同步锁

一、进程与线程

进程就是一个打开一个程序一个软件

线程就是一个软件里面的菜单栏里面展开的小功能依次理解

一个进程可以包含多个线程也可以单个(单线程)

然后那个CPU是同一时刻只能处理一件事

二、理解线程的状态

就绪>执行状态>阻塞状态

线程创建中申请的PCB值得是一个控制块，里面存的是当前线程的情况和活动过程

并且只有就绪才能转执行状态

多线程实现的方案(Thread )

方式一

1.记住通过继承Thread类并重新run()来完成的

2.重写run()里面是我们的业务

3.创建多个线程对象

4.线程对象调用start,以多线程的方式启动

方式二

1.自定义多线程类实现Runnable接口

2.添加抽象方法run

3.创建自定义类对象，作为目标业务类对象

4.创建多个线程对象thread,

5.以多线程方式启动刚建好的多个线程对象start();

举例：方式一记住这个是继承 extends Thread

Mythread t1=new Mythread();

Mythread t2=new Mythread();

Mythread t3=new Mythread();

Mythread t4=new Mythread();

t1.start();

t2.start();

t3.start();

t4.start();

class Mythread extends Thread{

@Override

public void run()

for (int i = 0; i <10 ; i++) {

System.out.println(i+"="+getName());}

举例：方式二这个是用到实现类接口 implements Runnable

通过图中方法让runnable和thread建立关系然后target就是runnable接口实现类的对象

MyRunnable target=new MyRunnable();

Thread t1=new Thread(target);

Thread t2=new Thread(target);

Thread t3=new Thread(target);

Thread t4=new Thread(target);

t1.start();

t2.start();

t3.start();

t4.start();

}

class MyRunnable implements Runnable{

@Override

public void run() {

for (int i = 0; i <10 ; i++) {

备注：curerntThread()是静态方法，可以被类直接调用，这个方法作用是获取当前正在执行的线程对象，咋们把它当作一个中转站，然后用 getname()再调用当前线程的名称

System.out.println(i+"="+Thread.currentThread().getName());

}

多线程实现的方案(Thread )

线程池理解

它的工具是Executors，这玩意是辅助创建线程池的工具类

方法：newFixedThreadPooL(int)括号里是定线程的数目；

举例：

上面那个中的子类部分不变动，公共类上面就换成了如下，就是提高了效率，不用一个线程创建一个对象了，这么个意思的

TicketRunnable2 target =new TicketRunnable2();

ExecutorService pool = Executors.newFixedThreadPool(5);//使用Exectors工具的方法
//循环启动线程
        for (int i = 0; i <5 ; i++) {
/**execute() 让线程池中的线程来执行业务，每次调用这方法，都会将一个线程加到就绪队列中
*这个方法的参数，就是我们要执行的具体业务，也就是目标业务类对象target*/
            pool.execute(target);
        }

>>>java进阶07—设计模式&注解&反射

一、单列设计模式

这个概念是主要目的就是为了节约系统内存空间，控制资源的使用

核心是确保对象有一个这个要用到RunTime接口

关于单例设计模式的两种设计方式：

* 1.饿汉式：不管你用不用这个类的对象，都会直接先创建一个

* 2.懒汉式：先不给创建这类的对象，等你需要的时候再创建--延迟加载的思想

* 延迟加载的思想：是指不会在第一时间就把对象创建好占用内存

* 而是什么时候用到，什么时候再去创建对象

* 3，线程安全问题：由于我们存在唯一对象single2，并且多条语句都操作了这个变量

* 如果将程序放到多线程的环境下，会容易出现数据安全的问题，

* 所以解决方案:（待补充）

怎么理解注解

这玩意是Java 1.5 开始引入的一种标注，相当于给代码打一个 tag、作一个标记。

有毛用？

编译器:让编译器 / APT根据注解的定义，去执行一些逻辑

运行期:让虚拟机根据字节码中的注解，执行一些逻辑

先这样理解：创建一个文件或一段代码，类型为 @interface。这样该 “类” 就变成了一个注解，为什么 “类”
要加引号呢，因为真正的类是 class 修饰的，而 @interface 修饰的就是一个注解。

语法格式@+类型+注解名

这个玩意一共分个三类

JDK自带注解>>>展开有5个

1.@SuppressWarnings(“deprecation”)

2.@Override :用来标识重写方法

3.@Deprecated标记就表明这个方法已经过时了，但我就要用，别提示我过期

元注解>>>展开有5个

@Target 注解用在哪里：类上、方法上、属性上等等

@Retention 注解的生命周期：源文件中、字节码文件中、运行中

@Inherited 允许子注解继承

自定义注解>>>

注意：注解的语法写法和常规java的语法写法不同

使用”ElementType.静态常量“的方式自定义注解具体可以加在什么位置

三、怎么理解反射

反射就是可以让运行中的 Java 程序对自身进行检查，或者说“自审”，也有称作“自省”。
反射能直接操作程序的私有属性。也可以当想使用别人的东西或者是资源时候，可以使用反射技术。反正不能直接看到源代码，就可以用反射技术

反射中单元测试方法：是java中最小的测试单位，使用灵活
语法要求：@Test+public+void+没有参数

<?> 代表是这个泛型范围更加宽广，理解为多态，反正就是约束类型的

反射前提

反射第一步获取字节码对象：

Class.forName(“类的全路径”);

类名.class

对象.getClass();

第二步使用常用方法

获取包名类名

clazz.getPackage().getName()//包名

clazz.getSimpleName()//类名

clazz.getName()//完整类名

获取成员变量定义信息

getFields()//获取所有公开的成员变量,包括继承变量

getDeclaredFields()//获取本类定义的成员变量,包括私有,但不包括继承的变量

getField(变量名)

getDeclaredField(变量名)

四、理解字节码对象

.class"文件的对象就是字节码对象。jvm会把.class文件加载到内存，并在堆里创建字节码对象并初始化字节码对象的静态属性，并把类型信息等加载到方法区。

先说说字节码是一种包含执行程序，由一序列 op 代码/数据对组成的二进制文件，是一种中间码。然后字节码对象。java世界里，一切都是对象，可分为两种对象，Class对象和实例对象。每个类的运行时的类型信息就是用Class对象表示的。它包含了与类有关的信息。其实我们的实例对象就通过Class对象来创建的。

每一个类都有一个Class对象，每当编译一个新类就产生一个Class对象，基本类型 (boolean, byte, char, short, int, long, float, and double)有Class对象，数组有Class对象，就连关键字void也有Class对象（void.class）。Class对象对应着java.lang.Class类，如果说类是对象抽象和集合的话，那么Class类就是对类的抽象和集合。

Class对象是在类加载的时候由java虚拟机（JVM）以及通过调用类加载器中的 defineClass方法自动构造的，一个类被加载到内存到供我们使用三个阶段：加载，连接，初始化

所有的类都是在对其第一次使用时，动态加载到JVM中的（懒加载）。当程序创建第一个对类的静态成员的引用时，就会加载这个类。使用new创建类对象的时候也会被当作对类的静态成员的引用。因此java程序程序在它开始运行之前并非被完全加载，其各个类都是在必需时才加载的。这一点与许多传统语言都不同。

社区回答理解：每个类被加载之后，系统就会为该类生成一个对应的字节码对象，通过该字节码对象就可以访问到JVM中的对应的类。

在Java中获得Class对象通常有三种方式。

第一种：使用类的.class属性

Class<类类型> clz1 = 类名.class;

第二种：通过Class类中的静态方法forName(String className)，传入类的全限定名（必须添加完整包名）比较常用

Class<?> clz2 = Class.forName("java.util.Date");

第三种：通过对象的getClass方法来实现，其中，getClass()是Object类中的方法，所有的对象都可以调用该方法

Date str = new Date()；

Class<?> clz3 = str.getClass()；