一、java基本格式

public class Demo1{
//公共的类的类名必须和文件名一致
public static void main(String[] args){
//java的输出语句,先输出后换行
System.out.println(“Hello world”);
//java的输出语句，输出之后不换行
System.out.print(“Hello world”);
System.out.print(“Hello world”);
}
}
**

1. 二、java标识符

**
java严格区分大小写：
1、标识符：取名字 规则
1.严格区分大小写
2.关键字（所有颜色不是黑色的都是关键字）不能是标识符
3.所有标识符都是由字母，数字，_，美元符号$组成
4.数字不能够开头
2、标识符:规范
1.见名知意
2.驼峰命名
1.包名:全部小写
2.类名每个单词的首字母大写 GetName
3.变量名和方法名，首个单词小写，之后每个单词首字母大写 getName
4.常量：所有单词全部大写单词和单词之间用下换线连接 GET_NAME

三、数据类型

数据类型 变量名 = 值
数据类型：2大类
1、基本数据类型 8个
1.整型
byte 1个字节 8bit 2^8=256 -128—127
short 2个字节 16bit 2^16=65536
int 4个字节 32bit 2^32=
long 8个字节 64bit
long比较特殊，使用long类型的时候需要在数值后面加上L
按照理论来说我们所有的数据类型肯定是选择合适的，内存空间不浪费
但实际来说，他的这个浪费的空间可以忽略不计，所以一般整数都使用int
2.浮点型
float 使用float类型的时候需要在数值后面加上F f
double
3.字符
char
4.布尔类型
Boolean
2、引用数据类型
3、基本数据类型的类型转换

1. 自动类型转换:小的类型会在和大类型做运算的时候进行自动类型转换
   基本数据类型从小到大：
   byte short int long float double char
   2.强制类型转换:大类型数据转成小类型数据
   语法 小类型的变量 = （小数据类型）大类型数据

四、运算符

1、算术运算符：+ - * / % ++ –
注意：
+：当他的左右2边都是数字的时候做相加操作，
当左右2边有字符串的时候做连接符号（拼接）
/：因为自动类型转换 在java中整数除以整数结果是整数
%：a%b a为正数，不管b是正是负，结果都为正
a为负数，不管b是正是负，结果都为负
++：在单目运算中，++在前和++在后没有区别，都是自增1
在双目运算中，++在前，会先自增1，然后再运算，
++在后，会先运算，然后再自增1
2、赋值运算符：+= -= *= /= =
3、比较运算符：> >= < <= != == 比较对象：instanceof
4、逻辑运算符：左右2边必须都是boolean值
&&：短路与：先判断左边，若左边为ture，再判断右边，若左边为false则 不再判断右边，直接返回false
||：短路或：只要有1个为真，结果为真,跟短路与是一个道理
!：非：!true=false
^：或异：一真一假为真，同真同假为假
&：逻辑与
|：逻辑或
5、位运算符:左右2边必须都是数字
进制 进制的转换
& | ! ^
先转换成为2进制，然后再进行计算
&: 1表示true 0表示fasle 有1个0结果就是0 2者都是真，结果为真，
有1个假，结果就是假
|:有1个1结果就是1
!:1结果是0，0的结果是1
^:1个0，1个1结果是1，2个1或者2个0 结果是0
6、三目运算符
A?B:C

五、流程控制

顺序结构：从上到下，从左到右
1、分支结构：
switch：等值判断
switch(变量){
case 值：
代码
break;
…
default:
代码
}
if：等值判断，范围判断 只能是boolean值
if—else
if—else if —else
2、循环结构
1.while
2.do-while 先执行，后循环，至少会执行一次
3.for
break：结束循环和分支
continue：结束本次循环进入下一次循环

加粗样式六、函数

1、语法[public static]  void（返回值）/数据类型    函数名(参数列表){如果是void，则表示没有返回值，如果函数有返回值则需要加上数据类型return  值;//值和返回值的数据类型一致}

2、看一个函数 是否有返回值
1.明确说明要返回值
2.但是这个返回执行完之后，需要他的结果在其他方法中操作
3.上述2者都是没有的，那就先当做没有返回值处理，然后再看方法是否符合要求
3、4种情况
1.没有参数没有返回值
public static void 函数名(){
}
在main方法中调用
函数名();
2.没有参数有返回值 (假如返回值时int类型的)
public static int 函数名(){
return 10;
}
在main方法中调用
int rest = 函数名();
-------------假如返回值时String类型的------------------
public static String 函数名(){
return “—”;
}
在main方法中调用
String rest = 函数名();
3.有参数没有返回值
public static void 函数名(参数){
}
在main方法中调用
函数名(值);
4.有参数有返回值
-------------假如返回值是int类型的------------------
public static int 函数名(参数){
return 10;
}
在main方法中调用
int rest = 函数名(值);
-------------假如返回值是String类型的------------------
public static String 函数名(参数){
return “—”;
}
在main方法中调用
String rest = 函数名(值);
函数和函数之间可以相互调用
4、重载
同一个类中，同一个函数名
参数的个数不同，参数的顺序不同，参数的类型不同
就会形成重载（重载和返回值没有关系）
4、递归
自己调用自己
解决复杂的代码的，方便阅读，但是执行效率很低，可以不用尽量不用

七、数组

1、特点
1.数组一旦声明其大小不可改变
2.数组是引用数据类型，但是数组可以被定义存储任意数据类型数据
3.数组的类型必须是一致的
4.数组有默认值，默认值就是定义的类型的默认值
5.数组有顺序，通过下标定义顺序 下标从0—length-1
2、声明和赋值
1.动态初始化
通过下标赋值
举例子： int [] arr ;
//声明一个变量这个变量是数组类型的，他的名字叫arr
arr = new int[3];
//给开辟一个空间这个空间3个大小没有值,把这个空间赋值给变量arr
int [] arr = new int[3];
arr[0] = 12;
2.静态初始化
int [] arr = {1,2,3}
//声明一个变量，类型是数组，名字是arr，开辟1个空间里面3个大小
值为1,2,3 吧这个空间赋值给arr变量
int [] arr = new int[]{1,2,3}
//声明一个变量，类型是数组，名字是arr，开辟1个空间里面3个大小
值为1,2,3 吧这个空间赋值给arr变量
3.默认初始化
每个数组都有默认值
3、操作
1.冒泡排序 是比较相邻的2个数
第一个循环，循环的是比较次数
第二个循环，循环的是下标
public static void sore(int[] arr) {
for (int i = 1; i < arr.length; i++) {
for (int j = 0; j < arr.length - i; j++) {
if (arr[j] > arr[j + 1]) {
int a = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = a;
}
}
}
System.out.println(Arrays.toString(arr));
}
2.增删改
数组的扩容
1.创建1个新的数组（数组的大小比比旧的数组大）
2.把旧数组中所有数据全部复制到新数组中
3.把新数组的地址复制给旧数组
3.查询
foreach循环遍历数组：
for(遍历出来数据的类型 变量名：需要遍历的数组、集合){
变量名就是集合、数组中的值
}
length—长度用来遍历下标 for循环
4. 其他
Arrays.toString(arr)---------输出数组中的元素
Arrays.CopyOf(arr,len)----------------将数组arr变成len长度

4、二维数组—了解
int [][] arr = new int[一条烟中多少包][一包烟中多少支];
每一包中的根数是相同
变量-------一支烟
一维数组-------一包烟，一包中可以有多支
二维数组------一条烟，一条烟中有多包，1包中又可以有多支
int [][] arr = new int[3][10];
arr.length----这条烟有多少包
arr[0].length----第一包有多少支
//每一包中个数都是再定义，可以设置不一样
1.动态初始化
int [][] arr = new int[10][];—这条烟有10包
arr[0] = new int[12];----第一包10支
arr[1] = new int[2];----第二包2支
2.静态赋值
int[][] arr = {
{1,2,3},
{12,34}
}

八、对象和类

1、定义类的语法
public class 类名{
//1.属性----名词----成员变量
//2.函数，方法-----动词----成员方法
}
2、定义对象的语法
类名 变量名 = new 类名();
访问属性：对象名.属性名 = 值 ; 对象名.属性名
方法方法：对象名.方法名();
3、类和对象在内存中的分析
4、构造方法
每个类中都有1个隐藏的无参数的构造方法
但是当我门写了有参数的构造方法之后，无参数的构造方法就没了，需要手动添加
作用：
1.创建对象 new+构造方法（构造器）----创建对象
2.用来初始化成员变量
语法
public 类名(){}//隐藏的构造方法

加粗样式九、封装

1、提供了4个权限修饰符
public：公共的 整个项目中所有都可以访问他（项目可见性）
protected：受保护的 当前包以及其子类
default：默认的 当前包（包可见性）
private：私有的 当前类 （类可见性）
2、为什么要封装
1.封装可以方便访问
2.数据安全性
3、权限修饰符
public：公共的 一个文件中可以有多个类，但只允许有一个公共类 项目可见性
构造方法并不只所有的都有public 修饰的，它是根据类来的，类是被public修饰的，那构造方法也是被public修饰的。
Protected：受保护的
default：普通的（默认） 包可见性
private：私有的
1.给私有属性提供setter（设置私有属性的值）和getter（获取私有属
性的值）方法
2.方法名有要求 set+属性名（首字母要大写） get+属性名（首字母
大写）
public protected default private
类，构造方法 √ √
属性 √ √ √ √
方法 √ √ √ √

这三个都可以被4个权限修饰符修饰
重点在属性私有化，提供getters和setters方法
4、this关键字：this指当前对象本身
1.访问方法 ：访问当前类中的方法，可以省略this
2.访问属性：当成员变量和局部变量同名的时候，使用this.属性表示成员变量
3.访问构造方法：this(值)—表示调用当前类中的构造方法

**十、继承
**
继承和ts中也是一样的
1、extends关键字----继承父类非私有的属性和方法
扩展类的功能
注意：不能多继承,可以多层次继承
2、super：指父类本身
1.访问方法 ：//访问当前父类中的方法，使用super.方法();
2.访问属性：super.属性—访问父类属性
调用父类的属性的时候，可以省略super，继承了属性，可以直接调用
3.访问构造方法：super(值)–调用的是父类的构造方法，只能写在第一行

3、重写：当父类的方法不满足子类的需求的时候就需要重写，重写只改变方法体
重写是覆盖子类继承父类的这个方法，在子类中覆盖，和父类本身方法无关

十一、toString
toString是顶级父类object的方法，在输出对象时会自动调用这个方法，如果不重写这个方法，直接输出对象时，输出的是储存这个对象的地址，所以在一般类中都会重写toString这个方法，重写为输出对象的属性。快捷方式：Source>Generate toString()…

十二、equals

equals是顶级父类object的方法，是用于比较的，在Object中他的比较是用“”进行比较的，基本数据类型使用“”比较的是值，引用数据类型使用“”比较的是地址，
如果我们使用equals进行比较引用数据类型，如果没有重写equals就是使用“”进行比较的，所以如果要使用equals进行引用数据类型值的比较，我们就要重写equals方法（自定义的类），有些地方会直接说：equals比较的是引用数据类型的值，不是地址，==比较的才是地址。快捷方式：Source>Generate equals()…

十三、abstract

抽象类：用来当做父类给子类继承，并且要求子类必须重写抽象方法
1.使用abstract修饰类
2.不能创建对象–创建对象是是否构造方法来的
3.在抽象类中可以定义普通类中定义的所有（变量，常量，方法，构造方法）
4.抽象方法没有方法体，加上abstract修饰方法

十四、final

final修饰变量的是常量
1、final修饰方法—方法不能被重写
2、final修饰的类----是不能被继承的
3、抽象类是否可以使用final修饰：不可以
因为抽象类被定义出来就是供子类继承的，而final修饰的类不能被继承，两者相悖，所以不可以

十五、static(静态的)

static修饰属性和方法
static修饰的都是属于类的，整个类只有1份，那么根据类创建的对象也都只有这一份，如果没有static修饰，那么每个对象在创建的时候都会有各自的一份
static修饰的是在第一次使用类的时候，进行加载，整个类中只加载1次
第一次使用类，并不等于第一次创建类
Student（第一次使用类） d = new Student()（第一次创建类）;

static修饰的是类的，在第一次使用类的时候加载，第一次使用类的时候可能还没有对象，非static修饰的是对象的，有对象的时候肯已经使用了类，加载过static修饰（new Student();）
1.在static的方法中，不能够直接调用非static的方法和属性，因为这个时候可能还没有对象，也就是可能还没有非static的方法和属性
2.可以创建对象调用，也可以不创建对象调用
3.不能有this，this指的是对象，同1
4.非static中，可以调用静态的属性和方法

使用static修饰的方法或属性：
1.创建对象访问
2.类名.方法 类名.属性

十六、多态

1、面向对象有3大特征：封装、继承、多态
2、多态按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。
多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。
3、多态：
1.必须有继承或者是实现
2.方法有重写
3.父类的引用指向子类的对象
4、多态使用（重点）：

• 1.多态的情况下，不能够调用子类的独有的方法
• 2.多态的情况下，调用的是父类的属性和方法，如果子类方法重写了父类的方法，那他调用的就是子类的重写方法
• 3.多态的情况下，调用的是父类的属性，不调用子类的属性
  5、父子转换
  1.子转父
  引用数据类型的自动类型转换
  Animals an = new Dog();
  2.父转子
  向下转换—为了调用子类独有的
  Dog d = (Dog)an;

十七、联级

1、MVC:（适用于界面是HTML）
M：model—模型 --数据层和实体层—模型
V：view----视图----界面
C：controlle—控制层
2、java控制台模拟使用三层架构

十八、常用类

1、Scanner
扫描器—控制台输入—实际作用并不大 new Scanner(System.in)
nextInt—获取键盘输入的int数据
next-----获取键盘输入的字符串
nextDouble-----获取键盘读入的double数据
nextLine—不推荐大家使用

2、System—系统类–当前Java运行的平台
out in err----输出 输入 错误输出
3、Object----顶级父类
equals-----比较，在object中使用==进行，子类需要比较时候重写
toString----自动调用，输出对象的时候自动调用，object中返回时对象的地址， 子类一般重写，返回属性信息
hashcode----返回的是一个对象的哈希值（集合）
getClass----获取对象的class对象(反射)

4、Math：数学类，提供了一些常用的方法
Math.abs(1);//绝对值
Math.ceil(12.4);//向上取整
Math.floor(12.4);//向下取整
Math.sqrt(9);//开平方
Math.max(12, 1);//最大值
Math.min(1, 23);//最小值
Math.pow(2, 3);//2的3次方
Math.round(12.3);//四舍五入，取整
Math.random();//随机数[0,1)

5、String,StringBuilder,StringBuffer(重中之重)
1.String:是字符串，不可变字符，final修饰，不可以被继承

// str.charAt(index)-----获取指定下标的字符
// str.length()-----------字符串中字符的个数
// str.compareTo(anotherString)-----比较2个字符，返回1大于 0等于 -1 小于
// str.equals(anObject)----比较等于true，不等于false
// str.concat(str4)-----拼接字符串
// str.contains(s)------判断是否包含字符串
// str.getBytes()-----把字符串转换成为byte数组
// str.indexOf(ch)----返回第一个该字符的下标
// str.lastIndexOf(ch)----返回最后一个该字符的下标
// str.replace(oldChar, newChar)----替换
// str.isEmpty()-----判断是否为空—true表示空
// str.split(regex)------分割
// str.trim()------去掉字符串左右2遍的空格
// str.substring(beginIndex, endIndex)----截取字符串，从开始下标到结束 下标（包头不包尾）
// str.substring(beginIndex)–从该下标截取字符串到末尾
2.StringBuilder，StringBuffer
StringBuilder:可变字符，final修饰，不可以被继承，线程不安全（效率高）
append()—追加字符串
StringBuffer:可变字符，final修饰，不可以被继承，线程安全（效率低）
StringBuffer需要进行线程同步操作，其性能要比StringBuilder要差但是适用于多线程并发。
3.使用
1）什么时候使用StirngBuilder什么时候使用StringBuffer：
1个是线程不安全的，1个是线程安全的，在多个线程的情况下我们才会使用Buffer，大部分情况下都是单线程的情况，这个时候使用StringBuilder
2）什么时候使用String，什么时候使用StringBuilder
1个是不可变字符序列，1个是可变字符序列，String他操作之后会生成 新的字符，而不是在，原有的字符上进行改变，所以适用于少量字符的操作，
StringBuilder是可变字符序列，所以大量字符操作使用StringBuilder，而且 StringBuilder的append方法比+=更加方便而且明确

*十九、时间
*
1、Date（方法已过时）
获取当前时间 new Date()
获取时间戳 getTime()
年月日时分秒-----year month+1 date hour minute second
2、Calendar
Calendar.getInstance()-----创建Calendar对象
年月日时分秒-----get(Calendar.YEAR) MONTH+1 DATE HOUR MINUTE SECOND
3、时间格式化
SimpleDateForMate:国际化
格式：yyyy–年 MM—月 dd----日 hour、Hour—小时 mm—分钟 ss—秒

1. 把时间对象转换成为一定格式的字符串—formate
2. 把一定格式的字符串转换成为时间对象—parse
   案例：
   //2010-2-12 12:23:34 把字符串依照这个格式进行转换成为时间对象—把时间对象按照这个格式转换成为字符串
   SimpleDateFormat formate = new SimpleDateFormat(“yyyy-MM-dd hh:mm:ss”);
   //把字符串依照这个格式进行转换成为时间对象
   try {
   Date parse = formate.parse(“2010-2-12 12:23:34”);//parse这个方法把字符串和规则一样转换成为时间
   System.out.println(parse.toLocaleString());
   }catch(Exception e) {
   e.printStackTrace();
   System.out.println(“格式不正确”);
   }
   //把时间对象按照这个格式转换成为字符串
   Date date = new Date();
   String format = formate.format(date);//format这个方法把时间按照规则转换
   System.out.println(format);

二十、堆栈内存分析

cpu在运行过程中，代码所占内存
堆：存放new出来的（不管代码写在哪里，只要是用过new）。开辟的空间
1.垃圾回收机制----不定时回收----开辟空间少，耗费内存就少
栈：写在方法中的变量(局部变量) 数据类型 变量名; （int num , Person p）
先进的后出，而且属于一个方法结束，他的先进的后出
栈中内存存在cpu中的时间对于堆中来说，时间相对较短
方法区：加载一个类的时候，加载的代码。我们在使用1个类的时候
他需要先进行加载1个类，这些，代码都会加载进我们的方法区
常量池：存放static修饰的变量，或者是常量，以及字符串常量
“1” “abc” “你好”

二十一、包装类

所有的基本数据类型都有对应的包装类
基本数据类型首字母大写变成包装类
byte------------Byte
short-----------Short
int-------------Integer----特殊
long------------Long
double----------Double
float-----------Float
boolean---------Boolean
char------------Character—特殊
注意事项：
1.基本数据类型，各自有各自的默认值，但是包装类的默认值都是null
2.所有的基本数据类型会自动包装成包装类，包装类会自动拆箱成基本数据类型
自动装箱----基本数据类型自动转换成为包装类
自动拆箱----包装类自动转换成为基本数据类型
3.基本数据类型上没有方法，所以包装类是提供一些关于基本数据类型的方法
包装类就是解决基本数据类型没有方法这个缺点
常用的方法：
int num = Integer.parseInt("")----把字符串转换成为数字int类型
double num = Double.parseDouble("")----把字符串转换成为数字double类型

二十二、异常

Throwable----是error和exception的父类基类
error ：是系统异常 ，error 是系统异常 ，通常很难解决。通常很难解决
exception：exception是语法的问题或者逻辑的问题，可以通过改变代码的方式来解决
堆栈溢出错误
1、编译时异常（受检时异常）
常见的受检时异常：IOException FileNotFoundException 等
2、运行时异常：run运行才出现的
常见的运行时异常：下标越界 NullPoint ClassCastException
异常解决;
1、try–catch–finally
1.通过Try包裹可能会出现的异常代码，通过catch进行异常的捕捉，捕捉了对应的异常之后，执行catch中的处理方式—（具体的处理方法随需求定）
catch去捕捉异常的时候顺序一定是先子类—父类
写法可以是一个catch捕捉多个异常
在异常处理中finally里面代码不管return或者异常等问题时候都会被执行
finally可写可不写
2、throws
throws—声明这个方法有1个异常，最后给jvm处理 + 异常类型
在项目中一般是view层处理异常
throw—抛出异常 ，在方法中抛出异常
throw new Exception(); throw +异常对象
3、throw 自定义异常
提供了多个构造方法，通过super调用父类的构造方法，例：
public class AgeOutOfBoundsException extends RuntimeException{
public AgeOutOfBoundsException(){
super();
}
public AgeOutOfBoundsException(String massage) {
super(massage);
}
// ArrayIndexOutOfBoundsException
public AgeOutOfBoundsException(int age) {
super(“年龄超出合理范围：”+age);
}
}

二十三、集合体系

变量：存储1个
数组：存储多个，[数组一旦创建大小是固定][数组中的数据类型必须相同]
集合体系：可以存储任意个数据，可以存储任意类型的数据

1、集合接口
Collection----------所有集合的父接口
List Set------2个子接口
list：存储的数据是有序的（下标），可以重复
set：存储的数据是无序的，不可以重复
Map----接口----他是key-value的格式，通过key找value

Iterator----迭代器接口----用来遍历集合
2、泛型

1. 问题1：
   往集合中存储任何东西的时候，取出来进行操作时候不方便—如果存储的是同一样比如下面全部是学生，拿出来就是Object不是Student还要强转
   解决方法：
   泛型
   1.在集合中怎么使用泛型
   集合的特点：
   存储数据没有数量限制
   存储数据没有类型限制-----泛型进行类型限制
   new ArrayList<类型>()----表示创建的这个集合对象是有类型限制 的，整个集合中只能够存储这种类型的数据
   2.泛型的好处：
   数据安全
   数据不需要强转，类型不是Object类型
   一般情况下来说，如果存放的数据都是同一个类型，那么都需要使用泛型 99%都 是要是用泛型，泛型必须是引用数据类型
2. 问题2：
   我有1个方法，这个方法是可以输入任意类型的
   解决方法1：
   public class Generics { //在创建对象的时候有1个类型E,在类中可以使用E这个类型
   /**
   • E:表示泛指的传入参数类型，传入的是E这个类型，返回值就是E这个类型
   • E在编译的时候是泛指1个类型，但是他具体根据谁来定类型
   • 在创建类的时候确定类
   • 添加的参数的类型和返回值的类型就必须和创建对象的类型一致
   • @param args
     /
     public E method3(E e) {
     return e;
     }
     }
     解决方法2：
     /*
   • 我们返回值的类型是由参数类型确定的，
   • 但是参数类型现在是不固定的
   • @param T—使用T泛指1个类型
   • 传入的类型是T，返回值类型就是T
   • T不能一直是泛指的，他在运行的时候是需要确定的。所以
   • 这个—这个T在调用方法的时候告诉你确定的类型
     */
     public T method2(T t) { //参数数据类型定义为T–这个T表示不固定
     return t;
     }

3、Collection具有的方法
add—添加1个元素
addAll—添加1个集合
clear----清空集合
contains—是否包含元素
containsall—是否包含集合中所有元素
equals—比较集合中对象
isEmpty—集合是否为空（没有元素）
iterator() ----遍历集合
remove----删除元素
removeAll----删除集合
size-----集合中元素的个数
toArray—把集合转换成为数组
4、List
具有collection中的所有方法
1.ArrayList：他的底层是数组实现的，增删慢，查找快，线程不安全，效率高（使用最多）
2.LinkedList：他的底层是双向链表实现的，增删快，查找慢
在ArrayList的基础上新增加了些方法 addFirst getFirst addLast getLast
在有特殊要求–和第一个数据以及最后一个数据相关的需求的时候使用
3.Vector：他的底层也是数组实现的，增删慢，查找快，他是线程安全，效率低
Vector他是属于线程安全的，只有在多线程情况下才会使用Vector
4.Stack：栈，先进的后出
push()—在最后添加
pop()—弹出最后一个，并删除
peek()—弹出最后一个，不删除
5.Queue：队列，先进的先出
offer()—在队伍的后面进行增加
poll()—弹出第一个，并删除
peek()—弹出第一个，不删除
6.遍历
for foreach iterator
5、Set：去除重复项，排序
1.TreeSet（必须实现compareble）
TreeSet他可以去除重复，底层是树实现
TreeSet去除重复，根据二叉树的原理
二叉树原理：右子树>左子树（节点和节点之间有大小之分）不会相等
在存入数据的时候，进行数据的大小比较（实现compareble 接口，实现compareTo）
2.HashSet(一般已经有的类都是重写了equals方法)
HashSet可以去除重复，底层是哈希表实现
HashSet去除重复的原理，根据哈希表的原理
哈希表原理：哈希值，equals（hashCode和equals重写还是不重写根据需求定）
如果hashSet存储数据，就根据需求去进行判断是否重复
hashCode方法就是用来获取哈希值的，每一个对象的哈希值不一样
hashSet是使用equals方法和hashCode
先比较hashCode值是否相等，如果hashCode值不相等那么就不 重复，HashCode不相等再比较equals方法，equals方法返回true表 示相等，false表示不相等
6、Map
K-V的存储，通过key找到value
创建：
// 泛型就是限制数据类型，map有key值的要求，也有value值类型的限制
HashMap<String, String> hashMap = new HashMap<>();
语法：
1.添加 put
2.查找 get keyset entrySet values
概念：
HashMap和HashTable都是底层散列表（哈希表）
HashMap的key值不能够重复，key和value都可以有null值
Hashtable的key不能够重复，key和value不能够用有null值，会报空指针异常，Hashtable是线程安全的，效率低

二十四、IO流

1、File—文件类
1.File:描述1个路径，这个路径可以是文件也可以是文件夹，而且这个路径可以是真实存在的，也可以是不真实存在。new File(“D:/a/b.txt”) new File(“D:/a”,”b.txt”)
2.方法
createNewFile---------------创建文件
mkdir------------创建文件夹（父路径必须存在）
mkdirs---------------创建文件夹（父路径可以不存在）
file.isFile----------------是否是文件
file.isDerectory-----------------是否是文件
delete---------------------------删除文件也可以是文件夹
file.exists-----------------------file描述的路径是否真实存在
getName---------------获取文件的名字 endsWith----------获取文件后缀
getParent----------------------获取父路径
canRead-----------------------可读
canWrite-----------------------可写
renameTo------------------------给文件改名
List------------------将该文件下所有文件名变成一个字符串集合
listFiles----------将该文件下所有文件对象变成一个File对象集合
2、IO流—字节流
1.在读取和写入过程中使用字节（可以操作图片，视频，音频等等），操作文字有可能出现乱码
2.输入与输出
输入流 输出流
抽象父类 InputStream（控制台输入可获得字节流） OutputStream
实现类1 FileInputStream FileOutputStream
使用 byte [] buf = new byte[1024];
Int len =is.read(buf);
write(buf,0,len); len：读取的字节个数放到数组，数组中字节的个数。-1表示文件结束

实现类2 BufferedInputStream BufferedOutputStream
使用 Buffered:缓存的意思，类中自带了1个数组进行缓存，他的读取和写入的速度会增快
创建：
new BufferedInputStream(new FileInputStream(“D:/a.txt”))
new BufferedOutputStream(new FileOutputStream(“D:/a.txt”))
实现类3 ObjectInputStream（反序列化）
读取对象 ObjectOutputStream（序列化）
写入对象
使用 把对象写到文件中，从文件中把对象读取到程序 序列化（把对象转换成为字节序列）和反序列化（把对象从字节序列编程对象）；当对象在网络中或者文本中传输的时候需要序列化

3、IO流—字符流
1.在读取和写入的过程使用字符（只能操作纯文本），不容易出现乱码
2.输入与输出
输入流 输出流
抽象父类 Reader Writer
实现类1 FileReader FileWriter
使用 char cbuf[] = new char[1024];
int len;
while((len =is.read(buf))!=-1){ write(cbuf,0,len)
}
实现类2 BufferedReader BufferdWriter
使用 String line; //读取的这一行的文件，当到文件末尾的时候他返回null
while((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
}
创建：
new BufferedReader(new FileReader(“D:/a.txt”));
new BufferedWriter(new FileWriter(“D:/a.txt”));
实现类3（转换流） InputStreamReader OutputStreamWriter
使用 转换流 ： 字节流转换成为字符流-----特殊性
把字节流当参数，把字符流当返回值

二十五、线程

1、进程与线程
进程：运行中的程序就叫做进程
线程：线程是进程的最小执行单元，1个运行的程序会有很多个执行单元
2、线程特点
1.线程是共享进程资源
2.线程是独立性：多个线程之间相互不干扰
3.并发性：多个线程可以同时执行（cpu给时执行，时间肉眼分辨不出，我们看到的效果就是同时进行）
3、线程的生命周期（重点）
新生（创建 ）：new线程
等待（就绪）：调用start方法，进入排队
运行：线程运行
阻塞：线程提供了一些阻塞的方法
死亡：线程结束

4、多线程----定义线程
1.继承Thread类—重写run方法—创建Thread对象—调用start方法（开启线程）
run方法是线程体，线程体中具体写什么是根据线程需要完成什么功能定的
可重写构造方法给线程传入一个字符串即线程的名字，通过调用getName()获取线程名

2.实现Runable接口—重写run方法—创建Thread对象，把runnable对象当参数—启动start
3.（了解）实现Callable接口—重写call方法—创建Callable接口对象—创建FutureTask对象，把包装后的Callable接口对象当参数—创建Thread包装Task对象—启动线程 可以选择返回值
4.定时器（了解）
Timer timer = new Timer(); //创建1个定时器
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println(“定时执行”);

		}}, 2000,1000); //2秒之后执行,间隔1秒执行1次

5、线程的阻塞的几种方法
1.Thread类的方法：
sleep:----睡眠指定时间之后苏醒，进入就绪状态
join：-----强势让其他线程进入阻塞，直到调用join的线程进入死亡，其 他线程才运行
yeild：----直接把运行中的线程进入就绪状态（没有什么实际效果）
2.Object类的方法：
wait:----wait是Object的，表示线程等待，他必须使用notitfy，notifyall 方法唤醒
6、线程的同步（线程安全）
解决方法：synchornized
让线程在执行某一个操作的时候，会等执行完毕之后，cpu才给其他线程执行，这个会让方法操作过程中安全，同时也会降低效率（12306多个窗口卖票）
1.同步代码块
synchornized(对象){
//锁，锁住这一段代码，其他线程不能够来这段代码之间干扰
}
2.同步方法
public synchornized void a(){} —锁着这一个方法，在这个方法
运行过程中，不允许其他的线程进行干扰，直到这个方法运行完成
7、线程的通信【L9010310】
1.死锁：两个线程相互拿着（synchornized锁住）对方需要的资源而不放手
在线程的通信中要避免这种情况
2.主要使用wait和notify2个方法，详情见代码
8、线程池【L9010310】
1.线程池：装了很多个线程的池子，
2.作用：
如果不使用池子，那么就是创建1个线程，然后用完销毁，如果使用线程的频率较高，就会消耗过多资源
所以，就出现了线程池，直接使用线程池的线程不需要自己去启动线程，只需要把需要执行的操作告诉线程池就可以，线程池会自动调用有空闲的线程来执行操作，用完又放回线程池里
3.线程池的优势：
1.线程池有利于管理
2.重用存在的线程，减少对象的创建，性能好
3.可以有效的控制最大的并发量，提高资源的使用率，避免过多的资源竞争导致的阻塞等情况
4.提供定时执行，定期执行，单线程，并发数量控制
4.线程池的用法
Executors.----来获取线程池
executor或submit方法来执行线程
Shutdown----关闭线程池
1.可缓存线程池：无限大
newCachedThreadPool
2.定长的线程池（使用最多）
newFixedThreadPool
3.定长，并且支持周期性任务–和定时器类似
newScheduledThreadPool
执行线程方法—schedule(target【Runnable对象】, 3【分】, TimeUnit.SECONDS【其他时间】)
4.单线程化线程池（只有1个线程来执行任务，他所有的任务必须先进先出）
newSingleThreadExecutor

JAVA oop 1.基本数据类型及其大小
整数
byte 1字节/8位/8bit -128 ~ 127
short 2字节/16位/16bit -32768~32767
int 4字节/32位 -21亿~21亿
long 8字节/64位 -922亿亿~922亿亿
浮点数
float 4字节/32位 ± 3.4E38 最多只保留8位有效数字
double 8字节/64位 ±1.7E308 最多只保留16位有效数字
非数字
char 2字节/16位 0~65535
boolean 16位 true false
科学计数法
123456789=1.23456789*10的8次方
=1.23456789E8
=1.2345678E8
123456780
所有的字符都采用一个整数来表示，
这个整数叫做这个字符的Unicode编码
char a=‘中’;
char a =20013;

---

限制访问符
public 公共的 所有类中都可访问
protected 受保护的 同一个包内或者子类中可访问
默认缺省 同一个中可访问
private 私有的 同类中可访问

---

final 最终的
可以用来修饰类 变量 方法
final修饰类 表示该类不可以被继承
final修饰变量 表示该变变量只能赋值一次，且使用时必须初始化
final修饰方法 表示该方法不可以被重写

---

1.关键字不一样 抽象类abstract class 接口是interface
2.抽象类中的属性可以是成员属性，也可以是类属性
接口中的属性必须是公共的常量
3.抽象类中的方法可以是具体的方法，也可以是抽象方法
接口中的方法只能是抽象方法，或者是default方法[1.8及以上]
4.抽象类有构造方法，接口没有构造方法
5.一个类只能继承一个抽象类
一个类可以实现多个接口

面向对象编程
面向过程与面向对象
类与对象的关系
属性，方法和构造方法
方法的重载
封装
**应用程序？**现实的虚拟
写程序？使用计算机语言去描述现实中的事物
面向过程？
描述一个事物的时候关注的是事情发展的步骤，流程
斗地主：洗牌 发牌 抢地主 出牌 结算
xipai() fapai() qiangdizhu() chupai() jiesuan()
main(){
xipai();
fapai();
qiangdizhu();
chupai();
jiesuan();
}
面向对象？
描述一个事物的时候关注的是事情中相关的人物
斗地主：
荷官 洗牌 发牌 结算
xipai() fapai() jiesuan()
玩家 抢地主 出牌
qiangdizhu() chupai()
牌
main(){
荷官.xipai();
荷官.fapai();
玩家.qiangdizhu();
玩家.chupai();
荷官.jiesuan();
}

---

对象：做事情的人或者物，是一个具体的个体
类: 表示的是对象共同特征的描述，是一个抽象的概念
类型 对象
学生 朱坤
电脑 某一台电脑
桌子 某一张桌子
类是对象的抽象
对象是类的具体表现

---

学生类
定义类
创建对象
调用属性和发
构造方法
每个类都默认隐式声明了一个无参数的构造方法
构造方法的特点
a.构造方法的名字必须和类名一致
b.构造方法不需要声明返回值类型
c.构造方法不能被重写[覆盖]
d.构造方法要通过new关键字调用
构造方法的重载
在一个类中可以定义多个构造方法，只要参数列表[类型，个数，顺序]不一样
方法的重载
在同一个类中定义多个同名不同参数列表的方法
方法的重载和返回值没有关系

---

封装：

一、java基本格式
public class Demo1{
//公共的类的类名必须和文件名一致
public static void main(String[] args){
//java的输出语句,先输出后换行
System.out.println(“Hello world”);
//java的输出语句，输出之后不换行
System.out.print(“Hello world”);
System.out.print(“Hello world”);
}
}
二、java标识符
java严格区分大小写：
1、标识符：取名字 规则
1.严格区分大小写
2.关键字（所有颜色不是黑色的都是关键字）不能是标识符
3.所有标识符都是由字母，数字，_，美元符号$组成
4.数字不能够开头
2、标识符:规范
1.见名知意
2.驼峰命名
1.包名:全部小写
2.类名每个单词的首字母大写 GetName
3.变量名和方法名，首个单词小写，之后每个单词首字母大写 getName
4.常量：所有单词全部大写单词和单词之间用下换线连接 GET_NAME

三、数据类型
数据类型 变量名 = 值
数据类型：2大类
1、基本数据类型 8个
1.整型
byte 1个字节 8bit 2^8=256 -128—127
short 2个字节 16bit 2^16=65536
int 4个字节 32bit 2^32=
long 8个字节 64bit
long比较特殊，使用long类型的时候需要在数值后面加上L
按照理论来说我们所有的数据类型肯定是选择合适的，内存空间不浪费
但实际来说，他的这个浪费的空间可以忽略不计，所以一般整数都使用int
2.浮点型
float 使用float类型的时候需要在数值后面加上F f
double
3.字符
char
4.布尔类型
Boolean
2、引用数据类型
3、基本数据类型的类型转换

1. 自动类型转换:小的类型会在和大类型做运算的时候进行自动类型转换
   基本数据类型从小到大：
   byte short int long float double char
   2.强制类型转换:大类型数据转成小类型数据
   语法 小类型的变量 = （小数据类型）大类型数据

四、运算符
1、算术运算符：+ - * / % ++ –
注意：
+：当他的左右2边都是数字的时候做相加操作，
当左右2边有字符串的时候做连接符号（拼接）
/：因为自动类型转换 在java中整数除以整数结果是整数
%：a%b a为正数，不管b是正是负，结果都为正
a为负数，不管b是正是负，结果都为负
++：在单目运算中，++在前和++在后没有区别，都是自增1
在双目运算中，++在前，会先自增1，然后再运算，
++在后，会先运算，然后再自增1
2、赋值运算符：+= -= *= /= =
3、比较运算符：> >= < <= != == 比较对象：instanceof
4、逻辑运算符：左右2边必须都是boolean值
&&：短路与：先判断左边，若左边为ture，再判断右边，若左边为false则 不再判断右边，直接返回false
||：短路或：只要有1个为真，结果为真,跟短路与是一个道理
!：非：!true=false
^：或异：一真一假为真，同真同假为假
&：逻辑与
|：逻辑或
5、位运算符:左右2边必须都是数字
进制 进制的转换
& | ! ^
先转换成为2进制，然后再进行计算
&: 1表示true 0表示fasle 有1个0结果就是0 2者都是真，结果为真，
有1个假，结果就是假
|:有1个1结果就是1
!:1结果是0，0的结果是1
^:1个0，1个1结果是1，2个1或者2个0 结果是0
6、三目运算符
A?B:C

五、流程控制
顺序结构：从上到下，从左到右
1、分支结构：
switch：等值判断
switch(变量){
case 值：
代码
break;
…
default:
代码
}
if：等值判断，范围判断 只能是boolean值
if—else
if—else if —else
2、循环结构
1.while
2.do-while 先执行，后循环，至少会执行一次
3.for
break：结束循环和分支
continue：结束本次循环进入下一次循环

六、函数
1、语法
[public static] void（返回值）/数据类型 函数名(参数列表){
如果是void，则表示没有返回值，如果函数有返回值则需要加上数据类型
return 值;//值和返回值的数据类型一致
}
2、看一个函数 是否有返回值
1.明确说明要返回值
2.但是这个返回执行完之后，需要他的结果在其他方法中操作
3.上述2者都是没有的，那就先当做没有返回值处理，然后再看方法是否符合要求
3、4种情况
1.没有参数没有返回值
public static void 函数名(){
}
在main方法中调用
函数名();
2.没有参数有返回值 (假如返回值时int类型的)
public static int 函数名(){
return 10;
}
在main方法中调用
int rest = 函数名();
-------------假如返回值时String类型的------------------
public static String 函数名(){
return “—”;
}
在main方法中调用
String rest = 函数名();
3.有参数没有返回值
public static void 函数名(参数){
}
在main方法中调用
函数名(值);
4.有参数有返回值
-------------假如返回值是int类型的------------------
public static int 函数名(参数){
return 10;
}
在main方法中调用
int rest = 函数名(值);
-------------假如返回值是String类型的------------------
public static String 函数名(参数){
return “—”;
}
在main方法中调用
String rest = 函数名(值);
函数和函数之间可以相互调用
4、重载
同一个类中，同一个函数名
参数的个数不同，参数的顺序不同，参数的类型不同
就会形成重载（重载和返回值没有关系）
4、递归
自己调用自己
解决复杂的代码的，方便阅读，但是执行效率很低，可以不用尽量不用

七、数组
1、特点
1.数组一旦声明其大小不可改变
2.数组是引用数据类型，但是数组可以被定义存储任意数据类型数据
3.数组的类型必须是一致的
4.数组有默认值，默认值就是定义的类型的默认值
5.数组有顺序，通过下标定义顺序 下标从0—length-1
2、声明和赋值
1.动态初始化
通过下标赋值
举例子： int [] arr ;
//声明一个变量这个变量是数组类型的，他的名字叫arr
arr = new int[3];
//给开辟一个空间这个空间3个大小没有值,把这个空间赋值给变量arr
int [] arr = new int[3];
arr[0] = 12;
2.静态初始化
int [] arr = {1,2,3}
//声明一个变量，类型是数组，名字是arr，开辟1个空间里面3个大小
值为1,2,3 吧这个空间赋值给arr变量
int [] arr = new int[]{1,2,3}
//声明一个变量，类型是数组，名字是arr，开辟1个空间里面3个大小
值为1,2,3 吧这个空间赋值给arr变量
3.默认初始化
每个数组都有默认值
3、操作
1.冒泡排序 是比较相邻的2个数
第一个循环，循环的是比较次数
第二个循环，循环的是下标
public static void sore(int[] arr) {
for (int i = 1; i < arr.length; i++) {
for (int j = 0; j < arr.length - i; j++) {
if (arr[j] > arr[j + 1]) {
int a = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = a;
}
}
}
System.out.println(Arrays.toString(arr));
}
2.增删改
数组的扩容
1.创建1个新的数组（数组的大小比比旧的数组大）
2.把旧数组中所有数据全部复制到新数组中
3.把新数组的地址复制给旧数组
3.查询
foreach循环遍历数组：
for(遍历出来数据的类型 变量名：需要遍历的数组、集合){
变量名就是集合、数组中的值
}
length—长度用来遍历下标 for循环
4. 其他
Arrays.toString(arr)---------输出数组中的元素
Arrays.CopyOf(arr,len)----------------将数组arr变成len长度

4、二维数组—了解
int [][] arr = new int[一条烟中多少包][一包烟中多少支];
每一包中的根数是相同
变量-------一支烟
一维数组-------一包烟，一包中可以有多支
二维数组------一条烟，一条烟中有多包，1包中又可以有多支
int [][] arr = new int[3][10];
arr.length----这条烟有多少包
arr[0].length----第一包有多少支
//每一包中个数都是再定义，可以设置不一样
1.动态初始化
int [][] arr = new int[10][];—这条烟有10包
arr[0] = new int[12];----第一包10支
arr[1] = new int[2];----第二包2支
2.静态赋值
int[][] arr = {
{1,2,3},
{12,34}
}

八、对象和类
1、定义类的语法
public class 类名{
//1.属性----名词----成员变量
//2.函数，方法-----动词----成员方法
}
2、定义对象的语法
类名 变量名 = new 类名();
访问属性：对象名.属性名 = 值 ; 对象名.属性名
方法方法：对象名.方法名();
3、类和对象在内存中的分析
4、构造方法
每个类中都有1个隐藏的无参数的构造方法
但是当我门写了有参数的构造方法之后，无参数的构造方法就没了，需要手动添加
作用：
1.创建对象 new+构造方法（构造器）----创建对象
2.用来初始化成员变量
语法
public 类名(){}//隐藏的构造方法

九、封装
1、提供了4个权限修饰符
public：公共的 整个项目中所有都可以访问他（项目可见性）
protected：受保护的 当前包以及其子类
default：默认的 当前包（包可见性）
private：私有的 当前类 （类可见性）
2、为什么要封装
1.封装可以方便访问
2.数据安全性
3、权限修饰符
public：公共的 一个文件中可以有多个类，但只允许有一个公共类 项目可见性
构造方法并不只所有的都有public 修饰的，它是根据类来的，类是被public修饰的，那构造方法也是被public修饰的。
Protected：受保护的
default：普通的（默认） 包可见性
private：私有的
1.给私有属性提供setter（设置私有属性的值）和getter（获取私有属
性的值）方法
2.方法名有要求 set+属性名（首字母要大写） get+属性名（首字母
大写）
public protected default private
类，构造方法 √ √
属性 √ √ √ √
方法 √ √ √ √

这三个都可以被4个权限修饰符修饰
重点在属性私有化，提供getters和setters方法
4、this关键字：this指当前对象本身
1.访问方法 ：访问当前类中的方法，可以省略this
2.访问属性：当成员变量和局部变量同名的时候，使用this.属性表示成员变量
3.访问构造方法：this(值)—表示调用当前类中的构造方法

十、继承
继承和ts中也是一样的
1、extends关键字----继承父类非私有的属性和方法
扩展类的功能
注意：不能多继承,可以多层次继承
2、super：指父类本身
1.访问方法 ：//访问当前父类中的方法，使用super.方法();
2.访问属性：super.属性—访问父类属性
调用父类的属性的时候，可以省略super，继承了属性，可以直接调用
3.访问构造方法：super(值)–调用的是父类的构造方法，只能写在第一行

3、重写：当父类的方法不满足子类的需求的时候就需要重写，重写只改变方法体
重写是覆盖子类继承父类的这个方法，在子类中覆盖，和父类本身方法无关

十一、toString
toString是顶级父类object的方法，在输出对象时会自动调用这个方法，如果不重写这个方法，直接输出对象时，输出的是储存这个对象的地址，所以在一般类中都会重写toString这个方法，重写为输出对象的属性。快捷方式：Source>Generate toString()…

十二、equals
equals是顶级父类object的方法，是用于比较的，在Object中他的比较是用“”进行比较的，基本数据类型使用“”比较的是值，引用数据类型使用“”比较的是地址，
如果我们使用equals进行比较引用数据类型，如果没有重写equals就是使用“”进行比较的，所以如果要使用equals进行引用数据类型值的比较，我们就要重写equals方法（自定义的类），有些地方会直接说：equals比较的是引用数据类型的值，不是地址，==比较的才是地址。快捷方式：Source>Generate equals()…

十三、abstract
抽象类：用来当做父类给子类继承，并且要求子类必须重写抽象方法
1.使用abstract修饰类
2.不能创建对象–创建对象是是否构造方法来的
3.在抽象类中可以定义普通类中定义的所有（变量，常量，方法，构造方法）
4.抽象方法没有方法体，加上abstract修饰方法

十四、final
final修饰变量的是常量
1、final修饰方法—方法不能被重写
2、final修饰的类----是不能被继承的
3、抽象类是否可以使用final修饰：不可以
因为抽象类被定义出来就是供子类继承的，而final修饰的类不能被继承，两者相悖，所以不可以

十五、static(静态的)
static修饰属性和方法
static修饰的都是属于类的，整个类只有1份，那么根据类创建的对象也都只有这一份，如果没有static修饰，那么每个对象在创建的时候都会有各自的一份
static修饰的是在第一次使用类的时候，进行加载，整个类中只加载1次
第一次使用类，并不等于第一次创建类
Student（第一次使用类） d = new Student()（第一次创建类）;

static修饰的是类的，在第一次使用类的时候加载，第一次使用类的时候可能还没有对象，非static修饰的是对象的，有对象的时候肯已经使用了类，加载过static修饰（new Student();）
1.在static的方法中，不能够直接调用非static的方法和属性，因为这个时候可能还没有对象，也就是可能还没有非static的方法和属性
2.可以创建对象调用，也可以不创建对象调用
3.不能有this，this指的是对象，同1
4.非static中，可以调用静态的属性和方法

使用static修饰的方法或属性：
1.创建对象访问
2.类名.方法 类名.属性

十六、多态
1、面向对象有3大特征：封装、继承、多态
2、多态按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。
多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。
3、多态：
1.必须有继承或者是实现
2.方法有重写
3.父类的引用指向子类的对象
4、多态使用（重点）：

• 1.多态的情况下，不能够调用子类的独有的方法
• 2.多态的情况下，调用的是父类的属性和方法，如果子类方法重写了父类的方法，那他调用的就是子类的重写方法
• 3.多态的情况下，调用的是父类的属性，不调用子类的属性
  5、父子转换
  1.子转父
  引用数据类型的自动类型转换
  Animals an = new Dog();
  2.父转子
  向下转换—为了调用子类独有的
  Dog d = (Dog)an;

十七、联级
1、MVC:（适用于界面是HTML）
M：model—模型 --数据层和实体层—模型
V：view----视图----界面
C：controlle—控制层
2、java控制台模拟使用三层架构

十八、常用类
1、Scanner
扫描器—控制台输入—实际作用并不大 new Scanner(System.in)
nextInt—获取键盘输入的int数据
next-----获取键盘输入的字符串
nextDouble-----获取键盘读入的double数据
nextLine—不推荐大家使用

2、System—系统类–当前Java运行的平台
out in err----输出 输入 错误输出
3、Object----顶级父类
equals-----比较，在object中使用==进行，子类需要比较时候重写
toString----自动调用，输出对象的时候自动调用，object中返回时对象的地址， 子类一般重写，返回属性信息
hashcode----返回的是一个对象的哈希值（集合）
getClass----获取对象的class对象(反射)

4、Math：数学类，提供了一些常用的方法
Math.abs(1);//绝对值
Math.ceil(12.4);//向上取整
Math.floor(12.4);//向下取整
Math.sqrt(9);//开平方
Math.max(12, 1);//最大值
Math.min(1, 23);//最小值
Math.pow(2, 3);//2的3次方
Math.round(12.3);//四舍五入，取整
Math.random();//随机数[0,1)

5、String,StringBuilder,StringBuffer(重中之重)
1.String:是字符串，不可变字符，final修饰，不可以被继承

// str.charAt(index)-----获取指定下标的字符
// str.length()-----------字符串中字符的个数
// str.compareTo(anotherString)-----比较2个字符，返回1大于 0等于 -1 小于
// str.equals(anObject)----比较等于true，不等于false
// str.concat(str4)-----拼接字符串
// str.contains(s)------判断是否包含字符串
// str.getBytes()-----把字符串转换成为byte数组
// str.indexOf(ch)----返回第一个该字符的下标
// str.lastIndexOf(ch)----返回最后一个该字符的下标
// str.replace(oldChar, newChar)----替换
// str.isEmpty()-----判断是否为空—true表示空
// str.split(regex)------分割
// str.trim()------去掉字符串左右2遍的空格
// str.substring(beginIndex, endIndex)----截取字符串，从开始下标到结束 下标（包头不包尾）
// str.substring(beginIndex)–从该下标截取字符串到末尾
2.StringBuilder，StringBuffer
StringBuilder:可变字符，final修饰，不可以被继承，线程不安全（效率高）
append()—追加字符串
StringBuffer:可变字符，final修饰，不可以被继承，线程安全（效率低）
StringBuffer需要进行线程同步操作，其性能要比StringBuilder要差但是适用于多线程并发。
3.使用
1）什么时候使用StirngBuilder什么时候使用StringBuffer：
1个是线程不安全的，1个是线程安全的，在多个线程的情况下我们才会使用Buffer，大部分情况下都是单线程的情况，这个时候使用StringBuilder
2）什么时候使用String，什么时候使用StringBuilder
1个是不可变字符序列，1个是可变字符序列，String他操作之后会生成 新的字符，而不是在，原有的字符上进行改变，所以适用于少量字符的操作，
StringBuilder是可变字符序列，所以大量字符操作使用StringBuilder，而且 StringBuilder的append方法比+=更加方便而且明确

十九、时间
1、Date（方法已过时）
获取当前时间 new Date()
获取时间戳 getTime()
年月日时分秒-----year month+1 date hour minute second
2、Calendar
Calendar.getInstance()-----创建Calendar对象
年月日时分秒-----get(Calendar.YEAR) MONTH+1 DATE HOUR MINUTE SECOND
3、时间格式化
SimpleDateForMate:国际化
格式：yyyy–年 MM—月 dd----日 hour、Hour—小时 mm—分钟 ss—秒

1. 把时间对象转换成为一定格式的字符串—formate
2. 把一定格式的字符串转换成为时间对象—parse
   案例：
   //2010-2-12 12:23:34 把字符串依照这个格式进行转换成为时间对象—把时间对象按照这个格式转换成为字符串
   SimpleDateFormat formate = new SimpleDateFormat(“yyyy-MM-dd hh:mm:ss”);
   //把字符串依照这个格式进行转换成为时间对象
   try {
   Date parse = formate.parse(“2010-2-12 12:23:34”);//parse这个方法把字符串和规则一样转换成为时间
   System.out.println(parse.toLocaleString());
   }catch(Exception e) {
   e.printStackTrace();
   System.out.println(“格式不正确”);
   }
   //把时间对象按照这个格式转换成为字符串
   Date date = new Date();
   String format = formate.format(date);//format这个方法把时间按照规则转换
   System.out.println(format);

二十、堆栈内存分析
cpu在运行过程中，代码所占内存
堆：存放new出来的（不管代码写在哪里，只要是用过new）。开辟的空间
1.垃圾回收机制----不定时回收----开辟空间少，耗费内存就少
栈：写在方法中的变量(局部变量) 数据类型 变量名; （int num , Person p）
先进的后出，而且属于一个方法结束，他的先进的后出
栈中内存存在cpu中的时间对于堆中来说，时间相对较短
方法区：加载一个类的时候，加载的代码。我们在使用1个类的时候
他需要先进行加载1个类，这些，代码都会加载进我们的方法区
常量池：存放static修饰的变量，或者是常量，以及字符串常量
“1” “abc” “你好”

二十一、包装类
所有的基本数据类型都有对应的包装类
基本数据类型首字母大写变成包装类
byte------------Byte
short-----------Short
int-------------Integer----特殊
long------------Long
double----------Double
float-----------Float
boolean---------Boolean
char------------Character—特殊
注意事项：
1.基本数据类型，各自有各自的默认值，但是包装类的默认值都是null
2.所有的基本数据类型会自动包装成包装类，包装类会自动拆箱成基本数据类型
自动装箱----基本数据类型自动转换成为包装类
自动拆箱----包装类自动转换成为基本数据类型
3.基本数据类型上没有方法，所以包装类是提供一些关于基本数据类型的方法
包装类就是解决基本数据类型没有方法这个缺点
常用的方法：
int num = Integer.parseInt("")----把字符串转换成为数字int类型
double num = Double.parseDouble("")----把字符串转换成为数字double类型

二十二、异常
Throwable----是error和exception的父类基类
error ：是系统异常 ，error 是系统异常 ，通常很难解决。通常很难解决
exception：exception是语法的问题或者逻辑的问题，可以通过改变代码的方式来解决
堆栈溢出错误
1、编译时异常（受检时异常）
常见的受检时异常：IOException FileNotFoundException 等
2、运行时异常：run运行才出现的
常见的运行时异常：下标越界 NullPoint ClassCastException
异常解决;
1、try–catch–finally
1.通过Try包裹可能会出现的异常代码，通过catch进行异常的捕捉，捕捉了对应的异常之后，执行catch中的处理方式—（具体的处理方法随需求定）
catch去捕捉异常的时候顺序一定是先子类—父类
写法可以是一个catch捕捉多个异常
在异常处理中finally里面代码不管return或者异常等问题时候都会被执行
finally可写可不写
2、throws
throws—声明这个方法有1个异常，最后给jvm处理 + 异常类型
在项目中一般是view层处理异常
throw—抛出异常 ，在方法中抛出异常
throw new Exception(); throw +异常对象
3、throw 自定义异常
提供了多个构造方法，通过super调用父类的构造方法，例：
public class AgeOutOfBoundsException extends RuntimeException{
public AgeOutOfBoundsException(){
super();
}
public AgeOutOfBoundsException(String massage) {
super(massage);
}
// ArrayIndexOutOfBoundsException
public AgeOutOfBoundsException(int age) {
super(“年龄超出合理范围：”+age);
}
}

二十三、集合体系
变量：存储1个
数组：存储多个，[数组一旦创建大小是固定][数组中的数据类型必须相同]
集合体系：可以存储任意个数据，可以存储任意类型的数据

1、集合接口
Collection----------所有集合的父接口
List Set------2个子接口
list：存储的数据是有序的（下标），可以重复
set：存储的数据是无序的，不可以重复
Map----接口----他是key-value的格式，通过key找value

Iterator----迭代器接口----用来遍历集合
2、泛型

1. 问题1：
   往集合中存储任何东西的时候，取出来进行操作时候不方便—如果存储的是同一样比如下面全部是学生，拿出来就是Object不是Student还要强转
   解决方法：
   泛型
   1.在集合中怎么使用泛型
   集合的特点：
   存储数据没有数量限制
   存储数据没有类型限制-----泛型进行类型限制
   new ArrayList<类型>()----表示创建的这个集合对象是有类型限制 的，整个集合中只能够存储这种类型的数据
   2.泛型的好处：
   数据安全
   数据不需要强转，类型不是Object类型
   一般情况下来说，如果存放的数据都是同一个类型，那么都需要使用泛型 99%都 是要是用泛型，泛型必须是引用数据类型
2. 问题2：
   我有1个方法，这个方法是可以输入任意类型的
   解决方法1：
   public class Generics { //在创建对象的时候有1个类型E,在类中可以使用E这个类型
   /**
   • E:表示泛指的传入参数类型，传入的是E这个类型，返回值就是E这个类型
   • E在编译的时候是泛指1个类型，但是他具体根据谁来定类型
   • 在创建类的时候确定类
   • 添加的参数的类型和返回值的类型就必须和创建对象的类型一致
   • @param args
     /
     public E method3(E e) {
     return e;
     }
     }
     解决方法2：
     /*
   • 我们返回值的类型是由参数类型确定的，
   • 但是参数类型现在是不固定的
   • @param T—使用T泛指1个类型
   • 传入的类型是T，返回值类型就是T
   • T不能一直是泛指的，他在运行的时候是需要确定的。所以
   • 这个—这个T在调用方法的时候告诉你确定的类型
     */
     public T method2(T t) { //参数数据类型定义为T–这个T表示不固定
     return t;
     }

3、Collection具有的方法
add—添加1个元素
addAll—添加1个集合
clear----清空集合
contains—是否包含元素
containsall—是否包含集合中所有元素
equals—比较集合中对象
isEmpty—集合是否为空（没有元素）
iterator() ----遍历集合
remove----删除元素
removeAll----删除集合
size-----集合中元素的个数
toArray—把集合转换成为数组
4、List
具有collection中的所有方法
1.ArrayList：他的底层是数组实现的，增删慢，查找快，线程不安全，效率高（使用最多）
2.LinkedList：他的底层是双向链表实现的，增删快，查找慢
在ArrayList的基础上新增加了些方法 addFirst getFirst addLast getLast
在有特殊要求–和第一个数据以及最后一个数据相关的需求的时候使用
3.Vector：他的底层也是数组实现的，增删慢，查找快，他是线程安全，效率低
Vector他是属于线程安全的，只有在多线程情况下才会使用Vector
4.Stack：栈，先进的后出
push()—在最后添加
pop()—弹出最后一个，并删除
peek()—弹出最后一个，不删除
5.Queue：队列，先进的先出
offer()—在队伍的后面进行增加
poll()—弹出第一个，并删除
peek()—弹出第一个，不删除
6.遍历
for foreach iterator
5、Set：去除重复项，排序
1.TreeSet（必须实现compareble）
TreeSet他可以去除重复，底层是树实现
TreeSet去除重复，根据二叉树的原理
二叉树原理：右子树>左子树（节点和节点之间有大小之分）不会相等
在存入数据的时候，进行数据的大小比较（实现compareble 接口，实现compareTo）
2.HashSet(一般已经有的类都是重写了equals方法)
HashSet可以去除重复，底层是哈希表实现
HashSet去除重复的原理，根据哈希表的原理
哈希表原理：哈希值，equals（hashCode和equals重写还是不重写根据需求定）
如果hashSet存储数据，就根据需求去进行判断是否重复
hashCode方法就是用来获取哈希值的，每一个对象的哈希值不一样
hashSet是使用equals方法和hashCode
先比较hashCode值是否相等，如果hashCode值不相等那么就不 重复，HashCode不相等再比较equals方法，equals方法返回true表 示相等，false表示不相等
6、Map
K-V的存储，通过key找到value
创建：
// 泛型就是限制数据类型，map有key值的要求，也有value值类型的限制
HashMap<String, String> hashMap = new HashMap<>();
语法：
1.添加 put
2.查找 get keyset entrySet values
概念：
HashMap和HashTable都是底层散列表（哈希表）
HashMap的key值不能够重复，key和value都可以有null值
Hashtable的key不能够重复，key和value不能够用有null值，会报空指针异常，Hashtable是线程安全的，效率低

二十四、IO流
1、File—文件类
1.File:描述1个路径，这个路径可以是文件也可以是文件夹，而且这个路径可以是真实存在的，也可以是不真实存在。new File(“D:/a/b.txt”) new File(“D:/a”,”b.txt”)
2.方法
createNewFile---------------创建文件
mkdir------------创建文件夹（父路径必须存在）
mkdirs---------------创建文件夹（父路径可以不存在）
file.isFile----------------是否是文件
file.isDerectory-----------------是否是文件
delete---------------------------删除文件也可以是文件夹
file.exists-----------------------file描述的路径是否真实存在
getName---------------获取文件的名字 endsWith----------获取文件后缀
getParent----------------------获取父路径
canRead-----------------------可读
canWrite-----------------------可写
renameTo------------------------给文件改名
List------------------将该文件下所有文件名变成一个字符串集合
listFiles----------将该文件下所有文件对象变成一个File对象集合
2、IO流—字节流
1.在读取和写入过程中使用字节（可以操作图片，视频，音频等等），操作文字有可能出现乱码
2.输入与输出
输入流 输出流
抽象父类 InputStream（控制台输入可获得字节流） OutputStream
实现类1 FileInputStream FileOutputStream
使用 byte [] buf = new byte[1024];
Int len =is.read(buf);
write(buf,0,len); len：读取的字节个数放到数组，数组中字节的个数。-1表示文件结束

实现类2 BufferedInputStream BufferedOutputStream
使用 Buffered:缓存的意思，类中自带了1个数组进行缓存，他的读取和写入的速度会增快
创建：
new BufferedInputStream(new FileInputStream(“D:/a.txt”))
new BufferedOutputStream(new FileOutputStream(“D:/a.txt”))
实现类3 ObjectInputStream（反序列化）
读取对象 ObjectOutputStream（序列化）
写入对象
使用 把对象写到文件中，从文件中把对象读取到程序 序列化（把对象转换成为字节序列）和反序列化（把对象从字节序列编程对象）；当对象在网络中或者文本中传输的时候需要序列化

3、IO流—字符流
1.在读取和写入的过程使用字符（只能操作纯文本），不容易出现乱码
2.输入与输出
输入流 输出流
抽象父类 Reader Writer
实现类1 FileReader FileWriter
使用 char cbuf[] = new char[1024];
int len;
while((len =is.read(buf))!=-1){ write(cbuf,0,len)
}
实现类2 BufferedReader BufferdWriter
使用 String line; //读取的这一行的文件，当到文件末尾的时候他返回null
while((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
}
创建：
new BufferedReader(new FileReader(“D:/a.txt”));
new BufferedWriter(new FileWriter(“D:/a.txt”));
实现类3（转换流） InputStreamReader OutputStreamWriter
使用 转换流 ： 字节流转换成为字符流-----特殊性
把字节流当参数，把字符流当返回值

二十五、线程
1、进程与线程
进程：运行中的程序就叫做进程
线程：线程是进程的最小执行单元，1个运行的程序会有很多个执行单元
2、线程特点
1.线程是共享进程资源
2.线程是独立性：多个线程之间相互不干扰
3.并发性：多个线程可以同时执行（cpu给时执行，时间肉眼分辨不出，我们看到的效果就是同时进行）
3、线程的生命周期（重点）
新生（创建 ）：new线程
等待（就绪）：调用start方法，进入排队
运行：线程运行
阻塞：线程提供了一些阻塞的方法
死亡：线程结束

4、多线程----定义线程
1.继承Thread类—重写run方法—创建Thread对象—调用start方法（开启线程）
run方法是线程体，线程体中具体写什么是根据线程需要完成什么功能定的
可重写构造方法给线程传入一个字符串即线程的名字，通过调用getName()获取线程名

2.实现Runable接口—重写run方法—创建Thread对象，把runnable对象当参数—启动start
3.（了解）实现Callable接口—重写call方法—创建Callable接口对象—创建FutureTask对象，把包装后的Callable接口对象当参数—创建Thread包装Task对象—启动线程 可以选择返回值
4.定时器（了解）
Timer timer = new Timer(); //创建1个定时器
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println(“定时执行”);

		}}, 2000,1000); //2秒之后执行,间隔1秒执行1次

5、线程的阻塞的几种方法
1.Thread类的方法：
sleep:----睡眠指定时间之后苏醒，进入就绪状态
join：-----强势让其他线程进入阻塞，直到调用join的线程进入死亡，其 他线程才运行
yeild：----直接把运行中的线程进入就绪状态（没有什么实际效果）
2.Object类的方法：
wait:----wait是Object的，表示线程等待，他必须使用notitfy，notifyall 方法唤醒
6、线程的同步（线程安全）
解决方法：synchornized
让线程在执行某一个操作的时候，会等执行完毕之后，cpu才给其他线程执行，这个会让方法操作过程中安全，同时也会降低效率（12306多个窗口卖票）
1.同步代码块
synchornized(对象){
//锁，锁住这一段代码，其他线程不能够来这段代码之间干扰
}
2.同步方法
public synchornized void a(){} —锁着这一个方法，在这个方法
运行过程中，不允许其他的线程进行干扰，直到这个方法运行完成
7、线程的通信【L9010310】
1.死锁：两个线程相互拿着（synchornized锁住）对方需要的资源而不放手
在线程的通信中要避免这种情况
2.主要使用wait和notify2个方法，详情见代码
8、线程池【L9010310】
1.线程池：装了很多个线程的池子，
2.作用：
如果不使用池子，那么就是创建1个线程，然后用完销毁，如果使用线程的频率较高，就会消耗过多资源
所以，就出现了线程池，直接使用线程池的线程不需要自己去启动线程，只需要把需要执行的操作告诉线程池就可以，线程池会自动调用有空闲的线程来执行操作，用完又放回线程池里
3.线程池的优势：
1.线程池有利于管理
2.重用存在的线程，减少对象的创建，性能好
3.可以有效的控制最大的并发量，提高资源的使用率，避免过多的资源竞争导致的阻塞等情况
4.提供定时执行，定期执行，单线程，并发数量控制
4.线程池的用法
Executors.----来获取线程池
executor或submit方法来执行线程
Shutdown----关闭线程池
1.可缓存线程池：无限大
newCachedThreadPool
2.定长的线程池（使用最多）
newFixedThreadPool
3.定长，并且支持周期性任务–和定时器类似
newScheduledThreadPool
执行线程方法—schedule(target【Runnable对象】, 3【分】, TimeUnit.SECONDS【其他时间】)
4.单线程化线程池（只有1个线程来执行任务，他所有的任务必须先进先出）
newSingleThreadExecutor

JAVA oop 1.基本数据类型及其大小
整数
byte 1字节/8位/8bit -128 ~ 127
short 2字节/16位/16bit -32768~32767
int 4字节/32位 -21亿~21亿
long 8字节/64位 -922亿亿~922亿亿
浮点数
float 4字节/32位 ± 3.4E38 最多只保留8位有效数字
double 8字节/64位 ±1.7E308 最多只保留16位有效数字
非数字
char 2字节/16位 0~65535
boolean 16位 true false
科学计数法
123456789=1.23456789*10的8次方
=1.23456789E8
=1.2345678E8
123456780
所有的字符都采用一个整数来表示，
这个整数叫做这个字符的Unicode编码
char a=‘中’;
char a =20013;

---

限制访问符
public 公共的 所有类中都可访问
protected 受保护的 同一个包内或者子类中可访问
默认缺省 同一个中可访问
private 私有的 同类中可访问

---

final 最终的
可以用来修饰类 变量 方法
final修饰类 表示该类不可以被继承
final修饰变量 表示该变变量只能赋值一次，且使用时必须初始化
final修饰方法 表示该方法不可以被重写

---

1.关键字不一样 抽象类abstract class 接口是interface
2.抽象类中的属性可以是成员属性，也可以是类属性
接口中的属性必须是公共的常量
3.抽象类中的方法可以是具体的方法，也可以是抽象方法
接口中的方法只能是抽象方法，或者是default方法[1.8及以上]
4.抽象类有构造方法，接口没有构造方法
5.一个类只能继承一个抽象类
一个类可以实现多个接口

面向对象编程
面向过程与面向对象
类与对象的关系
属性，方法和构造方法
方法的重载
封装
**应用程序？**现实的虚拟
写程序？使用计算机语言去描述现实中的事物
面向过程？
描述一个事物的时候关注的是事情发展的步骤，流程
斗地主：洗牌 发牌 抢地主 出牌 结算
xipai() fapai() qiangdizhu() chupai() jiesuan()
main(){
xipai();
fapai();
qiangdizhu();
chupai();
jiesuan();
}
面向对象？
描述一个事物的时候关注的是事情中相关的人物
斗地主：
荷官 洗牌 发牌 结算
xipai() fapai() jiesuan()
玩家 抢地主 出牌
qiangdizhu() chupai()
牌
main(){
荷官.xipai();
荷官.fapai();
玩家.qiangdizhu();
玩家.chupai();
荷官.jiesuan();
}

---

对象：做事情的人或者物，是一个具体的个体
类: 表示的是对象共同特征的描述，是一个抽象的概念
类型 对象
学生 朱坤
电脑 某一台电脑
桌子 某一张桌子
类是对象的抽象
对象是类的具体表现

---

学生类
定义类
创建对象
调用属性和发
构造方法
每个类都默认隐式声明了一个无参数的构造方法
构造方法的特点
a.构造方法的名字必须和类名一致
b.构造方法不需要声明返回值类型
c.构造方法不能被重写[覆盖]
d.构造方法要通过new关键字调用
构造方法的重载
在一个类中可以定义多个构造方法，只要参数列表[类型，个数，顺序]不一样
方法的重载
在同一个类中定义多个同名不同参数列表的方法
方法的重载和返回值没有关系

---

封装：

• 使用访问限定符来限定类，属性，方法和构造方法的可访问范围
  为什么需要封装？？
  对于属性的访问,可以有写访问和读访问
  通过访问限定符限定属性的可访问访问
  再通过setter和getter方法来对外提供访问接口
  提高数据的安全性
  封装的级别
  public 公共的 程序中随处可访问
  protected 受保护的 包内和子类中可访问
  缺省的 包内可访问
  private 本类中可访问
  ======================================================
  Java中的数据类型
  基本类型
  整型：byte short int long
  浮点型：float double
  非数字：char boolean
  引用类型
  数组
  类 [抽象类]
  接口 [枚举类型 注解类型]
  类和抽象类，接口
  1.关键字不一样 抽象类abstract class 接口是interface
  2.抽象类中的属性可以是成员属性，也可以是类属性
  接口中的属性必须是公共的常量
  3.抽象类中的方法可以是具体的方法，也可以是抽象方法
  接口中的方法只能是抽象方法，或者是default方法[1.8及以上]
  4.抽象类有构造方法，接口没有构造方法
  5.一个类只能继承一个抽象类
  一个类可以实现多个接口
  =========================================================
  为什么需要接口？？
  类中的方法全部是具体的方法
  抽象类中的方法可以是具体的方法，也可以是抽象方法
  接口中的方法全部是抽象方法

---

Eclipse中的工程结构：

• 工作空间[WorkSpace]
  工程[Project]
  src
  软件包[package]
  类/接口[class/interface]的源代码
  bin
  软件包[package]
  类/接口[class/interface]的字节码
  Idea中的工程结构
  工程[Project]，创建工程的时候指定路径
  模块[Module]
  src
  软件包[package]
  类/接口[class/interface]的源代码
  模块[Module]
  src
  软件包[package]
  类/接口[class/interface]的源代码
  out
  production
  模块
  软件包[package]
  类/接口[class/interface]的字节码
  模块
  软件包[package]
  类/接口[class/interface]的字节码
  =========================================================
  如何继承？
  public class A{}
  public class B extends A{}
  为什么需要继承？
  a.子类可以继承到父类中的属性和方法，减少代码的冗余
  b.子类可以定义自己特有的属性和方法，实现对父类的扩展
  子类特有的方法必须是子类类型的对象才能调用
  c.子类还可以修改【覆盖、重写】从父类继承来的属性和方法
  对象调用的是不是重写的方法，取决于new的类型

static 静态的

• 可以用来声明类，属性，方法和代码块
  static属性:类属性 该类所有的对象共享的一个变量
  非静态属性：成员属性 该类的每一个对象都独立的有一个变量
  static方法：类方法
  非static方法：成员方法
  调用成员方法的时候，根对象本身的类型[new的类型]有关系
  在调用类方法的时候，只跟变量的类型有关系
  static属性和static方法可以通过对象来调用
  但通常情况下都直接通过类名调用
  在静态方法中不能够直接调用非静态的属性和方法
  static类：一般用来定义内部类[嵌套类]
  static代码块
  static{
  }
  ===========================================================================
  程序的执行顺序
  1.加载类，将class文件加载到JVM的内存中[开辟类的内存空间]
  加载的时候，所有的static的属性和代码块都会按顺序执行
  2.开始执行主函数
  所有的方法[static方法和成员方法]必须要调用才会执行
  3.创建某个类的对象[开辟对象的内存]
  开辟对象的内存空间的时候，所有的成员属性和非静态代码块会按顺序执行。

理解参考运行实例

public class A{
public A(){
System.out.println(“A”);
}}
public class B extends A{
public B(){
System.out.println(“B”);
}}
public class C{
A a = new A();
static B b = new B();

public C(){System.out.println("C");
}public static void change(){B b = new B();
}
public static void main(String[] args){C.change();
}}

执行结果：ABAB

Java中的常用类
String StringBuffer StringBuilder
1.字符串的构造方式
String s = “ABCD”;
String s = new String(“ABCD”);
//字符数组转换成字符串
String s = new String(char[]);
String s = new String(char[],startIndex,count);
//字节数组转换成字符串
String s = new String(byte[]);
String s = new String(byte[],charset);
String s = new String(byte[],startIndex,count,charset);
字符集：
1.所有的字符都是用数字表示的
2.字符用哪个数字表示是有不同的标准的
3.这些标准就称作字符集
4.常见的字符集
ISO-8859-1 ~ ISO-8859-14 只识别半角字符
半角字符：ABC abc 123
全角字符: ＡＢＣａｂｃ　１２３
GBK 简体中文 字符集 [支持中文，英文和数字]
GB2312 GB18030
UTF-8 基于Unicode编码的字符集
2.字符串的常用方法
字符串转换成字符数组
toCharArray();
字符串转换成字节数组
getBytes();
getBytes(charset);
查找
charAt(index); 根据下标取出一个字符
indexOf(s); 查找s在字符串中第一次出现的下标位置
lastIndesOf(s); 查找s在字符串中最后一次出现的下标位置
contains(s); 是否包含指定的字符串

匹配
equals(s) 字符串是否以指定的字符串"相等"
equalsIgnoreCase(s)字符串是否以指定的字符串"相等" 忽略大小写
match(s) 字符串是否以指定的字符串匹配

替换
replace(oldString,newString) 替换指定的字符串
replaceAll(oldString,newString)替换指定的字符串
replaceFirst(oldString,newString) 替换指定的字符串,只替换第一次出现的

截取
subString(start)
subString(start,end);

切割
split(“标记”)

字符串长度:包含多少个字符
length()

String StringBuilder StringBuffer
String 基于char数组[jdk8]的实现，一旦定义好，长度就不可改变
基于byte数组[jdk11]的实现
当进行字符串拼接的时候，每次都需要创建新的数组，来存放数据
StringBuilder与StringBuffer 长度可变字符串
StringBuilder的性能要高于StringBuffer
StringBuilder是线程不安全的
StringBuffer是线程安全的

由于StringBuffer需要进行线程的同步操作，其性能要比StringBuilder差
StringBuffer适用于多线程的并发操作。

---

包装类
每一种基本类型都对应有一个包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
Integer
整数对象的创建
Integer t = 100;
Integer t= new Integer(100);
Integer t2 = new Integer(“1234”);

Integer类中的方法大多都是static方法String  s  =  toString(int);String  s  =  toString(int,进制)；String  s  =  toBinaryString(int);String  s  =  toOctalString(int);String  s  =  toHexString(int);int  t  =  Integer.parseInt(String);int  t  =  Integer.parseInt(String,进制);

-123的二进制：
先得到123的原码：00000000 00000000 00000000 01111011
取得反码： 11111111 11111111 11111111 10000100
+1 11111111 11111111 11111111 10000101
自动装箱和自动拆箱
自动装箱：基本类型的数据可以自动打包成对应的引用类型
自动拆箱：引用类型的数据可以自动出对应的基本类型

---

Random
Math
Date
Time
LocalTime
Calendar

浮点数的二进制表示方式：
20.5 = 205*10的-1次方 = 205E-1
1.将整数部分转换成二进制
除以2，取余数
20/2=10…0
10/2=5…0
5/2=2…1
2/2=1…0
1/2=0…1
20的二进制：10100
2.将小数部分转成二进制
乘以2，取整数部分
0.52=1.0 1
0.02=0 0
0.5的二进制：10
3.将整数部分和小数部分整合到一起
20.5的二进制：10100.10
4.将20.5的二进制用科学计数法表示，只保留一个整数位
10100.10 = 1.010010E4
5.将4次方也用二进制表示
4的二进制：100
20.5的二进制采用科学计数法：1.010010E100
6.准备存储
float的存储
float是32位的，第1位是符号位，表示正负
接下来8位是指数位
最后23位表示尾数位
a.存符号位，20.5是一个正数，符号位是0
b.存指数位 float在存储指数位的时候需要先加127，在存储
100+1111111 = 10000011
c.存尾数位 由于尾数部分的整数永远是1，所以1是不存储的，只存储小数部分
010010
如果小数部分不够23位，就在后面补0
符号位[1] 指数位[8] 尾数位[23]
0 10000011 01001000000000000000000

float  20.5的二进制:  01000001101001000000000000000000double的存储double是64位的  第1位是符号位，表示正负接下来11位是指数位最后52位表示尾数位a.存符号位，20.5是一个正数，符号位是0b.存指数位，double的指数位需要先+1023，在保存100+1111111111  =  10000000011c.存尾数位    由于尾数部分的整数永远是1，所以1是不存储的，只存储小数部分010010如果不够52位，就在后面补0符号位[1]        指数位[11]          尾数位[52]0              10000000011        0100100000000000000000000000000000000000000000000000double的20.5的二进制：0100000000110100100000000000000000000000000000000000000000000000取出float符号位  0取指数位，先减去127，得到真实指数10000011-1111111=100取得尾数部分  01001000000000000000000，在整数部分加11.01001000000000000000000拼接成一个科学计数法表示的数字1.01001000000000000000000E100去除科学计数法10100.1000000000000000000将小数点前面的部分取出，还原成整数  10100  -->    20将小数点后面的部分还原成整数0.10000000  ->0.5000000拼接到一起20.50.3*2=0.6      0
0.6*2=1.2      1
0.2*2=0.4      0
0.4*2=0.8      0
0.8*2=1.6      1
0.6*2=1.2      1
0.2*2=0.4      010100.010011001100110011001100110011001...1.0100010011001100110011001100110011001...E100float    0  10000011    01000100110011001100110
double  0  10000000011  01000100110011001100110123456
1.23456

JAVA文件

• 什么是文件？
  文件是外存储器中数据的组成方式
  外存储器:硬盘 U盘 光盘 软盘
  文件的分类
  目录文件
  标准文件
  虚拟内存文件
  文件的表示形式：
  字符串路径： D:\aa\b.txt
  文件对象: java.io.File类是用来操作文件的类
  Java中的特殊字符
  ‘’ 字符的边界字符
  “” 字符串的边界字符
  \ 转义字符
  \n 换行符
  \t 制表符
  如果需要将普通字符传转义特殊字符，需要用转义字符
  如果需要将特殊字符转义成普通字符，需要用转义字符
  "
  =============================================
  File类的常用构造方法
  new File(String path) 根据文件路径创建文件对象
  new File(String parent,String child) 根据父路径和子路径创建文件对象
  File类的常用方法：
  exists() 判断文件是否存在
  length() 获得文件的长度，总字节数
  lastModified() 文件的最后一次修改时间，毫秒时间
  delete() 删除文件
  deleteOnExit() 程序结束的时候删除文件
  createNewFile() 创建一个新的标准文件
  mkdir() 创建一个文件夹
  mkdirs() 创建多级文件夹
  isDirectory() 判断文件对象是不是文件夹
  isFile() 判断文件对象是不是标准文件
  list() 如果File对象是一个文件夹，则获得该文件夹下的所有文件的名字
  如果File对象是一个标准文件，则返回null
  listFiles() 如果File对象是一个文件夹，则获得该文件夹下的所有文件对象
  如果File对象是一个标准文件，则返回null
  getAbsolutePath() 获得文件对象的绝对路径
  ========================================
  统计指定的文件夹下有多少个标准文件？有多少文件夹？总大小是多少？
  递归操作：
  在方法中调用自己本身
  递归一定要有退出条件，否则就是死递归，死递归的结果会造成栈内存溢出
  所有的递归操作一定是在一个条件语句中

Java IO
即 Java 输入/输出系统。
Stream 流
Java 中将数据的输入输出抽象为流，流是一组有顺序的，单向的，有起点和终点的数据集合，就像水流。按照流中的最小数据单元又分为字节流和字符流。
流按最小数据单元分为字节流（byte） 和 字符流 （char），
字节流基类:InputStream（输入流）、OutStream（输出流）。
字符流基类:Reader（输入）、Writer（输出）。
Java 的 IO 主要包含两个部分：
1.流式部分：是 IO 的主体部分，也是本文介绍的重点， 流式部分根据流向分为输入流（InputStream/Reader）和输出流（OutputStream/Writer）， 根据数据不同的操作单元，分为字节流（InputStream/OutputStream）和字符流（Reader/Writer），依据字节流和字符流，Java 定义了用来操作数据的抽象基类InputStream/OutputStream 和 Reader/Writer，再根据不同应用场景（或功能），在这两种抽象基类上基于数据载体或功能派上出很多子类，用来满足文件，网络，管道等不同场景的 IO 需求，从而形成了 Java 的基本 IO 体系。
2.非流式部分：主要包含一些辅助流式部分的类，如SerializablePermission 类、File 类、RandomAccessFile 类和 FileDescriptor 等；

Java IO有很多分类，根据是否直接处理数据，Java io又分为节点流和处理流，节点流是真正直接处理数据的；处理流是装饰加工节点流的。
节点流
节点流是真正直接处理数据的。分为文件流、数组流、字符串流、管道流。

• 使用访问限定符来限定类，属性，方法和构造方法的可访问范围
  为什么需要封装？？
  对于属性的访问,可以有写访问和读访问
  通过访问限定符限定属性的可访问访问
  再通过setter和getter方法来对外提供访问接口
  提高数据的安全性
  封装的级别
  public 公共的 程序中随处可访问
  protected 受保护的 包内和子类中可访问
  缺省的 包内可访问
  private 本类中可访问
  ======================================================

Java中的数据类型

• 基本类型
  整型：byte short int long
  浮点型：float double
  非数字：char boolean
  引用类型
  数组
  类 [抽象类]
  接口 [枚举类型 注解类型]
  类和抽象类，接口
  1.关键字不一样 抽象类abstract class 接口是interface
  2.抽象类中的属性可以是成员属性，也可以是类属性
  接口中的属性必须是公共的常量
  3.抽象类中的方法可以是具体的方法，也可以是抽象方法
  接口中的方法只能是抽象方法，或者是default方法[1.8及以上]
  4.抽象类有构造方法，接口没有构造方法
  5.一个类只能继承一个抽象类
  一个类可以实现多个接口
  =========================================================
  为什么需要接口？？
  类中的方法全部是具体的方法
  抽象类中的方法可以是具体的方法，也可以是抽象方法
  接口中的方法全部是抽象方法

---

Eclipse中的工程结构：

• 工作空间[WorkSpace]
  工程[Project]
  src
  软件包[package]
  类/接口[class/interface]的源代码
  bin
  软件包[package]
  类/接口[class/interface]的字节码
  Idea中的工程结构
  工程[Project]，创建工程的时候指定路径
  模块[Module]
  src
  软件包[package]
  类/接口[class/interface]的源代码
  模块[Module]
  src
  软件包[package]
  类/接口[class/interface]的源代码
  out
  production
  模块
  软件包[package]
  类/接口[class/interface]的字节码
  模块
  软件包[package]
  类/接口[class/interface]的字节码
  =========================================================
  如何继承？
  public class A{}
  public class B extends A{}
  为什么需要继承？
  a.子类可以继承到父类中的属性和方法，减少代码的冗余
  b.子类可以定义自己特有的属性和方法，实现对父类的扩展
  子类特有的方法必须是子类类型的对象才能调用
  c.子类还可以修改【覆盖、重写】从父类继承来的属性和方法
  对象调用的是不是重写的方法，取决于new的类型

static 静态的

• 可以用来声明类，属性，方法和代码块
  static属性:类属性 该类所有的对象共享的一个变量
  非静态属性：成员属性 该类的每一个对象都独立的有一个变量
  static方法：类方法
  非static方法：成员方法
  调用成员方法的时候，根对象本身的类型[new的类型]有关系
  在调用类方法的时候，只跟变量的类型有关系
  static属性和static方法可以通过对象来调用
  但通常情况下都直接通过类名调用
  在静态方法中不能够直接调用非静态的属性和方法
  static类：一般用来定义内部类[嵌套类]
  static代码块
  static{
  }
  ===========================================================================
  程序的执行顺序
  1.加载类，将class文件加载到JVM的内存中[开辟类的内存空间]
  加载的时候，所有的static的属性和代码块都会按顺序执行
  2.开始执行主函数
  所有的方法[static方法和成员方法]必须要调用才会执行
  3.创建某个类的对象[开辟对象的内存]
  开辟对象的内存空间的时候，所有的成员属性和非静态代码块会按顺序执行。

理解参考运行实例

public class A{
public A(){
System.out.println(“A”);
}}
public class B extends A{
public B(){
System.out.println(“B”);
}}
public class C{
A a = new A();
static B b = new B();

public C(){System.out.println("C");
}public static void change(){B b = new B();
}
public static void main(String[] args){C.change();
}}

执行结果：ABAB

Java中的常用类
String StringBuffer StringBuilder
1.字符串的构造方式
String s = “ABCD”;
String s = new String(“ABCD”);
//字符数组转换成字符串
String s = new String(char[]);
String s = new String(char[],startIndex,count);
//字节数组转换成字符串
String s = new String(byte[]);
String s = new String(byte[],charset);
String s = new String(byte[],startIndex,count,charset);
字符集：
1.所有的字符都是用数字表示的
2.字符用哪个数字表示是有不同的标准的
3.这些标准就称作字符集
4.常见的字符集
ISO-8859-1 ~ ISO-8859-14 只识别半角字符
半角字符：ABC abc 123
全角字符: ＡＢＣａｂｃ　１２３
GBK 简体中文 字符集 [支持中文，英文和数字]
GB2312 GB18030
UTF-8 基于Unicode编码的字符集
2.字符串的常用方法
字符串转换成字符数组
toCharArray();
字符串转换成字节数组
getBytes();
getBytes(charset);
查找
charAt(index); 根据下标取出一个字符
indexOf(s); 查找s在字符串中第一次出现的下标位置
lastIndesOf(s); 查找s在字符串中最后一次出现的下标位置
contains(s); 是否包含指定的字符串

匹配
equals(s) 字符串是否以指定的字符串"相等"
equalsIgnoreCase(s)字符串是否以指定的字符串"相等" 忽略大小写
match(s) 字符串是否以指定的字符串匹配

替换
replace(oldString,newString) 替换指定的字符串
replaceAll(oldString,newString)替换指定的字符串
replaceFirst(oldString,newString) 替换指定的字符串,只替换第一次出现的

截取
subString(start)
subString(start,end);

切割
split(“标记”)

字符串长度:包含多少个字符
length()

String StringBuilder StringBuffer
String 基于char数组[jdk8]的实现，一旦定义好，长度就不可改变
基于byte数组[jdk11]的实现
当进行字符串拼接的时候，每次都需要创建新的数组，来存放数据
StringBuilder与StringBuffer 长度可变字符串
StringBuilder的性能要高于StringBuffer
StringBuilder是线程不安全的
StringBuffer是线程安全的

由于StringBuffer需要进行线程的同步操作，其性能要比StringBuilder差
StringBuffer适用于多线程的并发操作。

---

包装类
每一种基本类型都对应有一个包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
Integer
整数对象的创建
Integer t = 100;
Integer t= new Integer(100);
Integer t2 = new Integer(“1234”);

Integer类中的方法大多都是static方法String  s  =  toString(int);String  s  =  toString(int,进制)；String  s  =  toBinaryString(int);String  s  =  toOctalString(int);String  s  =  toHexString(int);int  t  =  Integer.parseInt(String);int  t  =  Integer.parseInt(String,进制);

-123的二进制：
先得到123的原码：00000000 00000000 00000000 01111011
取得反码： 11111111 11111111 11111111 10000100
+1 11111111 11111111 11111111 10000101
自动装箱和自动拆箱
自动装箱：基本类型的数据可以自动打包成对应的引用类型
自动拆箱：引用类型的数据可以自动出对应的基本类型

---

Random
Math
Date
Time
LocalTime
Calendar

浮点数的二进制表示方式：
20.5 = 205*10的-1次方 = 205E-1
1.将整数部分转换成二进制
除以2，取余数
20/2=10…0
10/2=5…0
5/2=2…1
2/2=1…0
1/2=0…1
20的二进制：10100
2.将小数部分转成二进制
乘以2，取整数部分
0.52=1.0 1
0.02=0 0
0.5的二进制：10
3.将整数部分和小数部分整合到一起
20.5的二进制：10100.10
4.将20.5的二进制用科学计数法表示，只保留一个整数位
10100.10 = 1.010010E4
5.将4次方也用二进制表示
4的二进制：100
20.5的二进制采用科学计数法：1.010010E100
6.准备存储
float的存储
float是32位的，第1位是符号位，表示正负
接下来8位是指数位
最后23位表示尾数位
a.存符号位，20.5是一个正数，符号位是0
b.存指数位 float在存储指数位的时候需要先加127，在存储
100+1111111 = 10000011
c.存尾数位 由于尾数部分的整数永远是1，所以1是不存储的，只存储小数部分
010010
如果小数部分不够23位，就在后面补0
符号位[1] 指数位[8] 尾数位[23]
0 10000011 01001000000000000000000

float  20.5的二进制:  01000001101001000000000000000000double的存储double是64位的  第1位是符号位，表示正负接下来11位是指数位最后52位表示尾数位a.存符号位，20.5是一个正数，符号位是0b.存指数位，double的指数位需要先+1023，在保存100+1111111111  =  10000000011c.存尾数位    由于尾数部分的整数永远是1，所以1是不存储的，只存储小数部分010010如果不够52位，就在后面补0符号位[1]        指数位[11]          尾数位[52]0              10000000011        0100100000000000000000000000000000000000000000000000double的20.5的二进制：0100000000110100100000000000000000000000000000000000000000000000取出float符号位  0取指数位，先减去127，得到真实指数10000011-1111111=100取得尾数部分  01001000000000000000000，在整数部分加11.01001000000000000000000拼接成一个科学计数法表示的数字1.01001000000000000000000E100去除科学计数法10100.1000000000000000000将小数点前面的部分取出，还原成整数  10100  -->    20将小数点后面的部分还原成整数0.10000000  ->0.5000000拼接到一起20.50.3*2=0.6      0
0.6*2=1.2      1
0.2*2=0.4      0
0.4*2=0.8      0
0.8*2=1.6      1
0.6*2=1.2      1
0.2*2=0.4      010100.010011001100110011001100110011001...1.0100010011001100110011001100110011001...E100float    0  10000011    01000100110011001100110
double  0  10000000011  01000100110011001100110123456
1.23456

JAVA文件

什么是文件？

• 文件是外存储器中数据的组成方式
  外存储器:硬盘 U盘 光盘 软盘
  文件的分类
  目录文件
  标准文件
  虚拟内存文件
  文件的表示形式：
  字符串路径： D:\aa\b.txt
  文件对象: java.io.File类是用来操作文件的类
  Java中的特殊字符
  ‘’ 字符的边界字符
  “” 字符串的边界字符
  \ 转义字符
  \n 换行符
  \t 制表符
  如果需要将普通字符传转义特殊字符，需要用转义字符
  如果需要将特殊字符转义成普通字符，需要用转义字符
  "
  =============================================
  File类的常用构造方法
  new File(String path) 根据文件路径创建文件对象
  new File(String parent,String child) 根据父路径和子路径创建文件对象
  File类的常用方法：
  exists() 判断文件是否存在
  length() 获得文件的长度，总字节数
  lastModified() 文件的最后一次修改时间，毫秒时间
  delete() 删除文件
  deleteOnExit() 程序结束的时候删除文件
  createNewFile() 创建一个新的标准文件
  mkdir() 创建一个文件夹
  mkdirs() 创建多级文件夹
  isDirectory() 判断文件对象是不是文件夹
  isFile() 判断文件对象是不是标准文件
  list() 如果File对象是一个文件夹，则获得该文件夹下的所有文件的名字
  如果File对象是一个标准文件，则返回null
  listFiles() 如果File对象是一个文件夹，则获得该文件夹下的所有文件对象
  如果File对象是一个标准文件，则返回null
  getAbsolutePath() 获得文件对象的绝对路径
  ========================================
  统计指定的文件夹下有多少个标准文件？有多少文件夹？总大小是多少？
  递归操作：
  在方法中调用自己本身
  递归一定要有退出条件，否则就是死递归，死递归的结果会造成栈内存溢出
  所有的递归操作一定是在一个条件语句中

Java IO
即 Java 输入/输出系统。
Stream 流
Java 中将数据的输入输出抽象为流，流是一组有顺序的，单向的，有起点和终点的数据集合，就像水流。按照流中的最小数据单元又分为字节流和字符流。
流按最小数据单元分为字节流（byte） 和 字符流 （char），
字节流基类:InputStream（输入流）、OutStream（输出流）。
字符流基类:Reader（输入）、Writer（输出）。
Java 的 IO 主要包含两个部分：
1.流式部分：是 IO 的主体部分，也是本文介绍的重点， 流式部分根据流向分为输入流（InputStream/Reader）和输出流（OutputStream/Writer）， 根据数据不同的操作单元，分为字节流（InputStream/OutputStream）和字符流（Reader/Writer），依据字节流和字符流，Java 定义了用来操作数据的抽象基类InputStream/OutputStream 和 Reader/Writer，再根据不同应用场景（或功能），在这两种抽象基类上基于数据载体或功能派上出很多子类，用来满足文件，网络，管道等不同场景的 IO 需求，从而形成了 Java 的基本 IO 体系。
2.非流式部分：主要包含一些辅助流式部分的类，如SerializablePermission 类、File 类、RandomAccessFile 类和 FileDescriptor 等；

Java IO有很多分类，根据是否直接处理数据，Java io又分为节点流和处理流，节点流是真正直接处理数据的；处理流是装饰加工节点流的。
节点流
节点流是真正直接处理数据的。分为文件流、数组流、字符串流、管道流。