Java复习笔记

Java  2018/5/24 周四    25 周五

1. 标识符

Java 所有关键字都是小写，goto和const 虽然从未使用但是也作为关键字保留

1. 关键字
2. Java 常量
   1. 用字符序列表示，分为不同数据类型
   2. 字符   ’’    ,字符串    ””

字符在计算机中存储为一个数字 assic码

1. 1. 常量 有时指不可变的变量      final
2.  Java 变量

1. 是最基本的存储单元  ，本质 是内存中的一小块区域
2. 三要素 ：变量名，数据类型，作用域

   ---

    

3. 声明----赋值---使用
4. double d1,d2,d3=0.123的意义

1. java变量的分类
   1. 按位置
      • 局部变量：方法或语句块内定义的变量，方法的参数也是局部变量
      • 成员变量：方法外部类内部（不叫全局变量  c++）

（静态成员变量是属于某各类的，不是属于某个对象的）

1. 1. 按类型
      • 基本数据类型
      • 引用数据类型
2. Java 变量的作用域：出了这个大括号谁也不认识它

7.程序的执行过程

1. 1. Load到内存
   2. 找到main 方法
   3. 运行时内存分配（最基础的有四部分 stack,heap  动态申请内存,data segment,code segment） 如下图

      ---

      5/26

      1.基本数据类型

   4. 1. 数值型：byte short int long 1248个字节   有一位是符号位

   5.    默认int  ，double

         八进制零开头，十六进制零X开头

         Long,float 型后边加L,f

   6. 1. 浮点型

   7.    在计算机中是离散的，数学上是连续的，所以有误差

         浮点数的精度指在第几位有误差，f是7，d是15

   8. 类型转换

   9.  Byte  short char 计算时自动转换为int ---long---float ---double

      double 转换为 float 时在float范围内可以，在范围外会出错（不能直接去掉因为有小数点）

      Float 转换为 long时 直接去掉小数点后，不是四舍五入

   10. 运算符
   11. If，for，while，break，continue

   12.  do {}while();记得加分号

        Break 用于终止某个语句块的执行

   13. switch  case break default

   14. Case穿透，推荐使用break; 多个case 可以合并写；只能探测int型 能转化为int 型和枚举类型；default 可以但不推荐省略

   15. 方法

   16.    Return 语句终止方法的执行并指定要返回的数据

       Java中进行方法调用传递参数时遵循值传递的原则

       基本数据类型传的是该数据值本身（复制）

       引用数据类型传的是对对象的引用，而不是对象

   17. 静态语句块，非静态语句块

   18.     

       5/27

   19. 类与类 之间的关系
       1. 继承 is-a
       2. 关联
       3. 聚合（聚集、组合） has -a
       4. 实现关系
   20. 面向对象与内存解析
       1. 同一类的每个对象有不同的成员变量存储空间
       2. 同一类的每个对象共享该类的方法（方法是一段代码，只有调用时才到内存中分配空间）
       3. 当一个方法调用完成之后，stack空间为它分配的内存（包括return 临时分配的内存）立即全部消失，而heap中的等待垃圾回收，main 方法结束后 全部清空
       4. 基本数据类型占一块内存，引用数据类型占两块内存
       5. 非静态方法是针对某一对象调用
       6. 
   21. 重载   ：名字相同，参数列表不同（两方面：个数，类型），返回值类型相同，修饰符一般不改，改的话只能往大的改
   22. This
   23. Static

   24. 在类中，用static 声明的变量为静态成员变量（data segment存放静态变量和字符串常量），只有一份，属于整个类

       在static 方法中不能访问  非static 成员

   25. package 和import
       1. com.bjsxt.java140
       2. 必须class文件的  最上层包的父目录 位于classpath 下
       3. 访问位于同一个包的类不需要引入
       4. jar  包
       5. 把jar 文件设置到classpath 下：.;jar的路径名称
   26. 访问控制

   27.  private default protected public

   28. 继承

   29. （1）也会继承父类的私有成员变量，但不能访问（拥有所有权，没有使用权）？？？

       （2）继承中的构造方法

   30. 

   31.  重写：  方法名相同，参数列表相同，返回值类型相同（重写方法不能比被重写方法拥有更严格的访问权限）
       1. 仅当实例方法是可访问的时候才能被重写。如果子类中定义的方法在父类中是私有的，那么这两个方法完全没有关系
       2. 静态方法也能被继承，但不能被重写。如果父类中的静态方法在子类中被重新定义那么父类的这个方法会被隐藏可以使用   父类名.静态方法名 调用隐藏的静态方法

   32.   Date String 等类重写了该方法

        

       10.打印对象相当于调用了toString 方法

       11.equals (Object 类中，本质和==一样，比较两个引用是不是指向同一个对象)

       ---

        

   33. 对象转型
       1. 父类引用可以指向子类对象
       2. 父类引用不可以访问子类新增加的成员（属性和方法）
       3. 把子类对象当做父类对象使用（父类引用指向子类对象，接口指向实现类的对象） 叫upcasting ,反之叫做downcasting
   34. 动态绑定和多态

   35.      动态绑定指的是在执行期间（不是编译期间）判断所引用对象的实际类型，根据其实际类型调用相应的方法，从而将可扩展性达到最好

             多态存在的三个条件：有继承，有重写，有父类引用指向子类对象

   36. 抽象类
       1. 含抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写
       2. 抽象类不能被实例化
       3. 抽象类只需声明，不需实现
   37. final 关键字
       1. Final 的变量的值不能被改变（final 的成员变量，final 的局部变量（形参））
       2. Final   的方法不能被重写，类不能被继承
   38. 接口
       1. 接口是抽象方法和常量值的集合
       2. 从本质上讲，接口 是一种特殊的抽象类，这种抽象类只包含常量和方法的定义而没有变量和方法的实现

   39. 例  public interface Runner {

       public static final int id = 1;

           Public void start();

           Public void run();

           Public void stop();

       }

   40. 接口的特性
       1. 接口声明的属性默认为public static final (可以省略)，也只能是public static fianl
   41. 1. 接口可以继承其他接口，并添加新的属性和方法
       2. 多个无关的类可以实现一个接口，一个类可以实现多个无关的接口
       3. 与继承类似，接口与实现类之间存在多态性

   42.    

       接口只能定义抽象方法，默认为public ，也只能为public

   43. 异常是运行期出现的错误，注意异常 的名字和行号
   44. Java.lang.throwable

   45. Error

       Exception

       RuntimeException

       和其他异常

   46. 其他异常必须被try catch
   47. 通常finally 可以进行资源的清理操作，如关闭打开的文件，删除临时文件
   48. Catch 住异常，但是不处理 ，只写个{} 是不好的行为
   49. 如果该方法处理不了这个异常 ，就继续往外抛
   50. Public static void main (String []args)  throws Exception {}

   51. 把异常抛给运行时系统，打印出堆栈信息（不推荐）

   52. 使用自定义的异常类，从某个类继承即可，从Exception 继承必须被处理，从RuntimeException继承 可以处理可以不处理
   53. *********重写的方法必须与原方法所抛的异常   一致  或不抛异常
   54.   throw 和throws 的区别：throws 用在方法头声明可能抛出的异常，throw 用在方法体的语句中表明一定会抛出某个异常

   55. 数组

   56. 声明数组时不能指明其长度，如int [5] a ;  不可以
   57. new 出来时分配空间，动态初始化 （分配空间和赋值分开）静态初始化（不分开）
   58. Java.lang.System.arraycopy
   59. 数组是引用类型，存在heap中
   60. 大数值 java.math.BigInteger   和java.math.BigeDecimal

   61.   不能用运算符+  —*\,用的是  BigInteger add( BigIntrger other );

         类似的有 subtract multiply divide  

   62. 应使用 int[] arrayname ,这样用[]将 数据类型 和 数组名字 分隔开 ，不易混淆
   63. 区分 java.lang.Math 类 和 java.math.BigInteger类

   64. 常用类

   65. String和StringBuffer类
   66. public final class String  ,不能被继承，一旦创建不可改变

   67.    在java中有3个类来负责字符的操作。

       1.Character 是进行单个字符操作的，

       2.String 对一串字符进行操作。不可变类。

       3.StringBuffer 也是对一串字符进行操作，但是可变类。

       String:
       为不可变对象,一旦被创建,就不能修改它的值.
       对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.
       String 是final类,即不能被继承.

       StringBuffer:
       是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象
       它只能通过构造函数来建立,
       StringBuffer sb = new StringBuffer();
       note:不能通过赋值符号对他进行赋值. 
       sb = "welcome to here!";//error
       对象被建立以后,在内存中就会分配内存空间,并初始保存一个null.向StringBuffer
       中赋值的时候可以通过它的append方法.
       sb.append("hello");

       字符串连接操作中StringBuffer的效率要比String高

        简言之 ，一个可变一个不可变，如果要对字符串进行大量修改，使用StringBuffer 更高效

   68. 基础数据类型包装类 将基础数据类型包装成一个对象
   69. Math 没啥说
   70. 1.Java.io.File类代表系统文件名（路径和文件名）并不代表物理硬盘上的实际文件
   71. File类的常见构造方法

   72. Public File (String pathname)

       以pathname 为路径创建File对象，如果pathname 是相对路径，则默认的当前

       路径在系统属性user.dir中存储

       Public File(String parent,String child)

       以parent为父路径，child为子路径创建File 对象

   73. File 的静态属性String separator 存储了当前系统的路径分隔符
   74. 
   75. 
   76. Enum 只能使用特定值中的一个，用enum关键字，是java.lang.Enum类型

   77.    

          public class TestEnum{

       public enum MyColor{red,green.blue};

       public static void main(String []args){

       MyColor m = MyColor.red;

       }

       }

       MyColor 是一个枚举类型 ，用它定义的变量只能取大括号里的值，类名.值

   78. 容器类java.util

   79. 

   80. 概要：一个图（上图），一个类（Collections）三个知识点（foreach ,Generic泛型，Auto-boxing,unboxing）,六个接口（Collection Map List Set Comparable Iterator)

        

   81. 为什么重写equals时要重写hashcode ?

   82.    容器类对象在调用remove ,contains 等方法时需要比较对象是否相等，这会涉及到对象类型的equals 方法和hashcode 方法；对于自定义的类，需要重写equals 和hashcode 等方法以实现自定义的对象相等规则（相等的对象应该具有相等的hash codes ）

   83. java.util.Iterator接口
       1. 所有实现了Collection接口的容器类都有一个iterator 方法用以返回一个实现了Iterator 接口的对象
       2. Iterator 对象称作迭代器，用以方便的实现对容器内元素的遍历操作
       3. Iterator 对象的remove 方法是迭代过程中删除元素的唯一安全的 方法（与锁定有关）
       4. 

   84. 只有这三个方法

   85. 增强的for循环，用于遍历一个数组或容器

   86.    对数组来说，不能方便地访问下标值；对集合来说，与使用iterator 相比不能方便地删除集合中的内容（在内部也是调用Iterator）.所以除了需要遍历所有元素并读出其中的内容外，不建议使用

         Int [] array = {1,2,3,4,5,6};

         for (int i :array)//把array里 的元素一个个放到 i 里边

         System.out.println(i);

        

       Collection c = new ArrayList();

       c.add(new String (“aaa”));

       c.add(new String (“bbb”));

       for(Object o :c)//把c里边的元素一个个放到o里边

       System.out.println(o);

   87. Set接口没有提供额外的方法，与集合相对应，（无序，不可重复，重复是指两个对象equals）
   88. Java.util.Collections类，此类完全由在Collection上进行操作或返回Collection 的静态方法组成
   89. Java.lang.Comparable接口只有一个方法，

   90.    public int compareTo(T  o) ;

       返回o表示 this == o;

       返回正数表示 this > o;

       返回负数表示this

       所有可以排序的类都实现了java.lang.Comparable接口，实现Compable接口的类通过实现comparableTo方法来确定该类对象的排序方式

   91. 如何选择数据结构，衡量标准是读，改的效率

   92.   Array 读快改慢，Linked 改快读慢，Hash两者之间

   93. 泛型：在定义集合的同时定义集合中对象的类型，可以在定义Collection 的时候指定亦可以在循环时用Iterator指定

   94.   语法 ： Map = new HashMap

         可增强程序的可读性和稳定性

   95. 链式学习法，问题学习法

   96. 节点流：可以从或向一个特定的地方（节点）读写数据。如FileReader.
   97. 处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。

   98. JAVA常用的节点流：

   99. 文 件 FileInputStream FileOutputStrean FileReader FileWriter 文件进行处理的节点流。
   100. 字符串 StringReader StringWriter 对字符串进行处理的节点流。
   101. 数 组 ByteArrayInputStream ByteArrayOutputStreamCharArrayReader CharArrayWriter 对数组进行处理的节点流（对应的不再是文件，而是内存中的一个数组）。
   102. 管 道 PipedInputStream PipedOutputStream PipedReaderPipedWriter对管道进行处理的节点流。

   103. 常用处理流（关闭处理流使用关闭里面的节点流）

   104. 缓冲流：BufferedInputStrean BufferedOutputStream BufferedReader BufferedWriter

   105.   ---增加缓冲功能，避免频繁读写硬盘。

   106. 转换流：InputStreamReader OutputStreamReader实现字节流和字符流之间的转换。

   107. 数据流 DataInputStream DataOutputStream 等-提供将基础数据类型写入到文件中，或者读取出来.

        流操作时为什么要关闭流

        需要自己close的东西一般是用了虚拟机之外的 资源 ，例如端口，显存，文件等

        虚拟机无法通过垃圾回收释放这些资源，只能程序员显式调用close来释放，要不然会占用资源，影响其他进程

        流的关闭顺序

   108. 一般情况下是：先打开的后关闭，后打开的先关闭
   109. 另一种情况：看依赖关系，如果流a依赖流b，应该先关闭流a，再关闭流b。例如，处理流a依赖节点流b，应该先关闭处理流a，再关闭节点流b
   110. 可以只关闭处理流，不用关闭节点流。处理流关闭的时候，会调用其处理的节点流的关闭方法。

   111. 注意：

   112. 如果将节点流关闭以后再关闭处理流，会抛出IO异常。
   113. 如果关闭了处理流，在关闭与之相关的节点流，也可能出现IO异常。（hadoop编程文件流操作中遇到了。）

   114.  

   115. Java 流式输入输出原理
   116. Java 流类的分类
   117. 输入输出流类
   118. 常见的节点流和处理流
   119. 文件流
   120. 缓冲流
   121. 数据流
   122. 转换流
   123. Print流
   124. Object流

   125.  

   126. 分类
        1. 按方向：输入、输出
        2. 按处理数据单位：字节、字符
        3. 按功能：节点流、处理流

   127. Java所有流类型位于java.io包内并且都分别继承自以下四种抽象流类型

        字节流    字符流

        输入流 InputStream      Reader

        输出流 OutputStream     Writer

         

   128. 处理流是连接在已存在的流（节点流和处理流）上，通过对数据的处理为程序提供更强大的读写功能

   129. 

         

        NOTE:  1.Close()和flush()  先写flush()把缓冲区的数据写入流中。再关闭，避免内存中缓冲区的数据还没有到达目的地时流就被close()掉

   130. String 类 的toCharArray()可以把自己转换为字符数组
   131. new对象（实例化）和调用close()时会抛异常
   132. 文件流

   133.   如果FileWriter("dir",true);的话表示这个文件不会被重新生成。而且写入的内容是从这个文件的结尾开始写入。说白了就是续写，原来的内容还在。

         

   134. （处理流）缓冲流
        1. 4种缓冲流BufferedReader......
        2. 缓冲流要套接在相应的节点流之上，对的读写数据提供缓冲的 功能，提高了读写的效率，同时增加了一些新的方法（缓冲输入流支持其父类的mark 和reset方法；BufferedReader提供了readLine方法用于读取一行字符串，以\r或\n分隔开；BufferedWriter提供了newLine方法用于写入一个行分隔符；）
        3. 对于输出的缓冲流，写出的 的数据流会先在内存中缓存，flush方法会使内存中的数据立刻写出
   135. (处理流)转换流  InputStreamReader   和OutputStreamWriter
        1. 用于字节数据到字符数据之间的转化
        2. 需要和InputStream  OutputStream 套接
        3. 转换流在构造时可以指定其编码集合

   136. 例如：InputStream isr = new InputStreamReader(System.in,”ISO8859_1”)

        七.（处理流）数据流  DataInputStream 和DataOutputStream

   137. 1.   需要套接在InputStream 和OutputStream 上
        2. 提供了可以存取与机器无关的java原始类型数据 （int    double等）的方法
        3. 构造方法为DataInputStream (InputStream in)

   138. 八.（处理流）Print流：PtintStream 和PrintWriter

   139. 1. 都属于输出流，分别针对字节和字符
        2. 提供了重载的print
        3. Println方法用于多种数据类型的输出
        4. 两者的输出操作不会抛出异常，用户通过检测错误状态获取信息

   140. 5.两者都有自动flush功能

        与 PrintStream 类不同，如果启用了自动刷新，则只有在调用 println、printf 或 format 的其中一个方法时才可能完成此操作，而不是每当正好输出换行符时才完成。这些方法使用平台自有的行分隔符概念，而不是换行符。

        Note: System类有（static void ）setIn /setOut方法用于重新分配标准输入输出流

   141. Object 流：ObjectInputStream 和ObjectOutputStream(他们的嵌套类：ObjectInputStream.GetField   ObjectOutputStream.GetField)(啥是嵌套类及内部类？
            可以在一个类的内部定义另一个类，这种类称为嵌套类（nested classes）,它有两种类型:
        静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。嵌套类从JDK1.1开始引入。其中inner类又可分为三种：
            其一、在一个类（外部类）中直接定义的内部类；
            其二、在一个方法（外部类的方法）中定义的内部类;
            其三、匿名内部类。链接https://blog.csdn.net/acumengrass/article/details/537686)

   142. -----------------------------------------------------------------------

        ObjectOutputStream可以将java对象写入outputstream流中（序列化），然后进行持久化（从内存存到磁盘），此对象必须是实现了java.io.Serializable 接口；

   143. 1. 需要序列化，必须是实现java.io.Serializable 接口；
        2. 关键字 transient 修饰的成员变量在序列化时不予考虑
        3. 若想自己控制序列化过程，实现Externalizable接口

   144.  Public interface Externalizable extends Serializable

        transient的用途及使用方法

        1，用途

        我们知道，当一个对象实现了Serilizable接口，这个对象就可以被序列化，我们不关心其内在的原理，只需要了解这个类实现了Serilizable接口，这个类的所有属性和方法都会自动序列化。而在开发过程中，我们可能要求：当对象被序列化时（写入字节序列到目标文件）时，有些属性需要序列化，而其他属性不需要被序列化，打个比方，如果一个用户有一些敏感信息（如密码，银行卡号等），为了安全起见，不希望在网络操作（主要涉及到序列化操作，本地序列化缓存也适用）中被传输，这些信息对应的变量就可以加上transient关键字。换句话说，这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。 
        所以，transient的用途在于：阻止实例中那些用此关键字声明的变量持久化；当对象被反序列化时（从源文件读取字节序列进行重构），这样的实例变量值不会被持久化和恢复。例如，当反序列化对象——数据流（例如，文件）可能不存在时，原因是你的对象中存在类型为java.io.InputStream的变量，序列化时这些变量引用的输入流无法被打开。

        2，使用方法

        序列化的时候，将不需要序列化的属性前添加关键字transient即可

        API ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。

        ObjectOutputStream 和 ObjectInputStream 分别与 FileOutputStream 和 FileInputStream 一起使用时，可以为应用程序提供对对象图形的持久存储。ObjectInputStream 用于恢复那些以前序列化的对象。其他用途包括使用套接字流在主机之间传递对象，或者用于编组和解组远程通信系统中的实参和形参。

         

                       DataOutputStream(OutputStream out)

        ---

         

五十个题做参考：http://www.importnew.com/12773.html

1. 基本概念
2. 创建和启动
3. 调度和优先级
4. 状态控制
5. 线程同步

多线程练习题https://blog.csdn.net/hl6621/article/details/78751822

什么是内存泄漏https://blog.csdn.net/jinchaoh/article/details/54863719