吐槽一下，书本是真的烂，错字多，代码错误多，提供答案不全

第一章 Java语言概述

2.“java编译器将源文件编译为的字节码文件是机器码”这句话正确吗？

答：不正确

javac.exe 将源文件编译为字节码的中间代码，jvm再翻译字节码解释成当前平台的机器码并执行

java中，字节码是CPU构架（JVM）的具有可移植性的机器语言。机器码(machine code)，学名机器语言指令，有时也被称为原生码（Native Code），是电脑的CPU可直接解读的数据。字节码（Bytecode）是一种包含执行程序、由一序列 op 代码/数据对 组成的二进制文件。字节码是一种中间码，它比机器码更抽象，需要直译器转译后才能成为机器码的中间代码。java文件编译过后会生成一个class文件，里面是以二进制方式存放的代码，机器可以识别class文件中的内容，然后作出相应的操作。

3.java应用程序的主类必须含有怎样的方法？

答：含有main方法

main方法是程序的入口，必须含有main方法

1，java允许类不加public关键字约束。

2，由于JVM在运行这个Java应用程序的时候，首先会调用main方法，调用时不实例化这个类的对象，而是通过类名直接调用因此需要限制为public static。(类名.main())

对于java中的main方法，jvm有限制，不能有返回值，因此返回值类型为void。

main方法中还有一个输入参数，类型为String[]，这个也是java的规范，main()方法中必须有一个入参，类型必须String[]，至于字符串数组的名字，这个是可以自己设定的，根据习惯，取名为args。因此，main()方法定义必须是：“public static void main(String 字符串数组参数名[])”。

4。“java应用程序必须有一个类是public类”这句话正确吗？

答：不正确，只能有一个public类 不是必须，可以没有

public类不是必须的，java文件中可以没有public类。public的类的类名必须和文件名相同，是为了方便虚拟机在相应的路径中找到相应的类所对应的字节码文件。编译器在编译时，针对一个java源代码文件只会接受一个public类。否则报错。（参考上一个问题，一个入口）

6。请叙述java源程序的命名规则。

答：与public的类同名。

• java 结尾
• 如果源文件没有 public 类，那么文件名只要跟某个类名相同

7。源文件生成的字节码文件在运行时都加载到内存中吗？

答：字节码文件是动态加载的，随需要运行才加载。

在运行JAVA文件的时候，首先会在内存中创建一个jvm，然后把硬盘里的class文件加载进来（和类加载器有关，按需加载），利用jvm去解释这些class文件，最后运行程序。

8.面向对象的程序设计语言有那些基本特征？

答：封装；继承；多态性（操作名称的多态、继承的多态）

9.在Java程序中有多个类文件时，用Java命令应该运行哪个类？

答：具有main方法的类

第二章 基本数据类型和数组

4。下列哪些语句是错的？

Int x=120；
Byte b=120；  
b=x；

答：B=x；错应为 b=（byte）x

高精度向低精度转换要强转

5。下列哪些语句是错的？

答：y=d；错，应y=（float）d

跟上题同理

6。下列两个语句是等价的吗？

Char  x=97;
Char  x=‘a’;

答：是等价的。

定义为字符型，'a'的ASCLL码是97

7。下列system.out.printf语句输出结果是什么？

Int  a=97;
Byte b1=(byte)128;
Byte b2=(byte)(-129);
System.out.printf(“%c,%d,%d”,a,b1,b2);

如果输出语句改为：

System.out.printf(“%d,%d,%d”,a,b1,b2);

输出什么？

答：输出a ， -128， 127

修改后输出 97，-128，127

运行上述代码之后输出的结果是-128。 这是因为byte类型的127在计算机底层是表示形式是01111111。加1之后则变为10000000，也就是-128。(涉及到原码、反码和补码的知识)

8.数组是基本数据类型吗？怎样获取数组的长度？

答：不是基本数据类型，是复合数据类型。可以通过：数组名.length的方法获得数组长度

9。假设有两个int类型数组：

Int[] a=new int[10]；
Int[] b=new int[8]；
b=a；
A[0]=100;

B[0]的值一定是100吗？

答；一定，因为a数组与b数组引用相同。

10。下列两个语句的作用等价吗？

Int[]  a={1，2，3，4，5，6，7，8}；
Int[]  a=new int[8];

答：不等价，前者有初值，后者指分配空间。初值数组元素为0

11.有语句：

int [] a={1,2,3},b={4,5};
a=b;

求a[0]=? b[1]=? 为什么？

答： a[0]=4 ; b[1]=5 因为有相同的引用，同指向b[].

12. Java语言使用 ? 编码，每个字符占 ? 字节 ? byte位

Unicode 2 16

第三章 运算符、表达式和语句

1。下列语句输出的结果是什么？

Int a=100, x,y;
X=++a;
Y=a--
System.out.printf(“%d, %d,%d”,x,y,a);

答：101，101，100

2。下列语句那些有错误?

Int x=0;
X=5.0/2;
Float y=12.5F;
y=5.0/2;

答：x=5.0/2; 错。

3。下列语句那些有错？

Byte x=32;
Char c=‘a’;
Int n=c-x;
c=c-x;

答：c=c-x；错 应为 int类型。

4下列语句正确的是

A.表达式“12+56>34”的值是true

B.表达式“12+56||34”是非法表达式

C.表达式“x+y=12”是非法表达式

D.表达式“12+56>34”的值是13

答： （A, B, C ）

5。对于整数m， m<<1的结果一定是2m吗？

答：不一定，高位有损失时，不是2m

6.对于两个int整形变量

Int m=120, n=240;

那么m^m=?;

m^n=?

答：m^m=0; m^n=120

7.下列System.out.printf语句输出的结果是什么？

Int x=10, y=10, z=10;
If(x>9){
y=100;
Z=200;
}
Else
	y=-100;
z=-200;
System.out.printf(“%d,%d,%d”,x,y,z);

输出： 10，100，-200

8.下列for语句输出结果是什么？

For(int i=1; i<=4; i++){

Switch(i){

Case 1: System.out.printf(“%c”,’a’);

Case 2: System.out.printf(“%c”,’b’);

Break;

Case 3: System.out.printf(“%c”,’c’);

Case 4: System.out.printf(“%c”,’d’);

Break;

}    
    
}

输出：a,b, b,c,d,d

9.下列System.out.printf语句输出的结果是什么？

Char a[]={‘a’,’b’,’c’,’d’,’e’};

For(i=0; i<=a.length/2; i++)

{

 char c=a[i];

 a[i]=a[a.length-(i+1)];

 a [a.length-(i+1)]=c;

}

System.out.printf(“%c%c%c%c%c”a[0],a[1],a[2],a[3],a[4]);

输出：e,d,c,b,a

10.下列System.out.printf语句输出的结果是什么？

 int a[]={3,4,1,2,-6};

for(int i=0; i<a.lemgth;i++){

  for(int j=i+1;j<a.length;j++){

​    if(a[j]<a[i]){

Int  n=a[j]; a[j]=a[i]; a[i]=n;}  }  }

System.out.printf(“%d,%d,%d,%d,%d”,a[0],a[1],

​          a[2],a[3],a[4]);

输出：-6,1,2,3,4

11.下面程序的输出结果是什么

x=-5,y=-1

最后一次while循环y=0时还要做一次--操作

第四章 类与对象

1.在声明类时，类名应遵循哪些习惯？

答：首字母大写， 望名知意

2.类体内容有哪两种重要成员？

答：成员变量，成员方法。

3.实例方法可以操作类变量吗？类方法可以操作实例变量吗？

答：实例方法可以操作类变量。

而类方法不可以操作实例变量。类方法只能操作类变量，而且类方法不能调用实例方法.

4.当类的字节码加载到内存时，类变量就一定分配了内存空间吗？

答：实例成员变量不分配内存，而类变量一定分配内存。

5.类的实例变量在什么时候分配内存？

答:声明之后，在用new关键字创建实例的时候才分配内存。

6.一个类的类变量被该类创建的所有对象共享吗？

答：共享

7.不同对象的实例变量分配的内存地址一定不同吗？

答：当出现引用赋值语句时两个实例变量的内存地址相同。

8.什么叫方法的重载？构造方法可以重载吗？

答：方法的重载是指一个类中可以有多个方法具有相同的名字，但这些方法的参数不同，或者参数的个数不同，或者参数的类型不同。构造方法可以重载。

9.请阐述为什么类方法不能调用实例方法？

答：对于类方法在该类加到内存时就分配了相应的入口地址，所以即使该类未创建对象，也可以通过类名调用类方法。而这时在类对象创建之前，实例方法还没有入口地址。还不知道一个方法从何处开始执行，当然不能调用。

10.请阐述，为什么类方法中不能操作实例成员变量？

答：对于类方法在该类加到内存时就分配了相应的入口地址，所以即使该类未创建对象，也可以通过类名调用类方法。而这时在类创建之前，实例成员变量还没有分配内存空间。没内存空间当然无法操作。

11.实例方法可以用类名直接调用吗？

答：不能，因为实例方法，用new创建对象后才分配入口地址，而类名，一经声明就分配类名地址。而这时对象创建之前实例方法还没有入口地址。实例方法表现实例的功能，或改变实例变量。用类调用改变那个实例的实例变量，表现那个实例的功能，不明确。

12.关键字this可以出现在构造方法中吗？可以出现在实例方法中吗？可以出现在类方法中吗？

答：可以出现在构造方法中，代表该类构造方法所创造出的对象。

可以出现在实例方法中，代表使用该方法的当前对象。

This不能出现在类方法中，因为类方法是通过类名调用的。

13.源文件声明编写的类一定在同一个包中吗？

答：不一定，当不在同一包中时，可用import语句将其所在的包引入该源文件中。

14.“import java.awt.*”与“import java.awt.Button”有什么不同？

答：前者引入了awt包中的所有类，后者只引入了Button一个类。

15.程序中使用了“import java.util.*;”程序运行时，是要加载java.util包中的全部类到内存吗？

答：不，只加载本程序用到的类到内存中，因为java程序是动态加载，字节码类文件。

16.有哪几种访问权限修饰符？说出一种的作用。

答：访问权限修饰符有public, private,protected.

Private作用是只允许本类的对象访问。

17.下面程序中那个语句是错的？

class A 

{  

  private float weight;  //weight被修饰为private的float型变量。

  public float f(float a,float b)  //方法 f是public方法。

   {    	return a; }         }

public class B

  {  

  void g()  

  { 

​    A a=new A();

​    a.weight=23f;  

​    a.f(3,4);   

}   }

答：a.weight=23f;错

18.请写入下列代码中类A的输出结果

class B{
    int n;
    static int sum = 0;
    void setN(int n){
        this.n = n;
    }
    int getSum(){
        for (int i=1;i<=n;i++){
            sum=sum+i;
        }
        return sum;
    }

    public static void main(String[] args) {
        B b1= new B(),b2= new B();
        b1.setN(3);
        b2.setN(5);
        int s1 = b1.getSum();
        int s2 = b2.getSum();
        System.out.println(s1+" "+s2);
        System.out.println(s1+s2);
    }
}	

27

类变量被所有对象共享

第五章 继承、接口与泛型

1。子类在什么情况下可以继承父类的友好成员？

答：父子类在同一包中时子类可以继承父类的友好成员。

2。子类通过什么办法，可以隐藏继承的成员变量。

答：子类成员变量与父类成员变量同名。

3。子类重写继承方法的规则是什么？

答：重写隐藏父类的方法需：返回的数据类型相同，参数的个数相同，并且类型相同，操作名称相同。

如果重写父类的方法后参数的个数或类型不同会出现子类方法的重载。

4.子类的构造方法的第一条语句是什么？

答：如果需要调用父类构造方法，则应是用super关键词调用父类的构造方法。

5。子类一旦重写了继承的方法，就会隐藏继承的方法。是这样吗？

答：不一定。在参数的个数或类型不同时会产生重载。如果只有返回值的类型不同，将会产生编译错误。

即重写可能会引发重载

(5)子类隐藏父类的方法，参数必须？相同并且？相同.

答： 个数 ，类型

6。子类重写继承方法时，可以降低方法的权限吗？

答：重写继承方法时不能降低访问权限。

7。简述关键字super的用法。

答：1）子类调用父类的构造方法。

2）子类对象引用被隐藏了的父类方法，或成员变量。

8.假设父类有一个方法：

Public double f(double x, double y){

return x+y;

}

是否允许子类再声明如下的方法：

Public float f(double x, double y){

return 23;

}

答：不允许。产生编译错误。

9。父类的final方法可以被子类重写吗？

答：不可以

10。什么类中可以有abstract方法？

答：被abstract修饰的类。接口中也可以有abstract方法

11。什么叫做对象的上转型对象？

答：用子类的构造方法构造出来的对象，赋值给父类对象。

12。什么叫接口回调？

答：用实现接口的类创建的对象，赋值给该接口声明的接口变量。

13。与类有关的匿名类一定是该类的子类吗？与接口有关的匿名类一定是实现该接口的一个类吗？

答：一定，因为类创建对象时，除了构造方法还有类体，此类体被认为是该类的一个子类去掉类声明后的类体。即匿名类，匿名类就是一个子类。与接口的匿名类相同。一定是子类。

14。怎样声明一个泛型类？

答：我们可以这样声明一个泛型类：

class A<E> 其中A时泛型的名称，E是其中的泛型，即我们没有指定E是何种类型的数据，它可以是任何对象或接口，但不能是基本数据类型。

15阅读下列程序，并说明输出结果。

class NegativeIntegerException extends Exception{
   String  message;
   public NegativeIntegerException(){
     message="方法的参数值不是正整数";
     }
   public String toString(){
    return  message;
   }
 }

class MaxCommonDivisor{
  public int getMaxCommonDivisor(int a, int b)throws NegativeIntegerException{
  if(a<0||b<0)
   throw new NegativeIntegerException();
   int r=0;
   if(a>b){
   int t=a;  a=b;  b=t;
   }
   r=a%b;
   while(r!=0){
   a=b;
   b=r;
   r=a%b;
   }
   return b;
  }
}

class MinCommonMultiple extends MaxCommonDivisor{

public int getMinCommonMultiple(int a, int b)throws NegativeIntegerException{
 
  if(a<0||b<0)
   throw new NegativeIntegerException();
   int y=0;
   int x=getMaxCommonDivisor(a,b);
   y=(a*b)/x;
   return y;
  } 
}

public class Example{
  public static void main (String arg[]){
  	int maxCommonDivisor,  minCommonMultiple;
  	MaxCommonDivisor  max=new MaxCommonDivisor();
  	MinCommonMultiple min = new MinCommonMultiple();
  	try{
  	  maxCommonDivisor=max.getMaxCommonDivisor(18,12);
  	  System.out.println("最大公约数："+ maxCommonDivisor);
  	  minCommonMultiple=min.getMinCommonMultiple(18,12);
  	  System.out.println("最小公倍数："+minCommonMultiple);
  	  maxCommonDivisor=max.getMaxCommonDivisor(-64,48);
  	  System.out.println("最大公约数："+maxCommonDivisor);
  	}
  	catch(NegativeIntegerException e){
  		System.out.println(e.toString());
  		}
  	}
}

最大公约数：6
最小公倍数：36
方法的参数值不是正整数
   
捕获到异常try最后一条语句不执行！

16.下列程序中，错误的代码是哪个？

代码4

重写继承方法时不能降低访问权限。

第六章 字符串和正则表达式

1。对于字符串

String S1=new String(“OK”);

String S2=new String(“OK”);

说出下列表达式的值：

S1==S2

S1.equals(S2)

答：（1） false (2) true

2.对于字符串

String s1=new String(“I love you zhht”);

String s2=s1.replaceAll(“love”,”hate”);

说出System.out.printf(“%s, %s”, s1,s2)的结果。

结果：I love you zhht , I hate you zhht

3.String 类和StringBuffer类有何不同？

答：String 类创建的字符串对象存储空间是不能修改的。

而使用StringBuffer类创建的对象是可以修改其字符串序列，即该类的对象的实体内存空间是可以改变的，便于存放可变字符串。

实体就是给每个对象分配的成员变量，成员变量有各自的内存空间

4。对于StringBuffer串

StringBuffer str=new StringBuffer(“abcdefg”);

str=str.delete(2,4);

说出System.out.println(str)的结果。

答：abefg (4为需要删除的下一个字符的下标)

5.StringTokenizer类的主要用途是什么？该类有哪几个重要的方法？

答：当我们分析一个字符串并将字符串分解成可被独立使用的单词时，可以使用java.util包中的StringTokenizer类.

可以使用nextToken()方法逐个获取字符串分析器中的语言符号（单词），每当获取到一个语言符号，字符串分析器中的负责计数的变量的值就自动减一，该计数变量的初始值等于字符串中的单词数目.

字符串分析器调用countTokens()方法可以得到计数变量的值。

字符串分析器通常用while循环来逐个获取语言符号，为了控制循环，我们可以使用StringTokenizer类中的hasMoreTokens()方法，只要计数的变量的值大于0，该方法就返回true，否则返回false。

只需要记住四个东西

StringTokenizer,nextToken,countTokens,hasMoreTokens

6。下列System.out.printf语句的输出结果是什么？

String s=new String(“we, go, to, school”);

StringTokenizer token=new StringTokenizer(s,”,”);

String word=token.nextToken();

Int n=token.countTokens();

System.out.printf(“%s,%d”,word,n); 

答：We ，3

3 的原因是 countTokens 只显示还未读取的单词数量

7。请说出Matcher对象的find()方法和lookingAt()方法有什么不同？

答：public boolean find() ：寻找input和pattern匹配的下一子序列

public boolean lookingAt()：判断从input的开始位置是否有和pattern匹配的子序列。

8。正则表达式中的元字符[123]代表什么意思？

答：代表1，2，3中的任何一个

9。说出与模式“A[125]{2}”匹配的4个字符串。

答：A12，A25，A15，A52

10。下列哪些字符串匹配模式“boy\w{3}”

boy111 B. boy!@#

C. Boyweo D. Boyboybpy

答：C。 boyweo A.boy111

11.有模式pattern=“A[1359]?”

求和模式pattern相匹配的全部字符串？

答： “A” , “A1”, “A3”, “A5”, “A9”

12.一个正则表达式是含有一些具有?的字符串，这些特殊字符称作正则表达式中的?

答：特殊意义字符, 元字符

第七章 常用实用类

1.怎样实例化一个Calendar对象？

答：Calendar类在java.util包中。使用Calendar类的static方法getInstance()可以初始化一个日历对象，如：

Calendar calendar= Calendar.getInstance();

2.Calendar对象调用set(1949, 9,1)设置的年月日分别是多少？

答：1949年10月1日

3.怎样得到一个1--100之间的随机数？

答：int randomNumber=(int)(Math.random()*100)+1

4.BigInteger类的常用构造方法是什么？

答：可以使用构造方法： public BigInteger(String val)

5.两个BigInteger类对象怎样进行加法运算？

答：BigInteger n1=new BigInteger ("大整数字符串"),

​ n2=new BigInteger("大整数字符串"),

​ result=null;

​ result=n1.add(n2);

6.LinkedList泛型类是一种什么数据结构？

答：是一种链表类数据结构。

7.对于需要经常查找的数据，应选用LinkedList还是选用HashMap<K,V>?

答：选用HashMap<K,V>

第八章 线程

1.线程和进程是什么关系？

答：线程是比进程更小的执行单位。一个进程在其执行过程中，可以产生多个线程，形成多条执行线索，每条线索，即每个线程也有它自身的产生、存在和消亡的过程，也是一个动态的概念。

2.线程有几种状态？

答：新建状态， 运行状态，中断状态，死亡状态

3.引起线程中断的常见原因是什么？

答：有4种：有4种原因的中断：

（a） JVM将CPU资源从当前线程切换给其他线程，使本线程让出CPU的使用权处于中断状态。

（b）线程使用CPU资源期间，执行了sleep(int millsecond)方法。

（c）线程使用CPU资源期间，执行了wait()方法。

(d) 线程使用CPU资源期间，执行某个操作进入阻塞状态，比如执行读/写操作引起阻塞。

4.一个线程执行完run（）方法后，进入什么状态？该线程还能再调用start（）方法吗？

答：一个线程执行完run（）方法进入死亡状态，之后还能再调用start（）方法运行

5.线程在什么状态时，调用isAlive()方法后返回值是false？

答:当线程进入死亡状态后（实体内存被释放），线程仍可以调用方法isAlive（），这时返回的值是false。（线程未调用start方法之前，调用isAlive()方法返回false).

6.线程调用interrupt()的作用是什么？

答： intertupt方法经常用来“吵醒”休眠的线程。当一些线程调用sleep方法处于休眠状态时，一个使用 CPU资源的其它线程在执行过程中，可以让休眠的线程调用interrupt 方法“吵醒”自己，即导致休眠的线程发生InterruptedException异常，从而结束休眠，重新排队等待CPU资源。

8.wait(), notify(), notifyAll()的作用分别是什么？

答：wait（）、notify（）和notifyAll（）都是Object类中的final方法，被所有的类继承，且不允许重写的方法。

当一个线程使用的同步方法中用到某个变量，而此变量又需要其它线程修改后才能符合本线程的需要，那么可以在同步方法中使用wait（）方法。使用wait（）方法可以中断方法的执行，使本线程等待，暂时让出CPU的使用权，并允许其它线程使用这个同步方法。其它线程如果在使用这个同步方法时不需要等待，那么它使用完这个同步方法的同时，应当用notifyAll（）方法通知所有的由于使用这个同步方法而处于等待的线程结束等待。(如果使用notify()方法则只通知处于等待中的某一个线程结束等待)

9.将例子10中的TicketSeller类中的循环条件：

While(fiveNumber<1)

改写成：

If(fiveNumber<1)是否合理，理由是什么？

答：是合理的，因为此循环只有一种可能作循环体内的语句。

10.将例子10中的TicketSeller类中出现的：

Wait( )

改写成：

Thread.sleep(2000)从新编译，运行，观察结果。

答：sleep(2000)线程到时醒来排队，这期间中断的原因不一定解决，wait()则直到中断原因消失才结束等待。

11.什么叫守护线程？

答：一个线程调用

void setDaemon(boolean on)

方法可以将自己设置成一个守护（Daemon）线程，例如：

thread.setDaemon(true);

线程默认是非守护线程，非守护线程也称作用户（user）线程。

当程序中的所有用户线程都已结束运行时，即使守护线程的run方法中还有需要执行的语句，守护线程也立刻结束运行。一般地，用守护线程做一些不是很严格的工作，线程的随时结束不会产生什么不良的后果。一个线程必须在运行之前设置自己是否是守护线程。

12.对于thread(Runnable target)构造的线程使用同一目标对象的线程，目标对象的成员变量自然成为这些线程_____________的数据单元。

答： 共享

第九章 输入、输出流

1.如果准备读取一个文件应使用FileInputStream流还是使用FileOutputStream流？
答：FileInputStream
2.FileInputStream流的read()方法和FileReader流的read()方法有什么不同？
答： FileInputStream流从输入流中顺序读取单个字节的数据。该方法返回字节数据值（0--255之间的整数）到末尾返回-1
FileReader流，输入流调用该方法从源中读取一个字符，该方法返回一个0---65535之间的一个整数（Unicode字符值）到末尾返回-1 。
3.BufferReader流能直接指向一个文件对象吗？
答：不能，要通过一个，底层的FileReader类的对象，才能指向一个文件对象。
4.ByteArrayOutputStream流怎样获取缓冲区中的内容？
答：这个流的对象可以通过public byte[ ] toByteArray( )方法，将刚刚写入缓冲区的内容全部返回。
5.DataInputStream类和DataOutputStream类的主要用途是什么？
答： 主要是将java基本数据类型写入底层流或以Java基本数据类型的方式读出底层流的内容。
6.使用ObjectInputStream类和ObjectOutputStream类有哪些注意事项？
答：值得注意：当用对象流写入或读出对象时，要保证对象是序列化的，对象实现Serializable接口。这是为了保证能把对象写到文件，并能再次把对象正确读回到程序中。
Java提供给我们的绝大多数对象都是所谓序列化的，比如组件等。一个类如果实现了Serializable接口，那么这个类创建的对象就是所谓序列化的对象。 Serializable接口中的方法对程序是不可见的，因此实现该接口的类不需要实现额外的方法，当把一个序列化的对象写入到对象输出流时，JVM就会实现Serializable接口中的方法，按着一定格式的文本将对象写入到目的地。

7.怎样使用输入/输出流技术克隆对象？
答：使用对象流很容易得获取一个序列化对象的克隆。我们只需将该对象写入到对象输出流，然后用对象输入流读回的对象就是原对象的一个克隆。
如：

Shop shop1=new Shop();
        Goods s1[]={new Goods("TV"),new Goods("PC")};
        shop1.setGoods(s1);
        try{   
            ByteArrayOutputStream out=new ByteArrayOutputStream();
              ObjectOutputStream objectOut=new ObjectOutputStream(out);
             objectOut.writeObject(shop1);  
              ByteArrayInputStream in=new ByteArrayInputStream(out.toByteArray());
              ObjectInputStream objectIn=new ObjectInputStream(in);
              Shop shop2=(Shop)objectIn.readObject();
        }

Shop2就是shop1的克隆。而且是深拷贝。

注意一下 out.toByteArray()的用法

8.使用RandomAccessFile类读写文件的好处是什么？
答 (1)用这个类创建的流对象，建立的流既可以向文件写，也可以从同一文件读出。
(2)可以将读取文件，或写入文件的任意位置。
9.使用RandomAccessFile类创建的流？输入流，？输出流。
答： 既不是， 也不是
10.经常使用File类的对象获取文件本身的一些信息，但不可以获得文件的______________
答：内容

第十一章 网络编程

1. 一个URL对象通常包含哪些信息？

   统一资源定标识（协议，主机地址，资源路径），返回的输入流（调用inputStream()方法）

2. 怎样读取URL中的资源？

   从返回的输入流中读取，默认是字节输入流。

3. 客户机的Socket对象与服务器的Socket对象是怎么通信的？

   服务器先创建ServerSocket对象，指定一个默认的监听端口，启动一个新线程执行该对象的accept方法，进入等待状态，即等待客户端套接字的连接。

   客户端创建Socket对象，指定访问的主机地址和端口号，期间是 TCP 的三次握手，分别是客户端发送TCP连接请求进入同步已发送状态，服务端确认TCP连接请求，进入同步已接收状态，客户端接收后进入连接已建立状态，再给服务器发送TCP连接确认的确认（普通的TCP确认报文段可以夹带数据），服务器接收到进入连接已建立状态。

   之后服务器的accept()方法将得到一个socket对象，获取输入流（客户端发送给服务器的数据通道）、输出流（服务器发送给客户端的数据通道）

   客户端创建的Socket对象获取输入流、输入流。之后双方就可以基于四个流进行通信。

4. ServerSocket对象调用什么方法来建立服务器端的Socket对象？该方法有什么特点?

   accept方法，调用后阻塞当前线程，需要开启新线程调用。

5. TCP通信与UDP通信的不同？

   

UDP是无连接不可靠服务，TCP是面向连接可靠服务，UDP可以单、多、广，TCP只能单。UDP传送协议数据单元PDU是用户数据报，TCP协议数据单元是TCP报文段，以及应用方面的不同。

7. D类地址是什么？与ABC类地址不同在哪？

   D类地址是多播组地址，负责一对多通信。ABC是主机可分配地址，D类主机不可分配地址，但是可以配置给主机的多播地址表。

第十二章 JDBC

仅需记住两段代码

package com.runoob.test;
 
import java.sql.*;
 
public class MySQLDemo {
 
    // MySQL 8.0 以上版本 - JDBC 驱动名及数据库 URL
    static final String JDBC_DRIVER = "com.mysql.cj.jdbc.Driver";  
    static final String DB_URL = "jdbc:mysql://localhost:3306/RUNOOB?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC";
 
    // 数据库的用户名与密码，需要根据自己的设置
    static final String USER = "root";
    static final String PASS = "123456";
 
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        try{
            // 注册 JDBC 驱动
            Class.forName(JDBC_DRIVER);
        
            // 打开链接
            System.out.println("连接数据库...");
            conn = DriverManager.getConnection(DB_URL,USER,PASS);
        
            // 执行查询
            System.out.println(" 实例化Statement对象...");
            stmt = conn.createStatement();
            String sql;
            sql = "SELECT id, name, url FROM websites";
            ResultSet rs = stmt.executeQuery(sql);
        
            // 展开结果集数据库
            while(rs.next()){
                // 通过字段检索
                int id  = rs.getInt("id");
                String name = rs.getString("name");
                String url = rs.getString("url");
    
                // 输出数据
                System.out.print("ID: " + id);
                System.out.print(", 站点名称: " + name);
                System.out.print(", 站点 URL: " + url);
                System.out.print("\n");
            }
            // 完成后关闭
            rs.close();
            stmt.close();
            conn.close();
        }catch(SQLException se){
            // 处理 JDBC 错误
            se.printStackTrace();
        }catch(Exception e){
            // 处理 Class.forName 错误
            e.printStackTrace();
        }finally{
            // 关闭资源
            try{
                if(stmt!=null) stmt.close();
            }catch(SQLException se2){
            }// 什么都不做
            try{
                if(conn!=null) conn.close();
            }catch(SQLException se){
                se.printStackTrace();
            }
        }
        System.out.println("Goodbye!");
    }
}

    public void InsertT(String Dbs,String exeInsert) {
        try {
            String connect="jdbc:mysql://localhost:3306/"+Dbs+"?serverTimezone=UTC";
            Connecton con=DriverManager.getConnection(connect,"root","sql2008");
            PreparedStatement pre=con.prepareStatement(exeInsert);
            int ok=pre.executeUpdate();
            if(ok==1)
                System.out.println("数据插入成功");
            else
                System.out.println("数据插入失败");
            con.close();
        }
        catch(SQLException e) {
            System.out.print(e);
        }
    }

注意下面两句话的用法

PreparedStatement pre = con.prepareStatement(exeInsert);
int ok = pre.executeUpdate();

更多参考 Java使用JDBC开发 之 PreparedStatement接口预处理对象_ONESTAR博客的博客-CSDN博客

你记得吗？类在实现接口方法时，一定要用public来修饰。