JAVA——待加强巩固的知识点

本帖用于记录在Java练习过程中做错的知识点，需要多加巩固，常更新，常回顾，常总结

2017/08/17

• Array对象常用方法中：

  不改变原数组：

  1、 concat()

  • 连接两个或多个数组
  • 不改变原数组
  • 返回被连接数组的一个副本

  ---

  2、join()

  • 把数组中所有元素放入一个字符串
  • 不改变原数组
  • 返回字符串

  ---

  3、 slice()

  • 从已有的数组中返回选定的元素
  • 不改变原数组
  • 返回一个新数组

  ---

  4、 toString()

  • 把数组转为字符串
  • 不改变原数组
  • 返回数组的字符串形式

  改变原数组：

  5、 pop()

  • 删除数组最后一个元素，如果数组为空，则不改变数组，返回undefined
  • 改变原数组

  • 返回被删除的元素

    ---

  6、 push()

  • 向数组末尾添加一个或多个元素
  • 改变原数组
  • 返回新数组的长度

  ---

  7、 reverse()

  • 颠倒数组中元素的顺序
  • 改变原数组
  • 返回该数组

  ---

  8、 shift()

  • 把数组的第一个元素删除，若空数组，不进行任何操作，返回undefined
  • 改变原数组
  • 返回第一个元素的值

  ---

  9、 sort()

  • 对数组元素进行排序(ascii)
  • 改变原数组
  • 返回该数组

  ---

  10、 splice()

  • 从数组中添加/删除项目
  • 改变原数组
  • 返回被删除的元素

  ---

  11、 unshift()

  • 向数组的开头添加一个或多个元素
  • 改变原数组
  • 返回新数组的长度
  
  

2017/08/10

• 1，Java 关键字列表 (依字母排序 共50组)：
  abstract, assert, boolean, break, byte, case, catch, char, class, const（保留关键字）, continue, default, do, double, else, enum, extends, final, finally, float, for,goto（保留关键字）, if, implements, import, instanceof, int, interface, long, native, new, package, private, protected, public, return, short, static, strictfp, super, switch, synchronized, this, throw, throws, transient, try, void, volatile, while
  2，保留字列表 (依字母排序 共14组)，Java保留字是指现有Java版本尚未使用，但以后版本可能会作为关键字使用：
  byValue, cast, false, future, generic, inner, operator, outer, rest,true, var,goto （保留关键字） , const （保留关键字） , null
  
  

• java中true ,false , null在java中不是关键字，也不是保留字，它们只是显式常量值，但是你在程序中不能使用它们作为标识符。
  其中const和goto是java的保留字。java中所有的关键字都是小写的，还有要注意true,false,null,　friendly，sizeof不是java的关键字,但是你不能把它们作为java标识符用。
  
  

• stream结尾都是字节流，reader和writer结尾都是字符流 两者的区别就是读写的时候一个是按字节读写，一个是按字符。实际使用通常差不多。 在读写文件需要对内容按行处理，比如比较特定字符，处理某一行数据的时候一般会选择字符流。 只是读写文件，和文件内容无关的，一般选择字节流。
  字节流：
  InputStream
  |-- FileInputStream (基本文件流）
  |-- BufferedInputStream
  |-- DataInputStream
  
  |-- ObjectInputStream
  字符流
  Reader
  |-- InputStreamReader (byte->char 桥梁）
  |-- BufferedReader (常用）
  Writer
  |-- OutputStreamWriter (char->byte 桥梁）
  |-- BufferedWriter
  |-- PrintWriter （常用）

• JAVA多线程实现方式主要有三种：

  1、继承Thread类

  2、 实现Runnable接口

  3、使用ExecutorService、Callable、Future实现有返回结果的多线程。

  其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。
  
  

• 一般关系数据模型和对象数据模型之间有以下对应关系：表对应类，记录对应对象，表的字段对应类的属性
  

• Collection

      -----List
  

                 -----LinkedList    非同步
  

                  ----ArrayList      非同步，实现了可变大小的元素数组
  

                  ----Vector          同步
  

                           ------Stack
  

      -----Set   不允许有相同的元素
  

  
  

  
  

  Map

      -----HashTable        同步，实现一个key--value映射的哈希表
  

      -----HashMap          非同步，
  

      -----WeakHashMap   改进的HashMap，实现了“弱引用”，如果一个key不被引用，则被GC回收
  
  

• 最终类就是被final修饰的类，最终方法就是被final修饰的方法。最终类不能被继承，最终方法不能被重写。
  

• 类中不能进行运算，只能定义方法和变量
  

• JSP内置对象和属性列举如下：
  1.request对象
       客户端的请求信息被封装在request对象中，通过它才能了解到客户的需求，然后做出响应。它是HttpServletRequest类的实例。
  2.response对象
       response对象包含了响应客户请求的有关信息，但在JSP中很少直接用到它。它是HttpServletResponse类的实例。
  3.session对象
       session对象指的是客户端与服务器的一次会话，从客户连到服务器的一个WebApplication开始，直到客户端与服务器断开连接为止。它是HttpSession类的实例.
  4.out对象
       out对象是JspWriter类的实例,是向客户端输出内容常用的对象
  5.page对象
       page对象就是指向当前JSP页面本身，有点象类中的this指针，它是java.lang.Object类的实例
  6.application对象
       application对象实现了用户间数据的共享，可存放全局变量。它开始于服务器的启动，直到服务器的关闭，在此期间，此对象将一直存在；这样在用户的前后连接或不同用户之间的连接中，可以对此对象的同一属性进行操作；在任何地方对此对象属性的操作，都将影响到其他用户对此的访问。服务器的启动和关闭决定了application对象的生命。它是ServletContext类的实例。
  7.exception对象
     exception对象是一个例外对象，当一个页面在运行过程中发生了例外，就产生这个对象。如果一个JSP页面要应用此对象，就必须把isErrorPage设为true，否则无法编译。他实际上是java.lang.Throwable的对象
  8.pageContext对象
  pageContext对象提供了对JSP页面内所有的对象及名字空间的访问，也就是说他可以访问到本页所在的SESSION，也可以取本页面所在的application的某一属性值，他相当于页面中所有功能的集大成者，它的本 类名也叫pageContext。
  9.config对象
  config对象是在一个Servlet初始化时，JSP引擎向它传递信息用的，此信息包括Servlet初始化时所要用到的参数（通过属性名和属性值构成）以及服务器的有关信息（通过传递一个ServletContext对象）
  

• java.awt： 包含构成抽象窗口工具集的多个类，用来构建和管理应用程序的图形用户界面

  java.lang： 提供java编成语言的程序设计的基础类

  java.io：　 包含提供多种输出输入功能的类，
  java.net：　 包含执行与网络有关的类，如URL，SCOKET，SEVERSOCKET，
  java.applet： 包含java小应用程序的类
  java.util：　 包含一些实用性的类
  

• 抽象类和接口不能实例化
  

• 自动类型转换遵循下面的规则：
  1.若参与运算的数据类型不同，则先转换成同一类型，然后进行运算。
  2.转换按数据长度增加的方向进行，以保证精度不降低。例如int型和long型运算时，先把int量转成long型后再进行运算。
  3.所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算。
  4.char型和short型参与运算时，必须先转换成int型。
  5.在赋值运算中，赋值号两边的数据类型不同时，需要把右边表达式的类型将转换为左边变量的类型。如果右边表达式的数据类型长度比左边长时，将丢失一部分数据，这样会降低精度
  

2017/08/09

• A，java是强类型语言，所有的方法必须放在类里面，包括main
  B ,java中可以有多个重载的main方法，只有public static void main(String[] args){}是函数入口
  C，内部类的类名一般与文件名不同
  D，函数都必须用{}括起来，不管是一条语句还是多条语句
  
  

• 两个最基本的java回收算法：复制算法和标记清理算法

  复制算法：两个区域A和B，初始对象在A，继续存活的对象被转移到B。此为新生代最常用的算法
  

  标记清理：一块区域，标记要回收的对象，然后回收，一定会出现碎片，那么引出

  标记-整理算法：多了碎片整理，整理出更大的内存放更大的对象
  

  两个概念：新生代和年老代

  新生代：初始对象，生命周期短的
  

  永久代：长时间存在的对象
  

  整个java的垃圾回收是新生代和年老代的协作，这种叫做分代回收。

  P.S：Serial New收集器是针对新生代的收集器，采用的是复制算法

  Parallel New（并行）收集器，新生代采用复制算法，老年代采用标记整理

  ParallelScavenge（并行）收集器，针对新生代，采用复制收集算法

  Serial Old（串行）收集器，新生代采用复制，老年代采用标记整理
  

  ParallelOld（并行）收集器，针对老年代，标记整理

  CMS收集器，基于标记清理
  

  G1收集器：整体上是基于标记 整理 ，局部采用复制
  

  
  

  综上：新生代基本采用复制算法，老年代采用标记整理算法。cms采用标记清理。
  
  

• 接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。另外，接口和抽象类在方法上有区别：    
  1.抽象类可以有构造方法，接口中不能有构造方法。  
  2.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
  3.抽象类中可以有普通成员变量，接口中没有普通成员变量 
  4. 抽象类中的抽象方法的访问类型可以是public，protected和默认类型
  5. 抽象类中可以包含静态方法，接口中不能包含静态方法
  6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型
  7. 一个类可以实现多个接口，但只能继承一个抽象类。二者在应用方面也有一定的区别：接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用，例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的Servlet都继承这个抽象基类，在抽象基类的service方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码。
  
  

• Java语言中的异常处理包括声明异常、抛出异常、捕获异常和处理异常四个环节。

  throw用于抛出异常。

  throws关键字可以在方法上声明该方法要抛出的异常，然后在方法内部通过throw抛出异常对象。

  try是用于检测被包住的语句块是否出现异常，如果有异常，则抛出异常，并执行catch语句。

  cacth用于捕获从try中抛出的异常并作出处理。

  finally语句块是不管有没有出现异常都要执行的内容。
  
  

• 抽象类

  特点:

  1.抽象类中可以构造方法

  2.抽象类中可以存在普通属性，方法，静态属性和方法。

  3.抽象类中可以存在抽象方法。

  4.如果一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法。

  5.抽象类中的抽象方法，需要有子类实现，如果子类不实现，则子类也需要定义为抽象的。

  接口

  1.在接口中只有方法的声明，没有方法体。

  2.在接口中只有常量，因为定义的变量，在编译的时候都会默认加上

  public static final 

  3.在接口中的方法，永远都被public来修饰。

  4.接口中没有构造方法，也不能实例化接口的对象。

  5.接口可以实现多继承

  6.接口中定义的方法都需要有实现类来实现，如果实现类不能实现接口中的所有方法

  7.则实现类定义为抽象类。
  
  

• 一、构造器；二、静态工厂方法；    基本细想：通过类中的静态方法返回对象。(如果构造方法私有，称做单例模式）三、通过Class类；    基本细想：实例化无参构造的类，先通过forName()方法实例化Class对象（即反射操作），然后用Class类中的newInstance()方法；实例化带参数构造的类，需要使用Class类中的getConstructors()方法获取所有的构造，然后同上操作。

  
  

• 垃圾回收主要针对的是堆区的回收，因为栈区的内存是随着线程而释放的。堆区分为三个区：年轻代（Young Generation）、年老代（Old Generation）、永久代（Permanent Generation，也就是方法区）。

   年轻代：对象被创建时（new）的对象通常被放在Young（除了一些占据内存比较大的对象）,经过一定的Minor GC（针对年轻代的内存回收）还活着的对象会被移动到年老代（一些具体的移动细节省略）。

  年老代：就是上述年轻代移动过来的和一些比较大的对象。Minor GC(FullGC)是针对年老代的回收

  永久代：存储的是final常量，static变量，常量池。

  str3,str4都是直接new的对象，而substring的源代码其实也是new一个string对象返回，如下图：

  
  

  经过fullgc之后，年老区的内存回收，则年轻区的占了15个，不算PermGen。所以答案选C
  

• 运行时数据区包括：虚拟机栈区，堆区，方法区，本地方法栈，程序计数器

  虚拟机栈区 ：也就是我们常说的栈区，线程私有，存放基本类型，对象的引用和returnAddress，在编译期间完成分配。

  堆区 ， JAVA 堆，也称GC堆，所有线程共享，存放对象的实例和数组，JAVA堆是垃圾收集器管理的主要区域。

  方法区 ：所有线程共享，存储已被虚拟机加载的类信息，常量，静态变量，即时编译器编译后的代码等数据。这个区域的内存回收目标主要是针对常量池的对象的回收和对类型的卸载。

  程序计数器 ：线程私有，每个线程都有自己独立的程序计数器，用来指示下一条指令的地址。

  
  

• floor: 求小于参数的最大整数。返回double类型-----n. 地板，地面
           例如：Math.floor(-4.2) = -5.0
  
  -----------------------------------------------------------
  ceil:   求大于参数的最小整数。返回double类型-----vt. 装天花板；
           例如：Math.ceil(5.6) = 6.0
  
  -----------------------------------------------------------
  round: 对小数进行四舍五入后的结果。返回int类型
           例如：Math.round(-4.6) = -5
  

• 加载驱动方法

  1.Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");

  2. DriverManager.registerDriver(new com.mysql.jdbc.Driver());

  3.System.setProperty("jdbc.drivers", "com.mysql.jdbc.Driver");
  
  

• 根据官方的JVM规范：
  如果try语句里有return，返回的是try语句块中变量值。
  详细执行过程如下：

  1. 如果有返回值，就把返回值保存到局部变量中；
  2. 执行jsr指令跳到finally语句里执行；
  3. 执行完finally语句后，返回之前保存在局部变量表里的值。

  如果try，finally语句里均有return，忽略try的return，而使用finally的return.

  
  

• 类变量既可以通过类来返回，也可以通过类的对象来访问。但通过类的对象来访问类变量时，实际不是访问该对象所拥有的变量，因为当系统创建该类的对象时，系统不会再为类变量分配内存，也不会再次对类变量进行初始化，也就是说，对象根本不拥有对应类的类变量，通过对象访问类变量只是一种假象，通过对象访问的依然是该类的类变量。
  

• Try...catch...finally与直接throw的区别：try catch是直接处理，处理完成之后程序继续往下执行，throw则是将异常抛给它的上一级处理，程序便不往下执行了。本题的catch语句块里面，打印完1之后，又抛出了一个RuntimeException，程序并没有处理它，而是直接抛出，因此执行完finally语句块之后，程序终止了
  

• 首先：创建并启动线程的过程为：定义线程—》实例化线程—》启动线程。
  一 、定义线程： 1、扩展java.lang.Thread类。2、实现java.lang.Runnable接口。
  二、实例化线程： 1、如果是扩展java.lang.Thread类的线程，则直接new即可。
                   2、如果是实现了java.lang.Runnable接口的类，则用Thread的构造方法：
          Thread(Runnable target) 
          Thread(Runnable target, String name) 
          Thread(ThreadGroup group, Runnable target) 
          Thread(ThreadGroup group, Runnable target, String name) 
          Thread(ThreadGroup group, Runnable target, String name, long stackSize)
  
  
  三、启动线程：在线程的Thread对象上调用start()方法，而不是run()或者别的方法。
  所以B的启动线程方法错误。
  
  

• “假设利用 return 语句从 try 语句块中退出。在方法返回前，finally子句的内容将被执行。如果 finally 子句中也有一个 return 语句，这个返回值将会覆盖原始的返回值。
  

• Applet 是一种在 Web 环境下，运行于客户端的Java程序组件。Applet 必须运行于某个特定的“容器”，这个容器可以是浏览器本身，也可以是通过各种插件，或者包括支持 Applet 的移动设备在内的其他各种程序来运行。与一般的Java应用程序不同，Applet 不是通过 main 方法来运行的。Applet运行之前，先调用 Init() 方法，然后调用 start() 方法，最后调用 paint() 方法。
  
  

• 1. Float是类，float不是类.
  2. 查看JDK源码就可以发现Byte，Character，Short，Integer，Long，Float，Double，Boolean都在java.lang包中.
  3. Float正确复制方式是Float f=1.0f,若不加f会被识别成double型,double无法向float隐式转换.
  4. Float a= new Float(1.0)是正确的赋值方法，但是在1.5及以上版本引入自动装箱拆箱后，会提示这是不必要的装箱的警告，通常直接使用Float f=1.0f.
  
  

• intValue()是把Integer对象类型变成int的基础数据类型；
  parseInt()是把String 变成int的基础数据类型；
  Valueof()是把String 转化成Integer对象类型；（现在JDK版本支持自动装箱拆箱了。）
  

• Java程序的种类有：

（a）内嵌于Web文件中，由浏览器来观看的_Applet
（b）可独立运行的 Application
（c）服务器端的 Servlets

• switch语句后的控制表达式只能是short、char、int、long整数类型和枚举类型，

不能是float，double和boolean类型。String类型是java7开始支持。

• 一次编译多个java文件用javac *.java. 即可编译当前目录下的所有java文件 

• 用 equals 方法，因为此方法先是比较类型，而 i ， d ， l 是不同的类型，所以返回假

• Java语言中的异常处理包括声明异常、抛出异常、捕获异常和处理异常四个环节。

throw用于抛出异常。
throws关键字可以在方法上声明该方法要抛出的异常，然后在方法内部通过throw抛出异常对象。
try是用于检测被包住的语句块是否出现异常，如果有异常，则抛出异常，并执行catch语句。
cacth用于捕获从try中抛出的异常并作出处理。
finally语句块是不管有没有出现异常都要执行的内容。

• Java的跨平台特性是因为JVM的存在， 它可以执行.class字节码文件，而不是.java源代码

• 异常处理一般格式：

捕获异常：
try{
    //代码块
}catch(异常类型，例如：Exception e){
    //需要抛出的异常，例如：e.printStackTrace();
}catch(异常类型){
    //需要抛出的异常
}finally{
    //必定执行的代码块
}
所以说在一个异常处理中catch语句块是可以多个的，也就是可以抛出多个异常！

• 在类方法中调用本类的类方法可直接调用。 实例方法也叫做对象方法。

类方法是属于整个类的，而实例方法是属于类的某个对象的。
由于类方法是属于整个类的，并不属于类的哪个对象，所以类方法的方法体中不能有与类的对象有关的内容。即类方法体有如下限制： 
(1) 类方法中不能引用对象变量；
(2) 类方法中不能调用类的对象方法；
(3) 在类方法中不能使用super、this关键字。
(4)类方法不能被覆盖。 
如果违反这些限制，就会导致程序编译错误。
与类方法相比，对象方法几乎没有什么限制：
(1) 对象方法中可以引用对象变量，也可以引用类变量；
(2) 对象方法中可以调用类方法；
(3) 对象方法中可以使用super、this关键字。