JavaSE学习笔记（3）

IO流：

        作用: 复制各种类型文本（字节流 & 字符流）

        读进来（input）、写出去（output）

流程：

        源文件--读进来(FileInputStream输入流类)--中转--写出去(FileOutputStream输出流类)--目标

        以Stream结尾的一般都是字节流。顶级类：InputStream、OutputStream 按字节传递

        Reader/Writer结尾的一般是字符流。顶级类：Reader、Writer 按字符传递

File类：

File file = new File("D:/bj"); // 获得目录
File[] files = file.listFiles(); // 获得当前目录下的所有文件与文件夹（深层无法获得）
File[] files = file.existe(); // 判断当前文件是否存在

字节流：FileInputStream（读进来）、FileOutputStream（写出去）

// 完成一个文件的复制 把 D:/bj.txt 复制 D:/bj2.txt
// [1] 创建流
InputStream input = new FileInputStream("D:/bj.txt");
OutputStream output = new FileOutputStream("D:/bj2.txt");
// [2] 使用流
int n = input.read();
while(n != -1){
    output.write(n);
    n = input.read();
}
// [3]关闭流
output.close;
input.close;

         如上为正常情况 使用中转方式为 1字节 、数组读取速度快，也就是说把原有的一次中转1字节改为一次中转1024字节

InputStream input = new FileInputStream("D:/bj.txt");
OutputStream output  = new FileOutputStream("D:/bj2.txt");
byte[] bytes = new byte[1024];
int n = input.read(bytes); // 读取的内容存到数组中，返回的就是读取内容长度
while (n != -1){
    output.write(bytes,0,n); // 写入数据。从0开始到n结束 以免写入空格 
    n = input.read(bytes);
}

            

缓冲流：

        作用：提升当前的读取速度

        概念： 相当于使用流里的数组平替，名为缓冲区，长度为8192

// 创建一个流
InputStream  input = new FileInputStream("D:/syd.txt");
OutputStream output = new FileOutputStream("D:/syd2.txt");
// 默认输入输出 缓冲区
BufferedInputStream bis = new BufferedInputStream(input);
BufferedOutputStream bos = new BufferedOutputStream(output);
// 准备一个中转
int n = bis.read();
bos.write(n);
while (n != -1){
    bos.write(n);
    n = bis.read();
}
// 关闭流
bis.close();
bos.close();

打印流：PrintStream、PrintWriter 只有输出流、没有输入流

        System.out、System.err 是 PrintStream的实例变量

bollean a = true;
PrintStream p = new PrintStream("D:/bj.txt");
p.print(a); // 直接打印到文件夹
p.close(); 

        字节无论打印什么都行，字符只能打印汉字、数字等文本

        字符速度比字节略快。

反射：

        概念： 通过对象的一些参数内容把对象创建出来。通过class类加载去获得参数内容

        反射创建对象的优点：

                        【1】知道一个String类型的路径，使用此就可以创建对象

                        【2】即使是私有权限的，使此仍可以访问

        反射创建对象的缺点：

                        【1】书写不便、可读性差

                        【2】暴力访问私有方法（是优也是缺）

获得class对象的三种方式：

        方式一：

                Class clazz = Class.forName("com.co.syd.User"); 

        方式二：

                Class clazz = User.class; 单纯获得类内信息用

        方式三：

                String str = "123";

                Class clazz = str.getclass();

        用反射创建对象 [必须要全路径]

        String str = "com.co.syd.User"

        类加载：获得一个类的结构

        Class clazz = Class.forName(str);  反射入口

        创建User对象，o就是User对象为Object类

        Object o = clazz.newInstance();

[A] class基本方法：

clazz.getPackage(); // 获得当前类所在的包
clazz.getName(); // 获得全路径
clazz.getSimpleName(); // 获得单独的类名
clazz.getSuperclass(); // 获得当前类的父类
clazz.getInterfaces(); // 获得当前类的接口

[B] 获得构造方法：

Constructor[] c = clazz.getConstructors(); // 获得所有构造方法
// 只能用Pubilc修饰
{
Constructor[] c = clazz.getConstructor(); // 获得无参构造器
Constructor[] c = clazz.getConstructor(String.class); // 获得有参构造
}
// 用什么修饰都可以
Constructor[] c = clazz.getDeclaredConstructor(String.class); //  返回一个构造函数对象

[C] 获得类中属性：

// 只可以是Pubilc修饰
{
clazz.getFields(); // 获得类中所有的属性 父类中也会获得
clazz.getField(); // 获得类中单个的属性
}
clazz.getDeclaredFields(); // 无法获得父类中属性，但会获得本类所有权限的属性

[D] 获得类中方法：

clazz.getMethods(); // 获得所有Public修饰的方法（子类 & 父类）
clazz.getMethod("aa",String.class);
clazz.getSuperclass.DeclaredMethods(); // 获得父类的所有方法

 使用反射调用方法：

         【1】类加载

                       class c = class.forName("~~~~");

         【2】创建对象

                        object o = c.getConstructor.newInstance();

         【3】获得方法对象

                        Method method = c.getMethod("a");

         【4】调用指定对象中的方法

                        method.invoke(stu);  调用对象中方法

                        method.invoke(stu,"sxt",123); 如果对象中方法有参数的话