Java基础

Java基础
Java开发环境的搭建
安装jdk8
下载JDK 则需要咱们去官网上进行下载：www.oracle.com/www.sun.com
测试
在DOS命令中输入cmd------>javac 测试
安装jre
安装JRE(JRE在Java中主要是负责提供一些咱们在编写程序的时候使用的资源)
配置环境变量
我的电脑–>属性–>高级环境变量–>系统变量
1.新建系统变量JAVA_HOME 变量值为jdk安装目录
2.新建系统变量CLASSPATH 变量值为.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;
3.在系统变量Path变量值前添加%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
测试
在DOC中输入Java 和Javac测试
编写代码
定义一个类
Public class MyTest(){}
定义一个方法(主方法)
Public static void main(String[]args){}
输出（向控制台）
System out println(“Hello Word ”);
xxx.java文件被编译后产生一个新的xxx.calss文件，这种.class文件在java中称为二进制文件
Public class和class修饰类的区别
用public class修饰类的话，类名称必须和文件XXX.java名称一致。
Class修饰类的话，类名称可以和XXX.java名称不一致。
注释
单行注释//
多行注释/* /
文档注释/* */
Java中的标识符
Java中的包，类，方法，参数和变量的名字可以是任意顺序的大小写字母，数字，下划线(_),和美元符号($),不能是数字开头 不能是Java中保留的关键字
Java中的关键字
goto和const没有意义；
Assert 是在JDK1.4之后加进来的；
Enum实在JDK1.5之后加进来的；
Java中的数据类型
Java中数据类型的划分

数据类型分为基本数据类型和引用数据类型
基本数据类型分为数值型，字符型(char),布尔型(boolean)
数值型分为整数类型和浮点类型
整数类型(byte),(shot),(int),(long)
浮点类型(float),(double )
引用数据类型分为类(class),接口(interface),数组([])
变量和常量
变量：
将内存中的某个内存块保留下来以供程序使用，里面的内容是可变的。
常量：
一个数就表示常量，常量的内容是不会改变的。
自动类型转换
1.类型兼容
2.目标类型大于原类型
3.Bute,short,char在运算时会自动转换为int型再运算

强制类型转换
目标类型 变量=（目标类型）值；

运算符

自增运算符和自减运算符
1、“++”/“–”只能用于变量的使用，不能用于常数；
2、“++”/“–”在前时：先自加/自减1再使用；
3、“++”/“–”在后时：先使用，再自加/自减1；
赋值运算符
= , +=, -=, *=, /=, %=
比较运算符

比较运算符的结果都是boolean型，也就是要么是true，要么是false。
逻辑运算符

& ：左边无论真假，右边都进行运算；
&&：如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算(见到false就不在执行)
| :左边无论真假，右边都进行运算；
|| :如果左边为假，右边参与运算，如果左边为真，那么右边不参与运算(见到true就不再执行)

^ :左右相同时结果为false;
逻辑运算操作的都是布尔型的变量
三元运算符
(条件表达式)?表达式1：表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；
运算符的优先级

流程控制语句
顺序结构
代码自上而下的逐行执行代码
分支结构
if分支语句
1.只是单独的判断条件是否成立；
if(条件表达式){
执行语句；
}
2.需要对条件成立和不成立时分别做出处理；
if(条件表达式){
执行语句；
}else{
执行语句；
}
3.针对多条件的情况分别作处理
if(条件表达式1){
执行语句；
}else if (条件表达式2){
执行语句；
}
……
else{
执行语句；
}
switch分支语句
循环结构：根据逻辑重复执行某个代码块
switch (表达式){
case 选择值1 ：
语句主体 1;
break;
case 选择值2 ：
语句主体 2 ；
break ；
…….
case 选择值n ：
语句主体 n ；
break ；
default：
语句主体 ；
}
循环语句
1、while循环
2、do…while循环
3、for循环
while循环
while(条件表达式)
{
执行语句；
}
do while循环
do{
执行语句；
}while(条件表达式);
for循环
for(初始化表达式；循环条件表达式；循环后的操作表达式)
{
执行语句；(循环体)
}
中断控制语句
break语句:
跳出整个循环体
continue语句:
跳出本次循环，继续下次循环

函数
简介
public static void main(String[] args){}这个函数称为主函数，主函数是Java程序的入口。
函数的定义
函数就是定义在类中的具有特定功能的一段独立小程序(Java代码)。
函数也称为方法。
修饰符 返回值类型 函数名(参数类型 参数名1,参数类型 参数名2，…)
{
执行语句;
return 返回值;
}
1、返回值类型：函数运行后的结果的数据类型，即与return后边返回值的类型一致。
2、参数类型：是形式参数的数据类型。
3、形式参数：是一个变量，用于接收此函数所需要传入的数据
4、return：用于结束函数。
5、返回值：该函数运算后的结果，该结果会返回给调用者。

函数的返回值
如果方法具有返回值，方法中必须使用关键字return返回该值，返回类型为该返回值的类型

方法没有返回值
如果方法使用void定义则表示的是此方法没有返回值，所以在定义方法的时候也就不适用return关键字返回数据
ublic void say(){//此方法没有返回值
…
return 返回值;//此处错误的
}
方法有返回值
如果方法是有返回值的，那么在定义方法的时候必须使用return关键字返回相对应的数据类型的返回值。
public static int addTwo(int a,int b){/方法有返回值，返回值的类型为int
return (a+b);//返回值一定要和上面的一直也就是int型
}//a和b被称为形式参数

方法的调用
方法定义了而不调用的话那么这个方法中的代码就不执行，也就是方法就不起作用，在调方法的时候一定要注意方法的参数和返回值。
public static void main(String[] args){
int num=addTwo(11,12);//接受方法的返回值
}//在主方法中调用addTwo()方法，11和12是实际参数
num就是方法的调用出接受返回值
小结
1、函数之间可以相互调用，不可以在函数内部定义函数。
2、定义函数时，函数若有结果，则应将结果返回给调用者，交由调用者处理。
3、java语言把函数的名称和参数列表称为方法的签名，在同一个类中，不允许存在两个相同签名的方法。
4、对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。

函数的重载（overload）
一个类中不能出现相同的方法。但是在Java相同的方法并不是指方法的名称相同，而是指方法的名称相同而且方法的参数类型和个数相同的方法才是相同的方法。
Java中相同的方法:
1、方法的名称相同
2、参数的类型的相同
3、参数的个数相同

重载的概念：
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
重载的特点
与返回值类型无关，只看参数列表。
重载方法的调用
重载方法被调用时，Java用参数的类型和（或）数量来表明实际调用的重载方法的版本。
数组
数组的定义
数组是一个变量，存储相同数据类型的一组数据，长度一旦定义就不能改变。

数组的创建语法
1.元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例：int[] score = new int[5];
2.元素类型[] 数组名 = {元素，元素，……};
实例：int[] score = {3,5,1,7};
数组中常见的错误
数组长度错误
使用第一种方式创建数组没有指定数组的长度
int[] arr=new int[];
数组越界
获取数组内容的时候指定索引超出了数组的长度
java.lang.ArrayIndexOutOfBoundsException
数组的排序
冒泡排序
一次循环产生一个最大或者最小值
快速排序
直接使用工具类完成数组的排序操作。
.sort()

二维数组
一维数组中存放的不再是Java中的基本数据类型了，而是在一维数组中存放的是一维数组。

1.先声明后赋值
格式1：int[][] arr = new int[3][2];
格式2：int[][] arr = new int[3][];
2.直接赋值
格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
面向对象
组成
1、对象的属性
属性指的用来描述对象的一些相关的信息。
2、对象的方法
对象的方法其实就是指的是对象具有的功能。
面向对象的三大特征
1、封装（Encapsulation）
对外部不可见
2、继承（Inheritance）
扩展类的功能
3、多态（Polymorphism）
方法的重载
对象的多态性
创建对象
对象的创建需要使用new关键字，根据类创建对象就是开辟堆栈内存的操作。

类名称 对象名称=new 类名称();
通过对象调用类中的属性和方法
给类的属性赋值：对象名.属性
调用类的方法：对象名.方法名()
成员变量和局部变量
成员变量：
1、成员变量定义在类中，在整个类中都可以被访问。
2、成员变量随着对象的建立而建立
3、成员变量有默认初始化值。
局部变量：
1、局部变量只定义在局部范围内，如：函数内，语句内等。
2、作用的范围结束，变量空间会自动释放。
3、局部变量没有默认初始化值。
Java中四种访问权限：
类中属性和方法的四种访问修饰符：
public:允许来自任何类中的方法访问。
private：只允许本类内部的方法访问，其他任何访问都被拒绝；
protected：允许本包中的类和（即便不在同一包下的）所有子类的方法访问（子类对象可以使用）。
无修饰限制：允许同一包下任何类中的方法访问。
什么是构造方法
构造方法是一个用来创建(实例化)对象的特殊的方法。
构造方法的定义
修饰符 类名(参数类型 参数名称,参数类型 参数名称…){
执行代码;
}
1、构造方法的名称就是类名
2、构造方法没有返回值类型这一说
构造方法什么时候使用
构造方法是在需要创建对象的时才去使用的方法。
构造方法的特点
1、在Java语言中，每个类都至少有一个构造方法；
2、如果类的定义者没有显式地定义任何构造方法，java编译器将自动为类提供一个默认的构造方法，默认构造方法没有参数，默认构造方法方法体为空；
3、在Java类中，一旦类的定义者显式地定义了一个或多个构造方法，系统将不再提供默认的构造方法(无参构造方法)；
构造方法的作用
1、实例化对象(创建对象)
2、给属性赋值
this关键字
使用this关键字区分局部变量和全局变量。
this关键字可以表示调用的类中的全局的属性。
this关键字的作用
1、this可以调用当前类的属性；
2、this可以调用当前类中的普通方法；
3、this可以调用当前类的构造方法；
注意：1.如果一个类中有多个构造方法的话，也可以利用this关键字互相调用。
2.使用this调用构造方法必须也只能放在构造方法的第一行，只能是构造方法调 用构造方法。
3.一个构造方法只能直接调用一个构造方法(因为this关键字调用构造方法代码只 能放在第一行)，普通方法不能通过this关键字调用构造方法
4.this表示的当前类的对象
this最重要的特点就是表示当前对象，在java中当前对象就是指当前正在调用类中 方法的对象。
static关键字
使用static声明属性
在程序中使用static声明属性的话，则此属性称为全局属性（有些也称为静态属性）
使用static声明方法
static既可以在声明属性的时候使用，也可以用其来声明方法，用它声明的方法有时也被称为“类方法”。
使用static修饰的属性属于全局属性，使用static修饰的方法称为类方法，使用static修饰的方法和属性都可以通过类名来直接调用，而不用使用对象来调用了。
static调用限制
非static声明的方法可以去调用static声明的属性或方法的。但是static声明的方法是不能调用非static类型声明的属性或方法的。
1、静态方法不能直接调用非静态的方法
2、静态方法不能直接调用非静态的变量
3、static关键字使用规则
a)非静态的方法可以调用静态属性和静态方法也可以调用非静态的方法和属性
b)静态方法只能直接调用静态属性和静态的方法
继承（private）
继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系，提供了多态的前提。
不能仅为了获取其他类中某个功能而去继承
访问限制
这里说的访问的限制其实就是指子类访问父类中属性或者方法的限制。
在使用继承的时候也应注意的是：子类是不能直接访问父类中的私有成员的，但是子类可以调用父类中的非私有方法，但是不能直接调用父类中的私有成员。

子类对象实例化过程
在继承的操作中，对于子类对象的实例化也是有要求的：“子类对象在实例化之前必须首先调用父类中的构造方法之后再调用子类自己的构造方法”。

子类创建对象的时候默认的是调用的父类中的无参构造方法,要想去调用有参构造方法的话则需要使用其他的方式。
方法的覆写
1、子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者覆写。
2、覆盖注意事项：
覆盖时，子类方法权限一定要大于等于父类方法权限
3、当子类需要父类的功能，而功能主体子类有自己特有内容时，可以覆写父类中的方法，这样，即延续了父类的功能，又定义了子类特有的内容。
注意：
1、如果子类覆写了父类的方法,那么子类对象调用将是自己覆写过的方法。
2、如果子类没有覆写父类的方法,那么子类对象调用将是父类中的方法。
方法的重载与覆写的区别
No. 区别点 重载 覆写
1 单词 Overload Override
2 定义 方法名称相同，参数的类型或个数不同 方法名称、参数的类型、返回值类型全部相同
3 对权限没有要求 被覆写的方法不能拥有更严格的权限
4 范围 发生在一个类中 发生在继承类中(子类和父类)

super关键字
1、super表示的父类对象
2、super可以调用父类中的非私有属性和方法
3、super调用父类的构造方法(调用构造方法的代码只能出现在构造方法的第一行)
this与super的区别
No. 区别点 this super
1 属性访问 访问本类中的属性，如果本类没有此属性则从父类中继续查找 访问父类中的属性
2 方法 访问本类中的方法，如果本类中没有此方法，则从父类中继续查找 直接访问父类中的方法
3 调用构造 调用本类构造，必须放在构造方法的首行 调用父类构造，必须放在子类构造方法的首行
4 特殊 表示当前对象 无此概念(父类的对象)
final关键字
1、修饰变量
使用final修饰的变量表示取值不会改变的常量。
final修饰变量的特征：
·final修饰符可以修饰变量,被修饰的变量即成为了常量
·final类型的变量必须显式地初始化，否则将导致编译错误
·final变量只能被赋值一次
·在定义final常量时，一般以大写字母命名，且多个单词之间以“_”符号隔开
定义要给全局常量：
2、修饰类
用final关键词修饰的类是不能被继承的，也称最终类。

-对该类的设计永远不需要任何改动
-处于安全的考虑
3、修饰方法
用final关键词修饰的方法不能被子类修改----确保该方法在子类中不被改变（覆盖）。
Object类
Java中所有的类都有一个公共的父类就是Object类，一个类只要没有明显的继承一个类，则肯定是Object类的子类。
1、Object类的常用的方法
No. 方法名称 类型 描述
1 public Object() 构造 构造方法
2 public boolean equals(Object obj) 普通 对象比较
3 public int hashCode() 普通 取得Hash码
4 public String toString() 普通 对象打印时调用
1、toString()方法
在直接输出对象的时候会默认调用类中的toString()方法
2、equals()方法
(1)equals()方法的主要功能是进行对象的比较操作;
(2)String本身也是Object类的子类，所以已经覆写了此方;
3、hashCode()方法
hashCode是返回对象在内存中地址转换成的一个hash值。
抽象类
如果一个类是由abstract修饰的那么这个类就成为抽象类：
抽象类中也可以直接定义属性和方法，抽象类除了普通类中可以定义的属性和方法外还可以在类中定义抽象方法。
抽象方法
多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。
抽象方法：Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法。
//定义一个抽象方法
public abstract void show();
注：抽象方法必须定义在抽象类中。
抽象类是专门用来继承的
抽象类的特点

1、抽象类和抽象方法必须用abstract关键字来修饰。
2、抽象方法只有方法声明，没有方法体，定义在抽象类中。
格式：修饰符 abstract 返回值类型 函数名(参数列表) ;
3、抽象类不可以被实例化，也就是不可以用new创建对象。原因如下：
抽象类是不具体的，没有对应的实例。而且抽象类即使创建了对象，调用抽象方法也没有意义。
3、抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。
抽象类的总结
1、抽象类中不一定有抽象方法
2、有抽象方法的类一定是抽象类
接口
接口的定义
接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。
Interface 接口名{}
子类实现接口
与抽象类一样，接口要使用也必须通过子类，子类通过implements关键字实现接口。
实现格式：
class 子类 implements 接口A,接口B,…{
}

接口的继承
Interface 子接口 extends 父接口，子接口，···，{}
接口与抽象类
共 性： 都是不断抽取出来的抽象的概念
区别 1： 抽象类体现继承关系，一个类只能单继承
接口体现实现关系，一个类可以多实现
区别 2： 抽象类中可以定义非抽象方法，供子类直接使用
接口的方法都是抽象，接口中的成员都有固定修饰符

对象多态性
对象多态性在Java中有两种，一定要保证类和类之间是有关系(继承,实现)：
1、向上转型----向上转型是自动转换
对象向上转型：父类 父类对象 = 子类实例 ;

2、向下转型
向上转型的时候是子类对象向父类对象转型，那么向下转型其实就将父类对象转换成子类对象。
向上转型时自动完成，但是向下转型则需要强制转换,
对象向下转型：子类 子类对象 = (子类)父类实例 ;
要想进行向下转型先得进行向上转型。

java.lang.ClassCastException：类型转换异常
无论发生向上转型还是向下转型父类对象永远调用的是子类中覆写父类的方法，子类自己的方法父类对象无法调用。
instanceof 关键字
在java中可以使用instanceof关键字判断一个对象是否是指定类的对象
用法：
对象 instanceof 类  返回boolean类型
内部类
1、内部类的定义
在类内部也可以定义另一个类。如果在类Outer的内部再定义一个类Inner，此时类Inner就称为内部类，而类Outer则称为外部类。
2、内部类的定义格式
标识符 class 外部类的名称{
// 外部类的成员
标识符 class 内部类的名称{
// 内部类的成员
}
}
内部类对象的创建
内部类对象的创建语法：
外部类.内部类 内部类对象=外部类对象.内部类对象;
内部类访问外部类属性和方法的规则
内部类访问外部类的属性和方法
内部类可以直接使用外部类中的属性和方法

内部类使用注意点
1、用static可以声明属性或方法，而用static也可以声明内部类，用static声明的内部类则变成外部类，但是用static声明的内部类不能访问非static的外部类属性。
2、也可以在方法中定义一个内部类，但是在方法中定义的内部类是不能直接访问方法中的参数的，如果方法中的参数要想被内部类所访问，则参数前必须加上final关键字。
匿名对象
一个方法只是调用一次的话，就使用匿名对象来完成方法的调用。
所谓的匿名对象其实就是只开辟堆内存不开辟栈内存而实现了方法的调用。
1、类中的方法只是单一的一个功能
2、匿名对象使用完成后就被垃圾回收机制回收(释放空间)
匿名内部类
当一个抽象类或接口的子类只需要使用一次的时候就可以使用匿名内部类的定义格式
前提：内部类可以继承或实现一个外部类或者接口。
匿名内部类一般是在需要接口或者抽象类对象的时候没有具体的创建相应的对象，只是通过接口或者抽象类创建了一个定义在方法中的类，这样定义在方法中的类就称为匿名内部类。

匿名内部类是在抽象类和接口的基础之上发展起来的另外一种内部类的展现形式。
总结
1、抽象类
i.抽象类不一定有抽象方法
ii.有抽象方法的类一定是抽象类
2、接口
i.接口中是由全局常量和抽象方法组成(公共)
ii.一个类实现一个接口这个类就需要覆写接口中全部方法
3、面向对象的多态性
i.方法的重载和覆写
ii.对象的向上转型和向下转型(要发生向下转型首先发生向上转型)
4、内部类
i.一个类定义在另一个类中那么这个类就是内部类
ii.匿名对象(只是用一次的对象)
iii.匿名内部类(匿名内部类一般是当做参数传递在方法中)
异常、访问权限
异常就是在程序的运行过程中所发生的不正常的事件，它会中断正在运行的程序
1、Throwable
Error—>错误
通常出现重大问题如：运行的类不存在或者内存溢出等。
不编写针对代码对其处理
Exception ---->异常
在代码段中发生的错误情况，可以改写代码处理解决
Java中异常和错误的父类都是Throwable
2、Exception和Error的子类名都是以父类名作为后缀。
3、异常分类
a.编译时异常
i.Exception以及它的所有子类
ii.(除了RuntimeException)都属于编译时异常
b.运行时异常
i.RuntimeException以及它的所有子类异常

常见的异常

异常的处理
1、使用try…catch…finally
2、使用throw是将异常进行抛出
throw用来抛出异常，根本没有处理异常。一般使用在方法中
3、throws关键字处理异常
throw关键字处理异常是在方法内容抛出，throws实在方法上抛出异常。
在main()方法上抛出了异常，main()方法是JavaSE中程序中代码执行入口，所以main()其实在Java中是JVM(虚拟机)调用的，所以此方法抛出了异常就交给了JVM进行处理了。
访问权限
包的意义
1.定义类时需要指定类的名称。但如果仅仅将类名作为类的唯一标示，则不可避免的出现命名冲突的问题。这会给组件复用以及团队间的合作造成很大麻烦！
2、在Java语言中，用包(package)的概念来解决命名冲突的问题。
3、在定义一个类时，除了定义类的名称以外，一般还要指定一个包名
4、package语句必须写在Java源文件的最开始，在类定义之前。
5、类一旦一定在了包中，那么类的全称应该是“包名.类名”。
import语句
import语句主要是用来导包的。
1、添加了包名的类在使用时就需要使用类的全称
2、java可以通过使用import语句对类的全称进行声明
3、通过import语句声明了类的全称之后，该源文件中就可以直接使用类名来进行访问
4、import语句中也可以使用“*”符号（声明了该包中所有类的全称）
包(package)
1、package语句可以划分不同的包，也就是可以使文件在不同目录下
2、import语句可以导入带包名的类，以便在使用时省略包名
3、但并不是所有带包名的类在使用时都需要导入包名，如：
1、同一个包中的类不需要导包
2、系统包java.lang中的类也不需要导包
String是java.lang包下面的类，所以不需要导包操作
修饰符的权限
属性 允许的访问
public 允许来自任何类中的方法访问
protected 允许本包中的类和（即便不在同一包下的）所有子类的方法访问（子类对象可以使用）
无修饰限制 允许同一包下任何类中的方法访问
private 只允许本类内部的方法访问，其他任何访问都被拒绝

常用类
string类的定义
public final class String
extends Object
implements Serializable, Comparable, CharSequence
String类的构造方法
public String(byte[] bytes)
public String(char[] value)
public String(String original)
使用equals()方法比较的内容，但是直接使用“==”比较的是对象的引用地址
1.1.1.1返回指定索引处的 char 值
方法的定义：
public char charAt(int index){}
1.1.1.2、按字典顺序比较两个字符串
方法的定义:
public int compareTo(String anotherString){}
1、如果参数字符串等于此字符串，则返回值 0；
2、如果此字符串按字典顺序小于字符串参数，则返回一个小于 0 的值；
3、如果此字符串按字典顺序大于字符串参数，则返回一个大于 0 的值。
1.1.1.3将指定字符串连接到此字符串的结尾
方法的定义:
public String concat(String str){}
1.1.1.4将指定字符串连接到此字符串的结尾
方法的定义:
public String concat(String str){}
1.1.1.5测试此字符串是否以指定的后缀结束
方法的定义:
public boolean endsWith(String suffix){}
1.1.1.6测试此字符串是否以指定的前缀开始
方法的定义:
public boolean startsWith(String prefix){}
1.1.1.7、将一个字符串转换成字节数组
方法的定义：
public byte[] getBytes(){}
1.1.1.8将一个字符串转换成字符数组
方法的定义:
public char[] toCharArray(){}
1.1.1.9返回指定子字符串在此字符串中第一次出现处的索引
方法的定义:
public int indexOf(String str){}
1.1.1.10获取字符串的长度
方法定义:
public int length(){}
1.1.1.11判断一个字符串长度是否为0
方法的定义:
public boolean isEmpty(){}
1.1.1.12字符串的替换
方法的定义:
public String replace(CharSequence target, CharSequence replacement){}
1.1.1.13字符串的拆分
所谓的字符串拆分其实是将一个指定的字符串按照指定的内容拆分成一个字符串数组
方法的定义:
public String[] split(String regex){}
1.1.1.14字符串的截取
方法的定义:
public String substring(int beginIndex){}
public String substring(int beginIndex, int endIndex){}
1.1.1.15将字符串转换成小写
方法方法定义:
public String toLowerCase(){}
1.1.1.16将字符串转换成大写
方法的定义:
public String toUpperCase(){}
1.1.1.17去掉字符串中的空格
方法定义:
public String trim(){}
1.1.1.18、将指定的类型转换成字符串
在String类中有很多的valueOf()方法，主要是将不同类型的数据转换成字符串，但是可以发现这些方法都是静态方法(使用static修饰的方法---->类方法)。
public static String valueOf(boolean b){}
public static String valueOf(char c){}
public static String valueOf(int i){}
public static String valueOf(long l){}
public static String valueOf(float f){}
public static String valueOf(double d){}
如果在代码中需要频繁的操作字符串的话那么最好不要直接使用String类。
StringBuffer类
1.1.1.19认识StringBuffer
StringBuffer是使用缓冲区，本身是操作字符串的，但是它与String类不同，String类的内容一旦声明后则不可改变，改变的只是其内存的地址指向，而StringBuffer中的内容是可以改变的。
对StringBuffer而言，本身是一个具体的操作类，所以不能String那样通过直接赋值的方式进行对象的实例化，必须通过构造方法。
1.1.1.20StringBuffer的构造方法
public StringBuffer(){}
public StringBuffer(String str){}
上面就是StringBuffer的常用的构造方法，一个是无参构造，一个是接收一个字符串参数的构造方法。
1.1.1.21字符串的连接操作(append)
在StringBuffer提供了一系列的append()方法，下面具体使用此方法，要注意的是这些方法的返回值是StringBuffer的对象：
public StringBuffer append(数据类型 b){}
1.1.1.22在任意位置处为StringBuffer添加内容
可以直接使用insert()方法进行内容的添加，public StringBuffer insert(int offset,String str)
StringBuffer中与String类是非常相似的都可以使用length()方法求出字符串的长度；
1.1.1.23字符串的翻转操作
直接使用reverse()方法就直接可以实现翻转的功能，public StringBuffer reverse()
1.1.1.24替换指定范围内的内容
在StringBuffer类中也存在replace()方法进行内容替换，public StringBuffer replace(int start,int end,String str)
1、start - 起始索引（包含）。
2、end - 结束索引（不包含）。
3、str - 将替换原有内容的字符串。
1.1.1.25字符串的截取
在StringBuffer中有一个subString()方法进行字符串的截取：public String substring(int start,int end)----字符串的截取不改变原有的数据
1、start - 起始索引（包含）。
2、end - 结束索引（不包含）。
1.1.1.26删除内容
因为StringBuffer里面的内容是可以修改的，在StringBuffer里可以进行内容的删除：public StringBuffer delete(int start,int end)
1、start - 起始索引（包含）。
2、end - 结束索引（不包含）。
1.1.1.27查找指定的内容是否存在
在String类里可以使用indexOf()方法进行指定内容的查询，而在StringBuffer里面也可以继续使用此方法，如果找到了则返回具体位置，否则的话返回-1；
public int indexOf(String str){}
1.1.1.28总结
凡是要频繁的修改字符串内容的时候，都要使用StringBuffer类来完成，而且在StringBuffer类里提供了一些在String类中没有的方法，包括：delete()，insert()等等；
StringBuffer的功能和StringBuilder类是一样的。
Runtime类
1.1.1.29认识Runtime类
Runtime运行时，是一个封装的JVM进程的类，每一个JAVA程序实际上都启动了一个JVM进程，每一个JVM进程都是这一个Runtime的实例，这个实例是JVM为其实例化的。
每一个Runtime对象都是由JVM进行实例化的，所以咱们直接可以使用此类的对象得到一些信息（JVM）；
1、获取Java 虚拟机中的空闲内存量：public long freeMemory()
2、获取Java 虚拟机中的最大内存量：public long maxMemory()
3、获取Java 虚拟机中的内存总量：public long totalMemory()
1.1.1.30Runtime与Process类
除了操作JVM内存外，Runtime可以运行本机可执行程序，比如：记事本等等；
public Process exec(String command)throws IOException
public static void main(String[] args) throws IOException {
Runtime runtime=Runtime.getRuntime();
Process process=runtime.exec(“notepad.exe”);//代开进程执行程序
}

通过进程的destroy()方法摧毁掉一个进程。
1.1.1.31总结
1、Runtime类本身就是一种单例设计的应用，因为咱们的整个JVM中只存在一个Runtime对象，
2、Runtime类的对象可以取得JVM的系统信息，还可以调用gc()方法释放垃圾空间，再者就是调用本机运行的程序(可执行程序)。
System类
1.1.1.32System类的基本使用
System类除了可以进行内容输出外，还可以通过一个方法取得一个操作的运行时间：
public static long currentTimeMillis()
返回的值是毫秒为单位的。
退出程序System.exit(0);//退出程序
1.1.1.33System类对IO流的操作
System类是一个普通的类，没有子类，但是在System类中有三个属性(全局常量)，这个三个全局常量分别为:
public static final PrintStream err;---->“标准”错误输出流。此流已打开并准备接受输出数据
public static final PrintStream out;---->标准”输出流。此流已打开并准备接受输出数据
public static final InputStream in;---->标准”输入流。此流已打开并准备提供输入数据
上面的三个属性是三个流的对象分别为两个打印流对象和一个字节输入流的对象。
1、System.in
此对象是字节输入流的对象，一般是用来指定控制台的内容输入
输入重定向
public static void setIn(InputStream in){}
//输入重定向
System.setIn(new FileInputStream(new File(“E:”+File.separator+“sjt1807”+File.separator+“test”+File.separator+“sram.txt”)));
将System.in对象的指定方法指向了sram.txt文件
输出重定向
public static void setOut(PrintStream out){}---->改变out对象的输出位置

File.separator
Date类和Calendar类
1.1.1.34、Date类
在java代码中操作的是java.util.Date不是java.sql.Date
在java.util.Date类中有一个方法是getTime()(在JDBC的时候使用)，返回值是表示当前日期时间的long型的数据，和System.currentTimeMilis()获取到内容是一样的。
1.1.1.35、Calendar类
使用此类可以直接将日期精确到毫秒。
public abstract class Calendar extends Object；
Calendar类是一个抽象类，既然是一个抽象类则肯定无法直接使用，此时要使用对象多态的概念，通过向上转型的关系实例化本类对象,可以发现在Calendar 类中定义的属性全部是静态的，这样就表示调用类中的属性的时候可以直接使用Calendar.属性。
通过Calendar类取得一个完整的日期，使用其子类实例化对象：
SimpleDateFormat类
1.1.1.36、Date---->String
通过SimpleDateFormat类完成java.util.Date类的对象向字符串的转换
public SimpleDateFormat(String pattern)
如果需要将一个Date类型数据转换成字符串，只需要在SimpleDateFormat 构造方法中指定要转换的格式即可。
1.1.1.37String—>String
通过SimpleDateFormat类完成字符串向指定字符串的转化,要想将一个字符串转换成Date在Java中提供了一个方法:
public Date parse(String source throws ParseException{}
在调用parse()方法之前一定要指定模板(“yyyy年MM月dd日 HH点:mm分:ss SSS”)：
Random类
在Java中Random类是用来产生随机数的。
public Random(){}
public Random(long seed){}
Random类中提供公用的构造方法；
public XXX nextXXX(){}
Math类
Math在Java中指的是有关数学运算的操作类。
1、Math运算绝对值
public static int abs(int a){}
2、Math运算立方根
public static double cbrt(double a){}
3、Math求最大值
public static int max(int a, int b){}
4、Math求最小值
public static int min(int a, int b){}
5、Math四舍五入
public static long round(double a){}
6、Math平方根
public static double sqrt(double a){}
7、Math幂运算
public static double pow(double a,double b){}
包装类
1.1.1.38包装类的具体介绍
No. 基本数据类型 包装类
1 int Integer
2 char Character
3 short Short
4 long Long
5 float Float
6 double Double
7 boolean Boolean
8 byte Byte
Integer、Byte、Float、Double、Short、Long都属于Number类的子类
Character属于Object的直接子类。
Boolean属于Object的直接子类。
1.1.1.39装箱操作
将一个基本数据类型变为包装类，这样的过程称为装箱操作
1.1.1.40拆箱操作
将一个包装类变为基本数据类型这样的过程称为拆箱操作
1.1.1.41字符串和基本数据类型的转换（重点）
在包装类中都有一个方法，就是将字符串转换成基本数据类型：
public static XXX parseXXX(String s)throws NumberFormatException
正则表达式
1.1.1.42、正则表达式内容介绍
Java中支持正则的类：
public final class Pattern extends Object implements Serializable{}
public final class Matcher extends Object implements MatchResult
这两个类是支持正则表达式的核心的类，Pattern类是用来指定正则表达式的模板，Matcher类是用来验证指定的内容是否和Pattern类指定的模板匹配，如果匹配则验证成功过否则验证失败。
1.1.1.43Pattern类的说明
Pattern类时一个最终的类，而且这个类中没有显示的提供任何的构造方法，此类中有一个或者多个方法能够获取Pattern类对象的方法。
public static Pattern compile(String regex)
1.1.1.44Matcher类的说明
在Java代码中创建Matcher类对象是通过Pattern类中的方法返回一个Matcher类的对象的。
public Matcher matcher(CharSequence input){}
简单的正则使用步骤是：
1、创建模板
Pattern pattern=Pattern.compile("\d");//参数为正则表达式
2、进行匹配内容的指定
//创建Matcher类的对象
Matcher matcher=pattern.matcher(str);

3、进行匹配(返回布尔型值)
//返回匹配结果
boolean boo=matcher.matches();
正则表达式中使用的标示符：
1、表示一个内容的字符(匹配的个数是1)：
i.[abc]：a、b 或 c;
ii.[^abc]：任何字符，除了 a、b 或 c；
iii.[a-z]：小写英文字母；
iv.[a-zA-Z]：所有的英文字母；
v.[0-9]：0-9的数字；
vi.\d：表示一个数字,是[0-9]的简写
vii.\D：表示非数字
viii.\s：表示空白字符
ix.\S：表示非空白字符
2、数量词(一个字符出现的次数)
以上的单个字符和数量词进行配合使用就可以表示多个字符或者数字了。
i.X? ：X出现一次或一次也没有
ii.X*： X出现零次或多次
iii.X+： X出现一次或多次
iv.X{n}： X出现恰好 n 次
v.X{n,}： X出现至少 n 次
vi.X{n,m}： X出现至少 n 次，但是不超过 m 次
3、进行内容的匹配
XY ：X 后跟 Y
X|Y ：X 或 Y

泛型
泛型具体的类型指定是在创建对象的时候指定。
1.1.1.45泛型的使用要求
在泛型的指定中，是无法指定基本数据类型的，必须设置成一个类，这样在设置一个数字的时候就必须使用包装类
1.1.1.46泛型的定义语法
[访问权限] class 类名称<泛型类型1,泛型类型2,…泛型类型3>{
[访问权限] 泛型类型标识 变量名称 ;
[访问权限] 泛型类型标识 方法名称(){} ;
[访问权限] 返回值类型声明 方法名称(泛型类型标识 变量名称){} ;}
1、能够接受任何数据类型
2、保证数据类型的统一性
使用泛型类的时候尽量去指定泛型的数据类型
1.1.1.47通配符的使用
使用一个符号来完成对应的多种数据类型的接收。在Java的泛型中有一个通配符”?”此通配符适合泛型类型的接收。
1.1.1.48受限泛型
在引用传递中，泛型操作中也可以设置一个泛型对象的范围上限和范围下限。范围上限使用extends关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类，而范围下限使用super进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至Object类。
1.1.1.49设置泛型的上限
1、在申明对象的时候使用：
设置的语法：
类名称<? extends 类> 对象名称
1.1.1.50设置泛型的下限
1、在申明对象的时候使用
类名称<? super 类> 对象名称
设置了下限的话则只能输出当前类及其父类。
1.1.1.51泛型接口
泛型接口的定义其实和泛型类的定义没有什么区别，只是定义类的时候使用class定义接口的时候使用interface定义。
案例:
public interface USB {//泛型接口
}
1.1.1.52泛型接口的实现
方式一:直接在子类中指定泛型的数据类型
方式二:在子类中也是用泛型
枚举
JDK 1.5之后，引入了一个新的关键字类型 —— enum，可以直接定义枚举类型
语法：
[public] enum 枚举类型名称{
枚举对象1,枚举对象2,…,枚举对象n ;
}
在枚举类中定义的不可改变的内容就是枚举的对象，通过对象可以获取对象名称，对象在枚举类中索引，获取对象中属性。
1.1.1.53获取枚举类中的对象名称
public final String name()
1.1.1.54获取枚举类中的对象位置
public final int ordinal()
注解(Annotation了解)
Annotation可以用来修饰类、属性、方法，而且Annotation不影响程序运行，无论是否使用Annotation代码都可以使用正常的执行
@Override：覆写的Annotation
@Deprecated：不赞成使用的Annotation
@SuppressWarnings：压制安全警告的Annotation
@Override主要是在方法覆写的时候使用，用于保证方法覆写的正确性。
@Deprecated注释的主要功能，是用来声明一个不建议使用的方法。如果在程序中使用了此方法的话，则在编译时将出现警告信息。
@SuppressWarnings注释的主要功能是用来压制警告，例如，之前讲解泛型操作的时候，如果在一个类声明时没有指明泛型的话，则肯定在编译时将产生，那么此时就可以使用@SuppressWarnings压制住这种警告。
集合

集合的简介
1、Java中的集合框架是指一系列存储数据的接口和类，这些类和接口都位于java.util包中
2、类集实际上就是一个动态的对象数组，与一般的对象数组不同，类集中的对象内容可以任意扩充。
集合的组成
1.1.1.55Collection集合
集合接口中最大的父接口是Collection接口，此接口下有两个子接口List接口,Set接口。

Collection接口中的常用的方法:
返回类型 方法名称 描述
boolean add(Object o) 在集合末尾添加元素
int size() 返回集合列表中元素个数
boolean removeAll(Collection col) 删除集合中的所有元素
boolean contains(Object o) 判断集合中是否存在指定的元素
boolean remove(Object o) 从集合中删除元素
void clear() 清除集合中的所有元素
Iterator iterator() 为Iterator接口实列化
Collection接口是最大的父接口，所以此接口中的方法可以被子类直接调用。
无论什么时候集合中存放的数据永远是对象
List集合
在List接口下常见的子类有三个：
1、ArrayList
2、LinkedList
3、Vector
ArrayList类和LinkedList类。
No. 方法 类型 描述
1 public void add(int index, E element) 普通 在指定位置增加元素
2 public boolean addAll(int index, Collection<? extends E> c) 普通 在指定位置增加一组元素
3 E get(int index) 普通 返回指定位置的元素
4 public int indexOf(Object o) 普通 查找指定元素的位置
5 public int lastIndexOf(Object o) 普通 从后向前查找指定元素的位置
6 public ListIterator listIterator() 普通 为ListIterator接口实例化
7 public E remove(int index) 普通 按指定的位置删除元素
8 public List subList(int fromIndex, int toIndex) 普通 取出集合中的子集合
9 public E set(int index, E element) 普通 替换指定位置的元素
此处的方法是List接口自己扩充的，所以List接口的子类都可以进行调用。
ArrayList
ArrayList是List子类，可以直接通过对象的多态性，为List接口实例化
ArrayList的定义：
public class ArrayList
extends AbstractList
implements List, RandomAccess, Cloneable, Serializable
1.1.1.56向集合中添加内容
此方法是集合中的末尾添加数据。
Collection接口方法的定义:
public boolean add(E e){}
向集合中添加内容(对象)。
List集合存放的元素有序
List集合存放的元素可以重复
1.1.1.57从集合中删除内容
Collection接口方法的定义：
public boolean remove(Object o){}
1.1.1.58获取集合的长度
方法的定义:
public int size(){}
返回值为int型的数据，此数据就是集合的长度。
1.1.1.59获取集合中的指定内容
方法的定义：根据索引找内容
public E get(int index){}
1.1.1.60将指定的元素插入此列表中的指定位置
方法的定义：
public void add(int index,E element){}
此方法是将一个内容插入到指定的位置。
1.1.1.61将一个集合添加到一个集合中
方法的定义:
public boolean addAll(Collection<? extends E> c)
1.1.1.62将一个集合添加到另一个集合的指定位置
方法的定义:
public boolean addAll(int index, Collection<? extends E> c){}
1.1.1.63清空集合
方法的定义格式：
public void clear(){};
此方法是Collection接口中的方法，所以此方法是子类覆写父类的方法。
1.1.1.64判断集合中是否包含内容
方法的定义：
boolean contains(Object o){}
此方法是判断集合中是都包含指定的内容
1.1.1.65判断集合是否为空
方法的定义：
boolean isEmpty(){}
1.1.1.66根据内容找索引
方法定义：
int indexOf(Object o){}
1.1.1.67修改指定位置处的内容
方法定义格式：
E set(int index, E element){}
1.1.1.68截取集合中的内容
此功能在实际开发中是比较常用的，所以下去掌握。
方法的定义:
List subList(int fromIndex, int toIndex){}
fromIndex - subList 的低端（包括）
toIndex - subList 的高端（不包括）
LinkedList
LinkedList表示的是一个链表的操作类
相对于ArrayList类LinkedList中有了很多自定义的方法，都和first，last有关。
No. 方法 类型 描述
1 public void addFirst(E o) 普通 在链表开头增加元素
2 public void addLast(E o) 普通 在链表结尾增加元素
3 public boolean offer(E o) 普通 将指定元素增加到链表的结尾
4 public E removeFirst() 普通 删除链表的第一个元素
5 public E removeLast() 普通 删除链表的最后一个元素

1.1.1.69、将内容添加到列表头和链表尾部
方法的定义:
public void addFirst(E e){}
public void addLast(E e){}
1.1.1.70获取集合中的第一个内容和最后一个
方法定义:
public E getFirst(){}
public E getLast(){}
ArrayList和Vector的区别
No. 比较点 ArrayList Vector
1 推出时间 JDK 1.2之后推出的，属于新的操作类 JDK 1.0时推出，属于旧的操作类
2 性能 采用异步处理方式，性能更高 采用同步处理方式，性能较低
3 线程安全 属于非线程安全的操作类 属于线程安全的操作类
4 输出 只能使用Iterator、foreach输出 可以使用Iterator、foreach、Enumeration输出
List集合内容的输出
List集合内容的输出其实就是从集合中获取对象进行输出。
1.1.1.71使用for循环输出
使用for循环则可定以来与索引输出对象
1.1.1.72使用for…each循环输出
for…each其实是一个专门用来输出对象集合或者数组的循环。
语法:
for(数据类型 对象:对象集合){
执行的语句;
}
1.1.1.73使用迭代器输出
Collection接口中有一个如下的方法：
Iterator iterator(){}
此方法返回值为Iterator，Iterator是一个接口，它属于工具，在这个接口中一共有以下的三个方法：
boolean hasNext(){}
E next(){}
void remove(){}
Iterator iterator=persons.iterator();//获取迭代器对象
while(iterator.hasNext()){//判断是否有下一个对象
System.out.println(iterator.next().getName());//获取对象
}
Set集合
List类型的集合中添加的元素是可以重复添加但是有序，而Set集合中不能重复添加对象，而且没有顺序。
Set集合在开发中常用的子类有两个：
1、HashSet
2、TreeSet
1.1.1.74HashSet
HashSet是Set接口的一个子类，主要的特点是：里面不能存放重复元素，而且是采用散列的存储方式，所以是没有顺序的。
从父类覆写过来的方法。
public boolean add(E e)
public boolean remove(Object o)
public void clear()
public boolean contains(Object o)
public boolean isEmpty()
public Iterator iterator()
public int size()
1.1.1.75、TreeSet
TreeSet集合中存放的内容需要排序，而这里的排序不是添加内容时的顺序而是要按照指定的属性来完成对象的排序操作。
1.1.1.76向Set集合中添加自定义的类的对象
给HashSet集合添加内容的时候没有出现异常，这是因为HashSet集合在添加的时候是不会给对象进行排序操作的。所以在使用HashSet集合的时候自定义的类和JRE提供的类的操作方式是一样的没有任何的区别。
java.lang.ClassCastException类型转异常

让Person类实现Comparable接口
Comparable接口的定义格式：
public interface Comparable{}
此接口是一个泛型接口，所以一个类在实现泛型接口的时候就应该满足泛型的设置。
在Comparable接口中有一个抽象方法：
int compareTo(T o)
Map集合
1.1.1.77Map接口的常用子类
1、HashMap：无序存放的，是新的操作类，key不允许重复。
2、Hashtable：无序存放的，是旧的操作类，key不允许重复。
3、TreeMap：可以排序的Map集合，按集合中的key排序，key不允许重复。
1.1.1.78HashMap
HashMap本身是Map的子类，直接使用此类为Map接口实例化即可；
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
向集合中添加对象：
public V put(K key, V value){}
在Map集合中是通过key值获取对应的内容的。
public V get(Object key){}
获取Map集合中全部的键(key):
public Set keySet(){}
获取Map集合中的所有value值
public Collection values(){}
判断指定的key是否存在:
public boolean containsKey(Object key){}
判断指定的value是否存在:
public boolean containsValue(Object value){}
1.1.1.79TreeMap
TreeMap是可以进行排序的，但是它的排序是给Map集合中的key(键)进行排序，和value(值)没关系。
1.1.1.80Map集合的内容输出
1、输出Map集合中key
要想输出key，首先应该从集合中获取key
多线程
进程与线程
多线程的实现(创建线程)：
在Java中创建线程的话有两种方式:
继承Thread类
实现Runnable接口
Thread类其实是Runable接口的一个子类，既然现在一个类实现了一个接口，那么此类就是接口的子类，既然存在子父的关系，那么就要出现面向对象的多态性了。
继承Thread类创建线程和使用线程
Thread类是在java.lang包中定义的，一个类继承了Thread类，此类就称为多线程操作类，在Thread的子类中，就必须明确的覆写Thread类中的run()方法，此方法称为线程的主体方法。
1.1.1.81创建线程类
案例:
创建一个多线程类：
public class MyThread extends Thread{//线程类
@Override
public void run() {//这个方法就是线程的主体方法
System.out.println("***********");
}
}
1.1.1.82开启线程
现在继承类Thread类创建了一个线程类，接下来就需要启动线程。在Java中启动线程使用的是start()方法。
Thread类中start()方法的定义:
public void start(){}
实现Runable接口完成线程的操作
Thread类是Runable接口的子类，那么Runable接口中抽象方法肯定被Thread类覆写了，所以如果一个类也实现了Runable接口的话也需要覆写run()方法。
1.1.1.83启动线程
Thread中有一个可以接收Runable接口对象的构造方法：
public Thread(Runnable target){}

在创建线程的类的时候，继承Thread不能达到资源共享的目的，而实现Runnable接口是可以达到资源共享的目的的，线程使用中如果需要资源的共享的话则使用Runnable接口.

Thread类中的其他方法
1.1.1.84、线程的休眠
public static void sleep(long millis) throws InterruptedException{}
1.1.1.85、线程的优先级

获取指定线程的优先级：
public final int getPriority(){}
返回线程的优先级。

1.1.1.86测试线程是否处于激活状态
public final boolean isAlive(){}
1.1.1.87线程的同步
线程的同步其实是同步代码或者方法。
使用synchronized关键字来完成同步操作。
Object类对线程的支持
public final void notify(){}
唤醒在此对象监视器上等待的单个线程。

public final void notifyAll(){}
唤醒在此对象监视器上等待的所有线程

public final void wait(long timeout) throws InterruptedException{}
public final void wait(long timeout,int nanos) throws InterruptedException{}
public final void wait() throws InterruptedException{}
让线程进入到等待状态
总结
1、通过继承Thread类创建线程类并可以开启线程执行代码
2、通过实现Runnable接口创建线程类并可以开启线程执行代码
IO流
1、File类
File类是在java.io包中，所有有关流的操作的类全部都是在java.io包中的。
File类的构造方法：
public File(String pathname){}
Pathname：是一个字符串，这个字符串就是要操作的文件的路径。
创建一个文件
public boolean createNewFile() throws IOException{}
创建文件夹
public boolean mkdir(){}
判断指定的文件或者文件夹是否存在
public boolean exists(){}
判断指定的内容是否是文件
public boolean isFile(){}
判断指定的内容是否是文件夹
public boolean isDirectory(){}
删除一个指定的文件
在File类中定义了如下的方法进行文件的删除：
public boolean delete(){}
以上的方法既可以删除文件又可以删除文件夹：
列出指定目录的全部文件
File类中存在两个列出指定文件夹中所有文件的方法
以字符串数组形式返回：public String[] list()
以File数组返回：public File[] listFiles()
递归调用:
方法自己调用自己的操作就叫做递归调用；
总结
1．File类是在java.io包中唯一与文件本身有关的类；
2．可以使用File类执行文件的创建和删除等操作；
3．在使用File类指定路径的时候一定要注意操作系统之间的差异，尽量使用separator进行分割；
2、流的概念
字节流与字符流
在java.io包中操作文件内容的主要有两大类：字节流,字符流，两类都分为输入和输出操作。在字节流中输出数据主要是使用OutputStream完成，输入使用的是InputStream完成，在字符流中输出主要使用Writer类完成，输入是使用Reader类完成。
内容操作就四个类：OutputStream，InputStream，Writer，Reader
IO流的操作流程基本上分为以下几步(以File操作位例)：
1．使用File类打开一个文件
2．通过字节流或者字符流的子类指定输出的位置
3．进行读/写操作
4．关闭输入/输出
提示：IO流属于资源操作，对于资源操作，操作的最后必须关闭流，否则会出现未知的错误
字节流
字节流主要是操作byte类型数据，以byte数组为准，主要的操作类就是OutputStream，InputStream：
字节输出流：OutputStream
字节输入流：InputStream
1.1.1.88字节输出流：OutputStream
OutputStream有如下的子类:
ByteArrayOutputStream, FileOutputStream, FilterOutputStream, ObjectOutputStream, OutputStream, PipedOutputStream
子类继承了父类，那么父类中的非私有化的方法是可以直接调用的。
OutputStream常用的方法：

要想使用以上的方法，则必须使用子类来实例化OutputStream的对象，因为OutputStream是抽象类，此时使用FileOutputStream子类进行对象的实例化：
public FileOutputStream(File file)throws FileNotFoundException{}
public FileOutputStream(File file, boolean append) throws FileNotFoundException{}
在FileOutputStream类中发现有三个输出内容的方法：
1、参数需要一个字节数组—输出一个字节数组
public void write(byte[] b)throws IOException{}
2、参数是字节数组和相对应的条件的设定------输出字节数组的一部分内容
public void write(byte[] b,int off, int len) throws IOException{}

3、参数是int型的数据------输出一个字节
public void write(int b)throws IOException{}
1.1.1.89字节输入流：InputStream
InputStream是一个抽象类，所以有关这个类的操作可以模拟OutputStream的方式。
InputStream类的子类：
AudioInputStream, ByteArrayInputStream, FileInputStream, FilterInputStream, InputStream, ObjectInputStream, PipedInputStream, SequenceInputStream, StringBufferInputStream
FileInputStream类中的方法：
1、构造方法
public FileInputStream(File file) throws FileNotFoundException{}
2、普通方法
public int read()throws IOException{}---->一次读取一个字节
public int read(byte[] b)throws IOException{}----->将内容读取到字节数组中
public int read(byte[] b, int off,int len)throws IOException---->读取指定长度的内容到字节数组中
1、将数据读取到指定的数组中
public int read(byte[] b)throws IOException{}
2、将数据一部分读取到指定的数组中
public int read(byte[] b, int off,int len)throws IOException{}

3、每次读取一个字节
public int read() throws IOException{}
下一个数据字节；如果已到达文件末尾，则返回 -1。
字符流
1.1.1.90字符输出流:Writer
字符输出流其实操作的就是字符，将数据按照字符的方式输出去。
public abstract class Writer extends Object implements Appendable, Closeable, Flushable
Writer类是一个抽象类那么只能依靠子类来向上转型了。
Writer的所有直接子类:
BufferedWriter, CharArrayWriter, FilterWriter, OutputStreamWriter, PipedWriter, PrintWriter, StringWriter
上面的子类中没有和文件(File)有关的类，那么这个类肯定是继承了上面的某一个子类：
public class FileWriter extends OutputStreamWriter {}
所以FileWriter其实也是Writer的子类，所以FileWriter类的对象也可以调用Writer的方法。
1、直接输出字符串的一部分
public void write(String str, int off,int len) throws IOException

2、直接输出一个字符串的全部
public void write(String str) throws IOException{}
3、直接输出一个字符数组
public void write(char[] cbuf) throws IOException{}
4、直接输出字符数组的一部分
public abstract void write(char[] cbuf,int off, int len)throws IOException{}
5、输出一个字符(字符是以int型的数据呈现的)
public void write(int c) throws IOException{}
1.1.1.91、字符输入流:Reader
字符输出流其实操作的就是字符，将数据按照字符的方式输出去。
public abstract class Reader
extends Object
implements Readable, Closeable
Reader类是一个抽象类那么只能依靠子类来向上转型了。
Reader的所有直接子类:
BufferedReader, CharArrayReader, FilterReader, InputStreamReader, PipedReader, StringReader
上面的子类中没有和文件(File)有关的类，那么这个类肯定是继承了上面的某一个子类：
public class FileReader extends InputStreamReader
所以FileReader其实也是Reader的子类，所以FileReader类的对象也可以调用Reader的方法。
1、将数据读取到一个数组中
public int read(char[] cbuf)throws IOException{}

2、将数据的一部分读取到数组中
public abstract int read(char[] cbuf,int off, int len) throws IOException{}
3、一次读取一个字符
public int read()throws IOException{}
字节流和字符流的区别
1、在日常生活中出现的文件都是以字节的形式出现的:图片，音乐，电影，语音等等。
2、字节流和字符流各有各的好处,当输出的内容是英文或者数字的话建议大家去使用字节流
3、如果输出的内容为中文则尽量去使用字符流,因为字符流可以解决中文乱码的问题
4、虽然字符流的操作比字节流的操作简单，但是在以后开发中大家发现大部分全部否是字节流的操作。
5、字节流不使用缓冲区,而字符流使用到了缓冲区：

在查找有关字符流的操作中有以下的一个方法：
public abstract void flush() throws IOException{}
刷新该流的缓冲
此方法就是将缓冲区的数据显示出来的。
字符流在关闭的时候会自动刷新缓冲区。
字节字符转换流
InputStreamReader类：
将字节流转换成字符流
public class InputStreamReader
extends Reader
在使用转换流的时候只能是字节流转换成字符流。
OutputStreamWriter类：
将字节流转换成字符流
public class OutputStreamWriter
extends Writer
打印流
打印流是输出流，主要负责输出内容的。
PrintStream类的常用方法：

BufferedReader类
BufferedReader类中的构造方法：
public BufferedReader(Reader in){}
public BufferedReader(Reader in,int sz){}

BufferedReader类中有一个特别的方法，那就是直接读取一行数据：
public String readLine() throws IOException{}
上面的方法只能读取一整行的内容。
Scanner工具类
在JDK1.5之后java提供了输入数据类，此类可以完成BufferedReader类的功能，也可以方便的对输出数据进行验证，此类存放在java.util包中。
Scanner类不在java.io包中，而在java.util包中，所以此类是一个工具类。
Scanner常用方法：

Scanner类有两个比较特殊的构造方法：
参数为File类的对象：
public Scanner(File source) throws FileNotFoundException
此方法创建的对象表示从文件中读取内容。
参数是一个字节输入流的对象：
public Scanner(InputStream source){}
此方法创建的对象表示从流中读取内容。
Scanner类中有很多的nextXXX()方法，这些方法可以准确的获取对应的类型的数据。

1.1.1.92、读取流中的内容
1.1.1.93读取指定类型的数据
1、获取布尔型的数据
public boolean nextBoolean(){}
Exception in thread “main” java.util.InputMismatchException
此异常表示的是输入的类型不匹配
2、获取整数型的数据
public byte nextByte(){}
public short nextShort(){}
public int nextInt(){}
public long nextLong(){}
1.1.1.94对Date类型的数据进行验证
对象流
1.1.1.95对象的序列化前提
一个对象产生之后实际上是在内存中开辟了一个空间，方便存储信息。
对象序列化，就是把一个对象变为二进制的数据流的一种方法，通过对象序列化可以方便的实现对象的传输或存储。
1.1.1.96对象的序列化和反序列化
要想完成对象的输入或输出，还必须依靠对象输出流ObjectOutputStream和对象输入流ObjectInputStream
使用对象的输出流输出序列化对象的步骤，有时也被称为序列化，而使用对象输入流读入对象的过程，有时也称为反序列化
1.1.1.97对象序列化
对象输出流：ObjectOutputStream
一个对象如果想要进行输出，则必须使用ObjectOutputStream类，此类定义为：
java.lang.Object
java.io.OutputStream
java.io.ObjectOutputStream
此类的构造方法有：
public ObjectOutputStream(OutputStream out)throws IOException

此类的常用方法：

1.1.1.98对象反序列化
使用ObjectInputStream可以把序列化好的对象反序列化回来。
ObjectInputStream定义如下：
java.lang.Object
java.io.InputStream
java.io.ObjectInputStream
常用的构造方法：
public ObjectInputStream(InputStream in) throws IOException

此类的常用方法：

1.1.1.99transient关键字
当使用Serializable接口实现序列化操作的时候，如果一个对象中的某个属性不希望被序列化，则可以使用trensient关键字声明；
总结：
1．对象序列化的作用，对象序列化并不一定都向文件中保存，也有可能面向于其他的输入或输出
2．被序列化对象的类必须实现Serializable接口
3．如果某个属性不希望被保存下来，则可以使用transient关键字声明。
Java反射
1、Class类不能直接通过构造方法创建对象
2、Class类中的方法只能通过Class类的对象来调用
3、Class类中有一个静态方法forName(String name)方法
Class类对象的创建
Class类主要负责获取一个类中的全部信息。通过Class可以完整的得到一个类中的完整结构，包括此类中的方法定义，属性定义等。
使用Class类中的forName(String className)
public static Class<?> forName(String className)throws ClassNotFoundException{}
使用类.class完成Class对象的创建
使用对象.getClass()完成Class对象的创建
Object类其实也对反射有支持，在此类中有如下的一个方法：
public final Class<?> getClass(){}

通过Class类获取类中的构造方法
使用Class类调用无参构造创建普通类的对象
如果要想通过Class类本身实例化其他类的对象，则可以使用newInstance()方法，但是必须要保证被实例化的类中必须存在一个无参构造方法。
public T newInstance() throws InstantiationException,IllegalAccessException{}

通过Class类的对象调用类中有参构造方法完成对象的实例化
Class类获取一个类中的全部构造方法
public Constructor<?>[] getConstructors()throws SecurityException{}
Construtor类中常用的方法
Construtor类中还有其他的一些方法：
No. 方法 类型 描述
1 public int getModifiers() 普通 得到构造方法的修饰符
2 public String getName() 普通 得到构造方法的名称
3 public Class<?>[] getParameterTypes() 普通 得到构造方法中参数的类型
4 public String toString() 普通 返回此构造方法的信息
5 public T newInstance(Object… initargs) throws InstantiationException,IllegalAccessException,
IllegalArgumentException,InvocationTargetException 普通 向构造方法中传递参数，实例化对象
获取构造方法的详细的信息
1.1.1.100、获取构造方法的修饰符
public int getModifiers(){}

1.1.1.101获取构造方法的名称
public String getName(){}
1.1.1.102获取构造方法的参数类型
public Class<?>[] getParameterTypes(){}
通过反射得到一个类的完整结构，那么这就要使用到java.lang.reflect包中的以下几个类：
1、Constructor：表示类中的构造方法
2、Field：表示类中的属性
3、Method：表示类中的方法
这三个类都是AccessibleObject类的子类

通过Class类获取类实现的接口
Class类中有一个获取类实现的接口的方法:
public Class<?>[] getInterfaces(){}

通过Class类获取类的父类
Class类中有一个方法获取父类：
public Class<? super T> getSuperclass(){}
通过Class类获取类中的全部方法
在Class类中有一个获取类中全部方法的方法：
public Method[] getMethods()throws SecurityException{}
Mthod类中的操作方法
No. 方法 类型 描述
1 public int getModifiers() 普通 取得本方法的访问修饰符
2 public String getName() 普通 取得方法的名称
3 public Class<?>[] getParameterTypes() 普通 得到方法的全部参数类型
4 public Class<?> getReturnType() 普通 得到方法的返回值类型
5 public Class<?>[] getExceptionTypes() 普通 得到一个方法的全部抛出异常
6 public Object invoke(Object obj,Object… args)
throws IllegalAccessException,
IllegalArgumentException,InvocationTargetException 普通 通过反射调用类中的方法，此方法在后面将为读者介绍。
1.1.1.103、Method类获取方法的修饰符
1.1.1.104Method类获取方法的名称
1.1.1.105、Method类获取方法的参数类型
1.1.1.106Method类获取方法的返回值类型
1.1.1.107Method类获取方法的异常类型
public int add(int a,byte b) throws ClassCastException,NullPointerException{
return (a+b);
}
1.1.1.108通过Method类的对象调用指定的方法
在Method中有一个方法是专门用来调用方法的。
public Object invoke(Object obj,Object… args) throws IllegalAccessException,
IllegalArgumentException,
InvocationTargetException{}
获取类中的属性并给属性赋值取值
获取类中的属性
在Class类中有两个获取属性的方法：
1、获取本类中的属性(没有私有化和非私有化之说)
public Field[] getDeclaredFields()throws SecurityException{}
2、获取本类及其父类中的非私有化的属性
public Field[] getFields() throws SecurityException{}
给指定的属性赋值
在反射中给属性赋值的话其实是使用Field类中set()方法完成属性的赋值：
让私有化的属性能够被访问：
public void setAccessible(boolean flag) throws SecurityException{}
获取属性值
public Object get(Object obj) throws IllegalArgumentException,
IllegalAccessException{}
网络编程
在网络编程中一般有两种编程方式:C(Client)/S(Server),B(Browser)/S(Server),所谓的C/S是客户端/服务端，B/S指的是浏览器/服务端
在Java中代表本机地址的方式一共有三种:
1、192.168.13.8
2、localhost
3、127.0.0.1
InetAddress类
InetAddress类主要表示IP地址，这个类有两个子类：Inet4Address，Inet6Address，一个用于表示IPV4，另一个表示IPV6协议。
InetAddress类的常用方法：

、URLEncoder与URLDecoder
Encoder最早是从电报中而来，使用Encoder进行编码，而使用Decoder进行解码操作，在网络中经常存在这样的编码和解码的操作。
URLEncoder类与URLDecoder类的常用方法

一般编码和解码是操作中文的。
使用URLEncoder进行内容的编码操作
使用URLEncoder类中静态方法就可以完成数据的编码操作：
使用URLDecoder完成数据的解码操作
在URLDdecoder类中共有一个decoder()方法，这个方法是静态的方法，可以进行数据的解码：
TCP程序设计：
TCP程序设计：
在java中使用Socket完成TCP程序的开发，使用此类可以方便的建立可靠的，双向的，持续的，点对点的通讯连接。
在Socket的程序开发中，服务端使用ServerSocket等待客户端的连接，对于java的网络程序来讲，每一个客户端都使用了一个Socket对象表示。
ServerSocket
ServerSocket类主要用在服务端程序的开发上，用于接收客户端的连接请求。
ServerSocket类的常用方法：

Socket
在服务端每次运行时都要使用accept()方法等待客户端连接，此方法执行之后服务端将进入阻塞状态，直到客户端连接之后程序才可以向下继续执行，此方法的返回值类型是Socket，每一个Socket都是表示一个客户端对象。

服务端不能同时处理多个客户端发送的数据。