目录
一、[Java 流(Stream)、文件(File)和IO](#Java 流(Stream)、文件(File)和IO)
[java io](#java io)
二、[java Scanner类](#java Scanner类)
三、java异常处理
四、继承
java
package com.company;
import java.io.*;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Collectors;
import java.util.stream.Stream;Java 流(Stream)、文件(File)和IO
java流（Stream）
用于处理集合数据，Stream是一种可以执行一系列操作（过滤。映射。减少等）以处理数据的抽象
Stream
java
//创建Stream
class Streamtest01{
public static void main(String[]args)
{
//从集合创建Stream
List<String> list= Arrays.asList();
Stream<String>Stream=list.stream();
//从数组创建Stream
String[]array={"x","y","z"};
Stream<String>stream2=Arrays.stream(array);
// 使用Stream.of创建Stream
Stream<String> stream3 = java.util.stream.Stream.of("1", "2", "3");
}
}stream常见操作
java
class Streamtest02{
public static void main(String[]args)
{
List<Integer>number=Arrays.asList(1,2,3,4,5,6,7);
//过滤偶数
List<Integer>evennumber= (List<Integer>) number.stream()
.filter(n->n%2==0)
.collect(Collectors.toList());
System.out.println(evennumber);
//将数字平方
List<Integer>Snumber=number.stream()
.map(n-> n * n)
.collect(Collectors.toList());
System.out.println(Snumber);
//计算总和
int sum=number.stream()
.reduce(0,Integer::sum);
System.out.println(sum);
}
}java文件操作
java文件操作（file） java的java.io.file类用来表示文件和目录路径名，可以使用File类创建、删除、检查文件和目录的属性等
java
//创建文件和目录
class Filetest01{
public static void main(String[]args)
{
try{
//创建文件
File file=new File("exampie.txt");
if(file.createNewFile())
{
System.out.println(file.getName());
}
else
{
System.out.println("file alread exists");
}
File file01=new File("www.txt");
if(file01.createNewFile())
{
System.out.println(file01.getName());
}
else
{
System.out.println("创建失败");
}
//创建目录
File diretory=new File("exampledir");
if(diretory.mkdir())
{
System.out.println(diretory.getName());
}
else
{
System.out.println("创建失败");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
//文件的读取和写入
class filerw{
public static void main(String[]args)
{
try{
//写入文件
FileWriter writer=new FileWriter("example.txt");
writer.write("hello");
writer.close();
//读取文件
FileReader reader=new FileReader("example.txt");
int character;
while((character=reader.read())!=-1)
{
System.out.print((char) character);
}
reader.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}java io
java io （输入输出）javaio库提供了多种输入输出流类，用于处理字节和字符数据，主要分为字节流和字符流两种
java
//字节流
//字节流用于处理8位字节数据，主要类是inputstream和outputstream以及其子类
class byteStream{
public static void main(String[]args)
{
try{
//写入字节文件
FileOutputStream fos=new FileOutputStream("bytrFile.txt");
String date="hello,b";
fos.write(date.getBytes());
fos.close();
//读取字节文件
FileInputStream fis=new FileInputStream("bytrFile.txt");
int bytedate;
while((bytedate=fis.read())!=-1)
{
System.out.print((char)bytedate);
}
fis.close();
} catch (Exception e) {
System.out.println("错误");
e.printStackTrace();
}
}
}
//字符流
//字符流用于处理16位字符数据主要是reader和writer及其子类
class charstream{
public static void main(String[]args)
{
try{
FileWriter writer=new FileWriter("charstream.txt");
writer.write("hello,char");
writer.close();
FileReader reader=new FileReader("charstream.txt");
int arr;
while ((arr=reader.read())!=-1)
{
System.out.print((char) arr);
}
} catch (Exception e) {
System.out.println("失败");
e.printStackTrace();
}
}
}java Scanner类
我们可以通过scanner类来获取用户的输入。创建scanner类的基本语法：Scanner s=new scanner(System.in);
数据输入
java
class Scannertest01{
public static void main(String[]args)
{
//使用next方法，空格之后的无法读取
//从键盘接收数据
Scanner scan=new Scanner(System.in);
//next方式接收字符串
System.out.println("next方式接收：");
//判断是否还有输入
if(scan.hasNext())//判断是否还有输入的数据
{
String str1=scan.next();//获取数据并将数据赋值给str1
System.out.println(str1);
}
scan.close();
//使用nextline方法
//从键盘接收数据
Scanner scan2=new Scanner(System.in);
System.out.println("nextline方法接收");
if(scan2.hasNextLine())
{
String str2=scan2.nextLine();
System.out.println(str2);
}
scan2.close();
}next()和nextline（）区别：
next（）：1、一定要读取有效字符之后才可以结束输入
2、对输入有效字符之前的空白，会自动将其去掉
3、只有输入有效字符后才将其后边的空白当成分隔符或者结束符
4、不能得到带空格的字符串
nextline（）：1、以enter为结束符，也就是说返回回车键之前的所有字符
2、可以获得空白字符
java异常处理
常见异常类型
经常出现的异常包含以下几大类：
因为用户发生的异常：
1、用户输入流非法数据
2、要打开的文件不存在
3、网络通信时连接中断，或者jvm内存溢出
因为物理错误引起的异常：
1、检查性异常
用try捕获
try {
// 可能会抛出异常的代码
} catch (IOException e) {
// 处理异常的代码
}
2、运行时异常
在编译时不强制性要求，通常是由程序中的错误引起的，这类异常可以原则处理，但并非强制性要求
3、错误
错误不是异常，而是脱离程序员控制的问题，错误在代码中通常被忽略，比如当栈溢出的时候，一个错误就发生了，它们在编译也检查不到
捕获异常：
使用try和catch关键字可以捕获异常，将代码放在可能出错的地方
代码块中的代码称为保护代码，catch语句包含要捕获异常类型的声明，
当保护代码中发生一个异常时，后面的catch就会被检查，如果异常发生在catch块中，异常会被传递到catch块，这和传递参数的方法是一样的
throw/throws关键字
用来处理异常，throw关键字用于在代码中抛出异常，throws关键字用于在方法声明中指定可能会抛出的异常类型
throw:
当代码执行到某一个条件下无法再继续执行时，可以使用throw关键字抛出异常，以告知调试者当前代码的执行状态
throws:
用于在方法声明中指定该方法可能抛出的异常，当方法内部抛出指定类型的异常时，该异常会被传力给调用该方法的代码，并且在该代码中处理异常
final异常：
final关键字用来创建在try代码块后面执行的代码块
无论是否发生异常，final代码块中的代码总是被执行
在final代码块中，可以运行清理类型等收尾善后性质的语句
final代码块出现在catch代码块最后
语法：
try{
// 程序代码
}catch(异常类型1 异常的变量名1){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}finally{
// 程序代码
}
声明自定义异常
在java中可以自定义异常，编写自己的异常类时，需要记住以下几点：
所有异常都必须是throwable的子类
如果希望写一个检查性异常类，那么需要继承RuntimrException类
class MyException extends Exception{
}
通用异常
在java中定义了两种类型的异常和错误
JVM（java虚拟机）异常：由JVM抛出的异常或者错误
程序级异常：由程序或者API程序抛出的异常
异常处理的最佳实践
在合适的位置进行捕获，对异常进行适当的处理。以确保程序的稳定性和可靠性
避免过度捕获异常，应该尽量精准捕获特定类型的异常
使用final块来十方资源，比如关闭文件、数据库等，以保证数据的正常链接
有限处理受检异常，避免将受检异常转换为非受检异常
java
//如果num<0,抛出一个异常
class yicghang{
public void checkNumber(int num) {
if (num < 0) {
throw new IllegalArgumentException("Number must be positive");
}
}
}
java
//try catch捕获异常
class ExcepTest{
public static void main(String args[]){
try{
int a[] = new int[2];
System.out.println("Access element three :" + a[3]);
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("Exception thrown :" + e);
}
System.out.println("Out of the block");
}
}继承
继承的概念
继承就是子类继承父类的行为和特征，使子类对象具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为 类的继承格式 class 父类 { } class 子类 extends 父类 { } supper关键字 java继承的类型：单继承、多重继承、不同类型继承同一个类、多继承（java不支持多继承）
//开发动物类，其中动物分别为企鹅以及老鼠，要求如下：
//
//企鹅：属性（姓名，id），方法（吃，睡，自我介绍）
//老鼠：属性（姓名，id），方法（吃，睡，自我介绍）
java
class qie{
private String name;
private int id;
public qie(String myname,int myid)
{
name=myname;
id=myid;
}
public void eat(){
System.out.println(name+"吃");
};
public void sleep() {
System.out.println(name + "睡");
}
public void introduction(){
System.out.println("大家好！我是"+name);
}
}
class mouse{
private String name;
private int id;
public mouse(String myname,int myid){
name=myname;
id=myid;
}
public void eat(){
System.out.println(name+"吃");
};
public void sleep() {
System.out.println(name + "睡");
}
public void introduction(){
System.out.println("大家好！我是"+name);
}
}
class animal{
private String name;
private int id;
public animal(String myname,int myid){
name=myname;
id=myid;
}
public void eat(){
System.out.println(name+"吃");
};
public void sleep() {
System.out.println(name + "睡");
}
public void introduction(){
System.out.println("大家好！我是"+name);
}
}
class qie1 extends animal{
public qie1(String myname, int myid) {
super(myname, myid);//调用父类的构造函数
}
class mouse02 extends animal{
public mouse02(String myname, int myid) {
super(myname, myid);
}
}
}supper关键字
1、访问父类的成员变量使用
这对于在子类中有相同名字的成员变量时很有用，以便明确指定你想要访问的是父类的成员变量
2、调用父类的构造函数
java
class qie1 extends animal{
public qie1(String myname, int myid) {
super(myname, myid);//调用父类的构造函数
}3、调用父类中的方法 super.print()//父类的print()方法