jdk目录结构
[外链图片转存失败(img-PLqOa7gE-1568599801662)(C:\Users\xlm\AppData\Roaming\Typora\typora-user-images\1565073815260.png)]
bin: 这是存放java启动命令以及其他开发工具命令（如javac）的，该目录应当保存到PATH变量中。
lib: 是JDK工具用到的类库及其他文件。tools.jar就包含了对开发工具的支持功能库；dt.jar就是所谓DesignTime的东西，估计是给JavaBean和IDE用的；jconsole.jar自然是给jconsole工具用的了；htmlconverter.jar是用来把用applet的HTML转成所谓Java Plug-In的，即标签改为。
jre: 这就是JDK自含JRE的根目录了，这是系统属性java.home所指向的目录。
jre/bin: 包含执行文件和dll等库文件，是JVM需要的，可执行文件和jdk/bin是一样，本目录不需要被PATH所包含。
jre/bin/client: 包含用Client模式的VM时需要的dll库。
jre/bin/server: 包含用Server模式的VM时需要的dll库。
jre/lib: 包含核心代码库(Java平台的core API)，如rt.jar是所谓的bootstrap的类库，还有很多其他需要的子目录和资源文件等等。注意这个lib目录和jdk/lib是不一样的。
jre/lib/ext: 是Extension Class Loader装入jar类库的地方，如localdata.jar包含的是java.text和java.util需要的东西。
jre/lib/security: 包含JVM安全需要的设置文件，JVM信任的证书也在这里。
jre/lib/applets: 用于applet需要用到的jar库文件，Applet类通过Applet Class Loader从本地文件系统中预加载，这样为减小大型 Applet 的启动时间提供了一些方式，好像从网上已经下载完成了一样。
jre/lib/fonts: 字体文件。
include: 包含C语言头文件，用于编写JNI程序和JVMDI(Debugger Interface)的程序时用到，好像还有JVMTI。
标识符
在java中对于包名、类名以及后面会学习到的变量名、方法名等都是有严格的命名规范的，我们把这些命名都称之为标识符
什么是标识符？
定义：Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
标识符的命名规范
①.由26个英文字母大小写，0-9 ，_或 $ 组成
②.数字不可以开头。
③.不可以使用关键字，但能包含关键字。
④.Java中严格区分大小写，长度无限制。
⑤.标识符不能包含空格。
关键字解释：
什么是关键字？
定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
比如class ，public，static。这些都属于关键字。不同的关键字，在Java代码中有不同的使用场景。
在实际开发中常用的一些关键字：
[外链图片转存失败(img-yUN4LTqt-1568599801663)(file:///C:\Users\xlm\AppData\Local\Temp\ksohtml5392\wps1.jpg)]
[外链图片转存失败(img-evB6lhXE-1568599801664)(file:///C:\Users\xlm\AppData\Local\Temp\ksohtml5392\wps2.jpg)]
Java中的名称命名规范
包名：多单词组成时所有字母都小写：com.xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单 词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
注意：规范不一定要去遵守，只是最好去遵守。而规定一定要去遵守。
常量与变量
对于超市管理系统，第一个界面已经编写完成，接下来编写第二个界面
[外链图片转存失败(img-T90Gy2nv-1568599801665)(file:///C:\Users\xlm\AppData\Local\Temp\ksohtml5392\wps3.jpg)]
问题：此种方式虽然能实现效果，但是存在一些问题
如：系统中用户的卡号是不能改变
但是后期买完东西，积分需要变化，此种写法积分不能改变
在java中对于值固定的，使用常量
对于值不固定的，使用变量
什么是变量？
解释变量之前先了解以下几个问题
1、计算机存储数据的方式？
内存： 瞬时存储数据
硬盘：永久存储数据
2、内存如何存储数据？
以一个生活中的案例来解释----------住宾馆
住宾馆相当于在宾馆中存人
开一个房间---------------------------------------开辟一块空间
大床房、单间、标间、总统套房--------------房间的类型
303、巴黎间、1206（别名）-----------------房间的地址
入住-----------------------------------------------存人
内存存数据步骤
开辟一块空间--------------------------变量
定义数据的类型------------------------变量的类型
给数据起一个别名----------------------变量名
存数据----------------------------------变量值
由此可以总结出：
变量的定义：它表示的是一个空间，在程序运行的过程中，可以随时去更改这个空间中的数据。体现在计算机中，就表示的是计算机内存中的一个存储区域
变量的三要素：变量类型、变量名、变量值
数据类型
定义变量时，需要知道变量的类型。不同的数据，当需要在Java程序中保存的时候，我们需要给其分配不同的内存空间（变量空间）。我们需要把不同的数据，划分成不同的类型。
Java中把数据共计划分成2大类型：
[外链图片转存失败(img-cS9TVDDb-1568599801666)(file:///C:\Users\xlm\AppData\Local\Temp\ksohtml5392\wps4.jpg)]
整型：
[外链图片转存失败(img-7cxVvuOa-1568599801667)(file:///C:\Users\xlm\AppData\Local\Temp\ksohtml5392\wps5.jpg)]
Java语言的整型常数默认为int型，声明long型常量可以加‘ l ’或‘ L ’ ，如：
long a = 55555555; //不出错，在Int表示的范围内(21亿内)。
long b = 55555555555;//不加l出错，已经超过int表示的范围。
浮点型：
[外链图片转存失败(img-Nu8bcDkk-1568599801668)(file:///C:\Users\xlm\AppData\Local\Temp\ksohtml5392\wps6.jpg)]
float类型又被称作单精度类型，尾数可以精确到7位有效数字，在很多情况下，float类型的精度很难满足需求。
double表示这种类型的数值精度是float类型的两倍，又被称作双精度，绝大部分应用程序都采用double类型。
Float类型的数值有一个后缀F/f ，没有后缀F/f的浮点数值默认为double类型
字符型：char
char 类型用来表示在Unicode编码表中的字符
它占2个字节，可允许有65536个字符
Unicode具有从0到65535之间的编码，他们通常用从’\u0000’到’\uFFFF’之间的十六进制值来表示
布尔类型：boolean
boolean类型（一位，不是一个字节）
boolean类型有两个值，true和false，用来判断逻辑条件，一般用于程序流程控制
注意：JAVA语言是强类型语言，对于每一种数据都定义了明确的具体数据类型。
如何定义变量？
方式一：先声明一个变量，再给变量赋值
注意：变量可以声明，但是如果需要使用声明的变量，一定要确保该变量已经初始化
否则会报错
方式二：声明变量的同时给变量赋值
练习一：
定义两个整型变量，在控制台输出两个变量的和
练习二：
描述一台汽车的信息
品牌（brand） 悍马
重量（weight） 4000.0kg
类型（type） 越野
价格 （price） 80万
练习三：
完成第二个界面
什么是常量？
对于系统中，积分应该使用变量，因为积分需要变化。对于卡号与姓名应该是固定不变的，所以需要使用常量
常量的概念
在Java中用于描述一些固定不变的数据的量，称之为常量
如何定义常量？
定义常量需要使用关键字final
修改系统的第二个界面，将卡号与姓名变成常量
数据类型转换
案例：定义一个float类型的变量并给该变量赋值10.0
此时发现报错
原因：在计算机中， 所有的小数默认double类型，所有的整数默认都是int类型。
10.0默认是double类型，而float类型是4个字节。double类型是8个字节，所以将double类型的10.0， 赋值给float类型的变量number，会报损失精度的错误
解决方案：
方式一：小数后面加f可以表示float类型存储
方式二：数据类型转换
在java中，不同的数据需要保存在不同的空间中，而开辟空间的时候，需要通过不同的类型关键字来定义当前这个空间是什么类型的空间。开辟的空间如果和保存的数据类型不一致，那么就很容易导致程序出现错误。这时我们就需要使用数据类型的转换技术，完成数据的保存工作。
数据类型的转换，可以分为两种：
1）隐式类型转换（自动类型转换）自动类型提升
2）强制类型转换
隐式类型转换
隐式类型转换：在程序中，空间保存的数据类型不一致的时候，java内部会自动的帮助我们转换。要能够自动转换，必须遵守Java中的自动转换的规则：
可以把小空间中的数据给大空间中保存。
如：byte 空间中的数据， 可以自动的转成 short int long float double
但是不能把double 保存在 byte 、int 、 short 、long 等空间。
容量小的类型可自动转换为容量大的数据类型；
强制类型转换
强制类型转换：大的数据类型需要强制转换成小的数据类型
强制类型转换：它一般都会有数据的丢失。
如何强制类型转换？
语法：小的数据类型 变量名 = （小的数据类型）大数据类型的数据
键盘输入
系统的两个界面已经完成，接下来需要将两个界面结合，如何结合？使用键盘输入
Scanner的作用：从键盘读入数据(小数、整数、布尔、字符…)到程序中；
需求：在控制台键盘输入一个姓名并打印
如何实现键盘输入？
步骤
第一步：创建键盘输入对象Scanner
Scanner input = new Scanner(System.in);
此句话中只有input是可以随意定义的，因为input是对象名
创建完成之后发现报错
原因：没有导入Scanner使用需要的包
如何解决？
方式一：手动输入如下代码import java.util.Scanner;
使用通配符导包：
如果需要导入同一个包中的多个类，每个类都使用import导入，很麻烦，所以 可以使用通配符：*；
import java.util.*;
方式二：将鼠标放置在Scanner单词上会出现一个弹框，选择Import’Scanner’(java.util)
方式三：联想法 利用alt+/
第二步
通过Scanner对象接受键盘输入的数据
根据不同的数据类型采用不同的接受方法
input.nextInt();用于接受整型
input.next();用于接受字符串类型
input.nextDouble();用于接受浮点型
input.nextBoolean();用于接受布尔类型
练习一：
键盘输入两个数，在控制台打印两个数的和
练习二：
键盘输入三个数，计算三个数的平均值
练习三：
键盘输入两个男生身高和两个女生身高，在控制台打印男生平均身高比女生平均身高高多少
运算符
在生活中，存在各种各样的数据运算，例：加、减、大于（>）、小于（<）
为了解决生活中的问题，就需要把生活中的所有常见的运算移植到Java中。
Java中的运算：
算术运算、赋值运算、比较运算（关系运算）、逻辑运算、位运算、三元(三目)运算
算术运算符
算术运算：和数学中的算术运算基本一致。
运算符号： + - *(×) /(÷) % (算余数 模运算) ++(自增) --(自减)
[外链图片转存失败(img-vpNlzwqV-1568599801668)(file:///C:\Users\xlm\AppData\Local\Temp\ksohtml5392\wps7.jpg)]
在Java中进行算术运算的时候，运算符两侧的类型一致的时候，
运算的结果必须和运算的数据类型保持一致。
当算术运算两侧的类型不一致的时候，结果向大的类型保持
注意算术运算中的+号和字符串的问题：
在Java中如果让字符串和+进行运算，这时这个+号变成连接符，它会把当前这个字符串和+号后面的内容连接成一个更长的字符串。
练习一：
通过键盘输入一个五位数，将该五位数倒序输出
（12345----------54321）
面试题：请选择2+“2”+2+2的结果是多少 A
A 2222 B 8 C 224 D 422
如果数值相加中存在字符串，那么最终结果会变成字符串拼接
练习二：
摄氏度与华氏度的转换公式为：摄氏度＝5/9.0*(华氏度-32)
键盘输入一个华氏度，输出对应的摄氏度
自加自减
Java中 ++（自加，自增） 和 --（自减）
当自加、自减出现的时候，需要给它们所在的那个变量空间中加1 或者 减1.
表现形式：
++或者–在变量的右侧，举例：i++，j–；
++或者–在变量的左侧，举例：++i，–j；
自加自减运算规律：
1）当自加自减在变量的右侧时，需要先把变量空间中的值临时存储，也就是说在内存中需要开辟一个临时空间，把这个值保存到临时空间中。然后给原来变量空间中+1或-1，最后把临时存储的那个数据和其他的运算符号进行运算。
2）当自加自减在变量的左侧时，这时直接给变量空间+1 或 -1，然后把空间中的值与其他的运算符号进行运算。
举例：
int a = 3;
int b = a++;
第一步：在内存中开辟一块空间命名为a，并将值3存入该空间
第二步：当执行第二条语句时，先在内存中开辟一块临时存储空间，并将3存储在该临时空间中，再将临时存储空间的值赋值给b，最后给内存中空间命名为a的值加一
赋值运算符
赋值运算符号：=
它是Java中的赋值号，它的功能是把右侧的结果，赋值到左侧的变量空间中。
在赋值运算中还有混合运算：
+= -= *= /= %= 称为算术运算和赋值运算的混合运算。
运算原则：既要遵守算术运算的规则，同时还要遵守赋值运算的规则。
a += b 相当于： a=a+b
混合运算符的好处：可以自动类型提升转换。
关系运算符
关系运算：就是我们数学中的比较大小。
运算符号：
> >=(大于等于) < <=(小于等于)
==(相等)[千万不要和赋值混淆] !=(不相等)
==表示的是左右两边是否相等。如果相等结果为true，不等结果false
= 在Java中称为赋值号。
注意：比较运算的结果一定是boolean值。
数组
一、两个数组比较
strarray[1].equals(strarray1[0])//比较两个数组内容是否相等
二、多维数组的定义
int[][] arraydemo=new int[2][3];
arraydemo[][]={{1,2,3},{4,5,6}}
三、使用数组常见错误
数组索引越界异常：ArraylndexOutOfBoundsException
空指针异常：NullPointerException
四、一维数组定义赋值
申明数组：int[] array;
构造数组：数组名=new 数组元素类型[元素个数]
初始化：int[] array={1,2,3,4,5,6}
int[] array=new int[]{1,2,3,4,5,6}
String str[]={"ew","we","ee"}
五、java方法的定义
格式：访问修饰符 方法的类型 返回值类型 方法名（参数列表）
{
函数体
}
public static void main(String args[]){
int a=0;
if(a==1){
System.out.println("a is 1");
}
}
[外链图片转存失败(img-DqMIcVOD-1568599801669)(C:\Users\xlm\Desktop\14N7MIM`3U%ARL%JGTM@COC.png)]
六、java方法的重载
重载：方法重载是指在一个类总定义多个同名 的方法，但要求每个方法具有不同的参数的类型或参数的个数。
重载规则：
- 多个方法名称相同
- 方法的参数个数不同或参数类型不同。
- 方法的返回类型、修饰符可以相同，也可不同
class chongzai{
void receive(int i){
System.out.println("Received one int data");
System.out.println("i="+i);
}
void receive(float i){
System.out.println("Received one int data");
System.out.println("i="+i);
}
void receive(String i){
System.out.println("Received one int data");
System.out.println("i="+i);
}
public static void main(String[] args){
chongzai m=new chongzai();
m.receive(3456);
m.receive(34.56f);
m.receive("方法重载");
}
}
七、Java方法参数传递
//值传递，最后a=10
void change(int a){
a=20;
}
int a=10;
change(a);
//地址传递会改变值
void change(int a[]){
a[0]=1;
}
int a[]={2,3};
change(a);
八、类的定义
[外链图片转存失败(img-TMILxe98-1568599801670)(C:\Users\xlm\Desktop\JAVA\笔记\1565077788034.png)]
九、类的构造方法
[外链图片转存失败(img-nCYP6lja-1568599801671)(C:\Users\xlm\Desktop\JAVA\笔记\类的构造方法.png)]
public class leigouzao{
String qqnum;
String pwd;
public leigouzao(String password){
pwd=password;
}
public static void main(String []args){
System.out.println( new String("111"));
}
}
十、对象的创建
[外链图片转存失败(img-GKQVL3Xm-1568599801671)(C:\Users\xlm\Desktop\JAVA\笔记\对象的创建.png)]
十一、类的封装
[外链图片转存失败(img-XxgBZLn7-1568599801673)(C:\Users\xlm\Desktop\JAVA\笔记\类的封装.png)]
十二、类的继承
格式：修饰符 class 子类名 extends 父类名
继承简介
概念：
java中的继承，是使用extends关键字在两个类之间建立的一种关系；
写法：
class Fu{}
class Zi extends Fu{}//表示Zi类继承Fu类；
在继承关系中，被其他类继承的类，叫做父类（超类），如本例中的Fu类；
继承其他类的类，叫做子类（派生类），如本例中的Zi类；
作用：
继承中子类可以直接拥有父类的成员；
继承作用
案例：使用java代码描述人和学生的信息；
此时发现两个类中存在大量重复代码，导致代码的复用性差。
要解决这种自身所有的属性和行为重复的问题，应该使用继承；
使用继承可以提高代码的复用性；
使用继承可以在两个类中建立一种关系；
使用注意：
1、继承中，父类的私有成员不能被子类继承；
2、继承中的两个类，应该有关系；
只有子类描述的事物 ，有父类描述的事物的特例的时候，才可以使用继承；
虽然在语法上，可以使用extends关键字在任意两个类之间建立继承关系，但是在开发中，只能是二者之间具有 “是” 的关系的时候才使用继承；
如果两个类不具有这种“是”的关系，那么就应该找他们共同的父类，然后将共同的信息放到共同的父类中，然后让两个类分别继承父类；
如：
鱼 和 苹果 ， 不具有 “是” 的关系，但是有共同的父类，都属于食物，所以可以建立一个食物类，然后让他们分别继承食物类；
java类的继承特点
单一继承
就是一个类只能直接继承一个父类；
[外链图片转存失败(img-1eSibvo4-1568599801674)(file:///C:\Users\xlm\AppData\Local\Temp\ksohtml5392\wps8.jpg)]
如果可以继承两个父类，那么当这两个父类中都具有共同的属性或行为时，在子类中调用，就不清楚到底会调用哪个（调用的不确定性）
多重继承
java中继承中，父类可以再继承其他类，叫做多重继承；
[外链图片转存失败(img-pzwXh2dP-1568599801676)(file:///C:\Users\xlm\AppData\Local\Temp\ksohtml5392\wps9.jpg)]
一个类只能直接继承一个父类，但是可以有多个子类；
一个类的父类还可以继承父类；
super和this关键字
[外链图片转存失败(img-lWIMQMCY-1568599801677)(C:\Users\xlm\Desktop\JAVA\笔记\supper this.png)]
方法的****重写（override）
重写的概念
在子类中定义和父类中相同的函数，直接调用函数时，实际使用的是子类中的函数，这种情况叫做方法的重写（覆写）；
一般开发中，如果父类的功能不满足子类需要，子类都会重写父类的函数；
重写的应用
案例：描述手机这类事物。原始的手机和现代的手机
以前的手机只能打电话，发短信
现在的手机继承父类的功能没有问题，只不过现在的手机功能更加的高级
打电话不仅仅可以打语音电话，还可以视频通话
发短信不仅仅可以发文字信息，还可以发送图片，表情，视频…
所以如果直接使用父类的方法已经不能满足需求了，此时子类就需要重写父类中的方法
重写的注意事项
1、子类重写的函数要和父类中的函数名要相同
2、子类重写的函数要和父类中的函数参数列表要相同；
3、子类重写的函数要和父类中的函数返回值类型相同；
4、子类重写的函数要和父类中的函数的访问方式相同
（也就是说，父类的方法是静态的，重写的方法也必须是静态的；父类的方法不是静态的，重写的方法也必须不是静态的）；
5、子类重写的函数，访问权限不能比父类的低；（可以和父类的访问权限不同，但是不能比父类访问权限低）
继承总结
继承的概念：通过extends关键字在两个类之间建立的一种关系；其中继承其他类的类叫做子类（派生类），被其他类继承的类叫做父类（超类）；
继承关系，一般用来表示子类和父类的 是 的关系，即子类描述的事物 是 父类描述的事物的一个特例；
继承的格式：
class Fu{}//父类
class Zi extends Fu{}//子类
继承的作用：子类可以直接拥有父类成员；其中，私有成员和构造函数不参与继承；
java中类继承的特点：只支持单一继承和多重继承，不支持多继承（一个类不能同时继承多个类）
继承中成员变量的特点：
子类中可以直接使用父类中定义的非私有的成员变量；
如果子类中定义了和父类中相同的成员变量，直接调用，实际使用的是子类中定义的成员变量；要使用父类中定义的成员变量，需要使用关键字super，格式是：super.变量名；
继承中一般函数的特点：
子类中可以直接使用父类中定义的非私有的一般函数；
如果子类中定义了和父类中一样的函数，直接调用，实际使用的是子类定义的函数；要使用父类中定义的一般函数，需要使用关键字super，格式是：super.函数名(参数);
方法重写的概念：在继承中，如果子类中定义了和父类中一样的函数，则子类对象实际使用的是子类中定义的函数，这种情况叫做函数的重写；
子类重写父类函数需要注意的事项：
1、子类中重写的函数，函数名、参数列表、返回值类型和是否静态，必须和父类中函数相等；
2、子类中重写的函数，访问权限不能比父类中函数低；
继承中子类实例化的特点：
1、子类实例化时，实际只创建子类一个对象；
2、子类对象中会为父类中的非静态成员变量分配空间；
3、在执行子类的构造函数时，必须要先调用父类的构造函数，作用是给父类的成员变量显示赋值；
4、子类调用父类的构造函数，需要使用super关键字，格式是：super(参数);并且super语句必须在子类构造函数的第一行；
5、子类构造函数中调用其他构造函数的this语句不能和调用父类构造函数的super语句共存；
super小结：super，表示父类；作用是区分子类和父类的成员，以及在子类的构造函数中调用父类构造函数；
案例：计算圆的面积（πrr）
第一步：定义一个圆类
第二步：测试
问题：用户此时可以随意的更改π的值
如何解决？
将π变成常量-----如何变成常量？-----使用final
Final关键字
final：表示最终的，最后的，主要用来修饰类、函数和变量；
final修饰变量
表示这个变量的值不能被修改；
因为被final修饰的变量的值不可改变，所以java中都使用它表示常量；
如果是常量，变量名的写法是：所有字母全部大写，多个单词之间使用下划线连 接；
[外链图片转存失败(img-8A4D2jux-1568599801678)(file:///C:\Users\xlm\AppData\Local\Temp\ksohtml5392\wps10.jpg)]
final修饰类
直接写在class关键字前面，表示这个类不能被继承；
final修饰函数
直接写在函数的返回值类型前面，表示这个函数不能被重写，但是可以被继承；
abstract关键字
案例：创建类描述猫和狗的行为；
猫的行为：抓老鼠；吃鱼；
狗的行为：看家；吃骨头；
分析：这个需求有两类事物，需要创建两个类来分别描述它们；
创建描述猫的类：
[外链图片转存失败(img-SSmrSoNy-1568599801679)(file:///C:\Users\xlm\AppData\Local\Temp\ksohtml5392\wps11.jpg)]
创建描述狗的类：
[外链图片转存失败(img-P3AzTVuC-1568599801680)(file:///C:\Users\xlm\AppData\Local\Temp\ksohtml5392\wps12.jpg)]
问题：上面两个类中有相同的方法
为了提高代码的复用性，需要将其抽取到共同的父类中；猫和狗都是动物，所以可以创建一个动物类，让猫和狗都继承它：
[外链图片转存失败(img-0FzmA5tp-1568599801681)(file:///C:\Users\xlm\AppData\Local\Temp\ksohtml5392\wps13.jpg)]
问题：在抽取共同方法到父类中的过程中发现，不同子类虽然具有相同的方法，但是不同子类的实现不同，在父类中无法准确描述；
[外链图片转存失败(img-PZVlkNPL-1568599801682)(file:///C:\Users\xlm\AppData\Local\Temp\ksohtml5392\wps14.jpg)]
像这种在父类中不能准确描述、需要子类去实现的方法，就应该定义为抽象方法；
抽象方法的书写格式：
A:抽象函数没有方法体，连大括号都没有；
B:抽象函数使用关键字abstract修饰，关键字写在函数的返回值类型前面；
抽象函数表示的是描述不清的功能；如果一个类中有了抽象函数，说明这个类表示的事物也是描述不清的，需要定义为抽象的类；
抽象类的书写格式：
直接将abstract关键字写在class关键字前面；
[外链图片转存失败(img-iIcg6TiG-1568599801683)(file:///C:\Users\xlm\AppData\Local\Temp\ksohtml5392\wps15.jpg)]
抽象类特点
1、抽象类不能实例化；
2、抽象类中的抽象函数必须由子类去实现，否则子类也是抽象类；
3、抽象类也是一个类，类中可以书写所有成员，也可以没有抽象函数；
4、因为抽象函数必须由子类实现，所以不参与继承的（private）和不能被子类重写的（final）关键字不能和abstract共存；
5、因为静态函数不需要类的对象就可以直接使用，所以static关键字也不能和abstract共存；
6、如果一个类不希望被实例化，但又希望被子类继承，就可以定义为抽象的，即使类中没有抽象函数；
普通类与抽象类的区别
1、普通类可以创建对象，抽象类不可以创建对象
2、普通类可以包含普通方法但是不能包含抽象方法，而抽象类既可以包含普通方法又可以包含抽象方法
3、抽象类中抽象方法不能使用private修饰，而普通类中方法可以使用private修饰
date与simpledateformat
Date d=new Date();//用于获取当前的时间，位于java.util包中
SimpleDateFormat s = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
System.out.println(s.format(d));
//将日期转为指定的日期文本
也可以将文本转变为日期
SimpleDateFormat s = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
String st = "2017年09月02日 12时11分32秒";
Date d1 = s.parse(st);
System.out.println(d1);
//获取时间加一年或加一月或加一天
Date date = new Date();
Calendar cal = Calendar.getInstance();
cal.setTime(date);//设置起时间
//System.out.println("111111111::::"+cal.getTime());
cal.add(Calendar.YEAR, 1);//增加一年
cd.add(Calendar.DATE, n);//增加一天
cd.add(Calendar.DATE, -10);//减10天
cd.add(Calendar.MONTH, n);//增加一个月
System.out.println("输出::"+cal.getTime());
产生随机数
import java.util.Random;
public class TestArrays1{
public static void main(String[] args){
//随机给二维数组赋值,打印输出每个元素
Random random=new Random();
int rand=0;//存储随机数
int[][] arrays=new int[3][4];//声明二维数组
//给数组赋值
for(int i=0;i<arrays.length;i++){
for(int j=0;j<arrays[i].length;j++){
rand=random.nextInt(100);//在0-100内随机生成一个正整数
arrays[i][j]=rand;
}
}
//打印输出(采用for循环)
System.out.println("采用for循环: ");
for(int i=0;i<arrays.length;i++){
for(int j=0;j<arrays[i].length;j++){
System.out.print(arrays[i][j]+" ");
}
}
//打印输出(采用增强for循环)
System.out.println();//换行
System.out.println("采用for循环: ");
for(int[] a:arrays){
for(int b:a){
System.out.print(b+" ");
}
}
}
工具类
[外链图片转存失败(img-dnyR7vbD-1568599801684)(C:\Users\xlm\Desktop\JAVA\笔记\工具类.png)]
[外链图片转存失败(img-mqVAz0U2-1568599801685)(C:\Users\xlm\Desktop\JAVA\笔记\工具类1.png)]
[外链图片转存失败(img-kpfL1hkK-1568599801687)(C:\Users\xlm\Desktop\JAVA\笔记\工具类2.png)]
文件的操作
[外链图片转存失败(img-p0BeQihA-1568599801688)(C:\Users\xlm\Desktop\JAVA\笔记\文件.png)]
package file;
import java.io.File;
import java.util.Date;
public class TestFile {
public static void main(String[] args) {
File f = new File("d:/LOLFolder/LOL.exe");
System.out.println("当前文件是：" +f);
//文件是否存在
System.out.println("判断是否存在："+f.exists());
//是否是文件夹
System.out.println("判断是否是文件夹："+f.isDirectory());
//是否是文件（非文件夹）
System.out.println("判断是否是文件："+f.isFile());
//文件长度
System.out.println("获取文件的长度："+f.length());
//文件最后修改时间
long time = f.lastModified();
Date d = new Date(time);
System.out.println("获取文件的最后修改时间："+d);
//设置文件修改时间为1970.1.1 08:00:00
f.setLastModified(0);
//文件重命名
File f2 =new File("d:/LOLFolder/DOTA.exe");
f.renameTo(f2);
System.out.println("把LOL.exe改名成了DOTA.exe");
System.out.println("注意： 需要在D:\\LOLFolder确实存在一个LOL.exe,\r\n才可以看到对应的文件长度、修改时间等信息");
}
}
package file;
import java.io.File;
import java.io.IOException;
public class TestFile {
public static void main(String[] args) throws IOException {
File f = new File("d:/LOLFolder/skin/garen.ski");
// 以字符串数组的形式，返回当前文件夹下的所有文件（不包含子文件及子文件夹）
f.list();
// 以文件数组的形式，返回当前文件夹下的所有文件（不包含子文件及子文件夹）
File[]fs= f.listFiles();
// 以字符串形式返回获取所在文件夹
f.getParent();
// 以文件形式返回获取所在文件夹
f.getParentFile();
// 创建文件夹，如果父文件夹skin不存在，创建就无效
f.mkdir();
// 创建文件夹，如果父文件夹skin不存在，就会创建父文件夹
f.mkdirs();
// 创建一个空文件,如果父文件夹skin不存在，就会抛出异常
f.createNewFile();
// 所以创建一个空文件之前，通常都会创建父目录
f.getParentFile().mkdirs();
// 列出所有的盘符c: d: e: 等等
f.listRoots();
// 刪除文件
f.delete();
// JVM结束的时候，刪除文件，常用于临时文件的删除
f.deleteOnExit();
}
}
TreeMap用法总结
public class TreeMap<K,V>
extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, Serializable
TreeMap中的元素默认按照keys的自然排序排列。
（对Integer来说，其自然排序就是数字的升序；对String来说，其自然排序就是按照字母表排序）
构造函数
-
TreeMap()：创建一个空TreeMap，keys按照自然排序TreeMap<Integer, String> treeMap = new TreeMap<>(); -
TreeMap(Comparator comparator)：创建一个空TreeMap，按照指定的comparator排序TreeMap<Integer, String> map = new TreeMap<>(Comparator.reverseOrder()); map.put(3, "val"); map.put(2, "val"); map.put(1, "val"); map.put(5, "val"); map.put(4, "val"); System.out.println(map); // {5=val, 4=val, 3=val, 2=val, 1=val} -
TreeMap(Map m)：由给定的map创建一个TreeMap，keys按照自然排序Map<Integer, String> map = new HashMap<>(); map.put(1, "val"); ... TreeMap<Integer, String> treeMap = new TreeMap<>(map); -
TreeMap(SortedMap m)：由给定的有序map创建TreeMap，keys按照原顺序排序
常用方法
增添元素
V put(K key, V value)：将指定映射放入该TreeMap中V putAll(Map map)：将指定map放入该TreeMap中
删除元素
void clear()：清空TreeMap中的所有元素V remove(Object key)：从TreeMap中移除指定key对应的映射
修改元素
V replace(K key, V value)：替换指定key对应的value值boolean replace(K key, V oldValue, V newValue)：当指定key的对应的value为指定值时，替换该值为新值
查找元素
boolean containsKey(Object key)：判断该TreeMap中是否包含指定key的映射boolean containsValue(Object value)：判断该TreeMap中是否包含有关指定value的映射Map.Entry<K, V> firstEntry()：返回该TreeMap的第一个（最小的）映射K firstKey()：返回该TreeMap的第一个（最小的）映射的keyMap.Entry<K, V> lastEntry()：返回该TreeMap的最后一个（最大的）映射K lastKey()：返回该TreeMap的最后一个（最大的）映射的keyv get(K key)：返回指定key对应的valueSortedMap<K, V> headMap(K toKey)：返回该TreeMap中严格小于指定key的映射集合SortedMap<K, V> subMap(K fromKey, K toKey)：返回该TreeMap中指定范围的映射集合（大于等于fromKey，小于toKey）
遍历接口
Set<Map<K, V>> entrySet()：返回由该TreeMap中的所有映射组成的Set对象void forEach(BiConsumer<? super K,? super V> action)：对该TreeMap中的每一个映射执行指定操作Collection<V> values()：返回由该TreeMap中所有的values构成的集合
其他方法
Object clone()：返回TreeMap实例的浅拷贝Comparator<? super K> comparator()：返回给该TreeMap的keys排序的comparator，若为自然排序则返回nullint size()：返回该TreepMap中包含的映射的数量
TreeMap<Integer, String> treeMap = new TreeMap<>();
treeMap.put(1, "a");
treeMap.put(2, "b");
treeMap.put(3, "c");
treeMap.put(4, "d"); // treeMap: {1=a, 2=b, 3=c, 4=d}
treeMap.remove(4); // treeMap: {1=a, 2=b, 3=c}
int sizeOfTreeMap = treeMap.size(); // sizeOfTreeMap: 3
treeMap.replace(2, "e"); // treeMap: {1=a, 2=e, 3=c}
Map.Entry entry = treeMap.firstEntry(); // entry: 1 -> a
Integer key = treeMap.firstKey(); // key: 1
entry = treeMap.lastEntry(); // entry: 3 -> c
key = treeMap.lastKey(); // key: 3
String value = treeMap.get(3); // value: c
SortedMap sortedMap = treeMap.headMap(2); // sortedMap: {1=a}
sortedMap = treeMap.subMap(1, 3); // sortedMap: {1=a, 2=e}
Set setOfEntry = treeMap.entrySet(); // setOfEntry: [1=a, 2=e, 3=c]
Collection<String> values = treeMap.values(); // values: [a, e, c]
treeMap.forEach((integer, s) -> System.out.println(integer + "->" + s));
// output：
// 1 -> a
// 2 -> e
// 3 -> c
遍历方式
-
for循环
for (Map.Entry entry : treeMap.entrySet()) { System.out.println(entry); } -
迭代器循环
Iterator iterator = treeMap.entrySet().iterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); }
补充：如何选择合适的Map
- HashMap可实现快速存储和检索，但其缺点是其包含的元素是无序的，这导致它在存在大量迭代的情况下表现不佳。
- LinkedHashMap保留了HashMap的优势，且其包含的元素是有序的。它在有大量迭代的情况下表现更好。
- TreeMap能便捷的实现对其内部元素的各种排序，但其一般性能比前两种map差。
LinkedHashMap映射减少了HashMap排序中的混乱，且不会导致TreeMap的性能损失。
将下java中的math类有那些常用方法？
Pow()：幂运算
Sqrt()：平方根
Round()：四舍五入
Abs()：求绝对值
Random()：生成一个0-1的随机数，包括0不包括1
String类的常用方法有那些？
charAt：返回指定索引处的字符
indexOf()：返回指定字符的索引
replace()：字符串替换
trim()：去除字符串两端空白
split()：分割字符串，返回一个分割后的字符串数组
getBytes()：返回字符串的byte类型数组
length()：返回字符串长度
toLowerCase()：将字符串转成小写字母
toUpperCase()：将字符串转成大写字符
substring()：截取字符串
format()：格式化字符串
equals()：字符串比较
如何将字符串反转？
Stringbuilder或者stringbuffer的reverse方法
String类方法
Calendar类对象信息的设置
Set设置
如：
Calendar c1 = Calendar.getInstance();
调用：
public final void set(int year,int month,int date)
c1.set(2009, 6 - 1, 12);//把Calendar对象c1的年月日分别设这为：2009、6、12
利用字段类型设置
如果只设定某个字段，例如日期的值，则可以使用如下set方法：
public void set(int field,int value)
把 c1对象代表的日期设置为10号，其它所有的数值会被重新计算
c1.set(Calendar.DATE,10);
把c1对象代表的年份设置为2008年，其他的所有数值会被重新计算
c1.set(Calendar.YEAR,2008);
其他字段属性set的意义以此类推
Add设置
Calendar c1 = Calendar.getInstance();
把c1对象的日期加上10，也就是c1也就表示为10天后的日期，其它所有的数值会被重新计算
c1.add(Calendar.DATE, 10);
把c1对象的日期减去10，也就是c1也就表示为10天前的日期，其它所有的数值会被重新计算
c1.add(Calendar.DATE, -10);
其他字段属性的add的意义以此类推
Calendar类对象信息的获得
Calendar c1 = Calendar.getInstance(); // 获得年份 int year = c1.get(Calendar.YEAR); // 获得月份 int month = c1.get(Calendar.MONTH) + 1; // 获得日期 int date = c1.get(Calendar.DATE); // 获得小时 int hour = c1.get(Calendar.HOUR_OF_DAY); // 获得分钟 int minute = c1.get(Calendar.MINUTE); // 获得秒 int second = c1.get(Calendar.SECOND); // 获得星期几（注意（这个与Date类是不同的）：1代表星期日、2代表星期1、3代表星期二，以此类推） int day = c1.get(Calendar.DAY_OF_WEEK);
Java 流(Stream)、文件(File)和IO
Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。
Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。
一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。
Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。
但本节讲述最基本的和流与 I/O 相关的功能。我们将通过一个个例子来学习这些功能。
读取控制台输入
Java 的控制台输入由 System.in 完成。
为了获得一个绑定到控制台的字符流，你可以把 System.in 包装在一个 BufferedReader 对象中来创建一个字符流。
下面是创建 BufferedReader 的基本语法：
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedReader 对象创建后，我们便可以使用 read() 方法从控制台读取一个字符，或者用 readLine() 方法读取一个字符串。
从控制台读取多字符输入
从 BufferedReader 对象读取一个字符要使用 read() 方法，它的语法如下：
int read( ) throws IOException
每次调用 read() 方法，它从输入流读取一个字符并把该字符作为整数值返回。 当流结束的时候返回 -1。该方法抛出 IOException。
下面的程序示范了用 read() 方法从控制台不断读取字符直到用户输入 “q”。
BRRead.java 文件代码：
//使用 BufferedReader 在控制台读取字符 import java.io.*; public class BRRead { public static void main(String args[]) throws IOException { char c; // 使用 System.in 创建 BufferedReader BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); System.out.println(“输入字符, 按下 ‘q’ 键退出。”); // 读取字符 do { c = (char) br.read(); System.out.println©; } while (c != ‘q’); } }
以上实例编译运行结果如下:
输入字符, 按下 'q' 键退出。
runoob
r
u
n
o
o
b
q
q
从控制台读取字符串
从标准输入读取一个字符串需要使用 BufferedReader 的 readLine() 方法。
它的一般格式是：
String readLine( ) throws IOException
下面的程序读取和显示字符行直到你输入了单词"end"。
BRReadLines.java 文件代码：
//使用 BufferedReader 在控制台读取字符 import java.io.*; public class BRReadLines { public static void main(String args[]) throws IOException { // 使用 System.in 创建 BufferedReader BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); String str; System.out.println(“Enter lines of text.”); System.out.println(“Enter ‘end’ to quit.”); do { str = br.readLine(); System.out.println(str); } while (!str.equals(“end”)); } }
以上实例编译运行结果如下:
Enter lines of text.
Enter 'end' to quit.
This is line one
This is line one
This is line two
This is line two
end
end
JDK 5 后的版本我们也可以使用 Java Scanner 类来获取控制台的输入。
控制台输出
在此前已经介绍过，控制台的输出由 print( ) 和 println() 完成。这些方法都由类 PrintStream 定义，System.out 是该类对象的一个引用。
PrintStream 继承了 OutputStream类，并且实现了方法 write()。这样，write() 也可以用来往控制台写操作。
PrintStream 定义 write() 的最简单格式如下所示：
void write(int byteval)
该方法将 byteval 的低八位字节写到流中。
实例
下面的例子用 write() 把字符 “A” 和紧跟着的换行符输出到屏幕：
WriteDemo.java 文件代码：
import java.io.*; //演示 System.out.write(). public class WriteDemo { public static void main(String args[]) { int b; b = ‘A’; System.out.write(b); System.out.write(’\n’); } }
运行以上实例在输出窗口输出 “A” 字符
A
**注意：**write() 方法不经常使用，因为 print() 和 println() 方法用起来更为方便。
读写文件
如前所述，一个流被定义为一个数据序列。输入流用于从源读取数据，输出流用于向目标写数据。
下图是一个描述输入流和输出流的类层次图。
下面将要讨论的两个重要的流是 FileInputStream 和 FileOutputStream：
FileInputStream
该流用于从文件读取数据，它的对象可以用关键字 new 来创建。
有多种构造方法可用来创建对象。
可以使用字符串类型的文件名来创建一个输入流对象来读取文件：
InputStream f = new FileInputStream(“C:/java/hello”);
也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：
File f = new File(“C:/java/hello”); InputStream out = new FileInputStream(f);
创建了InputStream对象，就可以使用下面的方法来读取流或者进行其他的流操作。
| 序号 | 方法及描述 |
|---|---|
| 1 | public void close() throws IOException{} 关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。 |
| 2 | protected void finalize()throws IOException {} 这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。 |
| 3 | public int read(int r)throws IOException{} 这个方法从 InputStream 对象读取指定字节的数据。返回为整数值。返回下一字节数据，如果已经到结尾则返回-1。 |
| 4 | public int read(byte[] r) throws IOException{} 这个方法从输入流读取r.length长度的字节。返回读取的字节数。如果是文件结尾则返回-1。 |
| 5 | public int available() throws IOException{} 返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取的字节数。返回一个整数值。 |
除了 InputStream 外，还有一些其他的输入流，更多的细节参考下面链接：
FileOutputStream
该类用来创建一个文件并向文件中写数据。
如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。
有两个构造方法可以用来创建 FileOutputStream 对象。
使用字符串类型的文件名来创建一个输出流对象：
OutputStream f = new FileOutputStream(“C:/java/hello”)
也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象：
File f = new File(“C:/java/hello”); OutputStream f = new FileOutputStream(f);
创建OutputStream 对象完成后，就可以使用下面的方法来写入流或者进行其他的流操作。
| 序号 | 方法及描述 |
|---|---|
| 1 | public void close() throws IOException{} 关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。 |
| 2 | protected void finalize()throws IOException {} 这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。 |
| 3 | public void write(int w)throws IOException{} 这个方法把指定的字节写到输出流中。 |
| 4 | public void write(byte[] w) 把指定数组中w.length长度的字节写到OutputStream中。 |
除了OutputStream外，还有一些其他的输出流，更多的细节参考下面链接：
实例
下面是一个演示 InputStream 和 OutputStream 用法的例子：
fileStreamTest.java 文件代码：
import java.io.*; public class fileStreamTest { public static void main(String args[]) { try { byte bWrite[] = { 11, 21, 3, 40, 5 }; OutputStream os = new FileOutputStream("test.txt"); for (int x = 0; x < bWrite.length; x++) { os.write(bWrite[x]); // writes the bytes } os.close(); InputStream is = new FileInputStream("test.txt"); int size = is.available(); for (int i = 0; i < size; i++) { System.out.print((char) is.read() + " "); } is.close(); } catch (IOException e) { System.out.print("Exception"); } } }
上面的程序首先创建文件test.txt，并把给定的数字以二进制形式写进该文件，同时输出到控制台上。
以上代码由于是二进制写入，可能存在乱码，你可以使用以下代码实例来解决乱码问题：
fileStreamTest2.java 文件代码：
//文件名 :fileStreamTest2.java import java.io.*; public class fileStreamTest2 { public static void main(String[] args) throws IOException { File f = new File(“a.txt”); FileOutputStream fop = new FileOutputStream(f); // 构建FileOutputStream对象,文件不存在会自动新建 OutputStreamWriter writer = new OutputStreamWriter(fop, “UTF-8”); // 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk writer.append(“中文输入”); // 写入到缓冲区 writer.append("\r\n"); // 换行 writer.append(“English”); // 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入 writer.close(); // 关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉 fop.close(); // 关闭输出流,释放系统资源 FileInputStream fip = new FileInputStream(f); // 构建FileInputStream对象 InputStreamReader reader = new InputStreamReader(fip, “UTF-8”); // 构建InputStreamReader对象,编码与写入相同 StringBuffer sb = new StringBuffer(); while (reader.ready()) { sb.append((char) reader.read()); // 转成char加到StringBuffer对象中 } System.out.println(sb.toString()); reader.close(); // 关闭读取流 fip.close(); // 关闭输入流,释放系统资源 } }
文件和I/O
还有一些关于文件和I/O的类，我们也需要知道：
Java中的目录
创建目录：
File类中有两个方法可以用来创建文件夹：
- **mkdir( )**方法创建一个文件夹，成功则返回true，失败则返回false。失败表明File对象指定的路径已经存在，或者由于整个路径还不存在，该文件夹不能被创建。
- **mkdirs()**方法创建一个文件夹和它的所有父文件夹。
下面的例子创建 "/tmp/user/java/bin"文件夹：
CreateDir.java 文件代码：
import java.io.File; public class CreateDir { public static void main(String args[]) { String dirname = “/tmp/user/java/bin”; File d = new File(dirname); // 现在创建目录 d.mkdirs(); } }
编译并执行上面代码来创建目录 “/tmp/user/java/bin”。
注意： Java 在 UNIX 和 Windows 自动按约定分辨文件路径分隔符。如果你在 Windows 版本的 Java 中使用分隔符 (/) ，路径依然能够被正确解析。
读取目录
一个目录其实就是一个 File 对象，它包含其他文件和文件夹。
如果创建一个 File 对象并且它是一个目录，那么调用 isDirectory() 方法会返回 true。
可以通过调用该对象上的 list() 方法，来提取它包含的文件和文件夹的列表。
下面展示的例子说明如何使用 list() 方法来检查一个文件夹中包含的内容：
DirList.java 文件代码：
import java.io.File; public class DirList { public static void main(String args[]) { String dirname = “/tmp”; File f1 = new File(dirname); if (f1.isDirectory()) { System.out.println(“目录 " + dirname); String s[] = f1.list(); for (int i = 0; i < s.length; i++) { File f = new File(dirname + “/” + s[i]); if (f.isDirectory()) { System.out.println(s[i] + " 是一个目录”); } else { System.out.println(s[i] + " 是一个文件"); } } } else { System.out.println(dirname + " 不是一个目录"); } } }
以上实例编译运行结果如下：
目录 /tmp
bin 是一个目录
lib 是一个目录
demo 是一个目录
test.txt 是一个文件
README 是一个文件
index.html 是一个文件
include 是一个目录
删除目录或文件
删除文件可以使用 java.io.File.delete() 方法。
以下代码会删除目录 /tmp/java/，需要注意的是当删除某一目录时，必须保证该目录下没有其他文件才能正确删除，否则将删除失败。
测试目录结构：
/tmp/java/
|-- 1.log
|-- test
DeleteFileDemo.java 文件代码：
import java.io.File; public class DeleteFileDemo { public static void main(String args[]) { // 这里修改为自己的测试目录 File folder = new File("/tmp/java/"); deleteFolder(folder); } // 删除文件及目录 public static void deleteFolder(File folder) { File[] files = folder.listFiles(); if (files != null) { for (File f : files) { if (f.isDirectory()) { deleteFolder(f); } else { f.delete(); } } } folder.delete(); } }
连接数据库
[外链图片转存失败(img-JC5ZtaEL-1568599801691)(D:\学习\培训\JAVA\笔记\连接数据库.png)]
irList.java 文件代码：
import java.io.File; public class DirList { public static void main(String args[]) { String dirname = “/tmp”; File f1 = new File(dirname); if (f1.isDirectory()) { System.out.println(“目录 " + dirname); String s[] = f1.list(); for (int i = 0; i < s.length; i++) { File f = new File(dirname + “/” + s[i]); if (f.isDirectory()) { System.out.println(s[i] + " 是一个目录”); } else { System.out.println(s[i] + " 是一个文件"); } } } else { System.out.println(dirname + " 不是一个目录"); } } }
以上实例编译运行结果如下：
目录 /tmp
bin 是一个目录
lib 是一个目录
demo 是一个目录
test.txt 是一个文件
README 是一个文件
index.html 是一个文件
include 是一个目录
删除目录或文件
删除文件可以使用 java.io.File.delete() 方法。
以下代码会删除目录 /tmp/java/，需要注意的是当删除某一目录时，必须保证该目录下没有其他文件才能正确删除，否则将删除失败。
测试目录结构：
/tmp/java/
|-- 1.log
|-- test
DeleteFileDemo.java 文件代码：
import java.io.File; public class DeleteFileDemo { public static void main(String args[]) { // 这里修改为自己的测试目录 File folder = new File("/tmp/java/"); deleteFolder(folder); } // 删除文件及目录 public static void deleteFolder(File folder) { File[] files = folder.listFiles(); if (files != null) { for (File f : files) { if (f.isDirectory()) { deleteFolder(f); } else { f.delete(); } } } folder.delete(); } }
连接数据库
[外链图片转存中…(img-JC5ZtaEL-1568599801691)]
42万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
