java03

目录

一、Java 流(Stream)、文件(File)和IO

java流（Stream）

java文件操作

java io

二、java Scanner类

next()和nextline（）区别：

三、java异常处理

 常见异常类型

throw/throws关键字

final异常：

通用异常

四、继承

继承的概念

supper关键字

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

//创建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常见操作

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类创建、删除、检查文件和目录的属性等

//创建文件和目录
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库提供了多种输入输出流类，用于处理字节和字符数据，主要分为字节流和字符流两种

//字节流
//字节流用于处理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);
数据输入

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块来十方资源，比如关闭文件、数据库等，以保证数据的正常链接
有限处理受检异常，避免将受检异常转换为非受检异常

//如果num<0,抛出一个异常
class yicghang{
    public void checkNumber(int num) {
        if (num < 0) {
            throw new IllegalArgumentException("Number must be positive");
        }
    }
}

//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），方法（吃，睡，自我介绍）

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、调用父类的构造函数

class qie1 extends animal{
    public qie1(String myname, int myid) {
            super(myname, myid);//调用父类的构造函数
    }

3、调用父类中的方法    super.print()//父类的print()方法