标签：最快 编译器 计算机 ++ 构造方法 异常处理 两种 内聚 默认
Java平台由Java 虚拟机和Java 应用程序接口搭建，Java语言则是进入这个平台的通道， 用Java语言编写并编译的程序可以运行在这个平台上。运行期环境代表着Java平台，开发人 员编写Java代码(.java文件)，然后将之编译成字节码(.class文件)，再然后字节码被装入内存， 一旦字节码进入虚拟机，它就会被解释器解释执行，或者是被即时代码发生器有选择的转换成 机器码执行
JVM栈由堆、栈、本地方法栈、方法区等部分组成 堆： 所有通过new创建的对象的内存都在堆中分配，堆的大小可以通过-Xmx和-Xms来控 制。 堆被划分为新生代和旧生代，新生代又被进一步划分为Eden和Survivor区，最后Survivor 由From Space和To Space组成 栈：每个线程执行每个方法的时候都会在栈中申请一个栈帧，每个栈帧包括局部变量区和操作 数栈，用于存放此次方法调用过程中的临时变量、参数和中间结果。 本地方法栈：用于支持native 方法的执行，存储了每个native 方法调用的状态 方法区：存放了要加载的类信息、静态变量、final类型的常量、属性和方法信息。JVM用持 久代（Permanet Generation）来存放方法区，可通过-XX:PermSize和-XX:MaxPermSize 来指定最小值和最大值
GC是垃圾收集的意思（GabageCollection）,内存处理是编程人员容易出现问题的地方，忘 记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动 监测对象是否超过作用域从而达到自动回收内存的目，Java语言没有提供释放已分配内存的 显示操作方法。
1.回收的内容是new出来的对象所占内存； 2.垃圾回收只与内存有关，清理内存外的资源依靠finalize()方法。垃圾回收机制在回收某个 对象的内存前会调用该对象的finalize()方法。 3.垃圾回收以单独的线程在后台运行，为减少虚拟机额外消耗，一般在内存不足时会进行垃圾 回收，所以就算强制系统垃圾回收，垃圾回收也不一定发生 4.对象在内存中的状态有可达状态、可恢复状态、不可达状态，当处于可恢复状态时可能会进 行垃圾回收。
通常我们定义一个基本数据类型的变量，一个对象的引用，还有就是函数调用的现场保存都使 用内存中的栈空间；而通过new关键字和构造器创建的对象放在堆空间；程序中的字面量 （literal）如直接书写的100、”hello”和常量都是放在静态区中。栈空间操作起来最快但是 栈很小，通常大量的对象都是放在堆空间，理论上整个内存没有被其他进程使用的空间甚至硬 盘上的虚拟内存都可以被当成堆空间来使用。
是能够定义成为一个中文的，因为java中以unicode编码，一个char 占16个字节， 所以放一个中文是没问题的
①普通的方法：建立一个临时变量，通过temp=a,a=b,b=temp来实现交换
②指针的方法：取两个数的地址，在swap方法中再用指针指向地址交换， 这时候为数值交换（函数调用结束后原空间的值也得到了交换）。 int swap(int *_x,int *_y)//主函数中把两个数的地址传过来 { int tmp = *_x;//定义中间变量 然后交换两个数 *_x = *_y; *_y = tmp; printf("%d %d",*_x,*_y); }
③加减交换：取两个数的和，然后通过减去另外一个数来得到这个数
④异或方法：通过二进制异或方法交换，如a=3二进制为11，b=2的二进制为10， 按位异或（两个值相同为0，否则为1
整数： byte short int long
浮点数 float double
布尔 boolean
字符 char
常用的类：BufferedReader BufferedWriter FileReader FileWirter String Integer
常用的包：java.lang java.awt java.io java.util java.sql
常用的接口：Remote List Map Document NodeList
2 <<3
witch（expr1）中，expr1是一个整数表达式。
因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。
long,string 都不能作用于swtich
&和&&都是逻辑运算符号，&&又叫短路运算符
区别如下 int i=1;
if(i==2 & i++==2){} //i==2为false,但i++==2还会继续比较，所以i++被执行
System.out.println(i); //i 打印出来为2
int j=1;
if(j==2 && j++==2){} //j==2为false,但j++==2不会继续比较，所以j++不被执行 System.out.println(j); //j打印出来为1
& 不管前面的条件是否正确，后面都执行
&& 前面条件正确时，才执行后面，不正确时，就不执行，就效率而言，这个更好
short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，需要强制转换类型）
short s1 = 1; s1 += 1;（可以正确编译）
选择if-else，因为如果第一个条件满足的话后面的就不会继续判断，提高执行效率。
== 可以比较基本数据类型的值也可以比较引用数据类型的值 equals()如果没有被重写的话是和==是一样的，如果被重写了就按照重写的规则进行比较
for(①；②；③){
④
}
顺序为： ① ② ④ ③
while 语法：
while(){
}
场景：循环次数不固定的时候使用。 先判断后执行
do-while 语法：
do{
}while(条件);
场景 ： 循环次数不固定的时候先执行后判断
for : 语法 for(表达式1；表达式2；表达式3){
执行的代码
}
循环次数固定的时候使用 先判断后使用
break跳出循环，continue跳出本次循环，进入下次循环
for( ; ; ){ }
创建了几个String Object ？如果是多个，那么他们之间有什么区别？
两个或一个，”xyz”对应一个对象，这个对象放在字符串常量缓冲区， 常量”xyz”不管出现多少遍，都是缓冲区中的那一个。New String每写一遍， 就创建一个新的对象，它一句那个常量”xyz”对象的内容来创建出一个新String对象。 如果以前就用过’xyz’，这句代表就不会创建”xyz”自己了，直接从缓冲区拿
算术运算符，关系运算符，位运算符，逻辑运算符，赋值运算符
double
System.out.println(Long.MAX_VALUE);//最大数:9223372036854775807 System.out.println(Long.MIN_VALUE);//最小数:-9223372036854775808
System.out.println(Double.MAX_VALUE);//最大数:1.7976931348623157E308 System.out.println(Double.MIN_VALUE);//最小数:4.9E-324
year%4==0&&year%100!=0)||year%400==0
byte Byte
short Short
int Integer
long Long
double Double
float Float
char Character
booelan Boolean
分析错误，设置断点
启动调试
单步运行
观察变量
发现问题
修正代码，重新运行
解决问题
数组是具有相同数据类型的数据集合，相同的数据类型，
意味着数组中每个数据都是同一类型数据，或者属于基本数据类型中相同类型的数据， 或者属于对象类型中相同类型的数据；如果按照维数来划分，
数组可分为一维数组、二维数组和多维数组等，每一维代表一个空间的数据
其实数组有一个缺点，就是一旦声明，就不能改变容量，这个也是其使用频率不高的原因
Arrays类的sort()方法实现排序功能; binarySearch()方法实现查找元素索引功能。
数组没有length()方法，有length 的属性。String 有length()方法。JavaScript中，获得字符串
public static void main(String[] args) {
int[] arr = { 3, 4, 8, 2, 5, 9, 1, 7 };
for (int i = 1; i < arr.length; i++){
for (int j = 0; j < arr.length - 1; j++){
if (arr[j] > arr[j + 1]){
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]);
}
}
1
2 7
3 8 12
4 9 13 16
5 10 14 17 19
6 11 15 18 21 22
二维数组的做法
参考案列
int[][] a = new int[6][6];
int b = 1;
for(int j = 0; j < 6; j++) {
for(int i = j; i < 6; i++) {
a[i][j] = b++;
}
}
public class Test1 {
public static void main(String[] args) {
int[] score1=new int[10];
int[][] score2;
String[][] names; //二维数组的初始化
score2=new int[][]{{1,2,3},{3,4,5,6},{16,7}};//静态初始化
names=new String[6][5];//动态初始化方式一
names=new String[6][];//动态初始化方式二，一定要设置行数
names[0]=new String[5];//第一行中有5个元素
names[1]=new String[4];
names[2]=new String[7];
names[3]=new String[5];
names[4]=new String[8];
names[5]=new String[5];
System.out.println("第一行中的元素："+names[1].length);
System.out.println(names.length);//打印的是二维数组有几行
//如何遍历二维数组
for(int m=0;m<score2.length;m++){//控制行数
for(int n=0;n<score2[m].length;n++){//一行中有多少个元素（即多少列）
System.out.print(score2[m][n]+" ");
}
System.out.println();
}
请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
1.确认使用for循环。
2.为避免重复输出结果，当找到和target值相等的array[][]时，立即跳出循环，并在循 环外判断是否存在。
3.输出结果
public static void main(String[] args) {
int[][] array={{1,2,3}, {2,3,4}, {3,4,5}};
boolean find=false ;
Scanner scanner =new Scanner(System .in);
System.out.println("请输入数字：");
int target=scanner .nextInt();//确认target的值
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
if (array[i][j]==target) { find=true;//返回true.
i=array.length-1;
j=array[i].length-1;//当target数值等于array[i][j]时，立即跳出循环。
}
}
}if (find) { System.out.println("存在数字 "+target);
//在循环外判断target值是否存在，并输出结果。
}else {
System.out.println("不存在数字："+target);
}
}
java中的保留字，现在没有在java中使用
|
对象 |
硬件环境 |
客户端要 求 |
软件安装 |
升级和维护 |
安全性 |
|
C/S |
用户固定，并且处于相同区域，要求拥有相同的操作系统。 |
客户端的计算机电脑配置要求较高。 |
每一个客户端都必须安装和配置软件. |
C/S每一个客户端都要升级程序。可以采用自动升级。 |
一般面向相对固定的用户群，程序更加注重流程，它可以对权限进行多层次校验，提供了更安全的存取模式，对信息安全的控制能力很强。一般高度机密的信息系统采用C/S结构适宜。 |
|
B/S |
要有操作系统和浏览器，与操作系统平台无关。 |
客户端的计算机电脑配置要求较低。 |
可以在任何地方进行操作而不用安装任何专门的软件。 |
不必安装及维护 |
Java运行时环境(JRE)是将要执行Java 程序的Java 虚拟机。 它同时也包含了执行applet需要的浏览器插件。 Java开发工具包(JDK)是完整的Java软件开发包， 包含了JRE，编译器和其他的工具(比如：JavaDoc，Java调试器)， 可以让开发者开发、编译、执行Java应用程序
不会，在下一个垃圾回收周期中，这个对象将是可被回收的。
吞吐量收集器使用并行版本的新生代垃圾收集器，它用于中等规模和大规模数据的应用程序。 而串行收集器对大多数的小应用(在现代处理器上需要大概100M左右的内存)就足够了
不是，String是引用数据类型，引用数据类型还有类，接口和数组。
当对象对当前使用这个对象的应用程序变得不可触及的时候，这个对象就可以被回收了
面向对象是一种使用封装、继承、多态、抽象等思想进行软件的分析和开发的方法，而java 就是一门面向对象编程的语言。
现实世界是由很多对象组成的，基于对象抽出了类
对象:真实存在的单个的个体，类:类型/类别，一类个体
生活中的类：根据对象相似的特征和相似的行为进行归类。例如：桌子、椅子 程序中的类 ：由两个部分组成：1.属性(成员变量)；2.方法(成员函数)
类是对象的抽象，而对象是类的具体实例。 类是抽象的，不占用内存，而对象是具体的，占用存储空间;类和对象是抽象与具体的关系
成员变量：
1. 类中，方法外
2. new时存在堆中，对象被回收时消失
3. 成员变量可以设置初始值也可以不设置，如果不设置会有默认值。
实例成员变量:
1. 属于对象的，存在堆中
2. 有几个对象就有几份实例变量
3. 必须通过对象名.来访问
静态成员变量:
1. 属于类的，存在方法区中
2. 只有一份
3. 常常通过类名.来访问
1. 方法中
2. 调方法时存在栈中，方法调用结束时与栈桢一并消失
3. 没有默认值
1. 普通类: 实例化一个该类的对象,然后通过对象名.方法名 访问
2. 静态类: 可以通过类名直接访问,而不用实例化对象
package:
1. 作用:避免类的命名冲突
2. 包名命名规范: 建议包名所有字母都小写,且有层次结构
3. 类的完全限定名: 包名.类名
import:
1. 作用:声明类/引入类
2. 同包中的类可以直接访问;
不同包中的类想访问:
2.1.先import 声明类再访问类(建议)
2.2.类的全称-----太繁琐(不建议)
形参,就是形式参数，用于定义方法的时候使用的参数，是用来接收调用者传递的参数的。
实参,就是实际参数，用于调用时传递给方法的参数。实参在传递给别的方法之前是要被预先 赋值的。
实参的个数、数据类型以及次序要和所调用方法声明的参数列表匹配
方法的参数列表可以是有参数的，也可以是没有参数的;
有参方法是指( )中包含一个或多个变量的定义，也称为参数列表
无参方法是指( )中不含参数
使用方法的好处：提高代码的复用性
值传递：方法调用时，实际参数将它的值传递给对应的形式参数，函数接收到的是原始值 的副本，此时内存中存在两个相等的基本类型，若方法中对形参执行处理操作，并不会影响实 际参数的值。 引用传递：方法调用时，实际参数的引用（是指地址，而不是参数的值）被传递给方法中 相应的形式参数，函数接收到的是原始值的内存地址，在方法中，形参与实参的内容相同，方 法中对形参的处理会影响实参的值。
注意: 这里要特殊考虑String，以及Integer、Double等几个基本类型包装类，它们都是 immutable 类型，因为没有提供自身修改的函数，每次操作都是新生成一个对象，所以要特 殊对待，可以认为是和基本数据类型相似，传值操作。
1. 代表本类当前对象的引用
2. 既可以调用本类成员变量、成员方法，也可以调用本类的构造方法。
3. 用于区别局部变量和成员变量
封装就是隐藏对象的属性和具体实现细节，仅对外提供公共的访问方式。
原则：
1. 将不需要对外暴露的信息隐藏；
2. 对外提供公共的访问方式。
好处：将变化隔离；提高了安全性；提高了代码代码重用性，便于使用。
不对，
private(私有)仅仅是封装的一种体现形式。我们常用的类，方法，函数也是封装。只 要是对外不可见，就能达到封装的效果，比如：包与包之间的访问。
get/set访问方式不是必须成对出现的，具体看需求，需要设置值就提供set方法，如果需 要访问值，就提供get方法
1. 方法名和类名完全一致
2. 没有返回值类型，连viod都没有。
3. 没有明确的返回值，但是可以有return关键字;
构造方法主要作用是用来给对象初始化，赋值只是它的捎带工作，也可以不用赋值。
Set方法只能用来赋值，在原有对象的基础上赋值，可以用来修改值。
构造方法重新赋值，相对于重新创建对象。
1. 静态代码块随着类的加载而加载，一般是用来加载驱动的。只在类加载的时候执行一次， 优先于构造方法执行
2. 构造代码块里边放的是所有构造方法的共性内容，为了简化书写，调高效率。每创建一次 对象，就执行一次，它是优先于构造方法执行的。
1. 所属不同：类变量属于类，是对象的共性内容；实例变量属于对象，是对象的特性内容。
2. 在内存中位置不同：类变量存在方法区的静态区；实例变量存在堆内存中。
3. 生命周期不同：类变量随着类的加载而存在，随着类的消失而消失；实例变量随着对象的 存在而存在，随着对象的消失而消失。
4. 调用方式不同：类变量既能被类名点的形式调用，也能通过对象点的形式调用；而实例变 量只能通过对象点的形式调用。
当多个类中有很多共性的内容时，我们可以把这些共性内容抽取出来封装成一个类，让这些类与这个封装的类产生关系。这种关系就是继承。
特点：可以从以下两方面来讲：
类与类之间的继承：只能单继承不能多继承，但是可以多层继承。
接口与接口之间的继承：既可以单继承也可以多继承。
好处：
1. 提高了代码的复用性、维护性、可扩展性。
2. 让类与类产生了关系，是多态的前提。
弊端：
增强了类与类的耦合性。
this代表本类当前对象的引用，谁调用我，我就代表谁。
super代表当前对象父类的内存空间标识。 (可以理解为父类的引用，通过super可以访问父 类的成员
不能，
super()调用的是父类的空参构造，this()调用的是本类的空参构造，因为它们都要求 放构造方法的第一行，所以不能同时使用。
访问权限修饰符是表明类成员的访问权限类型的关键字。使用这些关键字来限定程序的方法 或者变量的访问权限。
它们包含：
public: 所有类都可以访问
protected: 同一个包内以及所有子类都可以访问
默认: 归属类及相同包下的子类可以访问
private: 只有本类才能访问
多态是同一个行为具有多个不同表现形式或形态的能力。
多态的好处:
1. 提高了代码的维护性(继承保证)
2. 提高了代码的扩展性(由多态保证) 多态的弊端：不能使用子类的特有功能。
方法的重写和重载是Java多态性的不同表现。重写是父类与子类之间多态性的一种表现，重 载是一个类中多态性的一种表现。
方法重载：同一个类中,方法名相同,参数的类型、顺序和个数不同,与返回值类型和方法访问 修饰符无关
方法重写：不同类中,发生在继承类中,方法名称、参数类型、返回值类型全部相同,被重写的 方法不能拥有比父类更严格的权限
继承：在多态中必须存在有继承关系的子类和父类。
重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用 父类的方法和子类的方法
try 中是可能发生异常的程序段；
catch中依次编写对应的异常处理器方法，当抛出异常后，由运行时系统在栈中从当前位置 开始依次回查方法，直到找到合适的异常处理方法，如果未找到，则执行finally或直接结束 程序运行。 finally ：无论是否捕获或处理异常，finally 块里的语句都会被执行。
注意：
当在try 块或catch块中遇到return语句时， finally语句块将在方法返回之前被执行; finally块不会被执行情况: 在前面的代码中用了System.exit(0)退出程序。
throw用来抛出一个异常，在方法体内。语法格式为：throw 异常对象。
throws用来声明方法可能会抛出什么异常，在方法名后; 语法格式为：
throws 异常类型1，异常类型2...异常类型n。
error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指 望程序能处理这样的情况。
exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的 情况。
异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能 遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时 异常，但是并不要求必须声明抛出未被捕获的运行时异常。
final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。
finalize 是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可 以覆盖此方法提供垃圾收集时的其他资源回收
1. 抽象方法和抽象类都必须被abstract关键字修饰。
2. 抽象方法一定在抽象类中。
3. 抽象类不可以用new 创建和实例化对象。因为抽象类本身就是不完整的。
4. 抽象类中的抽象方法要被使用，必须由子类复写所有的抽象方法后，建立子类对象调用。
final：被final修饰的类不能有子类（不能被继承）。而被abstract修饰的类一定是一个父类（一定要被继承）
private: 抽象类中私有的抽象方法不被子类所知，就无法被复写；而抽象方法出现的就是需要被复写。
static：如果static 可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。可是抽象方法运行没意义。
1. 接口不可实例化，可结合多态进行使用(接口 对象=new 对象())
2. 接口里的成员属性全部是以 public(公开)、static(静态)、final(最终) 修饰符修饰
3. 接口里的成员方法全部是以 public(公开)、abstract(抽象) 修饰符修饰
4. 接口里不能包含普通方法
5. 子类继承接口必须实现接口里的所有成员方法，除非子类也是抽象类
1. 更加抽象,更加面向对象
2. 提高编程的灵活性
3. 实现高内聚、低耦合，提高可维护性，降低系统维护成本。
抽象类：是一个不能被实例化的类，因为它其中存在抽象方法，但它的其它行为和一个普通 类没什么不同。
接口：是java为了弥补不能多继承提供的概念，接口之间支持多继承，接口中只允许存在公 有静态常量或公有的抽象方法，一个类可实现多个接口，从而扩展不同的功能。
答：每种编程语言中都有集合，最初的Java版本包含几种集合类：Vector、Stack、HashTable 和Array。随着集合的广泛使用，Java1.2提出了囊括所有集合接口、实现和算法的集合框架。 在保证线程安全的情况下使用泛型和并发集合类，Java已经经历了很久。它还包括在Java并 发包中，阻塞接口以及它们的实现。集合框架的部分优点如下：
（1）使用核心集合类降低开发成本，而非实现我们自己的集合类。
（2）随着使用经过严格测试的集合框架类，代码质量会得到提高。
（3）通过使用JDK附带的集合类，可以降低代码维护成本。
（4）复用性和可操作性。
答：Java1.5引入了泛型，所有的集合接口和实现都大量地使用它。泛型允许我们为集合提供 一个可以容纳的对象类型，因此，如果你添加其它类型的任何元素，它会在编译时报错。这避 免了在运行时出现ClassCastException，因为你将会在编译时得到报错信息。泛型也使得代 码整洁，我们不需要使用显式转换和 instanceOf操作符。它也给运行时带来好处，因为不会产生类型检查的字节码指令。
答：
（1）Collection为集合层级的根接口。一个集合代表一组对象，这些对象即为它的元素。 Java平台不提供这个接口任何直接的实现。
（2）Set是一个不能包含重复元素的集合。这个接口对数学集合抽象进行建模，被用来代 表集合，就如一副牌。
（3）List是一个有序集合，可以包含重复元素。你可以通过它的索引来访问任何元素。List 更像长度动态变换的数组。
（4）Map是一个将key映射到value 的对象.一个Map不能包含重复的key：每个key 最多只能映射一个value。
（5）一些其它的接口有Queue、Dequeue、SortedSet、SortedMap和ListIterator。
答：
（1）尽管Map接口和它的实现也是集合框架的一部分，但Map不是集合，集合也不是 Map。因此，Map继承Collection毫无意义，反之亦然。
（2）如果Map继承Collection接口，那么元素去哪儿？Map 包含key-value 对，它提 供抽取key或value 列表集合的方法，但是它不适合“一组对象”规范。
答：Iterator接口提供遍历任何Collection的接口。我们可以从一个Collection中使用迭代 器方法来获取迭代器实例。迭代器取代了Java集合框架中的Enumeration。迭代器允许调用 者在迭代过程中移除元素。
答：使用包装类Integer。Integer.valueOf("2");其他基本数据类型都是类似
答：因为String是不可变的，当String创建之后，就不会再改变了。而char[]是可变的，程 序员在用完之后可以将其改变，不会留下任何原始数据。所以，在使用密码时，一般都是会用 char数组，例如JavaSwing中的JPassWordField，获取密码框的值就是使用char数据。而 不使用String。
答：使用SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date =sdf.parse("2017-12-10")。
答： String不可变的，其余两个为可变的，也就是可以自由增加或者删除字符串。 StringBuilder 和StringBuffer，前者是线程不安全的，后者是线程安全的。理论上StringBuilder 效率更高。 字符串大量拼接时，建议使用StringBuilder ，StringBuffer。
答：
（1）使用charAt方法截取之后,循环判断。
（2）使用apache commons lang包中的StringUtils：
int n = StringUtils.countMatches("ababababab", "a");
System.out.println(n);
答：
（1）字节流，字符流。
（2）字节流继承于InputStream OutputStream，
（3）字符流继承于Reader Writer。在java.io包中还有许多其他的流，主要是为了提高 性能和使用方便。
答：序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以 对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对 对象流进行读写操作时所引发的问题。
序列化的实现：将需要被序列化的类实现Serializable 接口，该接口没有需要实现的方法， implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如： FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用 ObjectOutputStream对象的writeObject(Objectobj)方法就可以将参数为obj的对象写出 (即保存其状态)，要恢复的话则用输入流。
答：
优势：对开发人员来说，使用处理流进行输入/输出操作更简单；使用处理流的执行效率 更高。
判别：处理流的构造器的参数不是一个物理节点，而是已经存在的流。而节点流都是直接 以物理IO及节点作为构造器参数的。
答：在java语言中，用stdin表示键盘，用stdout表示监视器。他们均被封装在System类的类变量in 和out中，对应于系统调用System.in和System.out。这样的两个流加上
System.err统称为标准流，它们是在System类中声明的3个类变量：
public static InputStream in；
public static PrintStream out；
public static PrintStream err；
答：
能被序列化：
①属性（包括基本数据类型、数组、对其它对象的引用）；
②类名；
不能被序列化：
①static的属性；
②方法；
③加了transient修饰符的属性。
要想序列化对象，必须先创建一个outputstream,然后把它嵌进objectoutputstream。 这时就能用writeobject()方法把对象写入outputstream,。读的时候需要把inputstream嵌 到objectinputstream中，然后在调用readobject()方法。
答：XML 可扩展标记语言(ExtensibleMarkuplanguage)，可以根据自己的需要扩展 XML。
XML 中可以轻松定义, 等自定义标签，而在 HTML 等其他标记语言中须使用预定义标签，比如，而不能使用用户定义的标。
答：DTD 与 XML Schema 有以下区别：
DTD 不使用 XML 编写而 XML Schema 本身就 是 xml 文件，这表示XML 解析器等已有的XML 工具可以用来处理 XML Schema。并且 XML Schema 是设计于DTD之后的，它提供了更多的类型来映射 xml 文件不同的数据类 型。DTD 是文档类型描述(Document Type definition)是定义 XML 文件结构的传统方式。
答：CDATA是指字符数据，它有特殊的指令被XML解析器解析。
XML 解析器解析XML 文 档中所有的文本，比如Thisisname ofperson，标签的值也会被解析，因为标签值也可能包含XML标签，比如FirstName。CDATA部分不会被XML 解析器解析。CDATA部分以结束。
答：XSLT也是常用的XML 技术，用于将一个XML 文件转换为另一种XML，HTML或者其*他的格式。XSLT为转换XML 文件详细定义了自己的语法，函数和操作符。通常由XSLT引擎 完成转换，XSLT引擎读取XSLT语法编写的XML 样式表或者XSL 文件的指令。XSLT大量使 用递归来执行转换。 一个常见XSLT使用就是将XML文件中的数据作为HTML页面显示。 XSLT 也可以很方便地把一种XML 文件转换为另一种XML 文档。
标签：最快 编译器 计算机 ++ 构造方法 异常处理 两种 内聚 默认
原文地址：https://www.cnblogs.com/daiwenxiang/p/12074803.html
