JAVA 学习笔记

转载:牛客吴彦祖
链接:https://www.nowcoder.com/discuss/28656
来源:牛客网

Java笔记

第一章

  1. Java最大的特点就是可以在不同的平台环境上运行。
  2. Java Write Once,Run Anywhere!
  3. Java体系结构中立。
  4. Java的版本分为:JSE 标准版;JEE 企业版;JME 小设备版。
  5. Java与C++的区别:(-3+1)去掉指针,去掉多继承,去掉运算符重载;增加自动内存分配与回收机制。
  6. Java面向对象的特点:封继多:封装、继承、多态。
  7. Java分布式:Java的网络编程如同从文件发送和接收数据一样简单。
  8. Java鲁棒性:异常处理机制、自动垃圾收集处理来进行内存管理。
  9. Java安全性:不支持指针、沙箱运行模式(Java程序的代码和数据在一定的空间执行)
  10. Java解释执行:代码被编译为JVM字节码,字节码的执行不依赖硬件配置。这是Java可以在不同平台上运行的基础。
  11. javac name.java name.class java name
  12. javac是编译命令 java是解释执行命令
  13. package 一个程序最多只能有1句,且只能放在第一句。
  14. import可有可无,有必须放在所有的类定义之前。
  15. JVM是运行java字节码的一台虚拟机。

第二章

  1. Java采用Unicode字符集,16位, ,支持大部分字符集。
  2. Java标识符不能以数字开头,名称与大小写相关。
  3. 标识符的使用习惯:1名次首字母大写;2动名词动词首字母小写,名次首字母大写;3常量全大写;4变量首字母小写其他的大写。
  4. Java数据类型:8个基本类型:byte、short、int、long、float、double、char、boolean;3个引申类型:class、interface、数组。
  5. Java中逻辑类型和整数类型不能直接转换。
  6. final修饰符号常量、其值在赋值之后不能改动。
  7. 类成员变量自动赋初值,局部变量不赋初值报错,引用作为类成员自动赋值为NULL。
  8. Java中取消的操作符:->、*、&、sizeof、其中三个与指针相关。
  9. 基本类型赋值在栈里;引用类型赋值在堆里;引用本身位于栈。
  10. 引用直接用==比较的是地址,要比较对象的实际内容,用equal()方法。
  11. Java中逻辑操作符&& || 有短路屏蔽,位操作符& |没有。
  12. 自动类型转换:低精度到高精度;高精度到低精度需要强制类型转换。
  13. Java是结构化程序设计语言:顺序结构、选择结构、循环结构。
  14. switch-case中只能用整型、字符型、枚举型、字符串。
  15. break跳到最近的}之后;continue跳出当前循环到下一次循环,当是while时直接判断条件,for还需要进行自加操作。
  16. 带有Lable的break和continue的区别:break跳到Lable之后跳过最近的{};contine跳到Lable之后进入{}。
  17. return返回结果、返回控制。

第三章

  1. 类变量 实例变量 类方法 实例方。
  2. 类变量、类方法既能用类名,也能用实例名访问。
  3. 实力变量、实例方法只能用实例名访问。
  4. 类方法中只能访问类变量,类方法中不能有this和super指针。
  5. 访问权限:public、protected、包(默认)、private。
  6. protected:1自己用;2子类用;3同一包中用。
  7. 不同访问权限的访问个体有:1类;2包;3子类;4不同包中的非子类。
  8. 构造方法是一个特殊的方法,与类名相同,无返回类型,通过new()调用。
  9. Java中没有析构函数,系统自动回收垃圾,对于不是通过new()申请的空间,用终结处理方法finalize()
  10. 对象的声明(标识符);实例化(用new分配空间);初始化(赋值)。
  11. 栈:基本类型和对象引用 堆:所有的Java对象,用new产生的数据。
  12. 类成员的初始化顺序:1静态成员;2组合对象成员;3类本身其他成员。
  13. 静态成员只初始化一次。
  14. Java包有一定的层次,对应外存上的目录结构,同一包中不能有相同的类名。
  15. 程序中没有package语句时,放入默认包中。
  16. 一个编译单元只能有一个公共类public class,公共类名与文件名相同,还可以有多个支持类。
  17. 导入的两个包中有同名类时,使用时用全名来区分。
  18. 为导入包而用类库中的类时,用全名引用;自定义的包,java+类名。
  19. java.lang 自动加载的默认包:基本数据的封装类、数学函数、字符串、线程等。
  20. java.util 工具类库:日期、日历、堆栈、向量、集合、哈希集。
  21. Object类:在lang包中,所有类的基类、定义所有类应有的公共函数。
  22. System类:在lang包中,不能实例化,所有方法均可直接引用,与系统属性相关。
  23. Math类:在lang包中,静态方法,不声明为实例,常用Math.PI、Math.E。
  24. String类:在lang包中,字符常量,不用new创建时由栈中引用指向常量池(不重复);用new创建时可重复。Substring截取中间一段,trim去掉两端空格。
  25. StringBuilder、StringBuffer:对于经常要修改的字符串,StringBuilder效率高于StringBuffer,StringBuffer在线程上是安全的,在大多实现过程中,StringBuilder要比StringBuffer快。
  26. String相当于字符中的常量,只要值变化,内存空间就变化。
  27. StringBuffer中的方法:append to追加、insert插入、delete删除、reverse反转。

第四章

  1. toString()函数,每个非基本类型中都有,未重写时默认输出为对象的内存地址。
  2. 组合:黑盒复用,依赖关系少,高效、动态。
  3. 继承:白盒复用,黏度高,易维护,破坏封装。
  4. 优先用组合。
  5. super出现在构造方法中必须在第一行。
  6. 重写:子类修改父类已有的方法(覆盖),重写的方法名、返回类型、参数类型必须完全相同,且被重写的方法不能有更严格的访问权限,发生在多态中,无新受检异常。
  7. 重载:同一类中方法名相同参数列表不同,只能通过参数列表重载,不能通过访问权限、返回类型、抛出异常重载;重载可以有不同的返回类型、访问权限、异常,但是不作为重载的标志。
  8. 抽象类abstract抽象类不能实例化,类中有抽象方法,abstract class a1{abstract void test();}函数声明之后有{}就算实现。
  9. 构造方法、静态方法、final方法不能使用abstract修饰。
  10. 接口默认为抽象类,实际上接口是抽象抽象类。
  11. final类不能被继承,因此final类中的成员函数没有机会被覆盖,默认都是final的。
  12. final方法:如果一个类不允许其子类覆盖某个方法,将这个方法声明为final。
  13. 将类方法声明为final更加高效,编译时绑定,静态绑定。
  14. final变量常量,修饰的成员的值一旦给定就无法改变:静态变量、实例变量、局部变量。
  15. static和final变量能够自动赋值为默认值。
  16. this()本类的构造函数 this.本类的变量或方法
    Super()超类的构造函数 super.超类的变量或方法
  17. 子类和超类有重名变量时,用this和super区分。
  18. 向上转型:子类转型为超类;超类的引用指向子类的对象。
  19. 超类的引用不能调用:1子类中定义而超类中没有定义的方法;2子类重写的方法。
  20. 只能将子类类型的引用赋值给超类类型的引用。
  21. 每个类实例对象都自带一个虚函数表,这个表中存储的是指向虚函数的指针。
  22. 超类和子类中都有的方法,才有多态的动态绑定问题。
  23. 重写的重要特征:除了函数的实现以外其他部分都相同;覆盖:均相同才能覆盖。
  24. Java中所有的成员方法都包含在虚表中,而C++中只有声明为virtual才是虚函数。
  25. 动态绑定和静态绑定的适用条件:静态:private、static、final、构造函数。
  26. 动态绑定的过程中,先在对象的实际类型的虚表中匹配,找不到的话再上溯到它的基类的虚表中找。
  27. this指针始终指的都是实际类型。
  28. 动态绑定指的是成员方法,成员变量始终都是静态绑定。
  29. 想要动态的调用变量成员,将变量成员封装在方法中返回。
  30. 重写是覆盖,同名的方法仅有一个;重载是并列,哪个参数匹配调用哪个。
  31. 多态的三种实现方式:1继承实现;2抽象类实现;3接口实现。
  32. 接口中只有常量和抽象方法。
  33. Java接口中的成员变量默认都是public static final类型的,这些关键字都可以省略,但是必须初始化。
  34. Java接口中的方法默认都是public abstract类型,不能有方法体,不能实现。
  35. 抽象类和接口的区别:抽象类中可以有写实的方法,但至少要有一个方法是抽象的;接口中所有的方法都必须是抽象的。
  36. Java接口中只能包含public static final成员变量和public abstract成员方法。
  37. 接口继承接口,类实现接口,类继承类。
  38. Java接口必须通过类来实现。
  39. 类实现接口时,当所有的方法没有全部被写实时,类应该声明为抽象类。
  40. 不允许创建接口实例,但是允许定义接口的引用指向实现了该接口的类实例对象。(类似于向上转型)
  41. 抽象类只能在继承体系中实现,而接口可以任意实现。
  42. 接口中的常量可以是不定常量,其值会在第一次访问是建立,然后保持不变。
  43. 内部类的访问权限控制符有:public、default、protected、private,嵌套内部类static。
  44. 创建非静态内部类时,一定要先创建其相应的外部类对象。
  45. outerclass.innnerclass innerobject=outerobject.new innerclass()
  46. 创建嵌套类对象时,不需要创建其外部类对象。
  47. outerclass.innnerclass innerobject=outerclass.new innerclass()
  48. 静态内部类不能访问外部类的非静态成员。
  49. 局部内部类:定义在一个方法或一个语句块中。
  50. 局部内部类访问外部类的局部变量时,只能访问final类型的。
  51. 局部内部类的访问优先级:内部类>外部类>局部final变量。
  52. 内部类的作用:允许protected和private权限,实现更小层次的封装。
  53. 内部类一般与接口联合使用,更好的实现多重继承。
  54. 匿名内部类:new 接口名(){} new 超类名(){}
  55. 内部类编译时生成的.class文件outerclassname$innerclassname.class 匿名内部类outerclassname$#.class #为数字,从1开始,每生成一个,数字递增1。
  56. 在内部类中调用this和new返回一个外部类时的不同,this得到的是创建该内部类的外部类对象的引用;而new创建一个新的引用。
  57. 有内部类的实例作为外部类的成员时,构造该外部类时,先创建内部类的成员实例,再创建外部类实例的其他成员。(相当于组合关系)
  58. 一个外部类的内部类被另一个类继承时,在该子类的构造方法中用外部类的一个实例调用超类的构造函数。Outerobject.super()。
  59. 一般的super()调用默认的都是extends类名中的构造函数。
  60. class son extends father{super();}
  61. class son extends father.innerclass{fatherobject.super();}

第五章

  1. AWT:重量级控件:靠本地方法实现其功能,不同的平台上不统一。
  2. Swing:轻量级控件:提供了AWT的所有功能,并大幅扩充。
  3. Swing中除了JFrame、JApplet、JDialog、JWindow之外都是轻量级控件。
  4. Button在AWT中,JButton在Swing中;其他的名称类似。
  5. Java采用向容器中添加组件的方式构建图形界面,通常用顶级容器作为所有组件的承载物。
  6. 容器之间可以完全嵌套。
  7. GUI组件分为:容器类、控件类、辅助类。
  8. 常用的组件及相关函数
    JFrame(窗口):setsize、setvisible、setlocation、setdefaultcloseoperation、getcontentpane
    JButton(按钮):settext、seticon、setbounds、addactionlistener
    JLable(标签):settext、seticon、settooltiptext、sethorizontextposition
    JTextField(文本框):addactionlistener、setcolums、settext
    JRadioButton(单选框);JDialog(对话框);JFileChooser(文件对话框);JComboBox(组合框):JTextField(文本域)、JMenu(菜单)。
  9. 布局管理:Container中有一个方法交setLayout()
  10. 不同的布局方式有:1BorderLayout;2FlowLayout;3GridLayout
  11. BorderLayout是JFrame的默认布局,组件分为5个区域,东西南北中。
  12. add(位置,组件)
  13. FlowLayout顺序布局:从左到右、从上到下、
  14. GridLayout网格布局:组件在网格中从左到右、从上到下。
  15. 事件处理:1事件;2源事件;3事件处理者。
  16. 事件处理的步骤:1注册事件监听器;2外部作用于事件源;3生成事件对象;4将事件对象传给事件处理器;5事件处理器进行处理。
  17. 定义监听器:actionPerformed、new创建监听器对象、注册监听器add***actionlistener()
  18. 监听器的三种实现方式:1实现注册写实;2内部类;3匿名内部类的实现。
  19. GUI编程中要用的三个包:import java.awt.;import javax.swing.;import java.awt.event.*。
  20. 适配器:Adapter:适配器产生的必要性:接口中有很多抽象函数未写实,当要用到其中的某个功能时,需要全部写实,带来不便;适配器实现了所有方法却不做任何事情,可被继承然后只需写实要用到的那个方法而不用管其他方法。
  21. 适配器是处于接口和类之间的一个过渡性产物,省去很多实现的麻烦。

第六章

  1. 异常的分类:1Exception经过处理能恢复正常,不中断现有程序;2Error无法恢复必须中断现行程序退出。
  2. 常见的异常:ArithmeticExption数学异常、OutofMemory内存溢出异常、NullPointerExption空指针异常、IndexOutofMemoryExption下标边界异常。
  3. 错误由JVM抛出。
  4. 异常分为受检异常和不受检异常:1不受检异常(编译器可处理):不要求程序员处理,最终可从main()抛出并用printStackTrace()一般是逻辑错误,包括RuntimeException和Error及其子类;2受检异常:强制程序员检测和处理。
  5. 异常的处理方法:1用try-catch-finally结构捕获和处理;2将异常层层向上抛直至转交给JVM处理。
  6. 多个catch块时只会匹配其中一个异常类并执行catch的代码,catch匹配的顺序是从上到下。
  7. 无论try语句块是否发生异常,finally语句块都是要执行的。
  8. try-catch-finally三个语句块不能单独使用,可组成try-catch-finally、try-catch、try-finally三种结构,catch块可以有多个,finally块只能有一个。
  9. try-catch-finally块中的变量的作用域为语句块内部,分别独立不能相互访问。
  10. catch块的参数有父子关系时,子类在前,父类在后。
  11. 返回类型+函数名称+形参列表+throws Exception{}
  12. 异常传递链:不处理不执行,方法在抛出异常的地方退出,不想终止方法就用try来捕获异常。
  13. 自定义异常在构造函数中super()来调用Exception类的构造函数。
  14. throws方法声明时放在方法中,throw在方法体中,在一个具体的动作。
  15. 如果抛出的异常一直未被处理,沿函数一直往上抛,从主函数中抛出之后由JVM处理,此时可以调用printStackTrace()打印这一异常所在的位置、类型等信息。

第七章

  1. Java中数组的下标从0开始编号,数组中除了元素之外还存在唯一的可被访问的属性length。
  2. 数组声明:类型[]数组名 类型 数组名[] []表示数组类型
  3. 数组的初始化:静态初始化、动态初始化。
  4. 静态初始化:[]中没有数字,各个元素的值显性给出。
  5. 动态初始化:[]中有数字或变量,用关键字new,数组中各个元素可以自动赋值。
  6. new申请空间时在堆上,在堆上均可自动赋值。
  7. 对象数组的初始化:类型[]数组名=new 类型{new 构造方法()…}
  8. 对于大型的数组或对象数组,一般结合循环语句来赋值。
  9. 多维数组:n维数组中存放着n-1维数组的引用。
  10. 不规则数组:数组元素引用的数组长度不等:a.length指的是第一维数组长度;a[i].length指的是对应维数数组的长度。
  11. 数组是一个特殊的对象,数组名存放一个对象的引用。
  12. 数组名实质是一个引用,所以可以作为参数。
  13. 数组工具类:Arrays,类函数:copyof数组中的值拷贝;sort升序排序;binarysearch查找特定值;equals判断两个数组是否相等。
  14. 对象比较接口:java.lang.comparable int compareTo(Object o)
    java.util.comparator int compare(Object o1, Object o2)
  15. 一个类用sort比较大小时,自动调用compareTo方法比较大小。
  16. 枚举:有限的、不变的值的集合。
  17. enum类型变量只能保存声明时给定的枚举值。
  18. 数组:静态容量,容量的一开始就定了。
  19. 类集Collection,是动态容量:有两个子集:1List对象有顺序,允许重复;2Set无序,不能重复。
  20. Map映射:键值对,键是唯一的,值可以重复。
  21. List:(有顺序,靠下标索引)ArrayList LinkedList
  22. List l=new ArrayList(),改变集合类型时代码不用变化,类似于接口引用一个实现了它的类,当使用类特有的方法时,不能用接口定义,而应该使用具体的类。
  23. ArrayList数组内部维护了一个Object类型的数组;LinkedList内部维护了一个有头结点的双向链表。
  24. 使用LinkedList可以很简单的构造堆栈、队列,addFirst、addLast、getFirst、getLast、removeFirst。
  25. 泛型,C++中的模版,声明泛型时,使用尖括号指定类型参数,应用时用具体的类型填入类型参数。
  26. 泛型:类模版、函数模版。
  27. 声明 class 类名<类型参数列表>{}
  28. 应用 类名<具体的类型列表>变量名=new类名<具体的类型列表>(构造函数的参数列表)。
  29. 类、接口、方法都能使用泛型。
  30. 集合Set:不允许重复,无下标索引,常用的集合HashSet、TreeSet、LinkedHashSet。
  31. system.out.println(set)用结合作为参数能直接输出结合中的元素,输出形式为[…,…,…]
  32. 迭代器:Iterator设计模式、对象,特别为遍历无索引的集合而准备。
  33. Iterator中的函数:next()首次使用时,返回序列的第一个元素,之后获得序列中的下一个元素并向后移;hasnext()判断是否有下一个。
  34. 迭代器的使用:判断it.hasnext();取出类型=it.next()
  35. for-each遍历,对迭代器进行了包装,代码更加简洁,只能遍历两种类型:1数组;2实现了Iterator接口的实例。
  36. 哈希集:HashSet:用哈希表和哈希算法实现快速查找,折中了数组和链表,内部维护了一个链表数组,拥有常数查找时间,要求对象重写hashCode、和equal方法。
  37. 哈希表类似于邻接表,散列、Cache映射寻址中的组相连。
  38. 哈希表工作的两大步骤:1获得哈希码,算出该插入哪个链表;2在链表上比较。
  39. 容量:链表数组的大小,载入因子,重构的条件;当元素数目>容量*载入因子时,重构翻倍。
  40. HashSet中没有相同的元素,所以内容equals的对象,hashcode一定也相等,hashcode不相等的两个对象一定不equals。
  41. hashcode默认返回的是内存地址,equals默认比较的也是内存地址。
  42. 哈希集中一般选一个不重复的关键词作为哈希码。
  43. TreeSet元素间有序但不能重复,,自平衡二叉树,必须实现comparable和compator接口来比较,写实equal保证唯一性,查找效率为 。
  44. LinkedHashSet哈希集+链表,在HashSet基础上将元素串起来,元素有序。
  45. 输入同一组数据,用不同的集输出,HashSet元素存放无序,LinkedHashSet保持添加顺序,TreeSet按排序存放。
  46. key-value关系对的无序容器,键值均为对象,键值对也为对象。
  47. 一个映射Map中不能有相同的key,每个key只能有一个value
  48. Map不能用迭代器,无序,无法索引。
  49. 遍历Map时,通过将映射转换为键或值来进行遍历。
  50. List Set Map为接口,不能实例化。
  51. 泛型<>的位置,函数:在访问控制符之后,类,接口在名称之后。理解:必须在可能出现类型的地方之前
  52. collection是list和set的父类,collection工具类,静态类,有常用的操作。

第八章

  1. 创建好的输入输出系统是艰难的工作:1与不同的源和目的端进行交互;2以不同的方式进行通信;3大多数I/O需要异常处理。
  2. Java通过各种封装的流类完成输入输出工作。
  3. 流:想象中无限长的数据序列1输入流输出流;2字符流字节流;3节点流处理流。
  4. 字节输入:InputStream、字节输出OutputStream、字符输入Reader、字符输出Writer。
  5. ByteArrayInputStream:将内存的缓冲区来当作InputStream使用。
  6. StringBufferInputStream:将String转换成InputStream。
  7. FileInputStream:从文件中读取信息。
  8. PipedInputStream:产生用于写入相关数据,实现管道化。
  9. ObjectInputStream:对象序列化输入流。
  10. SequenceInputStream:将两个或多个InputStream对象转换成单一的InputStream。
  11. DataInputStream:从流中读取基本的数据类型(int char long…)
  12. BufferedInputStream:使用缓冲区读入,防止每次读取都要进行操作破坏硬盘。
  13. LineNumberInputStream:跟踪输入流的行号。
  14. 节点流:从特殊位置读写的基本功能。
  15. 处理流:结合其他流的基础上,修改管理数据并提供额外功能。
  16. 常见的处理流:1缓冲Buffered;2过滤:Filter;3转换InputStreamReader;4对象序列化ObjectInputStream;5打印PrintStream。
  17. 缓冲流:不直接读写,对硬盘损害小,嵌套在其他节点流之上,提高效率。
  18. 缓冲流在构造时,一般有两个参数:1要包装的流类;2要缓冲的数据的大小。
  19. mark标记流中当前的位置;reset定位到最近的标记点;readline读一行;flush刷新。
  20. 打印流,不抛异常,自动刷新。
  21. 数据流:支持基本类型的输入输出,继承自InputStream、OutputStream。
  22. 流的难点在于:搞清格流之间的关系,流之间如何嵌套,如何用一个流若为参数来构造另一个流。
  23. 处理流需要在节点流的基础上封装构造,所以识别基本的节点流和处理流是一项基本功。
  24. 处理流在使用完毕之后要调用close函数,处理流是动态的,不关一直起作用。
  25. 标准I/O流,System.in键盘输入;System.out屏幕输出;System.err错误输出。
  26. 各种流类的嵌套定义和初始化时遵循一个原则,简单的被复杂的嵌套,简单的作为复杂的参数。
  27. Scanner类:扫描输入文本,除了可用正则表达式之外,还可分析字符串和基本类型。
  28. Scanner的使用: Scanner s=new Scanner(System.in) int ss=s.nextInt()
  29. 使用输入输出时导入一个包import java.io.*;
  30. 使用Scanner是import java.util.*;
  31. 文件输入输出流:FileInputStream、FileOutputStream 、FileReader、FileWriter。
  32. File类的构造:public File(String pathname)相对路径、绝对路径、父路径、子路径。
  33. mkdir创建文件夹 mkdirs在不存在为文件中创建文件夹
  34. 有关文件的输入输出:int b=0,while((b=in.reader()!=-1)){}
  35. 随机访问文件:适用于大小已知的记录组成的文件,seek到指定位置,getFilePointer得到当前指针位置。
  36. length判断文件大小。
  37. RandomAccessFile生成随机访问文件。

第九章

  1. 系统级并发,单个的一段程序执行控制流称为线程。
  2. 多线程:一个程序内有多个相同或不同的线程或执行不同的任务。
  3. 多线程的作用:1提高UI的响应速度;2提高硬件资源的利用率;3隔离高速硬件和低速硬件;4提供程序上的隔离不同的运行模块。
  4. 实现多线程的程序设计关键:获得Thread实例,重写run方法,调用start方法开始线程并分配资源。
  5. 从run方法中返回是退出线程唯一正确的方法。
  6. start是线程从系统外分配资源,run是线程获得资源后要进行的工作。
  7. 线程类Thread是Object的直接子类,成员属性:PRIORITY优先级。
  8. Thread的成员方法:sleep休眠指定的秒数,start启动线程,yield挂起暂停,run执行,notify唤醒。
  9. isLive判断线程是否处于活动状态,getName返回线程名称,currentThread返回正在执行的线程的引用。
  10. 继承Thread:1继承Thread类;2重写run方法;3new创建新对象;4调用start启动线程。
  11. 线程的不确定性:同一线程内执行的顺序是一定的,多个线程执行顺序有多种组合。
  12. 用继承Thread类的方式实现多线程,被Java多继承的限制不能再继承别的类。
  13. 用实现Runnable方法实现多线程:(更加通用的多线程方法),1实现Runnable方法;2重写public void run(){};3用new来实例新对象;4调用start启动线程。
  14. 通过继承和实现两种方法形成的线程类在使用时有区别:1继承实现的线程类能直接实例化;2通过实现的线程类实例化之后作为new Thread()的参数。
  15. 线程的生命周期:出生、就绪、运行、休眠、等待、阻塞、死亡。
  16. 两个线程的依赖关系:某格线程在另一个线程终止时才能继续执行,可调用另一个join的方法当另一个线程死亡时,该线程从等待态进入就绪态。
  17. 线程被创建时,从父线程中继承优先级,创建之后也能改变优先级。
  18. 优先级定义分为10级。
  19. 线程优先级的作用:方便操作系统的调度,优先级相同且不实用分时技术时,一个运行完才运行下一个,除非他自己变为其他状态。
    20 两个线程同时访问一个成员,造成对共享数据的冲突,造成一致破坏,为保证数据的一致性,引入同步锁sunchronized
  20. 同步分为方法同步和语句同步,方法同步在函数类型之前加sunchronized;语句同步在{}之前加sunchronized。
  21. 协作机制:生产者消费者模型。
  22. 死锁的解决:1逻辑隔离:每个同步区使用各自的锁;2尽快释放:使用完尽快释放锁对象;3按顺序申请:用到多格锁对象的申请一致。

第十章

  1. 数据库的组成:数据库、数据库管理系统、应用系统、数据库管理员、数据库用户。
  2. 数据类型:网状模型、层次模型、关系模型。
  3. 关系模型数据库是目前最流行的数据库。
  4. 数据库的数据有最小的冗余度和较高的数据和程序独立。
  5. SQL语言,常见的SQL查询命令
    查询:selsct…from…where
    操纵:insert、updata、delete
    定义:creat、alter、drop
  6. JDBC是为了JAVA专门和数据库交互的一套接口,用于执行SQL语句的JavaAPI。
  7. JDBC的基本功能:1加载JDBC驱动程序;2建立与数据库的联系;3使用SQL语言进行数据库操作和处理结果;4关闭相关链接。
  8. 写数据库程序要导入的包:import java.sql.*。
posted @ 2019-02-19 14:19  童小哥总是不开心。  阅读(60)  评论(0编辑  收藏