牛客 day2 - 7

9.25 day 2

1.

简述方法重写与方法重载的意义与区别：

方法重写：

1.参数列表必须完全与被重写方法相同

//参数列表（分为四种）：

（1）无参无返回值方法；

（2）有参无返回值方法；

（3）无参有返回值方法；

（4）有参有返回值方法；

2.返回类类型必须和被重写方法的返回类型完全相同

3.方法名相同

访问权限不能比父类被重写发方法的访问权限更低，此为一大

父类的成员方法只能被它的子类重写

声明为final的不能被重写

声明为static的方法不能被重写

子类和父类在同一包中，那么子类可以重写父类的所有方法，除了声明为private和final的方法

子类和父类不在同一个包中，那么子类只能够重写父类声明为public和protected的非final方法

重写的方法能够抛出任何非强制性异常,无论重写

强制性异常：所谓强制性异常就是在编写程序的过程中必需在抛出异常的部分try catch 或者向上throws异常。

** 非强制性异常**：所谓非强制性异常就和上面相反了

构造方法不能被重写

如果不能继承一个方法，则不能重写

方法重载：

被重载的方法必须改变参数列表（参数个数或类型或顺序不一样）

被重载的方法可以改变返回类型

可以改变访问修饰符

可以声明新的或更广的检查异常

无法以返回值类型作为重载函数的区分标准

因为重写的返回类型可以比父类小

2.

了解一下

hashCode方法本质就是一个哈希函数，这是Object类的作者说明的。Object类的作者在注释的最后一段的括号中写道：将对象的地址值映射为integer类型的哈希值。但hashCode()并不完全可靠的，有时候不同的对象他们生成的hashcode也会一样，因此hashCode()只能说是大部分时候可靠。

通常我们比较两个对象是否相同，我们会重写equals()，因为原版的equal效率比较低下，利用hashcode 生成hash值进行比较，这样通过equal比较的两个hashcode值肯定相同，如果这个hashcode相同了，再对比他们的equals()

equals()相等的两个对象hashCode()一定相等。

hashCode()相等的两个对象equal()不一定相等

3.

public class ZeroTest {
    public static void main(String[] args) {
     try{
       int i = 100 / 0;
       System.out.print(i);
      }catch(Exception e){
       System.out.print(1);
       throw new RuntimeException();
      }finally{
       System.out.print(2);
      }
      System.out.print(3);
     }
 }

分析：

catch捕捉之后，1

抛出异常之后程序终止，finally执行

throw抛出异常之后程序就不继续往下执行了。

answer:12

4.

public class Arraytest{
    int a[] = new int[6];
    public static void main ( String arg[] ) {
        System.out.println ( a[0] );
    }
}

在static方法中不能访问静态变量a,需要将a声明为static

5.

我们还要来补充一个运算符的补充知识点：

1、>>:右移运算符，num >> 1,相当于num除以2。

按二进制形式把所有的数字向右移动对应位数，低位移出（舍弃），高位的空位补符号位，即正数补零，负数补1。符号位不变。

如：

-1在32位二进制中表示为：

11111111 11111111 11111111 11111111

-1>>1：按位右移，符号位不变，仍旧得到11111111 11111111 11111111 11111111

因此值仍为-1

2、>>>:二进制右移补零操作符，左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充

如value >>> num中，num指定要移位值value 移动的位数。

扩展资料

“>>”和“>>>”等移位运算符的运算规则：

1、无符号右移，忽略符号位，空位都以0补齐。

value >>>a，a是要移位值value 移动的位数。

无符号右移的规则只记住一点：忽略了符号位扩展，0补最高位 无符号右移运算符>>> 只是对32位和64位的值有意义。

2、右移位运算符>>，若操作的值为正，则在高位插入0；若值为负，则在高位插入1。

右移补零操作符>>>，无论正负，都在高位插入0。

没有<<<是因为不需要

6.

interface中的方法默认为public abstract 的 ，变量默认为public static final 
    //不能有private出现

7.

Float正确赋值方式：

Float a = new Float(1.0)

Float f = 1.0f 若不加f会被识别成double型，double无法向float转换

8.

标准输入指键盘输入；标准输出指输出到屏幕上。

记住System,out,println()就不会错

一般用 System,in创建inputStream对象，用Symstem,out创建outputStream对象

9.

方法头指：修饰符+返回类型 +方法名（形参列表）

方法名相同，参数类型相同

子类返回类型小于等于父类方法返回类型， 子类抛出异常小于等于父类方法抛出异常， 子类访问权限大于等于父类方法访问权限。

所以说返回类型可以不同的

10.

intValue()是把Integer对象类型变成int的基础数据类型

parseInt()是把String变成int的基础数据类型

ValueOf()是把String转化为Integer对象类型

11.

执行结果是？

class BaseClass {
    public BaseClass() {}
 
    {
        System.out.println("I’m BaseClass class");
    }
 
     static {
         System.out.println("static BaseClass");
     }
 }
 
 public class Base extends BaseClass {
     public Base() {}
 
     {
         System.out.println("I’m Base class");
     }
 
     static {
         System.out.println("static Base");
     }
 
     public static void main(String[] args) {
         new Base();
     }
 }

 
public class Father {  
    static {
        System.out.println("父类静态代码块");    }
​
    {
        System.out.println("父类非静态代码块");    }
     public Father(){
        System.out.println("父类构造函数");    }   }
public class Son extends Father{ 
    static {
        System.out.println("子类静态代码块");    }
​
    {
        System.out.println("子类非静态代码块");    } 
    public Son(){
        System.out.println("子类构造函数");    }
    public static void main(String[] args) {
        Son son = new Son();    }
}
​
/*结果为：   父类静态代码块
    子类静态代码块
    父类非静态代码块
    父类构造函数
    子类非静态代码块
    子类构造函数 
​
​

父类静态代码块->子态静态代码块->父类非静态代码块->父类构造函数->子类非静态代码块->子类构造函数

12.

输出结果？

public class EqualsMethod
{
    public static void main(String[] args)
    {
        Integer n1 = new Integer(47);
        Integer n2 = new Integer(47);
        System.out.print(n1 == n2);
        System.out.print(",");
        System.out.println(n1 != n2);
    }
}
​

使用Integer a = 1;或Integer a = Integer.valueOf(1); 在值介于-128至127直接时，作为基本类型。

使用Integer a = new Integer(1); 时，无论值是多少，都作为对象。

false,true

13.

public class Test {
    private static int j = 0;
 
    private static Boolean methodB(int k) {
        j += k;
        return true;
    }
 
    public static void methodA(int i) {
        boolean b;
        b = i < 10 | methodB(4);
        b = i < 10 || methodB(8);
 
    }
 
    public static void main(String args[]) {
        methodA(0);
        System.out.println(j);
    }
}

这道题主要考的是"|"与"||"的区别

用法：condition 1 | condition 2、condition 1 || condition 2

"|"是按位或：先判断条件1，不管条件1是否可以决定结果（这里决定结果为true)，都会执行条件2

"||"是逻辑或：先判断条件1，如果条件1可以决定结果（这里决定结果为true)，那么就不会执行条件2

14.

public static void main(String[] args) {
    Object o1 = true ? new Integer(1) : new Double(2.0);
    Object o2;
    if (true) {
    o2 = new Integer(1);
    } else {
        o2 = new Double(2.0);
    }
    System.out.print(o1);
    System.out.print(" ");         
    System.out.print(o2);
}
​

三元操作符如果遇到可以转换为数字的类型，会做自动类型提升。

1.0 1

R：

1.程序计数器是一块较小的内存空间，它的作用可以看做是当前线程所执行的字节码的信号支持器，每个线程都需要一个独立的程序计数器

2.方法区是各个线程共享的内存区域，它用于存储已经被虚拟机加载的常量、即时编译器编译后的代码、静态变量等数据

3.java虚拟机栈描述的是java方法执行的内存运行，每个方法被执行的时候都会创建一个栈帧，用于存储 局部变量表、动态链接等信息

4.java堆：对于绝大多数应用来说，这块区域是JVM所管理的内存中最大的一块

5.JDBC：Java Database Connectivity，是标准的javaAPI，是一套客户端程序与数据库交互的规范

9.26 day 3

1.类变量（static）在不设置初始值时,会进行默认值赋值，而局部方法中声明的变量则必须进行初始化，它不会进行默认值赋值

2.了解forward,redirect:

URL:统一资源定位符，又是也被俗称为网页地址

http://www.runoob.com/index.html?language=cn#j2se

• 协议为(protocol)：http

• 主机为(host:port)：www.runoob.com

• 端口号为(port): 80 ，以上URL实例并未指定端口，因为 HTTP 协议默认的端口号为 80。

• 文件路径为(path)：/index.html

• 请求参数(query)：language=cn

• 定位位置(fragment)：j2se，定位到网页中 id 属性为 j2se 的 HTML 元素位置 。

1.从地址栏显示来说

forward是服务器请求i资源，服务器直接访问目标地址的URL，把哪个URL的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道浏览器发送的内容从哪里来，所以他的地址栏还是原来的地址

redirect是服务器根据逻辑，发送一个状态码，告诉浏览器重新去请求那个地址，所以地址栏显示的是新的URL

2.从数据共享来说

forward:转发页面和转发到的页面可以共享request里面的数据

redirect不能共享数据

3.从运用地方来说

forward:一把用于用户登录的时候，根据用户转发到响应的模块

redirect:一般用于用户注销登录时返回主页面和跳转到其他的网站

4.从效率来说

forward:高

redirect:低

3.

二维数组的声明

4.

对象的序列化：

Java平台允许我们在内存中创建可复用的Java对象，但一般情况下，只有当JVM处于运行时，这些对像才可能存在，即，这些对象的生命周期不会比JVM的生命周期更长。但子啊显示应用中，就可能要求在JVM停止运行之后能够保存（持久化）的对象，并在将来重新读取被保存的对象。

使用Java序列化，在保存对象时，会把其状态保存为一组字节，在未来，再将这些字节组装成对象。必须注意的是，对象序列化保存的是对象的"状态"，即它的成员变量。对象序列化不会关注类中的静态变量

将Java对象或数据结构通过序列化机制转换成二进制字节流传输到网络其他结点或存储介质上

声明ObjectOutputStream和ObjectInputStream可以将第项进行传输

注意：

1.基本数据类型的变量可以直接序列化

2.对象要被序列化，它的类必须要实现Serializable接口，

如果一个类中有引用类型的变量，这个引用类型的变量的类也必须实现Serializable接口。如果这个引用类型的变量不想被实例化，则用transient修饰

5.

Integer是类，默认值是null

6.

String.valueOf(m) : 是将m（char类型）转化为String

char 只有转化到int 才会转化成assic码

7.

yiled方法属于高风亮节的行为，这个坑位我不上了，后面跟我同级别的先上厕所。这样比较好记！

高优先级的就是你们的县长，县长要上厕所，对不起，你得出来，县长先上，县长上完了，CPU分配到你了，你才能继续拉X。

进程是有优先级的。如果即将被运行的进程的优先级比正在运行的进程的优先级高，则系统可以强行剥夺正在运行的进程的CPU，让优先级高的进程先运行

8.

1.Bootstrap ClassLoader 负责加载$JAVA_HOME中jre/lib/rt.jar里所有的class，由C++实现，不是ClassLoader子类

2.Extension ClassLoader

负责加载java平台中扩展功能的一些jar包，包括$JAVA_HOME中jre/lib/*.jar或-Djava.ext.dirs指定目录下的jar包

3.App ClassLoader

负责记录classpath中指定的jar包及目录中class

4.Custom ClassLoader

属于应用程序根据自身需要自定义的ClassLoader

加载过程中会先检查类是否被已加载，检查顺序是自底向上，从Custom ClassLoader到BootStrap ClassLoader逐层检查，只要某个classloader已加载就视为已加载此类，保证此类只所有ClassLoader加载一次。而加载的顺序是自顶向下，也就是由上层来逐层尝试加载此类。

9.

如果子类没有声明任何构造函数，还是会调用Parent的构造函数

没有声明的话，系统会自动声明一个没有参数的构造器，还是会调用父类的

10.

Boolean flag = false;
if(flag = true){//if((flag = true)==true),这里会拆箱
sout("true");
}

11.

创建线程的方法：1）从Java.lang.Thread类派生一个（就是继承）新的线程类，重写它的run()方法；2） 实现Runnable接口，重写Runnable接口中的run()方法。

12.

java.lang包中不能被继承的类：

public final class Byte

public final class Character

public static final class Character.UnicodeBlock

public final class Class<T>

public final class Compile

public final class Double

public final class Float

public final class Integer

public final class Long

public final class Math

public final class ProcessBuilder

public final class RuntimePermission

public final class Short

public final class StackTraceElement

public final class StrictMath

public final class String

public final class StringBuffer

public final class StringBuilder

public final class System

public final class Void

public final class Boolean

9.27 day 4

1.

char foo = '中'

答案：A 这在java中是正确的，在C语言中是错误的，java的char类型占两个字节，默认使用GBK编码存储。这种写法是正确的，此外java还可以用中文做变量名。

2.

对于以下代码段，4个输出语句中输出true的个数是( )。

class A{}
​
class B extends A{}
​
class C extends A{}
​
class D extends B{}
​
A obj = new D();
​
System.out.println(obj instanceof B);
​
System.out.println(obj instanceof C);
​
System.out.println(obj instanceof D);
​
System.out.println(obj instanceof A);

A

| |

B C

|

D

D属于B,D属于A,D属于D,D不属于C

3个，看是否在一条线上

3.

分析以下打印结果：

*代表空格

虽然每次结果不同，但是第一个空格之前必然有 0 1 2 3 4 这四个数字，这是因为第一个空格出现，意味着第一个线程执行完毕，必然会打印这四个数字。又因为线程并发执行，所以后面两个线程个别数字可能会提前打印，这就导致了答案有很多。

线程间是异步的，也就是随机调用的；而线程内部是同步的，也就是顺序执行的

4.

clone()方法属于Object类，作用是创建并且返回此对象的一个副本

copy()方法属于java.noi.file.Files类， 其作用是将字节从文件复制到I/O流或从I/O流复制到文件

5.

分析下面代码的输出内容

public class SystemUtil{
    public static boolean isAdmin(String userId){
        return userId.toLowerCase()=="admin";
    }
    public static void main(String[] args){
        System.out.println(isAdmin("Admin"));
    }
}

String.toLowerCase()是重新new String()的方式然后返回的，

admin指向内存字符串常量池中admin的地址

而以new String()的方式重新返回是以一个对象形式返回，指向的是这个字符串对象再堆内存中的地址

6.

finalize是方法名，在垃圾收入集器将对象从内存中清楚出去之前做必要的清理工作

9.28 day 5

1.

final 定义的方法里，不是必须要用final定义变量

final 定义的变量，可以在不是必须在定义的同时完成初始化，也可以在构造方法中完成初始化

public class A{
    final int i;
    public A(){
        i=0;
    }
}
 

2.

final修饰方法，不能被子类重写，但是可以被重载

3.final 定义的变量，可以用static也可以不用

4.

jar 将许多文件组合成一个jar文件

5.

javac 编译

6.

javadoc 它从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档

7.

javah 把java代码声明的JNI方法转化成C\C++头文件，JNI可参考

 如
​
​
  public class HelloNative {
​
    public static native void greeting();
​
​
​
  }
​
​
  使用javah后生成
​
​
  /* DO NOT EDIT THIS FILE - it is machine generated */
​
    #include <jni.h>
 /* Header for class
    javaTest_semaphore_HelloNative */
​
    
​
    
 #ifndef _Included_javaTest_semaphore_HelloNative
 #define
    _Included_javaTest_semaphore_HelloNative
 #ifdef __cplusplus
​
    extern "C" {
 #endif
 /*
  * Class:    
    javaTest_semaphore_HelloNative
  * Method:    greeting
  *
    Signature: ()V
  */
 JNIEXPORT void JNICALL
    Java_javaTest_semaphore_HelloNative_greeting(JNIEnv *, jclass);
​
    
​
    
 #ifdef __cplusplus
 }
 #endif
 #endif
​
​

8.

public class Demo {
    public static String sRet = "";
    public static void func(int i)
    {
        try
        {
            if (i%2==0)
            {
                throw new Exception();
            }
        }
        catch (Exception e)
        {
            sRet += "0";
            return;
        } 
        finally
        {
            sRet += "1";
        }
        sRet += "2";
    }
    public static void main(String[] args)
    {
        func(1);
        func(2);
        System.out.println(sRet);
    }
}

“1201”

①调用func(1),if不符合，直接进入finally，sRet=“1"

②finally语句中没有返回值，故继续向下执行，sRet="12"

③调用func(2),if符合，sRet="120"，此时有返回值!!!

④调用finally语句，sRet="1201"

⑤因为已经有返回值了，finally之后的语句也不再执行，sRet="1201"。

如果finally前面的代码中有return，那么先执行finally中的语句然后再执行return。

如果finally中的代码也有return，则finally中return的结果会覆盖前面代码中的return结果。

9.

面向对象方法的多态性是指

对于同一个父类方法，不同的子类会有不同的实现方式（针对一消息，不同的对象可以以适合自身的方式加以响应）

10.

来识记一下：

虚拟机中没有泛型，只有普通类和普通方法

所有泛型类的类型参数在编译时都会被擦除

创建泛型对象时请指明类型，让编译器尽早的做参数检查

泛型的类型擦除机制并不意味着不能在运行时动态获取List<T>中T的实际类型

List<String> list = new ArrayList<String>();//这里后面加不加String都是一样的，编译时会子哦对那个擦除
Class clazz = list.getClass

11.

12.

一旦执行到return，就不再执行后续的代码

try{中有return}还继续finally中的语句

13.

对属性使用getter和setter方法，体现的是注入性

14.

重载，判定方法只有方法名一致，形参列表不同

15.

transient关键字的作用，在已实现序列化的类中，有的变量不需要保存在磁盘中，就要transient关键字修饰，在已序列化的类中使变量不序列化

static 和 transient修饰的对象不能被序列化

16.

重载的要求是： 方法名称必须相同 参数列表必须不同（个数不同、或类型不同、参数类型排列顺序不同等） 对返回值没有要求

public double max(int x,int y)
    //重载
    public int max(double a,double b){}

17.

重写接口中的方法，访问权限一定是public

18.

public class MyClass {
    long var;
    public void MyClass(long param) { var = param; }//(1)
    public static void main(String[] args) {
        MyClass a, b;
        a =new MyClass();//(2)
        b =new MyClass(5);//(3)
    }
}

看清楚了，Myclass方法并不是构造参数，而是返回类型为void的普通方法，普通方法自然需要实例化对象然后去调用它

a.Myclass(5)

普通方法可以和类名相同

19.

接口中字段的修饰符：

public static final(默认不写)

接口中方法的修饰符：

public abstract(默认不写)

20.

Integer a1 = 17,a2 =17;
//像这种形式的
// Integer a = 常数
//常数介于-128到127之间的数，Integer直接从数组中取，故a1, a2指向的是同一个对象
Integer b1 = 2017,b2 = 2017;
//因为常数>127，所以两个都是Integer对象
Integer c1 = new Integer(17);
Integer c2 = new Integer(17);
//这样的形式是new出来的对象，对象的地址当然是不同的
Integer d1 = new Integer(2017);
int d2 = 2017;
//d1 与 d2比较，会自动拆箱

9.29 day 6

1.关于String,StringBuffer,StringBuilder,

String是final修饰的，不可变

在运行速度上StringBuffer因为兼顾了线程安全，效率不及StringBuilder

StringBuffer是线程安全的

运行速度StringBuilder>StringBuffer>String

2.

在异常处理中，释放资源，关闭数据库，关闭文件应由finally完成

try:可能发生异常的语句

catch:捕获，并处理异常（printStackTrace()用来跟踪异常事件发生时执行堆栈的内容）

throw:方法内部抛异常

throws:声明方法异常

finaly：代码中无论是否有异常都会执行，清除资源

3.

//接口
interface B{
void print();
}
//没有{}

4.

Math.floor(-8.5) =

Math.floor(x) 返回小于等于x的最接近整数，类型为double

(double)-9.0

5.

关于抽象类

JDK1.8以前

抽象类的方法默认访问权限为protected

JDK 1.8时

抽象类的方法默认访问权限变为default

关于接口

JDK1.8以前，接口中的方法必须是public

JDK1.8时，接口中的方法可以是public，也可以是default

JDK1.9时，接口中的方法可以是private

6.

CyclicBarrier:多个线程互相等待，直到到达同一个同步点，再继续一起执行

重点是多个线程，在任意一个线程没有完成，所有的线程都必须互相等待，然后继续一起执行。

CountDownLatch:一个或多个线程，等待其他多个线程完成某件事情之后才能执行

重点是“一个线程（多个线程）等待”，而其他的N个线程在完成“某件事情”之后，可以终止，也可以等待。

CountDownLatch是计数器，线程完成一个记录一个，只不过计数不是递增而是递减，而CyclicBarrier更像是一个阀门，需要所有线程都到达，阀门才能打开，然后继续执行。 按照这个题目的描述等所有线程都到达了这一个阀门处，再一起执行，

7.

面向对象程序设计方法并不会让人觉得简单易懂

8.

public class NameList
{
    private List names = new ArrayList();
    public synchronized void add(String name)
    {
        names.add(name);
    }
    public synchronized void printAll() {
        for (int i = 0; i < names.size(); i++)
        {
            System.out.print(names.get(i) + "");
        }
    }
 
    public static void main(String[]args)
    {
        final NameList sl = new NameList();
        for (int i = 0; i < 2; i++)
        {
            new Thread()
            {
                public void run()
                {
                    sl.add("A");
                    sl.add("B");
                    sl.add("C");
                    //前面是A线程的一个整体部分 1
                    sl.printAll();
                    //A线程的另一个 部分 2 
                    //这两个部分之间线程会穿插执行
                }
            } .start();
        }
    }
}
​
/*
分析过程：
每个线程都是顺序执行的，所以sl.printAll()必须在前三句执行之后执行，也就是输出的内容必有（连续或非连续的）ABC
线程之间是穿插执行的，所以一个线程执行sl.printAll()；之前可能有另一个线程执行了前三句的前几句
eg:代码输出可能是ABCAABCABC
线程1执行完前三句add之后线程2插一脚执行了一句add
然后线程1再执行sl.printAll()；
输出ABCA。
接着线程2顺序执行完输出ABCABC
*/

10.7 day7

1.识记内容：

Statement每次执行sql语句，数据库都要执行sql语句的编译，最好用于仅执行一次查询并返回结果的情形，效率高于PreparedStatement

PreparedStatement 是预编译的，使用PreparedStatement有几个好处：

a.在执行可变参数的一条SQL时，PreparedStatement比Statement的效率高，因为DBMS预编译一条SQL当然比多次编译一条SQL的效率要搞

b.对于多次重复执行的语句，使用PreparedStament效率会更高一点，并且在这种情况下也比较适合使用batch

Callable 可调用的

CallableStatement继承自PreparedStatement,PreparedStatement继承自Statement

2.记忆一段代码;

TreeSet ts = new TreeSet();
TreeSet ts2 = new TreeSet();
for(int i=606;i<613;i++){
    if(i%2==0){
     ts.add(i);
     }
 }
ts2 = (TreeSet)ts.subSet(608,true,611,true);
//true表示包含边界值（608和611)，如果是false就不包含，表示只有在608和611之间的值才可以加入，set没有重复值
ts.add(609);
sout(set+" "+subSet);

3.

HttpSessionAttributeListener:可以实现此侦听器接口获取此web应用程序中会话属性列表更新的通知

HttpSessionBindingListener:当该对象从一个会话中被绑定或者解绑时通知该对象，这个对象由HttpSessionBindingEvent对象通知

HttpSessionObjectListner:没有该接口API

HttpSessionListener:当web应用程序中的活动会话列表发生更改时通知该接口的实现类，为了接收该通知时间，必须在web应用程序的部署描述符中配置实现类

HttpSessionActionListener:绑定到会话的对象可以侦听容器事件，通知他们会话将被钝化，会话将被

4.

java系统提供3种类加载器：

启动类加载器（Bootstrap ClassLoader)

扩展类加载器(Extension ClassLoader)

应用程序类加载器（Application ClassLoader)

5.

对于任意一个类，都需要由加载它的类加载器和这个类本身一同确立其在java虚拟机中的唯一性，每一个类加载器，都拥有一个独立的类名称空间。比较两个类是否“相等”,

只有在这两个类是由同一个类加载器加载的前提下才有意义，否则，即使这两个类来源于同一个Class文件，被同一个虚拟机加载，只要加载他们的类加载器不同，那么两个类必定不相同

6.

类只需加载一次就行，因此要保证类加载过程线程安全

7.

一个类可以自定义无穷多个构造函数

8.

导入包：

import包名，*代表包下面所有的类，再有包就不包括了

9.

String s1=new String（ ” xyz ” ）;
String s2=new String（ ” xyz ” ）;
Boolean b1=s1.equals(s2);//这个比较的是对象的内容
Boolean b2=(s1==s2);//比较存储地址是否相同
System .out.print(b1+ ” ” +b2); 
//equals比较的是内容，==比较的是地址，不管先创建还是后创建，一个在常量池，，一个 在堆内存，肯定不是同一个地址

10.

java线程是一个运用很广泛的终点知识

1.首先我们必须清楚的认识到java的线程分为两类：用户线程和daemon线程

A.用户线程：用户线程可以简单的理解为用户定义的线程，当然包括main线程

B.daemon线程：daemon线程是为我们创建的用户线程提供服务的 线程，特征：当用户线程运行结束的时候，daemon线程会自动退出

2.daemon线程的特点：

A.守护 线程创建的过程中需要先调用setDaemon方法进行设置，然后再启动线程，否则会爆出异常

B.由于daemon线程的终止条件是当前是否存在用户线程，所以我们不能指派daemon线程来进行一些业务操作，而只能服务用户线程

C.daemon线程创建的子线程仍然是daemon线程

11.

类中实例变量可以不用初始化，使用相应类型的默认值即可；方法中的定义的局部变量必须初始化，否则编译不通过

public static void main(String[] args){
    String s;//error,局部变量
    System.out.println("s="+s);
}

12.

Java中的包一般均包含相关的类，Java中的包和操作系统没有任何关系，java中的包是用来组织文件的一种虚拟文件系统

import语句并没有将对应的java源文件拷贝而仅仅是引入，告诉编译器要使用外部文件，编译时候要去读取这个外部文件

Java提供的包机制和IDE没有关系

定义在同一个包内的类可以不经过import而直接 相互使用

13.

Stub（存根）与动态链接的技术有关

存根类是一个类，它实现了一个接口，它的作用是：如果是一个接口有很多方法，如果要实现这个接口，就要实现这个接口。但是一个类从业务来说，可能只需要其中一两个方法。如果直接去实现这个接口，除了实现所需的方法，还要实现其他所有的无关方法。而如果通过继承存根类就实现接口，就免去了这种麻烦。

14.

IOException在编译时会被发现

NullPointerException在编译时不会被发现

SQLException在编译时会被发送、

FileNotFoundException在编译时会被发送