javaSE ———— 2021-08-23

最新推荐文章于 2024-09-15 19:46:31 发布

.zj..

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量120

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_45257570/article/details/119880291

版权

javaSE

- 一、IO流

二、重写规则
在重写方法时，需要遵循以下的规则：
(一) 父类方法的参数列表必须完全与被子类重写的方法的参数列表相同，否则不能称其为重写而是重载。

(二) 父类的返回类型必须与被子类重写的方法返回类型相同，否则不能称其为重写而是重载。

(三) Java中规定，被子类重写的方法不能拥有比父类方法更加严格的访问权限。编写过Java程序的人就知道，父类中的方法并不是在任何情况下都可以重写的，当父类中方法的访问权限修饰符为private时，该方法只能被自己的类访问，不能被外部的类访问，在子类是不能被重写的。如果定义父类的方法为public，在子类定义为private，程序运行时就会报错。

(四) 由于父类的访问权限修饰符的限制一定要大于被子类重写方法的访问权限修饰符，而private权限最小。所以如果某一个方法在父类中的访问权限是private，那么就不能在子类中对其进行重写。如果重新定义，也只是定义了一个新的方法，不会达到重写的效果。

(五) 在继承过程中如果父类当中的方法抛出异常，那么在子类中重写父类的该方法时，也要抛出异常，而且抛出的异常不能多于父类中抛出的异常(可以等于父类中抛出的异常)。换句话说，重写方法一定不能抛出新的检查异常，或者比被重写方法声明更加宽泛的检查型异常。例如，父类的一个方法申明了一个检查异常IOException，在重写这个方法时就不能抛出Exception，只能抛出IOException的子类异常，可以抛出非检查异常。同样的道理，如果子类中创建了一个成员变量，而该变量和父类中的一个变量名称相同，称作变量重写或属性覆盖。但是此概念一般很少有人去研究它，因为意义不大。
方法重载(Overloading)
方法重载是让类以统一的方式处理不同类型数据的一种手段。调用方法时通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法，这就是多态性。

所谓方法重载是指在一个类中，多个方法的方法名相同，但是参数列表不同。参数列表不同指的是参数个数、参数类型或者参数的顺序不同。

方法的重载在实际应用中也会经常用到。不仅是一般的方法，构造方法也可以重载。

在方法重载时，方法之间需要存在一定的联系，因为这样可以提高程序的可读性，一般只重载功能相似的方法。

重载是指我们可以定义一些名称相同的方法，通过定义不同的参数来区分这些方法，然后再调用时，Java虚拟机就会根据不同的参数列表来选择合适的方法执行。也就是说，当一个重载方法被调用时，Java用参数的类型或个数来决定实际调用的重载方法。因此，每个重载方法的参数的类型或个数必须是不同。

虽然每个重载方法可以有不同的返回类型，但返回类型并不足以区分所使用的是哪个方法。

当Java调用一个重载方法是，参数与调用参数匹配的方法被执行。在使用重载要注意以下的几点:
1.在使用重载时只能通过不同的参数列表，必须具有不同的参数列表。
2.不能通过访问权限、返回类型、抛出的异常进行重载。
3.方法的异常类型和数目不会对重载造成影响。
4.可以有不同的返回类型，只要参数列表不同就可以了。
5.可以有不同的访问修饰符。
6.可以抛出不同的异常。

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型呢？可以相同也可以不同。
每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
只能重载构造函数

四、重载规则
被重载的方法必须改变参数列表；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。

访问修饰符
在这里插入图片描述
六、总结
重写与重载之间的区别

方法重载：
1、同一个类中
2、方法名相同，参数列表不同（参数顺序、个数、类型）
3、方法返回值、访问修饰符任意
4、与方法的参数名无关

方法重写：
1、有继承关系的子类中
2、方法名相同，参数列表相同（参数顺序、个数、类型），方法返回值相同
3、访问修饰符，访问范围需要大于等于父类的访问范围
4、与方法的参数名无关
在这里插入图片描述

final的作用，throw和throws的区别，final finally finalize

① 可以用来修饰一个类
② 可以用来修饰一个方法
③ 可以用来修饰一个局部变量
④ 可以用来修饰一个成员变量
共同点
两者在抛出异常时，抛出异常的方法并不负责处理，顾名思义，只管抛出，由调用者负责处理。

区别
（1）throws用于方法头，表示的只是异常的申明，而throw用于方法内部，抛出的是异常对象。
（2）throws可以一次性抛出多个异常，而throw只能一个
（3）throws抛出异常时，它的上级（调用者）也要申明抛出异常或者捕获，不然编译报错。而throw的话，可以不申明或不捕获（这是非常不负责任的方式）但编译器不会报错。

总结
实际开发中，可以根据实际需求自定义异常，具体实现方式可以通过继承Exception类来进行实现。

一、IO流

1 File文件

Java中，java.io.File类表示一个目录（文件夹）或者一个文件

1 将一个时间戳转化日期格式

 //将一个时间戳转化日期格式
  		File file = new File("d:/java/peject");
        SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss" );
        long time = file.lastModified();//文件最后修改时间  time：时间戳的格式
        Date date = new Date(time);//    new Date():当前时间
        String format = sd.format(date);
        System.out.println(format);

将一个字符串类型转成Date类型： String 转 Date

   //string 强转date类型
  //获取当前系统时间
  SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat(“YYYY-MM-dd HH:mm:ss”);
  String str = simpleDateFormat1.format(new Date());
  //string 强转date类型
  Date dateTime1 = simpleDateFormat1.parse(str);

2 使用递归输出文件夹下的所有文件

File file = new File("d:/java/peject");
        File[] files = file.listFiles();
        if(files != null){
            for (File f : files){
                if(f.isDirectory()){
                    System.out.println(f.getPath());
                }else {
                    System.out.println(f.getName());
                }
            }
        }

3 File常用方法

		File file = new File("d:/java/project");
		canRead()//是否可读
		canWrite()//是否可写
		 System.out.println(file.isDirectory());//是否是目录
        System.out.println(file.exists());//true  该文件或目录是否存在
        System.out.println(file.createNewFile());//false  此目录不存在时，创建一个指定的目录
        System.out.println(file.isAbsolute());//true  是否为绝对路径名
        System.out.println(file.getParent());//d:/java  返回目录父目录的路径名字符串
        System.out.println(file.getName());//project  此抽象路径名表示的文件或目录名称
        System.out.println(file.getPath());//d:/java/project  转换为一个路径名
        System.out.println(file.getAbsolutePath());//d:java/project  绝对路径名
        System.out.println(file.getAbsoluteFile());//d:java/project  绝对路径名
        System.out.println( file.mkdir()); //创建此抽象路径名指定的目录
        String[] files = file.list();//返回该file中的文件或目录名称
        File[] files1 = file.listFiles();//返回该file中的文件或目录名称

2 字节流

输入流：java.io.InputStream
输出流：java.io.OutputStream

字节流:

1 字节流 `FileInputStream FileOutputStream`

package com.hisoft.io;
import java.io.*;

public class InputOutStream {
    public static void main(String[] args) throws IOException {

        File file = new File("D:/img/5.jpg");
        FileInputStream fis = new FileInputStream(file);//输入流对象

        File fil = new File("D:/img/6.jpg");
        FileOutputStream fos = new FileOutputStream(fil);//输出流对象

        byte[] buffer = new byte[1024];//1KB
        int len = -1;
        while ((len = fis.read(buffer)) != -1) {
            fos.write(buffer, 0, len);
        }
        fos.flush();//刷新缓冲流 防止还有数据读取完但是还没有写完
        fos.close();
        fis.close();

    }
}

2 字节流 `BufferedInputStream BufferedOutputS`

public class InputOutStream {
    public static void main(String[] args) throws IOException {


        FileInputStream fis = new FileInputStream(new File("d:/img/5.jpg"));//输入流对象
        FileOutputStream fos = new FileOutputStream(new File("d:/img/6.jpg"));//输出流对象

        //装饰着模式   缓冲流
        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        int len = -1;
        while ((len = bis.read()) != -1) {
            bos.write(len);
        }
        bis.close();
        bos.close();
	 }
 }

3 字节流 `DataOutputStream DataInputStream`

public class InputOutStream {
    public static void main(String[] args) throws IOException {

        //将基本数据类型写进去d:/img/1.text中
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("d:/img/1.text"));
        dos.writeInt(10);
        dos.writeUTF("数据流");
        dos.writeDouble(12.0);
        dos.flush();
        dos.close();

        //从d:/img/1.text中读取数据输出在控制台
        DataInputStream dis = new DataInputStream(new FileInputStream("d:/img/1.text"));
        System.out.println( dis.readInt());
        System.out.println(dis.readUTF());
        System.out.println(dis.readDouble());
        dis.close();
	}
}

4 字节流 `ObjectOutputStream ObjectInputStream`序列化

1 序列化后的类的对象才可以被ObjectOutputStream和ObjectInputStream使用(对象流)
2 参与序列化与反序列化的类必须实现java.io. Serializable接口，并推荐生成序列化ID
3 静态属性不参与序列化与反序列化操作
4 父类可以序列化，那么子类必然可以序列化，无论子类是否实现java.io.Serializable接口
5 类序列化时，属性引用的对象也会被序列化
6 不参与序列化操作的属性需要标记为transient

public class User implements Serializable {
    private static final long serialVersionUID = -8332118031131546027L;//序劣化id
    public int id;
    public String name ;
    public transient int age ;//该属性不会被序列化
    public String password;
    
}***User*******
%********%
public class InputOutStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {

        //序列化:把一个java对象写入外部文件
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:/img/2.text"));
        User user = new User(1, "rose", 12, "123");
        oos.writeObject(user);

        //反序列化:从外部文件读取一个Java对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/img/2.text"));
        Object obj = ois.readObject();
        User use = (User) obj;
        System.out.println(use);
	}
}

3 转换流(功能流)

图示：

1 转换流 `OutputStreamWriter` `InputStreamReader`

public class InputOutStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {

        //输出转换流（也就是写入字符）
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d:/img/3.text"), "utf-8");
        osw.write(10);
        osw.write("转化流");
        osw.write("转化流");
        osw.flush();
        osw.close();

        //输入转换流（也就是读取字符）
        InputStreamReader isr = new InputStreamReader(new FileInputStream("d:/img/3.text"), "utf-8");
        char[] buffer = new char[1024];
        StringBuilder sb = new StringBuilder();//可以调用append方法拼接字符串
        String str = null;
        StringBuilder string = null;

        int len = -1;
        while ((len = isr.read(buffer)) != -1) {
            str = new String(buffer, 0, len);
            string = sb.append(str);//拼接输出
        }
        System.out.println(string);
        isr.close();
   }
}

2 字符流`BufferedWriter BufferedReader`

public class InputOutStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //输出转换流（也就是写入字符）
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File("d:/img/3.text"))));
        bw.write(10);
        bw.write("转化流");
        bw.write("转化流");
        bw.flush();
        bw.close();
        //输入转换流（也就是读取字符）
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("d:/img/3.text"))));

        StringBuilder sb = new StringBuilder();//可以调用append方法拼接字符串
        String str = null;
        while ((str = br.readLine()) != null) {
            sb.append(str);
        }
        System.out.println(sb);

3 字符流 `FileWriter FileReader`

public class InputOutStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //写出
        FileWriter fw = new FileWriter("d:/img/10.text",true);
        fw.write("字符流");
        fw.write("文件");
        fw.flush();
        fw.close();
        //读入
        FileReader fr = new FileReader("d:/img/10.text");
        char[] buffer = new char[512];																																																																																																																																																																																													
        int len = -1;
        while ((len = fr.read(buffer)) != -1) {
            String str = new String(buffer,0,len);																																																																																																																																																																																										            System.out.println(str);          																																																																																									
        }     
         fr.close(); 
	}
}