Java基础
课前的复习内容:
- 继承
- 作用: 代码重用,复用
- 单继承
- 子类的实例
- 先创建父类实例
- 再创建子类实例
- 两个实例绑定,整体作为一个实例
- 调用成员时,先找子类再找父类
- 方法重写 Override
- 继承的方法,在子类中重新定义重新编写
- super
- super.xxxx()
- 重写时,调用父类中同一个方法的代码
- super(...)
- 调用父类的构造方法
- 默认 super()
- 手动 super(参数)
- 必须是首行代码
- super.xxxx()
异常:
throw:
手动的进行抛出异常,执行异常抛出的动作,若没有出现错误,则会以return的形式进行正确的返回
自己进行创建异常的实例进行调用,涉及到错误信息的反馈的位置
package day1301_异常;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
//进行异常的手动的抛出
function();
}
public static void function() {
System.out.println("请输入两个浮点数");
double double1=new Scanner(System.in).nextDouble();
double double2=new Scanner(System.in).nextDouble();
//两个数相除的结果
try {
//将要有关异常运行的代码都要放进try的括号中进行处理
double divide = divide(double1,double2);
System.out.println(divide);
} catch (ArithmeticException e) {
//进行打印异常的信息
e.printStackTrace();
// 这里反馈给用户的信息
System.out.println("除数不可以为零,请您原谅");
}
}
public static double divide(double double1, double double2) {
if (double2==0) {
//括号里面的是反馈给程序员的,这是自己创建的异常的实例
ArithmeticException e= new ArithmeticException("除数不可以为零");
throw e;
}
return double1/double2;
}
}
异常的包装
捕获的异常的实例:包装成为另外的实例在进行抛出
try {
} catch (AException e) {
throw new BException(e)
}
使用的场景:
不能抛出的异常,包装成为能抛出的类型继续抛出
简化异常,多种异常类型,进行简化为一种类型
方法的重写:
重写的方法的异常的管道,不可以比父类的方法多
练习:异常的包装
package day1301_异常;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import javax.management.RuntimeErrorException;
public class Test2 {
public static void main(String[] args) {
function1();
}
public static void function1() {
// 进行异常的包装
ArrayList<String> arrayList=new ArrayList<>();
Collections.addAll(arrayList,
"2019-6-3","2019-6-2","2019-6-15","2019-6-12","2019-6-29","2019-6-18","2019-6-2","2019-6-30","2019-6-3","2019-6-1");
//上面的排序按照的是字符的排列的顺序
Collections.sort(arrayList);
System.out.println(arrayList);
//进行重写比较器,可以直接在内部new出啦一分实例
Collections.sort(arrayList,new Comparator<String>() {
//进行实现他的抽象方法
public int compare(String o1, String o2) {
//按照日期的大小进行排序
//String---SimpleDateFormat------>Date,作用就是将字符串转化为日期的类型
//处理日期格式的工具
//首相new出来一个实例,然后进行设定日期的格式
SimpleDateFormat simpleDateFormat=
//在这里大小写是有区别的,注意他的大小写的问题
new SimpleDateFormat("yyyy-MM-dd");
//先进行创建实例对象simpleDateFormat,利用创建出来的对对象进行将字符类型的数据转化为日期类型
//用格式工具进行字符串的转化
try {
Date Date1 = simpleDateFormat.parse(o1);
Date Date2 = simpleDateFormat.parse(o2);
return Date1.compareTo(Date2);
} catch (Exception e) {
//一般的捕获异常,需要进行修复,但是在此处并不处理这一个异常,将异常继续抛出
//进行包装成为可以进行抛出去,因为没有该方法的特殊的管道
throw new RuntimeException(e);
}
//调用方法Date1.compareTo(Date2)进行日期的比较大小
}
});
System.out.println(arrayList);
}
}
自定义异常:
现有的异常类型,需要表示具体的业务中的错误的情况,需要自定义一个新的异常的类型
自定义的异常:
起一个合适的类名---->继承一个合适的类名---->添加合适的构造的方法
练习:自定义异常
在这里进行要区分==和equals()之间的区别
package day1301_异常;
import java.util.Scanner;
//进行测试自定义的异常
public class Test3 {
public static void main(String[] args) {
System.out.println("请你输入用户名");
String userName = new Scanner(System.in).nextLine();
System.out.println("请你输入密码 ");
String passWord = new Scanner(System.in).nextLine();
try {
//进行判定用户名和密码是否正确
login(userName,passWord);
System.out.println("欢迎登陆");
} catch (UsernameNotFoundException e) {
System.out.println("你的用户名输入不正确,请重新输入");
}catch (WrongPasswordException e) {
System.out.println("你的密码输入不正确,请重新输入");
}
}
//此方法没有默认的管道,是能自己进行添加管道,利用throws这一个关键字
private static void login(String userName, String passWord) throws UsernameNotFoundException, WrongPasswordException {
//进行检查用户名和密码 abc 123
//自己书写错误的代码,在这里比较不乐意使用!=这一个符号
// if (userName!="abc") {
// throw new UsernameNotFoundException();
// }
// if (passWord!="123") {
// throw new WrongPasswordException();
// }
if (!userName.equals("abc")) {
throw new UsernameNotFoundException();
}
if (!passWord.equals("123")) {
throw new WrongPasswordException();
}
}
}
创建的密码错误的类的方法,和选择继承的方法 (Exception和RuntimeException)常选用的继承的异常的父类
package day1301_异常;
//进行测试自定义的异常
//首先进行选择合适的父类异常进行选择
public class UsernameNotFoundException extends Exception{
public UsernameNotFoundException() {
super();
// TODO Auto-generated constructor stub
}
public UsernameNotFoundException(String message, Throwable cause, boolean enableSuppression,
boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
// TODO Auto-generated constructor stub
}
public UsernameNotFoundException(String message, Throwable cause) {
super(message, cause);
// TODO Auto-generated constructor stub
}
public UsernameNotFoundException(String message) {
super(message);
// TODO Auto-generated constructor stub
}
public UsernameNotFoundException(Throwable cause) {
super(cause);
// TODO Auto-generated constructor stub
}
}
RuntimeException
Exception
检查异常,强制开发人员先考虑出现错误如何进行处理,编译器会检查时候添加了异常的处理代码,没有处理不能够被编译
RuntimeException
非检查异常,有默认管道,编译器不检查这种异常
catch 和 throws
底层的异常,一般需要抛到上层处理,可以选择合适的卫视进行处理
经验不足时,首先选择的是throws
catch:进行异常的捕捉,进行处理
throws:将异常抛出
io流
input和output 输入/输出 文件的输入和输出是讲的Java是主要的人称,是对于内存数据来讲的
保存文件(输出):程序执行时候,把内存中的数据,保存到存储器中(文件),代表的是输出
读取数据(输入):从外部的存储器读取数据,把数据读入到内存中由程序来处理
java.io
File 封装磁盘的路径的文件(文件、文件夹、不存在的路径都可以)
FileInputStream FileOutputStream
ObjectInputStream ObjectOutputStream
InputStreamReader OutputStreamWriter
File的方法
文件或文件夹属性的方法
length() getName() getParent() exists() isFile() idDirctory()
package day1302_File;
import java.io.File;
//进行测试File类
public class Test1 {
public static void main(String[] args) {
String path;
// path="F:\\2019黑马附赠资料在D盘\\txs.txt";//存在的文件,双\\其中一个是转移符号的作用
path="F:/2019黑马附赠资料在D盘";//存在的文件安夹,或者只单单的用一个/就可以
// path="F:\\2019黑马附赠资料在D盘\\zxh";//不存在的路径
//是将File文件进行封装文件
//路径字符串封装到File实例
File file=new File(path);
System.out.println(file.getName());
System.out.println(file.getParent());
//显示他的绝对的路径,就是完整的路径
System.out.println(file.getAbsolutePath());
System.out.println(file.length());
System.out.println(file.exists());
System.out.println(file.isFile());
//是否是文件夹
System.out.println(file.isDirectory());
}
}
创建或者是删除
creatNewFile()
新建的文件,不在进行创建,返回的是布尔的值,文件夹不存在,会出现异常
mkdirs()
逐层的进行创建多层文件夹
删除文件,或者是删除空的文件夹
package day1302_File;
import java.io.File;
import java.io.IOException;
import java.util.Scanner;
public class Test2 {
/*
* 新建文件夹:F:\\abc\\aa\bb
* 新建文件夹:F:\\abc\\aa\bb\\f1
* 进行删除f1文件夹
* 进行删除bb文件夹
*/
//在这里进行添加文件的异常的管道
public static void main(String[] args) throws IOException {
System.out.println("请按回车键进行下一步的操作");
//记忆文件和文件夹的创建的代码的书写
//先将创建对象,然后调用对象的方法,完成文件或者是文件夹的创建
new Scanner(System.in).nextLine();
File dir=new File("F:\\abc\\aa\\bb");
//这两行代码表示的是进行创建文件夹bb
dir.mkdirs();
new Scanner(System.in).nextLine();
//直接将文件的路径进行写全
File file = new File("F:\\abc\\aa\\bb\\f1");
//或者是利用另外的一个多态的方法,父目录和文件以逗号隔开
File file2 = new File(dir, "f1");
file.createNewFile();
file2.createNewFile();
new Scanner(System.in).nextLine();
file.delete();
new Scanner(System.in).nextLine();
file2.delete();
new Scanner(System.in).nextLine();
dir.delete();
}
}
文件夹列表
list()
获取文件列表,string[]数组,只包含文件的名称的字符串
[“a.txt“]["b.jpg "]["c.abc"]
listFiles()
获取文件列表,File[]数组,包含每个文件得File对象,里面出来的包含文件的各种的属性
[{.......}{.......}{........}]
如果对文件夹,或者对不存在的路径,或无权进入的文件夹,会返回null值
package day1302_File;
import java.io.File;
import java.util.Scanner;
public class Test3 {
public static void main(String[] args) {
//
System.out.println("输入文件夹");
String string = new Scanner(System.in).nextLine();
System.out.println("打印的是字符串的类型");
//将对象封装称为文件夹
File dir=new File(string);
if(!dir.isDirectory()) {
System.out.println("你输入的不是有效的路径");
//try里面书写的是可以执行的代码块
return;
}else {
//进行遍历文件夹里面的文件
//遍历出来的是字符串的类型
String[] names = dir.list();
if(names==null) {
//这里面包含了三种情况,文件夹为空,文件夹不存在,或者是文件夹没有权限进行访问
System.out.println("不可以获取文件的列表");
return;
}
else {
//利用的是
for(String name : names) {
System.out.println(name);
}
}
//打印的如果文件的形式,则输出的文件的全路径的形式
System.out.println("打印的是文件的形式");
//遍历出来的是文件的类型
File[] listFiles = dir.listFiles();
//将得到的文件进行遍历
if (listFiles==null) {
System.out.println("你搜索的文件夹为空");
return;
}else {
for (File file : listFiles) {
System.out.println(file);
}
}
}
}
}
练习:求文件夹的总大小(就是累加文文件夹里面的所有的文件的总大小,不一定只有一层的情况)
package day1302_File;
import java.io.File;
import java.util.Scanner;
//用到了方法的递归i
public class Test4 {
public static void main(String[] args) {
System.out.println("输入文件夹");
String string = new Scanner(System.in).nextLine();
System.out.println("打印的是字符串的类型");
//将对象封装称为文件夹
File dir=new File(string);
if(!dir.isDirectory()) {
System.out.println("你输入的不是有效的路径");
//try里面书写的是可以执行的代码块
return;
}
long size=dirLength(dir);
System.out.println(size);
}
public static long dirLength(File dir) {
File[] listFiles = dir.listFiles();
if (listFiles==null) {
//若选择的文件夹是空的,直接返回0
return 0;
}
long sum=0;
for (File file : listFiles) {
if(file.isFile()) {
//file是问价
sum=sum+file.length();
}else {
//递归调用的方法书写(可以理解为方法进行调用自身的方法)
//file是文件夹
sum+=dirLength(file);
}
}
return sum;
}
}
流:Stream
把数据的读写,抽象成数据在管道中进行流动
简便的理解方法:读进来,写出去
读:把数据读出内存
写:把内存中的数据,向外部进行输出
单方向流动
输入流:只能进行从外部流入内存,只能用来读取数据
输出流:就是数据从内存中流出到外部设备,只能用来输出数据
数据从头到尾只能够进行流动一次,不能够进行反复的流动
FileInputStream:文件的输入流
FileOutputStream :文件的输出流
这两个对象都是插在文件上的,读写文件的数据,直接的插在文件上的流,只有这一个文件流,其他的方法都是不可以的
方法:
write( int b )
int是四个字节,
只输出字节,只输出末尾的一个字节值
write(byte[] ,start, length)
就是进行指定的输出文件的字节,从start开始,长度是length的字节
read()
读取一个字节的值,在补三个字节0,转成int类型
read(byte[] buff)
就是创建数组进行提高处理数据的速率,定义为数组的大小测试值是8096,buff就相当于自己在餐厅的饭盒一样,将buff工具交给方法。进行运算,若文件中的数据读取完成之后,在进行读取数据,会进行返回-1的形式进行警告
package day1401;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Arrays;
//进行测试文件流
public class Test1 {
public static void main(String[] args) throws Exception {
FileInputStream fileInputStream = new FileInputStream("F:\\abc\\f1");
//进行创建批量处理的对象
byte[] buff=new byte[5];
int n; //返回值来保存每一批的数量
while ((n=fileInputStream.read(buff))!=-1) {
System.out.println(n+"个:"+Arrays.toString(buff));
}
System.out.println("------------------");
//在read()括号里面的buff就相当于存储数据的饭盒
n=fileInputStream.read(buff);
System.out.println(n+"个:"+Arrays.toString(buff));
n=fileInputStream.read(buff);
System.out.println(n+"个:"+Arrays.toString(buff));
n=fileInputStream.read(buff);
System.out.println(n+"个:"+Arrays.toString(buff));
n=fileInputStream.read(buff);
System.out.println(n+"个:"+Arrays.toString(buff));
n=fileInputStream.read(buff);
System.out.println(n+"个:"+Arrays.toString(buff));
n=fileInputStream.read(buff);
System.out.println(n+"个:"+Arrays.toString(buff));
}
}
读取结束,在进行读取数据,返回值为-1,进行警告
package day1303_字节流;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class Test1 {
public static void main(String[] args) throws Exception {
/*
* d:/abc/f1
*
* --f1,进行插入管道
*/
FileOutputStream fileOutputStream = new FileOutputStream("F:\\abc\\f1");
fileOutputStream.write(97);
fileOutputStream.write(98);
fileOutputStream.write(99);
fileOutputStream.write(356);
String [ ] a={
"101","102","103","104","105","106","107","108","109","110"
};
byte [ ] b= {
101,102,103,104,105,106,107,108,109
};
fileOutputStream.write(b,0,6);
//进行释放的系统的资源
fileOutputStream.close();
}
}
文件的加密,文件的解密:主要是更改文件的数据的顺序进行加密,然互还原顺序进行解密
算法的使用:对上面的数据进行异或处理,异或两次会还原原来的数据
练习:文件的加密,,就是涉及到文件的同时进行读写的操作
package day1303_字节流;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.util.Scanner;
public class Test3 {
public static void main(String[] args) {
//
System.out.println("输入文件");
String string = new Scanner(System.in).nextLine();
//将输入的文件封装成为File
File file=new File(string);
//进行判定输入的file是不是文件
if (!file.isFile()) {
System.out.println("输入的不是文件");
return;
}
System.out.println("请你输入要加密的Key::");
int Key=new Scanner(System.in).nextInt();
try {
/*
* 加密进行复制
* a.jpg---->"a.jpg".毫秒值
*/
//进行创建方法进行加密
encryptCopy(file,Key);
System.out.println("成功");
} catch (Exception e) {
System.out.println("失败");
//进行打印完整的错误的信息
e.printStackTrace();
}
}
public static void encryptCopy(File file, int key) throws Exception {
// 进行构建加密的方法,先将文件加密输入到内存,然后在将加密之后的数据从内存输出到外部的内存中
//传进来的是源文件的父目录
//原文件名.毫秒值
File to=
new File
(file.getParentFile(),
file.getName()+"."+System.currentTimeMillis());
//创建文件的输入流,放在file身上
FileInputStream fileInputStream = new FileInputStream(file);
//创建文件的输出流,放在to身上
FileOutputStream fileOutputStream = new FileOutputStream(to);
int b;
//从原文件中进行读取到加密到内存中
while ((b=fileInputStream.read())!=-1){
//将数据异或处理
b^=key;
//直接向目标文件进行输出
fileOutputStream.write(b);
}
fileInputStream.close();
fileOutputStream.close();
}
}
利用数租的提高数据的传送的速率:方法如下