面向对象
继承
extends
私有的东西无法被继承
所有类是继承于 java.lang.Object
当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。
申明一个类从另外一个类继承而来
class 父类 {
}
class 子类 extends 父类 {
}
继承类型
java支持多重继承，不支持多重继承
继承特性
单继承
punlic classA(){
.....
}
public classB() extends A{
}
多重继承
punlic classA(){
.....
}
public classB() extends A{
}
public classC() extends B{
}
不同类继承同一类
punlic classA(){
.....
}
public classB() extends A{
}
public classC() extends A{
}
不支持多继承
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AlLPQ9i4-1626616459931)(C:\Users\HuEris\AppData\Roaming\Typora\typora-user-images\image-20210714192534678.png)]
punlic classA(){
.....
}
public classC() extends A，B{
}
implements
变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。
public interface A {
public void eat();
public void sleep();
}
public interface B {
public void show();
}
public class C implements A,B {
}
super
实现对父类成员的访问
public Student() {
//隐藏:调用父类构造器
//调用父类构造器，必须在子类构造器第一行
super();
//this();
System.out.println("student无参执行了");
}
注意点
super 调用父类构造方法，必须在构造方法第一个
super 必须在只能出现在子类方法或者构造方法中
super和this不能同时调用构造方法
与this区别
代表对象不同
this：本身调用者这个对象
super：代表父类对象的应用
前提
this：没有继承也可使用
super：只有在继承条件下可以使用
构造方法
this（）：本类的构造
super（）：父类的构造
this
向自己的引用
方法重写
alt+insert-》overread
1.**要有继承关系，子类重写父类方法 ** 方法必须一致（方法体不同）
2.方法名必须相同
3.参数列表必须相同
4.修饰符：范围可以扩大，但不能缩小;
(public->Protected->Default->private)
5.抛出的异常:范围之可以扩大，不可以缩小
ClassNotFoundException-》Exception（大）
WHY
1.父类的功能，子类不一定需要，或者不一定满足
重写与重载之间的区别
| 区别点 | 重载方法 | 重写方法 |
|---|---|---|
| 参数列表 | 必须修改 | 一定不能修改 |
| 返回类型 | 可以修改 | 一定不能修改 |
| 异常 | 可以修改 | 可以减少或删除，一定不能抛出新的或者更广的异常 |
| 访问 | 可以修改 | 一定不能做更严格的限制（可以降低限制） |
封装
关键字 private
优点：
- 良好的封装能够减少耦合。
- 类内部的结构可以自由修改。
- 可以对成员变量进行更精确的控制。
- 隐藏信息，实现细节。
属性私有 get，set
alt+insert ->get and set ->选择属性
学生类：
//类 private：私有
public class pri {
//属性私有
private String name;
private int id;
private char sex;
//不能直接引用
// 要通过 public 的get，set方法
//get获得数据
public String getname(){
return this.name;
}
//set 设置值
public void setname(String name){
this.name=name;
}
this
解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。
主类
//一个项目应该只存一个main方法public class Appication { public static void main(String[] args) { pri p1=new pri(); //不能直接用p1.name; //因为属性是私有的 p1.setname("hu");//先进行set System.out.println(p1.getname());//在get值 }}
1.一个项目应该只存一个main方法，新建一个类进行构造
public class Appication { public static void main(String[] args) { //new实例化了一个对象 person per=new person("huxiangxiang"); System.out.println(per.name);//null }}
2.有参构造
//有参构造：一旦定义了有参构造，无参必须显示定义public person(String name){ this.name=name;}
3.无参
public person(){}
4.方法名和类名相同
没有返回值
5.作用
new本质再调用构造方法
初始化对象的值
6.注意点
定义有参构造后，想使用无参构造，显示的定义一个无参的构造
7.快捷键
构造参数使用 alt+insert
无参：constructor select none
有参：constructor ok
多态
注意
多态是方法的多态，属性没有多态性
父类和子类，有联系，否则类型转换异常（ClassCastException）
存在条件：
有继承关系，
方法需要重写，
父类引用 指向子类对象 Parent p = new Child();
没有重写就没有多态
不能重写的方法有：
static，方法属于类，不属于实例
final 常量池里面
private 是私有的，私有的方法不能重写
//对象的实际类型是确定的
//new A();
//new B();
//
A s=new A();//子类
B s1=new A();//父类引用指向子类
s.run();
s1.run();//子类重写了父类的方法，执行子类
//子类调用的方法是自己的或父类
//父类可以引用子类的，不能调用父类的方法
instanceof
System.out.println(x instanceof y) true / false
可以判断是否存在父子关系
类型之间的转换
低到高 自动转换
高到低 强制转换
父 》 子
高 》 低
Person stu = new Student（）；
Student stu=（Student）stu；
stu 就是可以使用Student 的方法了
子》父
可能会丢失一些方法
抽象类
abstract
修饰类
//抽象类
//类需要被继承 extends（接口可以多继承）
public abstract class A {
//抽象方法，只有方法名字，无方法实现
//约束
public abstract void dosome();
//不能new这个抽象类，只能靠子类去实现：约束
//类存在了抽象方法，必须是抽象类
//普通类可以存在抽象方法
}
抽象类可以有构造方法，只是不能直接创建抽象类的实例对象而已。在继承了抽象类的子类中通过super()或super(参数列表)调用抽象类中的构造方法
接口
只有规范**，无法自己写方法~专业的约束，约束和实现分离：面向接口编程*
接口无法被实例化，但是可以被实现。
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
声明类关键字是class
声明接口的关键字是interface
[可见度] interface 接口名称 [extends 其他的接口名] {
// 声明变量
// 抽象方法
}
//类可以实现接口 implement 接口
//实现接口的类，就需要重写接口中的方法
//实现多继承
public class Aampl implements A,AB{
@Override
public void test(String a) {
}
@Override
public void add(String name) {
}
//interface 声明接口关键字，接口都需要有实现类
public interface A {
//接口中所有定义其实都是抽象的 public abstract
void add(String name);
}
public interface AB {
void test(String a);
}
接口作用
1、约束
2.定义一些方法，让不同人实现
3.方法都是 public abstract
4.常量都是 public static final
5.接口不能被实例化，接口中没有构造方法
6.implements 可以实现多个接口，里面必须要重写方法
异常
两大类
处理异常对象：java.lang.Throwable
错误ERROR
异常EXCEPTION
类型
检查性异常：
运行时异常：
出错：
Java 根据各个类库也定义了一些其他的异常，下面的表中列出了 Java 的非检查性异常。
| 异常 | 描述 |
|---|---|
| ArithmeticException | 当出现异常的运算条件时，抛出此异常。例如，一个整数"除以零"时，抛出此类的一个实例。 |
| ArrayIndexOutOfBoundsException | 用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引。 |
| ArrayStoreException | 试图将错误类型的对象存储到一个对象数组时抛出的异常。 |
| ClassCastException | 当试图将对象强制转换为不是实例的子类时，抛出该异常。 |
| IllegalArgumentException | 抛出的异常表明向方法传递了一个不合法或不正确的参数。 |
| IllegalMonitorStateException | 抛出的异常表明某一线程已经试图等待对象的监视器，或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。 |
| IllegalStateException | 在非法或不适当的时间调用方法时产生的信号。换句话说，即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。 |
| IllegalThreadStateException | 线程没有处于请求操作所要求的适当状态时抛出的异常。 |
| IndexOutOfBoundsException | 指示某排序索引（例如对数组、字符串或向量的排序）超出范围时抛出。 |
| NegativeArraySizeException | 如果应用程序试图创建大小为负的数组，则抛出该异常。 |
| NullPointerException | 当应用程序试图在需要对象的地方使用 null 时，抛出该异常 |
| NumberFormatException | 当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。 |
| SecurityException | 由安全管理器抛出的异常，指示存在安全侵犯。 |
| StringIndexOutOfBoundsException | 此异常由 String 方法抛出，指示索引或者为负，或者超出字符串的大小。 |
| UnsupportedOperationException | 当不支持请求的操作时，抛出该异常。 |
下面的表中列出了 Java 定义在 java.lang 包中的检查性异常类。
| 异常 | 描述 |
|---|---|
| ClassNotFoundException | 应用程序试图加载类时，找不到相应的类，抛出该异常。 |
| CloneNotSupportedException | 当调用 Object 类中的 clone 方法克隆对象，但该对象的类无法实现 Cloneable 接口时，抛出该异常。 |
| IllegalAccessException | 拒绝访问一个类的时候，抛出该异常。 |
| InstantiationException | 当试图使用 Class 类中的 newInstance 方法创建一个类的实例，而指定的类对象因为是一个接口或是一个抽象类而无法实例化时，抛出该异常。 |
| InterruptedException | 一个线程被另一个线程中断，抛出该异常。 |
| NoSuchFieldException | 请求的变量不存在 |
| NoSuchMethodException | 请求的方法不存在 |
异常方法
下面的列表是 Throwable 类的主要方法:
| 序号 | 方法及说明 |
|---|---|
| 1 | public String getMessage() 返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。 |
| 2 | public Throwable getCause() 返回一个Throwable 对象代表异常原因。 |
| 3 | public String toString() 使用getMessage()的结果返回类的串级名字。 |
| 4 | public void printStackTrace() 打印toString()结果和栈层次到System.err，即错误输出流。 |
| 5 | public StackTraceElement [] getStackTrace() 返回一个包含堆栈层次的数组。下标为0的元素代表栈顶，最后一个元素代表方法调用堆栈的栈底。 |
| 6 | public Throwable fillInStackTrace() 用当前的调用栈层次填充Throwable 对象栈层次，添加到栈层次任何先前信息中。 |
捕获异常
选中有异常语句 ：ctrl+alt+T
使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。
try/catch代码块中的代码称为保护代码，使用 try/catch 的语法如下：
try
{
// 程序代码
}catch(ExceptionName e1)
{
//Catch 块
}
Catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try 后面的 catch 块就会被检查。
如果发生的异常包含在 catch 块中，异常会被传递到该 catch 块，这和传递一个参数到方法是一样。
多重捕获块：
层层递进，最大的在最后面
try{
// 程序代码
}catch(异常类型1 异常的变量名1){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}catch(异常类型3 异常的变量名3){
// 程序代码
}
finally关键字
finally 关键字用来创建在 try 代码块后面执行的代码块。
无论是否发生异常，finally 代码块中的代码总会被执行。
在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。
try{
// 程序代码
}catch(异常类型1 异常的变量名1){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}finally{
// 程序代码
}
- catch 不能独立于 try 存在。
- 在 try/catch 后面添加 finally 块并非强制性要求的。
- try 代码后不能既没 catch 块也没 finally 块。
- try, catch, finally 块之间不能添加任何代码。
实例：
public static void main(String[] args) {
try{//======try 监控区域
int e=1/0;
System.out.println(e);
} catch (ArithmeticException e ){ //=======捕获异常 想要捕获的异常类型
System.out.println("程序出错，除数不能为0");
}finally{ //=========处理善后工作
System.out.println("结束");
}
//finally 可以不要，try，catch必须得要
在方法上抛出异常，在 main() 方法中使用 try catch 捕获异常，并输出异常信息。代码如下：
thorws方法的头部声明这个异常
import java.io.FileInputStream;
import java.io.IOException;
public class Test04 {
public void readFile() throws IOException {
// 定义方法时声明异常
FileInputStream file = new FileInputStream("read.txt"); // 创建 FileInputStream 实例对象
int f;
while ((f = file.read()) != -1) {
System.out.println((char) f);
f = file.read();
}
file.close();
}
public static void main(String[] args) {
Throws t = new Test04();
try {
t.readFile(); // 调用 readFHe()方法
} catch (IOException e) {
// 捕获异常
System.out.println(e);
}
}
}
throw用来直接拋出一个异常，后接一个可拋出的异常类对象，在方法体中
//在方法上抛出异常
public void test(int a,int b) throws ArithmeticException{
if (b==0){
throw new ArithmeticException();//主动抛出异常，一般用于方法中
}
System.out.println(a/b);
}
自定义异常
- 所有异常都必须是 Throwable 的子类。
- 如果希望写一个检查性异常类，则需要继承 Exception 类。
- 如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。
总结
-
处理运行时异常，采用合理规避同时辅助try catch处理
-
多重catch 后，加一个catch（Exception）处理遗漏的异常
-
对于不确定代码，加上try catch，处理潜在异常
-
Alt+Enter会提示你怎么去处理异常
-
尽量去处理异常，不要只简单的调用printStackTrace（）去打印
-
尽量添加finally语句去释放占用资源
网络编程
目的
1.直接或间接地通过网络协议与其它计算机实现数据交换，进行通讯。
要素
IP地址和端口号
网络通信协议:UDP,TCP
如何实现
① 通信双方地址：IP和端口号
② 一定的规则（即：网络通信协议。有两套参考模型）
TCP/IP参考模型(或TCP/IP协议)：事实上的国际标准
Ip地址和端口号
1.InetAddress类代表IP
- 一的标识 Internet 上的计算机（通信实体）
- 本地回环地址(hostAddress)：127.0.0.1 主机名(hostName)：localhost
/*
1 java中使用InetAddress代表IP
2 IP的分类：IPV4和IPV6 万维网和局域网
3 域名：www.baidu.com www.cnblogs.com
4 本地回路地址：127.0.0.1 对应着：localhost
5 如何实例化InetAddress类的对象，两个静态方法：
InetAddress getByName(String host)
InetAddress getLocalHost()
6 两个常用方法
getHostName()
getHostAddress()
7 端口号：正在计算机上运行的进程
*/
public class InetAddressTest {
public static void main(String[] args){
try {
// File file = new File("test.txt");
InetAddress IP1 = InetAddress.getByName("192.168.3.2");
System.out.println(IP1);
InetAddress IP2 = InetAddress.getByName("www.baidu.com");
System.out.println(IP2);
// 获取本地IP
InetAddress localHost = InetAddress.getLocalHost();
System.out.println(localHost);
// getHostName()
System.out.println(IP2.getHostName());
// getHostAddress()
System.out.println(IP2.getHostAddress());
} catch(UnknownHostException e){
e.printStackTrace();
}
}
}
端口号
- 端口号就是标识正在计算机上运行的进程（程序）
- 不同的进程有不同的端口号
- 被规定为一个 16 位的整数 0~65535。
- 端口号与IP地址的组合得出一个网络套接字：Socket
端口分类：
① 公认端口：0~1023。被预先定义的服务通信占用（如：HTTP占用端口 80，FTP占用端口21，Telnet占用端口23）
② 注册端口：1024~49151。分配给用户进程或应用程序。（如：Tomcat占 用端口8080，MySQL占用端口3306，Oracle占用端口1521等）。
③ 动态/私有端口：49152~65535
通信协议TCP和UDP
TCP协议：
✔ 使用TCP协议前，须先建立TCP连接，形成传输数据通道
✔ 传输前，采用“三次握手”方式，点对点通信，是可靠的
✔ TCP协议进行通信的两个应用进程：客户端、服务端。
✔ 在连接中可进行大数据量的传输
✔ 传输完毕，需释放已建立的连接，效率低
服务端
1.自己要拥有一个端口号地址
2.等待客户端连接过来
3.读取客户端信息
4.管道流输出
5.关闭，从小到大
客户端
1.要知道服务器地址，端口号
2.创建socket连接
3.发送IO流、
4。关闭从小到大
UDP协议：
✔ 将数据、源、目的封装成数据包，不需要建立连接
✔ 每个数据报的大小限制在64K内
✔ 发送不管对方是否准备好，接收方收到也不确认，故是不可靠的
✔ 可以广播发送
✔ 发送数据结束时无需释放资源，开销小，速度快
客户端
//1.建立 一个Socket
DatagramSocket datagramSocket = new DatagramSocket();
//2.建立包
String msg="你你好啊";
//发送给谁
InetAddress inetAddress=InetAddress.getByName("localhost");
int port=999;
//3.发送包
//数据 数据长度起始 发送给谁
DatagramPacket datagramPacket = new DatagramPacket(msg.getBytes(),0,msg.getBytes().length);
//关闭流
datagramSocket.close();
服务端
//还是要等待客户端
public class UdpS {
public static void main(String[] args) {
//开放端口
try {
DatagramSocket datagramSocket = new DatagramSocket();
//接收数据包
byte[] bytes = new byte[1024];
DatagramPacket datagramPacket = new DatagramPacket(bytes,0,bytes.length);
datagramSocket.receive(datagramPacket);
System.out.println(datagramPacket.getAddress().getHostName());
datagramSocket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Socket编程（套接字）
1.网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标识符套接字。
2.Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gzYHMSBQ-1626616459937)(C:\Users\HuEris\AppData\Roaming\Typora\typora-user-images\image-20210717093721488.png)]
客户端Socket的工作过程包含以下四个基本的步骤：
**1.**创建 Socket：根据指定服务端的 IP 地址或端口号构造 Socket 类对象。若服务器端响应，则建立客户端到服务端的通信路线。若连接失败，则会出现异常。
**2.**打开连接到 Socket 的输入/出流： 使用 getInputStream()方法获得输入流，使用 getOutputStream()方法获得输出流，进行数据传输
3.按照一定的协议对 Socket 进行读/写操作：通过输入流读取服务器放入线路的信息(但不能读取自己放入路线的信息)，通过输出流将信息写入线程
**4.**关闭 Socket：断开客户端到服务器的连接，释放线路
服务器(服务端)程序的工作过程包含以下四个基本的步骤：
1.调用 ServerSocket(int port) ：创建一个服务器端套接字，并绑定到指定端口 上。用于监听客户端的请求。
2.调用 accept()：监听连接请求，如果客户端请求连接，则接受连接，返回通信 套接字对象。
3.调用 该Socket类对象的 getOutputStream() 和 getInputStream ()：获取输出 流和输入流，开始网络数据的发送和接收。
4.关闭ServerSocket和Socket对象：客户端访问结束，关闭通信套接字。
服务器必须事先建立一个等待客户请求建立套接字 连接的ServerSocket对象
TCP编程实现C/S文件传输
实现功能：客户端发送文件给服务端，服务端将文件保存在本地。
/**
* @description: TCP编程，客户端发送文件给服务端，服务端将文件保存在本地。
* @author: laizhenghua
* @date: 2020/11/28 20:08
*/
public class TCPSocketTest {
/* 客户端 */
@Test
public void client() {
Socket socket = null;
OutputStream writer = null;
BufferedInputStream bis = null;
try {
socket = new Socket(InetAddress.getByName("127.0.0.1"),8089);
writer = socket.getOutputStream();
bis = new BufferedInputStream(new FileInputStream(new File("me.jpg")));
byte[] buffer = new byte[1024];
int len;
while((len = bis.read(buffer)) != -1){
writer.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if(socket != null){
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(writer != null){
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(bis != null){
try {
bis.close();
System.out.println("发送成功！");
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/* 服务端 */
@Test
public void server() throws IOException { // 这里异常应该使用try-catch-finally
ServerSocket socket = new ServerSocket(8089);
System.out.println("正在等待客户端连接...");
Socket clientSocket = socket.accept();
System.out.println("客户端已连接IP地址为："+clientSocket.getInetAddress().getHostName());
InputStream is = clientSocket.getInputStream();
BufferedOutputStream reader = new BufferedOutputStream(new FileOutputStream(new File("new_me.jpg")));
byte[] buffer = new byte[1024];
int len;
while((len = is.read(buffer)) != -1){
reader.write(buffer,0,len);
}
System.out.println("接收成功");
socket.close();
clientSocket.close();
is.close();
reader.close();
}
}
IO流
分类
处理数据：字符流，字节流
数据流向：输入流，输出流
字符流基于字节流
字符流
1·以字符为单位
2.只能处理字符类型数据
3.会用到缓冲区
字节流
1·以字节为单位
2能处理所有类型的数据
3.不会用到缓冲区，直接在文件里操作
优先选择字节流
输入流和输出流
输入是进行读
输出是进行写
InputStream
1.是所有输入字节流的父类,是一个抽象类
2.介质流
ByteArrayInputStream 从Byte数组
StringBufferInputStream StringBuffer
FileInputStream 本地文件
PipedInputStream 从与其它线程共用的管道中读取数据
3.装饰流
ObjectInputStream
FilterInputStream所有的子类
4.文件分离器File.separator
作用相当于 ’ ’ 在 windows 中 文件文件分隔符 用 ’ '
5.读文件内容可能大可能小
先知道文件路径
实例化File
实例化文件输出流
/**
* 字节流
* 读文件内容,节省空间
* */
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName="D:"+File.separator+"hello.txt";
File f=new File(fileName);
InputStream in=new FileInputStream(f);
byte[] b=new byte[(int)f.length()];//文件内容
in.read(b);
System.out.println("文件长度为："+f.length());
in.close();
System.out.println(new String(b));
}
}
6.不知道文件大小
int count =0;
int temp=0;
while((temp=in.read())!=(-1)){
b[count++]=(byte)temp;
}
注意：当读到文件末尾的时候会返回-1.正常情况下是不会返回-1的。
DataInputStream
DataInputStream input = new DataInputStream(new FileInputStream(file));
char[] ch = new char[10];
int count = 0;
char temp;
while((temp = input.readChar()) != 'C'){
ch[count++] = temp;
}
OutputStream
1.输出字节流的父类，抽象类
2。介质流
ByteArrayOutputStreamByte 向数组写入数据
FileOutputStream 本地文件写入数据
3.装饰流
ObjectOutputStream
FilterOutputStream的子类都是装饰流。
管道流
/**
* 测试类
* */
class hello{
public static void main(String[] args) throws IOException {
Send send=new Send();
Recive recive=new Recive();
try{
//管道连接
send.getOut().connect(recive.getInput());
}catch (Exception e) {
e.printStackTrace();
}
new Thread(send).start();
new Thread(recive).start();
}
压缩文件
具体看：https://www.cnblogs.com/QQ846300233/p/6046388.html
PrintStream
outputStream 屏幕输出
1.system.in
2.system.out
3.system.err（ System.err.println(“这些在文件中才能看到哦！”``);）
字符输入流
Reader输入字符流父类
介质流;
CharReader char数组
StringReader String中
PipedReader 是从与其它线程共用的管道中读取数据。
BufferedReader 很明显就是一个装饰器，它和其子类负责装饰其它Reader 对象。
FilterReader 是所有自定义具体装饰流的父类，其子类PushbackReader 对Reader 对象进行装饰，会增加一个行号。
InputStreamReader 是一个连接字节流和字符流的桥梁，它将字节流转变为字符流。
FileReader可以说是一个达到此功能、常用的工具类。
循环判断是否结束，不知道文件有多大
字符输出流
Writer 是所有的输出字符流的父类，它是一个抽象类。
介质流
CharArrayWriter、Char 数组
StringWriter 、String 中写入数据。
PipedWriter 是向与其它线程共用的管道中写入数据，
BufferedWriter 是一个装饰器为Writer 提供缓冲功能。
PrintWriter 和PrintStream 极其类似，功能和使用也非常相似。
OutputStreamWriter 是OutputStream 到Writer 转换的桥梁，它的子类FileWriter 。
向文件写入数据
/**
* 字符流
* 写入数据
* */
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName="D:"+File.separator+"hello.txt";
File f=new File(fileName);
Writer out =new FileWriter(f);
String str="hello";
out.write(str);
out.close();
}
}
Writer out =new FileWriter(f,true);
追加数据、换行
使用“\r\n”
比如将str变为String str="\r\nhello";
字符和字节转换
具体的对象体现：
InputStreamReader:字节到字符的桥梁 读入
OutputStreamWriter:字符到字节的桥梁 写出
File类
(https://www.cnblogs.com/QQ846300233/p/6046388.html)
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
