2023年JAVA课堂笔记基础详细解释.doc

JAVA编程基础—课堂笔记详解
1）课程使用的开发环境：
l bin:文献中重要是包含我们此后要用到的命令
l lib:重要包含java开发过程中要用到的java包
2）环境变量的配置
l 假如使用ecplise等开发工具，则不配置环境变量也是可以正常使用jdk等功能，但是在dos中却使用不了，配置环境变量则可以在dos中使用
l 环节：
右击我的电脑—》属性—》高级—》环境变量—》编辑系统变量中的path（在path后面加上一个“；”号，再将bin文献途径C:\Program Files\Java\jdk1.6.0_11\bin加上去——》查看系统变量中是否有classpath变量，假如没有则——》新建——》classpath，将“.;C:\Program Files\Java\jdk1.6.0_11\lib” 附加到classpath后面——》拟定。
3）在dos中运营java程序
l 通过cd命令找到java文献所在的途径
l 编译：javac helloworld.java——注意此处文献名的大小写要区分
l 编译完毕后会出现一个helloworld.CLASS文献
l 运营：java helloworld——不加扩展名，真正运营的是.class文献
l 注意：java文献名字必须与文献中具有public static void main()类的名字是同样
4）
l java虚拟机的作用是将字节码文献解释成机器语言；不同的操作系统平台要安装不同的JDK；
l java是一种半编译半解释的文献；源文献——》字节码：编译方式
l 字节码——》机器代码：解释方式
5）使java的格式优化：
source->format：优化文档格式
6）在dos中提取java文档的信息（提取文档注释的信息）
javadoc -d textdoc -version -author helloworld.java
7）当在数字后面加上一个L时，则系统会认为它是一个长整形；
l 同样在一个浮点数后面加上F/D系统就会认为它是单精度活或者双精度；
l 转义字符例如：‘\n’是一个字符，同时Unicode编码也是一个字符，例如‘\’;因此区分字符和字符串是通过双引号/单引号区分 而不是字符的长度区分。
面向对象编程；
1） 在类中有属性和方法，不能将功能性的语句放到类中，只能放到方法中
2） 通过return将方法要返回的值返回；同时，return有立即结束方法的执行，并返回到调用点。
3)在程序里是看不到对象的，只能通过引用来使用它
在Human aMan=new Human();中：
Human aMan:对引用的声明
New human（）：对象的创建；
4)未被初始化的引用是不能使用的，编译的时候就会犯错；但当一个对象的引用指向的是空值（null值），在编译的时候是不会犯错的，但是在运营的时候会出现错误。
5)Tostring用法：
l toString就是让你重载用以在调用的时候输出你像要输出的信息的, 也就是当打印输出一个对象时，系统自动调用其toString方法，打印的是toString方法的返回值。
l Public string toString()//重载这个类的Tostring方法
{
Return ”name:”+name+”&sex:”+sex+”&age”+age+”&telephone”+telnum;//自己想要构建的字符串
}
l toString的使用
System..out.println(对象引用)// System..out.println(对象引用.tostring())；
l 假设对象的名字叫做car则：
System.out.println(car)或者System.out.println(car.toString);
6）程序包；
l 右击project——》new——》package；同时也可以在一个包下再建立子包；在一个package右击新建package，包的名字的书写：父包的名字.子包的名字；
l 在一些java开发工具中编写程序时，系统会自动给你分派到选择的包中，但用DOS书写代码，或者调用存在在包中的JAVA文献时，就需要指出所在的包
l 例如：package mypackage;
Public class myclass{…………}
l 若想访问其他包中的类必须将类所在的包的名字：
Java.io.fileinputstream.stream// fileinputstream包名，stream类名
也可以使用import引入其他的包的类：
Import java.io.fileinputstream;
7）堆与栈的区别：
l Java的堆是一个运营时数据区,类的(对象从中分派空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分派内存大小，生存期也不必事先告诉编译器，由于它是在运营时动态分派内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺陷是，由于要在运营时动态分派内存，存取速度较慢。
l 栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺陷是，存在栈中的数据大小与生存期必须是拟定的，缺少灵活性。栈中重要存放一些基本类型的变量（,int, short, long, byte, float, double, boolean, char）和对象句柄。
l 实例变量（成员变量）：直接定义在类中而不属于任何方法。在对象被创建时创建；存放在堆中
l 局部变量：在方法中定义的变量和方法中的参数变量；方法执行时创建，方法退出时释放；存储在栈中
l 静态变量（static）：存放在静态存储区中
8）JAVA参数的传递：
l Java语言中方法的传递采用值传递的规则
l 在方法中对基本类型参数进行的一切修改都不会影响到方法外的变量；//由于传递的只是值
l 方法中对引用类型的修改会影响到引用所指向的值；//例如对对象进行传递，由于对象为引用类型，所以传递的是对象的地址，则会改变。
l 方法中改变引用变量指向的对象不会影响方法外的引用变量；//即在方法中为引用变量分派了新的空间时，方法结束，引用变量就会释放空间，并指向调用方法前的空间，此时方法内的变化不会影响到方法外部。
9） This的作用：
l 作为当前类的引用；
例如：robot robot1=new robot（this）；
l 将代码中的成员变量与方法中的局部变量区分开（防止歧义）。
例如：this。Name=Name
JAVA中的运算符：
1） 两个整数之间相除的到的结果还是一个整数5/2=2，其取值是相除后的整数部分。
2） i的值为5；表达式（i++）的值为5，运算完毕i的值为6；
3） =：是赋值运算；==：是比较运算符
对于浮点数进行比较不能用==号，由于浮点数的小数点不一定到第几位，一次采用F1-F2<1E-4来判断。
连续的比较不能3<i<8,必须用到逻辑与&&运算符；即：3<i&&i<8
4） System.out..print(s)：表达输出s，但不换行；System.out..println(s):表达输出s，并且换行。System.out..println()：表达换行。
5）逻辑运算（&&、||）执行时会出现短路现象，位运算不会出现短路现象。
什么叫做短路现象那：在进行二元逻辑运算时，假如第一个操作数就可以拟定表达式的值而不需要再计算第二个操作数，这种现象叫做逻辑表达式的短路。
5） 算数右移>>，左移<<：最高位补符号；
逻辑右移>>>：最高位补0；
7)三元运算符：
Boolean-exp?express1:express2
8)浮点型文字常量默认为double型，而double型常量不能赋值给float型
Float a=3.14(错)
Float a=3.14f(对)
9）表达式的运算至少要用int类型
Byte b3=b1+b2:error，变量的运算只少要int型
Byte b3=1+2；对的，由于运算的为常量
整个表达式的中变量的运算向着表达式中最大的类型靠拢，至少应当为int 型；这是表达式的自动提高的过称（隐式类型转换）。
程序的流程控制：
1） switch（整形变量或者整形表达式）
2） 带标号的break
对于某一个循环做一个标号，break 标号_name就会跳出这个循环；

数组：
1） 数组的声明，只是声明了对象的引用，即：若仅仅写char[] s;这只是个引用，没有指向任何空间和有效的数据，是不可使用的；在使用数组的时候需要创建数组对象。
2） 使用关键字new创建数组对象，在创建对象时，需要指明数组的大小。 数组对象被创建之后，假如不对其进行赋值，则每个成员都会被默认的初始化为0值。
Char s[]=new char[16];
3)数组的显示初始化：
Char[] s={‘a’,’b’,’c’};
3） 对于数组可以用空来赋值，这时它就不指向任何数据
Char s[]=null;
4) 当已经用new为数组创建数组对象后，必须对数组中的每个成员一一赋值。
对的的方式：Int i[]=new int[3];
For(int j=0;j<3;j++)
{ i[j]=j+1; }
错误：一起赋值是不允许的：
I[]={1,2,3};:：是不允许的。
5）多维数组的创
Java中没有真正意义上的多维数组，而是通过数组的数组来实现的
多维数组的声明方式如下，以二维为例： int[][] a
多维数组可以用以下方式进行创建： int[][] a = new int[10][8];
错误写法：
Int[][] a=new int[][]//错：用new创建数组时，至少要在第一个维度上指定明确大小；
Int[3][] b=new int[3][]数组声明的时候，[]内必须是空的
Int[]d=new int[]{1,2,3,}//对的
Int[]d=new int[3]{1,2,3,}//错误，
Int[]d=new int{1,2,3,}//错误
类的继承与组合：
1） 一个概念是另一个概念的一种；比如苹果是水果的一种，燕子是鸟类的一种，但是父亲与儿子的关系不是一种继承关系（儿子不是父亲的一种 哈哈）。
2）类的继承使用关键字：extends
class Super{}
class Derived extends Super{}
3）子类可以加入自己的方法和属性。
4）可以将父类的引用指向一个子类的对象，这种引用使用的时候，只能使用子类从父类继承来的方法；即这个引用只能访问父类的成员，而不能访问子类的成员。
例如：上溯造型（将子类的对象赋值给父类的引用）：
Human h;
Parent p=new Parent();
H=p;
*((Human)p):对P进行强制类型转换，注意此时只是将引用p转换成了Human类型，而其真正指向的对象还是persion类型。
下塑造型（将父类引用指向的子类对象，通过强制类型转换赋值给一个子类的引用）：
Human h=new Parent();//指父类的引用指向的必须是子类的对象
Parent p;
P=(Parent)h;//强制类型转换
错误的操作：（编译时通过，运营时将抛出异常）
Human h=new Human();
Parent p;
P=(Parent)h;//强制类型转换
编译的时候只能看出变量的类型（等号左边的），对象的类型是在程序运营起来之后才干拟定。

4） instanceof运算符：
superRef instanceof DevriedClass
superRef与DevriedClass必须在继承树的同一条分支上，否则无法通过编译；
判断引用superRef所指向的对象的实际类型是DevriedClass类型或是DevriedClass的一个继承类时，上面表达式返回TRUE，否则FALSE；
类的访问控制：
1）Java语言中类的成员有四种存取权限：
Public： 所有包中的所有类均可访问protected ：所在包中的类和其他包中继承当前类的继承类可以访问
无 ：只有所在包中的类可以访问
Private： 只有当前类可以访问
2）方法的重载
Java语言中允许多个方法拥有同样的名字，这种情况叫做方法的重载(overload)
重载的多个方法必须要有不同的参数表，只能通过参数表分辨，不能通过返回值
3）方法的覆盖：
在类的继承过程中，子类可以定义同父类完全同样(涉及参数表和返回值)的方法，在通过子类对象调用方法时，将调用子类的方法而不是父类的方法，这 种情况叫做方法的重置或覆盖(override)
要覆盖父类的方法，必须是子类的方法同父类的方法完全同样——不管是参数列表还是返回值
在覆盖父类的方法时，可以给方法赋予不同的访问限制符，但是，覆盖方法的访问限制不能比原方法的访问限制更窄： private<无<protected<public
4）在子类中覆盖和重载都是针对方法而言。
在子类中可以声明与父类中的变量同名的变量，并且所声明的变量可以与父类的变量有不同的类型。子类中的新变量与父类中的同名变量是两个不同的变量，都可以被访问，访问的变量是哪一个取决于对象引用的类型。
在子类和父类的方法中有覆盖的方法时，调用的方法取决于引用所指向的对象的类型。
5）多态：
通过引用实现的动态绑定的方法；通过同一个方法来解决同一个父类的不同子类，从而实现不同的结果的方法。
例如：
class Employee
{
void salary()
{System.out.println(" Employee salary");
}
}
Class Secretary extends Employee
{
void salary()
{System.out.println(" Secretary salary");
}
}
Class Manager extends Employee
{
void salary()
{System.out.println(" Manager salary");
}
}
Public Class salary
{ public void salaryofemployees(Employee e)
{
e.salary();
}
public static void main(String[] args)
{Secretary s=new Secretary();
Manager m=new Manager();
EmployeeSalary.salaryOfEmployee(s);
EmployeeSalary.salaryOfEmployee(m);
}
6）super关键字：
是一个指向当前对象的父类的引用。
只能使用在类的方法中。
作用：
l 指向当前对象的父类引用
通过super就可以调用父类的protected和public变量和方法；//super.name;
Protected：封装范围是在它所有的子类中可用
l 代表父类的构造方法。
通过super关键字可以在子类中对父类的构造方法进行初始化，并且必须先初始化父类的构造方法，再初始化子类中的参数（假如不通过super调用父类的构造方法，则系统会自动去调用父类没有带参数的构造方法，假如此时父类中定义了带参数的构造方法，无参构造方法就会消失，则运营就会犯错）
Class upper
{ Public upper(int i){};
}
Class derived extends upper
{
Public derived（int i）
{super(m)//super中传递的参数不一定非要通过derived的参数传递，可以写为
//super（3），只要类型与父类中的参数类型相同即可
}
}
This关键字可以调用本类的其他构造方法。
7）什么叫做单态：
l 在整个系统运营的过程中，某个类的对象只有唯一的一个。
l 一方面他的构造方法必须是private类型的，以保证在类外就不能创建新的对象。
l 唯一的对象是在类中定义的，且是私有的，用static修饰（假如一个对象用static修饰，则在整个程序的运营过程中只有一个）
l 使用过程中，只能通过方法指向那个唯一的引用。
例如：public class Company
{
Private Company(){ };
Private static Company company=new Company(();
Public static Company instance()
{
Return company;
}
}
Company c=Company.instance();
8）Object类中的方法：
l ==在基本数据类型中是判断基本类型的值是否相等；在引用类型中是判断两个对象的引用是否相同。默认情况下equal方法与等号的作用是同样的。但一般对其进行覆盖，使其的作用与==的作用不同，
例如：string s1=new string(“hello”);
string s2=new string(“hello”);
string s3=s1;
s1==s2; //结果为FALSE，由于s1,s2的引用值并不同
s1==s3； //结果为TRUE，由于s1,s3为同一个引用；
s1.equals(s2); //true，由于s1,s2引用所指向的值是相同的
s1.equals(s3); // true，由于s1,s2引用所指向的值是相同的
在字符串类型中对equals方法进行了重写，使其具有比较两个引用所指向的值是否相同的作用。
l 在object类中有很多像equals同样的方法，我们可以对其进行重写，以实现自己想要的方法。
例如：
Class Student
{
String name;
Int age;
Public Boolean equals(Object obj)//object为系统类，可以传递任意类型参//数
{
Student st=null;
If(obj instanceof Student) //判断obj与student是否为同一类型。
St=(Student )obj;
Else
Return false;
If(st.name==this.name&&st.age==this.age)
Return true;
Else
Return false;
}
}
9）Static：
l 访问方式：既可以通过创建对象，使用引用访问；也可以直接通过类名进行访问。
l 特点：静态变量是存放在静态存储区的，它不会存放在创建对象时动态分派的空间中；在类装入javas虚拟机时，静态变量就被创建，所有对象都共享这一个静态变量。
l 作用：静态变量和方法可以记录存放所有对象的信息，表达类自身的某些特性和操作。
l 静态方法：不能直接访问类中的非静态成员（通过创建对象，使用对象的引用可以访问非静态成员），只能直接使用静态成员。
10）Final关键字：
l 在Java中final关键字可以被用来修饰类、方法和变量
l 用final修饰类时表达此类不可以被继承
l 用final修饰方法是表达此方法不可以被继承类重置
l 用final修饰变量是表达该变量是一个常量，在初始化后不能被改变
l 在final关键字修饰类或方法时，不能同abstract关键字共同使用
l 使用final关键字修饰类的变量时，假如修饰static变量，则须在定义时或者在静态块中进行初始化；假如修饰普通变量，则可以在定义时，在动态块中， 或者在构造方法中进行初始化
l Public static final——全局常量
11）Abstract
l 抽象类定义格式：
Abstract class class_name
{ int name
Abstract void eat();//抽象方法不能有方法体,默认都是public类型的。
Public void say(){system.out.print(”it is delicious”)}
}
不能创建抽象类的对象。
抽象方法与普通方法相比最大的不同是没有方法体，即没有具体的实现；抽象方法只能定义在抽象类中，不能定义在普通类中，一个抽象类里是可以没有抽象方法的,也可以有非抽象属性和方法。
若一个类继承了一个具有抽象方法的抽象类，但是没有对所有的抽象方法进行重写，那么这个类也必须书写成抽象的，由于抽象方法中必须存在抽象类中。
12）接口：
l Java不允许进行多重继承，为了避免单根继承带来的局限性，产生了接口。
l 接口可以看作是没有成员变量，并且所有方法都是抽象方法的抽象类。
l 接口中的方法都省略了public abstract，且接口中的方法不能用final修饰。
l 在接口中没有成员变量，接口中的数据一定是全局常量，即都是public static final型的，但是public static final已经被省略掉了

格式：
Interface MyInterface
{
Void method1( ); //接口中的方法都省略了public abstract
Int method2( );
Int i=10; //接口中是没有成员变量的，因此所有这样定义的数据都是全局变量
}
l 接口的使用：
Class myclass implements myinterface
{
}
l 对接口中抽象方法的实现，必须用public关键字修饰，否则编译犯错
l 假如实现一个借口h是并没有实现接口中的所有方法，那么这个类就需要声明为抽象类,由于抽象方法只能在抽象类中。
l 一个类可以在继承一个父类的同时，实现一个或多个接口，但extends必须写在implements的前面。
l 一个类可以继承多个接口，接口之间可以多重继承
Interface DerivedInterface extends MyInterface1,MyInterface2
{
Method…………
}
13）无论在哪一个类中写主方法都是可以的，只是运营的时候要找到主方法所在的类，然后就可以运营。
14）内部类：
l 定义：内部类是定义在其他类中的或方法中的类，包含内部类的类通常称作：Enclosing Class；内部类的存取控制方式与同它在同一位置上的成员是相同的。
l 静态内部类：
定义静态内部类的方法类似于声明一个类的静态成员变量。
Public class Enclosing
{
Private static int staticMember=0;
Public static class StaticInner //静态内部类
{
Public void innerMethod()
{System.out.println(staticMember);}
}
}
声明静态内部类的引用：
Enclosing.StaticInner innerRef;
创建静态内部类的对象：
innerRef=new Enclosing.StaticInner();
注：静态内部类不能与Enclosing Class同名；
静态内部类可以访问Enclosing Class内的静态成员，不能直接访问非静态成员；
Enclosing Class不能直接访问静态内部类的成员。
l 成员内部类：
定义一个成员内部类的方法类似与定义一个类的普通成员；
Public class Enclosing
{
Private int Member=0;
Public class MemberInner //静态内部类
{
Public void innerMethod()
{System.out.println(Member);}
}
}
声明成员内部类的引用：
Enclosing.MemberInner innerRef;
创建成员内部类的对象：
Enclosing enclosing=new Enclosing（）；
InnerRef=enclosing.new MemberInner();
或者：
InnerRef=new Enclosing.new MemberInner();
注：
成员内部类不能与Enclosing Class同名；
成员内部类不能定义静态的成员变量和方法；
成员内部类可以访问Enclosing Class中的所有成员，无论是静态还是非静态；而Enclosing Class不能直接访问成员内部类的成员。
在成员内部类的方法中this是内部类当前对象的引用，假如需要访问当前的外部类对象需要使用Enclosing.this
l 本地内部类
本地内部类是定义在方法中的内部类
Public void containInner()
{
Class Locallnner
{
Public void print(){}
}
Locallnner innerRef=new Locallnner();//本地内部类的访问在方法中
}
注：
同定义在方法中的变量同样，本地内部类只能在定义它的方法中使用，并且不能使用public private等访问权限控制
本地内部类不能与Enclosing Class同名；
本地内部类可以访问Enclosing Class中的所有成员，无论是静态还是非静态；而Enclosing Class不能直接访问本地内部类的成员。
在本地内部类的方法中this是内部类当前对象的引用，假如需要访问当前的外部类对象需要使用Enclosing.this

本地内部类可以访问包含它的方法中的变量和方法的参数，但是这些变量或参数必须声明为final，内部类中不能改变他们。
l 匿名内部类：

匿名内部类等号右边的可以是接口，抽象类，正常类；弊端是不能被重用。
异常：
1）异常的简介：
l 异常是程序开发和运营过程中产生的不正常的、错误的情况。
l 在Java中产生的任何一个异常都被表达为一个对象，不同的异常被表达为不同类型的对象，这些对象属于共同的基类Throwable
l 在java程序中，发生异常时，会在发生异常的地方就会中断，后面的不会执行；当使用try{}catch(){}块做了解决之后，后面的代码就可以继续执行下去。
2）异常解决的方法：
Try/catch关键字：
结构：
Try{//也许产生异常的代码}
Catch（someexception e）{//解决异常的代码}
Catch（someexception e）{//解决异常的代码}
注：Try下面如假如具有多个catch语句的话，只会调用跟异常情况相符合的那个cache语句。当要书写多个catch块时，要把子类的exception写在前面。
什么代码写在Try中:
对于存在抛出异常隐患的代码应当写在try中；
不是写在try中的代码越多越好；只要把也许出现异常的哪一行代码写进去就好，由于在try中，假如加入了太多的代码，那么出现异常的那一行之后的所有代码也是不可以执行的。
Catch中写什么？
Catch中写什么，就会在程序结果中输出什么。
e.printStackTrace()：抛出异常的信息，可以直接使用
e.getMessage():返回发生异常的字符串，需要通过print输出。
throw e；可以在catch块中使用throw抛出异常；重新抛出的异常不会被同一个try下的其他catch块解决，只能被包裹当前try/catch结构更大的try/catch来捕获解决，或者被抛出当前方法，由方法的调用者进行解决。
Catch中假如什么都不写，那么只是把异常给屏蔽掉了，异常真正的犯错路线是不悔显示的。
当try中发生异常时，Java虚拟机就会自动创建一个异常对象，并传递给catch解决；Catch（exception e）//不明确具体是什么类型异常时，就写;exception，由于exception是所有异常的父类

程序员可以解决的是异常exception，对于error是虚拟机的内部错误，要寻找虚拟机的内部错误。

Finally语句块：
写在try catch后面，无论怎么样都会执行的语句块

在这个方法中有异常，但是方法的书写者并没有对方法进行解决，这就需要方法的使用者自行进行异常解决，
抛出异常就是将异常屏蔽了，使不犯错误，但事实上异常还是存在的
Throw（exception）抛出了那个异常就要对这个异常进行try catch解决。
覆盖方法时所抛出的异常规格不能超过父类声明的异常。
自定义异常

Run-------run--------arguments------VM ----–ea

Dos下：
1)先编译
2)Java –ea class_name;
-ea只在只在这一次运营中有效，下次写文献还要写上-ea
通常是做一些私有方法的检查

基于文本的应用程序
1）命令行参数：
允许程序运营起来之后，往里面输入参数
所谓的命令行参数就是主方法main括号中的参数
1、在dos中用java命令运营的时候对main中的参数进行赋值
Java classname 参数1 参数2 参数3……//参数之间以空格分隔
2、在ecplise下传递参数
Run——run——arguments——program argument中输入自己的参数（参数之间以空格分隔）
控制台I/O
System.in
Fanhui的是inputstream，以字节为单位
BufferedReader：允许一次读取多个字符
System.in.read（）;返回值是一个整型值。就是当前字符的ASCII编码，可以通过强制类型转换将其转换为一个字符，且要写在try catch块中，当需要读入多个字符是需要用到循环，直到你输入-1时，或者是回车（/r）时循环结束
读取多行：
现将System.in转换为字符流
InputStreamReader ir=new InputStreamReader（System。In）；
BufferedReader in=new BufferedReader（ir）；

System.error
File类
Delete删除文献时，要保证文献的内容为空；
创建文献时也要保证要存放文献的目录已经存在

将A文献的内容放入B文献中
对A文献的内容读出来写到B文献中
进内存：输入流（从磁盘输入到内存，读的方法）
出内存：输出流（从内存输出到磁盘上，写的方法）

I/O流：
1） p466页 467页
2） P468
3） p469节点流，解决流的概念
4） p470有那些节点流
5） 解决流：有哪些解决流？在后面
节点流：文献流
字节流：FILeInputStream.FileOutputStream:对字节进行操作。
字符流：FileWriter：可以直接写入一行字符串；
FileReader：读取时候要读入到字符数组中。
方法： read（）；//对于文献流中的“读操作”都要读到一个数组中，而不能直接将字//符串输出
Write（）；
以对E盘下的f.txt文献为例进行操作
File filename==new File(“e:\\f.txt”)
l 以字节的形式向文献写入内容：
FileOutputStream output=new FileOutputStream(filename/这里也可以直接输入途径，true);// Append=true：在源文献基础上追加内容；默认是FALSE：即覆盖源文献内容。
byte b[]=”string……”.getBytes（）/.getBytes（）方法将字符串转换为字符
output.write（b）；
l 以字节的形式将文献内容读到内存：
FileInputStream input=new FileInputStream(fielname/这里也可以直接输入途径);
byte a[]=new Byte[input.available]//定义一个字节数组以存放要读进来的字节数据，//input.available表达读进来的数据的长度。
Int len=Input.Read（a）；//读入到字符数组a，并且将字节数组的长度返回到一个int类//数据中
System.out.println(new String(a,0,len));//输出字节数组
l 以字符的形式向文献写内容
FileWriter w=new FileWriter(filename,);
w.write(“string……”);//字符流可以直接向文献写入字符串。
l 以字符的形式从文献读取内容
FileReader r=new FileReader(filename);
char[] buf=new char[1024];//可以给出数组的大小，也可以像上面那样定义
int len=in.read(buf);
System.out.println(new String(buf,0,len));
节点流：内存流
用于内存数组，类似于内存虚拟文献的功能。

实现在读到文献时换行：
运用BufferedWriter bw=new BufferedWriter（filewriter_name）;
bw..write(“adfljafdlj;als”);
bw.newLine();
bw.write(“sdfsdfdf0”).
Bw.close();

Character.toUpperCase(小写字母)=大写字母
ByteArrayOutputStream：将读到的字符暂时存储在内存缓冲区中。

管道的功能：
将两个流连接，能完毕通讯的过程

解决流