JavaSE知识点总结

目录

• 0.代码展示
• 1.Java程序设计概述
• 2.Java语言的开发环境
• 3.Java程序的基本结构
• 4.对象和类
• 5.继承和多态
• 6.泛型程序设计
• 6.1封装
• 7.接口和内部类
• 8.异常处理
• 9.反射，代理，标注
• 10.java常用类
• 11.IO流
• 13.线程
• 14. Java 异常详解

0.代码展示

	// 1. 把数组中的字段变成字符串,并且循环展示
	// 输出：[1, 2, 4, 545, 11, 32, 13131, 4444]
	int[] ints = {1, 2, 4, 545, 11, 32, 13131, 4444}; //定义数组
        int[] code = new int[2]; //定义数组
        System.out.println(Arrays.toString(new int[] {1, 2, 4, 545, 11, 32, 13131, 4444}));
	
	// 2. 三元运算符 AngularJS:data.isDeleted = data.isDeleted=="1"?"是":"否";
	int x = -100;
	System.out.println(x > 0? 1:(x==0? 0:-1));
	
	// 3. 输出倒叙循环 快捷键: split.forr
	for (int i = list.size() - 1; i >= 0; i--) { System.out.println(list.get(i)); }

---

1.Java程序设计概述

1. 开发Java语言的公司？
   • Sun （Sun Microsystems）太阳微电子公司开发
2. Java的三个版本
   • J2SE(Java2 Standard Edition) 标准版(JavaSE，Java基础，使用与桌面版本开发)
   • J2EE(Java 2 Platform,Enterprise Edition) 企业版(JavaEE，适用于Web网页开发)
   • J2ME(Java 2 Micro Edition) 微小版(手机端、机顶盒开发)
3. Java语言的几个主要特点？
   • 平台无关性：能运行于不同的平台上
   • 安全性：去掉了指针操作，内存由操作系统分配
   • 面向对象：利用类使程序更加利于维护
   • 分布式：可以使用网络文件和使用本机文件一样容易
   • 健壮性：检查程序编译和运行的错误
4. Java的三大核心机制
   • 虚拟机机制：利用虚拟机解释字节码执行java程序实现跨平台
   • 垃圾收集机制：自动内存回收
   • 代码安全性机制：加载代码后校验代码后再执行代码

---

2.Java语言的开发环境

0. 老鸟建议
   • 如果只是运行Java程序，只需要JRE就可以，JRE通常非常小，其中包含了Java运行虚拟机 ----> JVM。
   • 如果要开发Java程序，则需要安装JDK。
1. JDK是什么？
   • JDK(Java Development Kit)Java开发工具包。包括了JRE，是开发Java的人员必备的开发运行Java程序的工具。
2. JRE是什么？
   • JRE（Java Runtime Environment）Java运行环境，运行JAVA程序所必须的环境的集合，包含JVM标准实现及Java核心类库。
3. JVM是什么？
   • JVM (Java Virtual Machine) Java虚拟机，它是一个虚构出来的计算机,是通过在实际的计算机上仿真模拟各种计算机功能来实现的。
4. 安装JDK的操作系统问题？
   • 必须针对于不同的操作系统下载安装不同的JDK，例如windows下安装针对于windows的JDK，linux下安装针对于linux的JDK。
5. 需要配置的相关环境变量？
   • path：用于搜索外部命令，例如编译程序的javac命令，执行程序的java命令
   • classpath：用于搜索类，即class文件，例如可以在不同的位置执行类文件
6. 配置环境变量的方式？
   • 有两种：临时配置和持久配置
     + 临时配置：在命令行下用set 变量名 = 变量值 ，仅在当前命令行窗口有效
     + 持久配置：在我的电脑——属性中配置，持久有效
7. 可以编写Java程序的常见开发工具？
   • 记事本，EditPlus，ULTRAEDIT，Eclipse，Jbuilder，NetBeans，idea
8. Java文件的类型？
   • 有两种：
     • 扩展名为java的文件：是Java源文件，属于编译之前的纯文本文件，存储java源代码。
     • 扩展名为class的文件：是Java类文件，属于编译之后的二进制文件，存储字节码。
9. Java的编译运行原理？
   • 首先编写java源文件，然后编译成class类文件，然后通过(JVM虚拟机)解释成机器码到硬件执行。
10. Java是编译型语言，还是解释型语言？
    • 既不是完全编译型，也不是完全解释型，是半编译半解释的。
11. JDK图解

    

12. 第一个Java程序的总结和提升

13. 个别最基本用到的DOS命令

    

14. 总结

    

---

3.Java程序的基本结构

0. 规定

   • 标识符必须以字母、下划线、美元符 "$" 开头。
   • 标识符其他部分可以是字母、下划线_、美元符 $ 和数字的任意组合。
   • Java标识符的大小写敏感、且长度无限制。
   • 标识符不可以是Java的关键字。
   • Java中的保留字/关键字。

     

   • 从整体上可以将变量划分为局部变量、成员变量(也称为 实例变量)和静态变量。

     

   • 常量——老鸟建议

     

   • Java的基本类型

     

   • 雷区：浮点型比较请使用BigDecimal

     

   • Java中的运算符

     

   • 赋值及其扩展运算符

     

   • 位运算符

     

     • System.out.println(10>>2); //相当于：10/2/2
     • System.out.println(10<<2); //相当于：10 乘 2 乘 2
   • 运算符的优先级

     

   • 自动类型转换

     

   • 浮点数存在舍入误差，数字不能精确表示。如果需要进行不产生误入误差的精确数字计算，请使用BigDecimal类。

1. Java语言区分大小写吗？

   • 区分，不管是数据还是标识符或者关键字都区分大小写，例如public不能写成Public， “abc”不能写成“ABC”，int i不能写成INT I等等。

2. main方法是作什么用处的？

   • 这是程序的入口方法，是由虚拟机自动调用的。

3. 语句必须用分号结束吗？

   • 必须的，但是代码块{}可以用分号结束，也可以不用分号结束

4. Java中有几种注释，各自的功能

   • 有三种：
     • 单行注释//：加在行首只能注释一行
     • 多行注释/* */：注释多行，但不能嵌套使用
     • 文档注释/**  */：用于生成HTML形式的文档，需要配合javadoc命令实现

5. Java语言的数据类型是强类型还是弱类型？

   • 是强类型，意味着每一个变量都必须明确声明数据类型。

6. Java语言中数据类型的划分？有什么区别？

   • 分成基本类型和引用类型两大类。
     • 基本类型：有8种，只能存储单一的值，不以对象的形式存在
     • 引用类型：除了基本类型之外其他的都是引用类型，能够存储复杂数据类型，以对象的形式存在

7. 基本类型都有哪8种类型？

   • 布尔类型：boolean：占1个字节
   • 字符类型：char：占2个字节
   • 整形： byte(1) short(2) int(4) long(8)
   • 浮点型：float(4) double(8)

8. 布尔值可不可以用0或者非0数代替？

   • 不可以，布尔值只能是true和false，不能使用数字，这和C语言是不一样的。

9. 直接写个整数10默认是什么类型的？

   • 整型的直接量例如10，100等默认的数据类型都是int型

10. 如何让一个整型的直接量变成long型的？

    • 在直接量后面加大写L后者小写l，例如10L

11. 整型数据在程序中直接使用可以使用什么进制？

    • 10进制 ，8进制 ，16进制 ，但不能使用二进制

12. 浮点运算在Java中有没有误差？

    • 有误差，所以精密运算请使用BigDecimal类

13. 直接写一个3.14的直接量是什么数据类型的？

    • 是double型，如果想表示是float的3.14必须写成3.14F或者3.14f，double型的3.14也可以 3.14D

14. char型采取的是什么类型的字符集？

    • 是Unicode全球统一编码，支持任何世界上官方的语言中的字符

15. 常见的转义字符有哪些？

转义序列	名称
\b	退格
\t	制表
\n	换行
\r	回车
''	双引号
'	单引号
\\	反斜杠

16. 常见的Unicode字符对应的编码？
    • 大写的A到Z是对应65到90，小写的a到z是对应97到122，字符0到9是对应48到57
17. 空字符是不是用’’（两个并列的单引号）来表示？
    • 不是，空字符用’\u0000’来表示，两个并列的单引号什么也不是。
18. 点,分号,花括号的各自的作用?
    • 点的作用有两个：一个是使用类或对象中的成员，用对象.成员，再一个就是包名和子包名
    • 分号的作用是表示语句结束
    • 花括号的作用是代表一个语句块
19. 语句和关键字之间可以有任意的空白吗？
    • 可以的，例如System.out.                  println(100);就是正确的语句，但是关键字本身不能加空白或换行
20. 标识符是什么？
    • 标识符就是指在程序中给包，类，接口，方法，变量起的名字
21. 标识符有什么起名规则？
    • 应以字母、下划线、美元符开头
    • 后跟字母、下划线、美元符或数字
    • 不能用关键字和保留字
    • 严格区分大小写
    • 名称长度没有限制
22. 中文的变量名可以吗？
    • 是可以的，例如 int 数字 = 10;这个语句是正确的。因为java中采取Unicode字符集，所以任何的Unicode中的字符都可以作为标识符的名称，但考虑字符集的支持问题推荐还是使用。
23. 关键字和保留字有区别吗？
    • 在1.5后没有区别，都被称作关键字，但是1.5之前认为关键字是在Java中有特殊用途的不允许编程人员擅自改作其他用途，而保留字是在Java中没有特殊用途但不允许编程人员擅自改作其他用途，按此说法goto和const应该是此意义上的保留字。
24. true，false，null可以用作标识符命名吗？
    • 不可以，这3个虽然不是关键字，但都是有特殊用途的值，也不能作为标识符命名
25. 一条声明语句可以声明多个变量吗？
    • 可以的，例如以下声明都是正确的

    int i;
    int i,j;
    int i = 10,j;
    int i,j = 10;
    int i = 10,j = 20;

26. 变量在没有赋值的情况下可以使用吗？
    • 不可以，变量没有赋值使用会报出变量未初始化的编译错误。
27. 常量有什么特点？
    • 在声明变量的时候加上final修饰符即为常量，表示这个变量只能被赋一次值。
28. 算数运算符有哪些？
    • 基本算数运算符有+ - * / % ++ --
29. 单目运算符，双目运算符，三目运算符都是什么意思？
    • 其实也有叫一元运算符，双元操作符，三元操作符的，指的是有几个操作数形成一个完整表达式，例如++就是一个单目运算符，只需要一个操作数就可以形成表达式，像i++，而+运算符就是双目运算符，需要两个操作数形成表达式，例如5 + 3，还有三目运算符，例如5 > 3 ? 0 : -1
30. ++和--放在前面和放在后面有什么区别？
    • 如果是在一个表达式中，那++放后面表示先运算表达式，然后再进行自增运算，如果在一个表达式中，++放前面，则表示先进行自增运算然后在运算表达式。--同样道理。
    • 例如：

    int i = 10;
    int j = i ++; //先进行赋值运算然后再进行自增运算 j的结果是10
    int i = 10;
    int j = ++ i ; //先进行自增运算然后再进行赋值运算 j的结果是11

31. -5 % 2等于几，5 % -2等于几？
    • -5 % 2等于-1，5%-2等于1，运算得到是正数还是负数取决于第一个操作数的符号
32. 5 / 2 结果是不是2.5？
    • 不是，是2，因为5和2都是int类型，所以不可能得到double型的结果。
33. 比较运算符有哪些？
    • 有>  <  >=  <=  ==  != 六项基本比较运算
34. 任何数据类型都可以使用> < >= <=运算符吗？
    • 不是所有数据类型，例如true>false这个表达式就是编译错误，
    • 布尔类型和引用类型的表达式只能用==和！=两个比较运算，例如”abc” <= ”xyz” 这个表达式也是编译错误的
35. 'a' > 'b'这个表达式编译正确吗？
    • 编译正确,'a'和'b' 是字符类型，内部用Unicode编码表示的话a是97，b是98，所以实际上比较的是97>98，结果为false
36. 逻辑运算符有哪些？
    • 有 &逻辑与，|逻辑或，！逻辑非，^ 异或，&& 短路与，||短路或
37. 逻辑与，逻辑或和短路与，短路或有什么区别？

    • 逻辑与和短路与的区别是：

      • 如果是逻辑与&，不管第一个表达式是true还是false，都会执行第二个表达式，例如a > b & x < y，即使a > b为false，也会执行x > y
      • 如果是短路与&&，如果第一个表达式为false，将不会执行第二个表达式，例如a > b && x < y，如果a > b为false，就不会执行x > y
      • int a = 10，b = 8;
      • System.out.println(a > b | b>a); //true
      • System.out.println(a > b & b>a); //false

    • 以此类推，逻辑或和短路或的区别是：

      • 如果是逻辑或|，不管第一个表达式是true还是false，都会执行第二个表达式
      • 如果是短路或||，如果第一个表达式为true，将不会执行第二个表达式
38. 与或非三个逻辑运算符的优先级是怎么排列的？
    • “非”优先级最高，“与”其次，“或”优先级最低
39. 原码，反码，补码分别是什么意思？
    • 原码：将数字转换为二进制，第一位为符号位，正数为0，负数为1
      • 例如：12的原码是00001100 -12的原码是10001100
    • 反码：正数的反码和原码相同，负数的反码将原码符号位之外的位逐位取反
      • 例如：12的反码是00001100 -12的反码是11110011
    • 补码：正数的补码和原码相同，负数的补码将反码加1
      • 例如：12的补码是00001100 -12的补码是11110100
    • 最后强调一点，计算机存储数据用补码形式来存储。
40. 位运算符都有哪些？
    • &与 |或 ^异或 ~非 >>右移 <<左移 >>>无符号右移
41. 1<<35怎么理解？
    • 1是int类型是32位，所以需要把35%32=3，所以事实上是和执行1<<3等价的
42. 数据类型转换需要遵循什么原则？
    • 小类型向大类型转换，是自动转换的，或者说隐式转换的
    • 大类型向小类型转换，是需要强制转换的，或者说显式转换
43. byte b = 10这个语句是正确的，为什么10是int型比byte大还不需要强制转换呢？
    • 因为在java中做了特殊处理，其中规定byte，short，char类型可以直接赋予int类型的直接量，但是不能 超过类型的数值范围，如果超出，则必须使用强制类型转换
44. byte b = (byte) 300;强制转换后的结果是44，是按照什么规律得出来的？
    • 是先把300转换成二进制，然后根据byte类型的大小截取了后8个位
45. byte b = (byte) true;这个转换成立吗？
    • 不成立，布尔值和数字是不兼容的，不能作任何转换。
46. int i = (int) “100”;这个转换成立吗？
    • 不成立，引用类型和基本类型是不能直接强制转换的，需要用包装类的方法来转换。
47. char型和short型哪个比较大？
    • 不能说哪个大，哪个小，这两个类型char的取值是从0_{65535，而short类型的取值是-32768}32767，这个两个类型之间的转换都需要强制转换。
48. 字符串是不是基本类型？
    • 不是，String是java.lang包中的一个类，是引用类型的，8种基本类型中没有一个是String类型。
49. 空字符串用什么来表示？
    • 用””（两个并列的双引号）表示，代表0个长度的字符串对象。
50. String s = “”;和String s = null;有什么区别？
    • 第一个表示s被赋值，指向了一个字符串对象，第二个表示s没有指向任何对象实例，是真空
51. 两个字符串用什么运算符可以连成一个字符串？
    • 用+运算符，例如”abc” + “xyz”最后的结果就是“abcxyz”
52. 数学运算符加法和字符串连接符都是+，怎么区分？
    • 是通过运算符两边的操作数来判断的，如果两边的操作数都是数字型的基本类型，则进行数学运算，如果两边的操作数有一个是字符串，则把另一个操作数也转换为则进行字符串连接运算。
53. 判断字符串内容相同用什么方法？
    • 用equals方法判断内容相同，==只能判断引用是否相同
54. 提供用户输入使用哪个类
    • 使用javav.util.Scanner类
55. if语句可以用if(-1)形式判断吗？
    • 不可以，数字不能代替布尔值
56. if语句和循环语句的花括号什么时候可以省略？
    • 当执行的语句只有一句的时候
57. switch语句有哪些规则？
    • 表达式expr的返回值必须是下述几种类型之一：int, byte, char, short或枚举常量；
    • case子句中的值必须是常量，且所有case子句中的值应是不同的，也必须是下述几种类型之一：int, byte, char, short或枚举常量
    • default子句是任选的；
    • break语句用来在执行完一个case分支后使程序跳出switch语句块；
58. 对于退出循环break和continue有什么区别？
    • break：退出整个循环
    • continue：退出当前循环，继续执行下一次循环
59. 声明数组创建数组的方法，以下声明都是合法的
    • int[] a; int a[]; String[] a;
    • 以下创建数组对象是合法的
      • int[] a = new int[3];
      • int[] a = {1,2,3};
      • int[] a = new int[]{1,2,3};
60. int[] x和String[] s这两个数组对象，哪个是基本类型，哪个是引用类型？
    • 两个都是数组对象，都是引用类型的
61. 数组元素下标最小是多少，最大是多少，超出范围会怎么样？
    • 最小是0，最大是数组元素个数减一，超出范围将会出现下标越界异常
62. 得到数组长度用length属性还是length（）方法？
    • 是length属性，得到字符串长度才有length方法
63. 声明int[][] a = new int[3][]，a是一个二维数组，a[0]本身是什么类型的？
    • 二维数组的元素都是一维数组，a[0]是int[]类型的
64. 数组的大小一经创建可不可以改变大小了？
    • 不可以，数组是定长的，一经创建就不能再改变大小了
65. 可以把2个int型，3个double型，4个String型的值放到一个数组中吗？
    • 不可以，数组的元素类型必须是相同类型的
66. java中的多维数组必须是要形成矩阵排列吗？
    • 不一定，也可以是不规则的。
67. 操作数组比较方便的实用类？
    • java.util.Arrays类提供了很多关于数组的实用方法。

---

4.对象和类

1. OOP是什么意思。
   • Object Oriented Programming(面向对象编程)
2. 类和对象的区别？
   • 类：对象的蓝图，生成对象的模板，是对一类事物的描述，是抽象的概念上的定义
   • 对象：对象是实际存在的该类事物的每个个体，因而也称为实例
3. 类之间的3种关系？
   • 依赖关系（uses-a）
   • 聚集关系（has-a）
   • 继承关系（is-a）
4. 一个java源文件可以写多个类吗？
   • 可以，但必须只能有一个公有类，并且文件名和公有类的类名相同。
5. 类中有哪些成员？
   • 有属性（数据域），方法，构造器（构造方法）
6. 构造方法和普通方法的区别？
   • 构造方法没有返回值，方法名必须和类名相同，需要用new语句调用构造方法。
7. 普通方法可不可以也类名作为方法名？
   • 是可以的，因为调用普通方法的语法和调用构造器的语法不一样。
8. 一个构造器调用另外一个构造器需要用什么语法？
   • 用this（）语法调用另外一个重载构造器，需要注意的是调用语句必须是构造器中的第一句
9. 什么时候虚拟机会自动添加一个默认构造器？
   • 当类中没有显式定义任何构造器的时候，虚拟机会自动添加一个无参的构造器
10. 实例成员和静态成员的区别？
    • 实例成员：是属于对象实例的，用对象.成员名称语法调用
    • 静态成员：和对象实例无关，是属于类本身的，用类名.成员名称语法调用
11. 静态初始化块statci{}的执行时机是什么时候？
    • 在类被加载的时候，仅执行一次。
12. 静态方法可不可以直接调用同一个类中的非静态方法？
    • 不可以，静态方法不能直接调用一个非静态成员，需要用对象调用。
13. 包是什么？
    • 包实际上就是物理上的文件夹，可以把类放到不同的包中。
14. 把一个类放到包中，需要在类中加上什么语句？
    • 需要加上包声明package语句，必须写在源文件的第一句。
15. 什么时候需要导入类？用什么语句？
    • 当使用的类和当前类并不在同一个包中的时候，用import语句导入。
16. 默认包中的类可以导入吗？
    • 不可以，不在默认包中的类无法使用默认包中的类。
17. java中哪个包中的类是自动导入的？
    • java.lang包
18. 什么叫做完整类名？
    • 顶层包名.子包名.类名
19. 静态导入语句有什么作用？
    • 在使用类中的静态成员的时候前面不需要加类名前缀。
20. 局部变量和全局变量的区别？

| 区别 | 局部变量 | 全局变量 | 没有访问权限
| 有访问权限--- | --- | --- | 默认值
| 声明位置 | 方法或使用形式块内部 | 方法外类内部 |
| 访问权限修作用域饰符 | 没有访问权限 | 有访问权限 |
| 默认值生命周期 | 没有默认值 | 有默认值 |
| 使用形式 | 直接使用 | 对象调用 |
| 作用域 | 在方法或语句块内部 | 整个类 |
| 生命周期 | 进入方法或语句块创建退出方法或语句块销毁 | 随着对象的创建而创建 随着对象的销毁而销毁 |

21. 赋值语句赋给目标的是值还是引用？
    • 如果是基本类型则赋的是值本身，引用类型则赋的是引用地址。
22. 多态
    • 多态是指的同一个方法的调用，由于对象不同可能会有不同的行为。现实生活中，同一个方法，具体实现会完全不同。
    • 人.休息(); 普通的人：睡一觉。 小孩儿：出去玩一圈。 程序员：敲两行代码。
    • 多态的要点。
      • 多态是方法的多态，不是属性的多态（多态与属性无关）。
      • 多态存在的三个必要条件：继承、方法重写，父类引用指向子类对象。
      • 父类引用指向子类的对象后，用改父类引用调用子类重写的方法，此时多态就出现了。

package com.chinalefe.component;

/**
 * 测试多态：张三：记录于2020.08.24
 */
public class TestPolym {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animalCry(animal);

        Dog dog = new Dog();
        animalCry(dog);

        animalCry(new Cat());
    }

    static void animalCry(Animal a){
        a.shout();
    }
}

class Animal{
    public void shout(){
        System.out.println("叫了一声！");
    }
}

class Dog extends Animal{
    public void seeDoor(){
        System.out.println("看门中……");
    }
    public void shout(){
        System.out.println("汪汪汪……");
    }
}

class Cat extends Animal{
    public void shout(){
        System.out.println("喵喵喵……");
    }
}

24. ==和equals的区别
    • ==作为基本类型，比较的是值是否相等；作为引用类型，对比的是引用对象的地址是否相等。
    • equals是不可以对比基本类型的，若没有重写equals，对比的是对象的地址，如果重写过equals，对比的是值是否相等。

---

5.继承和多态

1. 类的继承是谁继承谁？
   • 是子类继承了父类，子类也称为派生类，父类也称为超类或基类
2. 子类继承了父类的什么东西？
   • 子类可以继承父类的数据域（属性），方法，但构造器不能继承
3. 私有成员能被子类继承吗？
   • 能继承，但是由于访问权限的控制，在子类中不能直接使用父类的私有成员
4. Object是什么类？
   • 这个所有类的根类，任何类如果没有写显式的继承语句，默认都是直接继承Object类的
5. java中是单继承还是多继承？
   • 是单继承，一个子类只能有一个父类
6. 访问权限修饰符有几种，访问的范围又是多大？
   • 4种：
     • private：私用 只能在被类中被访问
     • default：默认 只能被同一个包中的类访问
     • protected：受保护的 只能被同一个包中的类和不同包中的子类访问
     • public：公有 可以被任何类访问
7. 覆盖方法的规则有哪些？
   • 子类覆盖方法和父类被覆盖方法的方法返回类型，方法名称，参数列表必须相同
   • 子类覆盖方法的访问权限必须大于等于父类的方法的访问权限
   • 方法覆盖只能存在于子类和父类之间
   • 子类覆盖方法不能比父类被覆盖方法抛出更多异常
8. 参数列表是否相同从哪几方面看？
   • 从三方面看：参数个数，类型和顺序，需要注意的是参数的名字不相同是无所谓的
9. 覆盖方法的规则有哪些？
   • 方法名相同
   • 方法的参数类型,个数,顺序至少有一项不同
   • 方法的返回类型和修饰符均不受限制
10. 可变长参数的声明格式是什么？实际上是什么类型的？
    • 类型 … 变量，实际上是一个一维数组
11. this和super是作什么用处的？
    • this：本身代表当前的对象引用，可以用this.成员名称调用当前对象的属性和方法，如果属性和局部变量重名，可以用this.属性名和局部变量区分开。也可以用this（）语法调用本类重载构造器。
    • super：本事是一个特殊关键字，可以用super.成员名称调用从父类继承的属性和方法，也可以用super（）语法调用父类构造器。
12. super代表子类中的父类对象引用吗？
    • 不，这个错误的说法，super不代表任何对象引用，仅仅是一个关键字
13. 什么时候子类构造器会自动调用父类无参构造器？
    • 当子类构造器中没有任何显式构造器调用的时候，即既没有this（）调用也没有super（）
14. 一个父类类型的引用变量可以引用一个子类的实例吗？
    • 可以，这个引用变量是一个多态对象
15. 多态对象有什么特点？
    • 多态对象只能使用父类的成员，但如果多态对象使用了被子类覆盖的方法，则会动态绑定使用子类的成员，称为虚拟方法调用
16. 引用类型之间的类型转换需要遵循哪些规则？
    • 自动转换：从子类到父类的类型可以自动转换
    • 强制转换：从父类到子类的类型要强制转换
    • 无继承关系的类型转换是非法的
17. instanceof操作符是作什么用处的？
    • 可以判断一个对象的类型是否是某一个类的类型或子类，也可以判断这个对象的类型是否是一个接口的实现类
18. toString方法什么时候会自动被调用？
    • 在打印语句中传入引用类型的对象或者对象和字符串作连接时
19. 默认的equals方法实现的是比较内容还是比较引用地址？
    • 在Object中是比较引用地址。
20. 覆盖equals方法和hashCode方法有什么规则？
    • 必须保证当两个对象equals比较为true的时候，返回的hashCode相同
21. java中有几个包装类？
    • 有8个包装类，正好对应8种基本数据类型。
      • 分别是：Boolean Byte Short Integer Long Character Float Double
22. 装箱和拆箱分别是什么意思？
    • 装箱指的是把基本类型包装成包装类的引用类型
    • 拆箱指的是把包装类形式的引用类型转换为基本类型
    • 例如：
      • Integer objInt = new Integer(10);//装箱
      • int i = objInt.intValue();  //拆箱
23. JDK1.4和1.5的装箱和拆箱有什么区别?
    • 自动拆装箱，例如：
      • Integer intObj = 10;//自动装箱
      • int i = intObj + 5;//自动拆箱
24. final修饰符如何使用，使用了final修饰符有什么特点？
    • final修饰符可以修饰类，方法，变量
    • final类为最终类，不能被子类继承
    • final方法为最终方法，不能被子类覆盖
    • final变量为常量，只能赋一次值

---

25. abstract修饰符如何使用，使用了abstract修饰符有什么特点？
    • abstract修饰符可以修饰类和方法
    • abstract类为抽象类，是不能创建对象的
    • abstract方法为抽象方法，只有方法的声明，没有具体的实现
    • 需要注意的是：
      • 有抽象方法的类一定是抽象类
      • 抽象类不一定有抽象方法
      • 抽象类也有构造器，但不能创建对象实例
26. abstract不能和哪些修饰符配合使用？
    • 不能和private，static，final一起使用
27. 可以在非抽象方法中调用抽象方法吗？
    • 可以，模板方法设计模式就是典型的这种调用
28. instanceof使用
    • instanceof是二元运算符，左边是对象，右边是类；当对象是右边类或子类创建对象时，返回true，否则返回flase

    

29. 占位符【隔开代码】

    class Student extends Person(){}  //测试这个类
System.out.println(stu2 instanceof Student); //true
System.out.println(stu2 instanceof Person);  //true
System.out.println(stu2 instanceof Object); //true
System.out.println(new Person() instanceof Sstudent); //flase

---

6.泛型程序设计

1. 泛型的特点是什么？
   • 主要特点是类型参数化，后期绑定数据类型
2. 泛型支持基本类型吗？
   • 不支持，只支持引用类型
3. 如果没有传入类型参数，默认是什么类型？
   • 默认是Object类型
4. 泛型方法有什么特点？
   • 将泛型参数声明在方法中，调用方法的时候绑定泛型
5. 泛型类声明泛型参数的时候，<T extends A类型>表示什么意思？
   • 表示绑定的类型必须是A类型后者是A类型的子类或实现类
6. 泛型举例

// 调用：extends CommonDao<Staff, Long>

package com.example.demo.dao;


import java.io.Serializable;
import java.util.List;

public interface CommonDao<E, PK extends Serializable> {
    public List<E> getAll();

    public E get(PK id);

    public void add(E user);

    public void delete(PK id);

    public void batchDelete(PK[] ids);

    public void update(E user);

    public List<E> getList(E condition);

}

---

6.1封装

1. 采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。
2. super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
3. this关键字：指向自己的引用。
4. 示例

5. this 和 super

class Animal{
    private String name = "张萨博";
    private int age;
	
    public Animal() {}
	
    Animal(String name, int age){
        this.name = name;
        this.age = age;
    }
    
    //省略getter和setter
}

class Dog extends Animal{
    private String name = "王老五";
    String color;
	
    public Dog() {}
	
    Dog(String name, int age, String color){
        // super()构造方法必须得放到第一行。
        // 凡是子类的构造方法当中都会有super()，不写默认也会有。
        // super()不能和this()一起使用。因为会重复调用super()，和自定义的冲突。
        // super是关键字，this是地址。
        super(name, age);
        this.color = color;
    }
	
    public String string(){
        return super.getName();
    }
	
    //省略getter和setter
	
    // 测试
    public static void main(String[] args) {
        Dog dog = new Dog("wc",10,"white");
        System.out.println(dog.getName());
        System.out.println(dog.color);
	
        System.out.println(dog.getName()); //王老五
	System.out.println(dog.string()); //张萨博
    }
} 

---

7.接口和内部类

1. 声明一个接口的关键字是什么？
   • interface关键字
2. 接口中的成员有什么特点？
   • 数据域必须是（public static final修饰）公有静态常量
   • 方法必须是（public abstract修饰）公有抽象
   • 没有构造方法
3. 接口能创建对象实例吗？
   • 不能，接口没有构造器，不能创建对象
4. 接口和类的关系？
   • 接口和类之间是实现关系，一个类用implements语句实现了某接口，这个类被称为接口的实现类，一个类可以实现多个接口，一个类实现了某接口，必须覆盖这个接口中的所以方法，否则这个类必须是个抽象类
5. 接口和接口的关系？
   • 接口和接口之间是继承关系，一个接口用extends继承另外一个接口，称为这个接口的子接
   • 一个接口可以继承多个父接口
6. 内部类如何
   • 一个类声明在另一个类的里面，这个类就被称为内部类，而外面的类被称为外部类
7. 内部类可以分成几种？
   • 实例内部类：声明在方法外边没有static修饰符
   • 静态内部类：声明在方法外边有static修饰符
   • 局部内部类：声明在方法里边
8. 如何创建实例内部类的对象实例？
   • 需要用外部类的对象来创建
   • 例如：
     • class A {   
       class B {}
     • }
9. 如果像创建B类的实例，则必须用以下语句：
   • A a = new A();
   • A.B b = a.new B();
10. 如何在实例内部类中访问外部类的成员？
    • 在实例内部类中可以直接使用外部类的成员，不需要创建外部类的对象实例，但是如果在内部类中的成员名称屏蔽隐藏了外部类的成员（即外部类和内部类的成员名相同），则需要用“外部类名.this.成员名”访问外部类成员

---

8.异常处理

1. 异常的对象的根类是哪个类？
   • 是Throwable类
2. Throwable类有哪两个分支？
   • 分成Error类和Excepion类两个分支
   • Error类表示严重错误
   • Exception类表示可以在程序中处理的错误
3. Exception类有哪两个分支？
   • 分成运行时异常和非运行时异常（已检查异常）
   • 运行时异常编译不检查，在运行时才会发生异常
   • 已检查异常编译时就会作检查，不处理异常则通不过编译
4. 如果在try块中发生异常，那么程序将会跳转到哪？
   • 会跳转到catch语句块
   • catch语句可以用父类类型捕获子类异常吗？
   • 因为有多态特点，是可以的
5. 处理异常代码finally语句会在什么时候执行？
   • finally代码在任何时候都会执行，不管有没有发生异常。
6. 如何声明已检查异常，由谁来处理这个异常？
   • 用throws语句来声明一个已检查异常，由方法的调用者来处理这个异常
7. 如何抛出一个异常？
   • 用throw语句抛出
8. 如何创建一个自定义的异常类？
   • 创建一个类，只要让它继承任何一个现有的异常类就可以了
9. 覆盖方法对于异常有什么要求？
   • 覆盖方法不能比父类方法抛出更多异常

---

9.反射，代理，标注

1. 获得一个类型的Class对象有哪几种途径？
   • 方法1：对象.getClass()
   • 方法2：类型名.class
   • 方法3：Class.forName()
2. 反射相关的类型都有哪些？
   • Class 代表一个运行时类
   • Field 代表一个类的属性
   • Method 代表一个类的方法
   • Constructor 代笔一个类的构造器
3. 如何声明一个自定义标注？
   • [<修饰符>] @interface <标注名>{
     • 返回值方法名称（）；
     • 返回值方法名称（）；
     • ……
   • }
   • 例如：
   • public @interface MyComment {
     • int id();
     • String info();
   • }
4. java有几个内置标注？
   • 有3个
     • @Override——用于修饰此方法覆盖了父类的方法，而非重载。
     • @Deprecated——用于修饰已经过时的方法。
     • @SuppressWarnings——用于通知Java编译器禁止特定的警告。

---

10.java常用类

1. 字符串String是可变类还是不可变类？

   • 是不可变类，一经创建就不能修改其内容了

2. 字符串的常用方法有哪些？

   • charAt方法：可以返回指定位置的字符
   • substring方法：可以截取子字符串, 从那开始到从那里结束, 开始从0开始
     • String str = "604031708393620_20210303170851";
     • System.out.println(str.substring(0, str.indexOf("_")));
     • 输出: 604031708393620
   • length方法：返回字符串长度
   • indexOf方法：查找子串的位置
   • lastIndexOf方法：反向搜索字串的位置
   • replaceAll方法：替换字符串
   • split方法：分解字符串
     • Arrays.asList(str.split("/")).forEach(System.out::println)
   • toLowerCase, toUpperCase方法：字符串大小写转换

3. StringBuffer类和String类有什么区别？

   • StringBuffer是可变类，String是不可变类

4. StringBuffer类和StringBuilder类有什么区别？

   • StringBuffer类是线程安全的，StringBuilder类是线程不安全的

5. Math类主要提供了哪些方法？

   • Math类提供了大量的和数学运算相关的静态方法
   • Set集合和List集合共同的父接口是什么？
   • 是Collection集合

6. Set集合和List集合有什么区别？

   • Set: Collection的子接口，不记录元素的保存顺序，且不允许有重复元素
   • List: Collection的子接口，记录元素的保存顺序，且允许有重复元素

7. ArrayList和LinkedList有什么不同？

   • ArrayList 的内部实现是基于内部数组Object[]，所以从概念上讲它更像数组
   • LinkedList的内部实现是基于一组连接的记录，所以它更象一个链表 结构，所以它们在性能上有很大。
   • ArrayList 随机访问比较块，但插入和删除元素比较慢
   • LinkedList但插入和删除元素比较快，但随机访问比较慢

8. HashTable和HashMap有什么不同？

   • HashTable是线程安全的，HashMap是线程不安全的

9. Vector和ArrayList有什么不同？

   • Vector是线程安全的ArrayList是线程不安全的

---

11.IO流

1. 流分成哪两类？
   • 按照单位划分分成字节流和字符流。
   • 按输入输出分成输入流和输出流
2. 和文件流相关的有那几个类？
   • FileInputStream文件输入字节流
   • FileOutputStream文件输出字节流
   • FileReader文件输入字符流
   • FileWriter文件输出字符流
3. 文件流操作应该用字节流还是字符流？
   • 如果是纯文本文件应该用字符流
   • 如果是二进制文件应该用字节流
4. 文件操作用哪个类？
   • 用java.io.File类
5. Java 常用IO流操作详解
   • https://www.cnblogs.com/shuaiguoguo/p/8883862.html

---

13.线程

1. 创建一个线程类的两种方式？
   • 继承Thread类
   • 实现Runnable接口
2. 线程体应该放在哪个方法里面？
   • run方法
3. 启动新的线程用什么方法？
   • 用start方法
4. 一个线程对象能够用start多次启动吗？
   • 不可以，一个线程方法只能start一次
5. 线程有哪几种主要状态？
   • 有四种，分别是：
     • 新生状态，可运行状态，阻塞状态，死亡状态
6. 线程的同步需要用什么方法？
   • 旧的方法是用synchronized关键字
   • 新的方法是用ReentrantLock类的lock和unlock方法

---

14. Java 异常详解

1. 占位符

   修改时间：2021年3月9日16:33:45

2. Java的throws Exception

   • (终极解释！！！)throws Exception放在方法后边，是throws Exception表示的是本方法不处理异常，交给被调用处处理(如果你不希望异常层层往上抛，你就要用throws Exception) ，而且被调用处必须处理。
   • 方法上面加上
     • public void exportCollisionBarrierData(List collisionAnalysisInfoList, HttpServletResponse response) throws Exception;
   • 调用方法的地方加上
     • try {} catch (Exception e) {}
   • 也可以手动抛出异常
     • throw new Exception("test方法有问题"); // 手动抛出一个异常

3. 异常的处理

   • 抛出异常：
     • throw（自定义抛出一个异常）例：throw new Exception("Key为空null");
     • throws（用于方法后面，意识代表本方法不处理异常，让调用者处理异常）Map queryDismantPartInfo(String taskNo)throws Exception;
   • 捕获异常：try，catch，finally
   • 抛出异常throw
     • throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结 束当前方法的执行。
     • 使用的格式：
       • throw new 异常类名(参数)；

4. 异常概述

   • 异常：有异于常态，和正常情况不一样，有错误出现。
   • 在 Java 中的表现：扰乱程序正常执行的顺序。

异常名称	说明	举例
Error	程序中无法处理的错误。	服务器挂了、JVM 内存满了
RuntimeException	程序运行期间出现的异常	空指针异常、数组下标越界异常
CheckedException	程序编译期间出现的异常	IOException

2. 异常处理结果图

3. 实例说明

package demo04;

public class ExceptionMain {
    public static void main(String[] args) {
        ExceptionDemo demo = new ExceptionDemo();

        System.out.println(demo.division1(6, 0));
        //System.out.println(demo.division2(6, 0)); // 方法抛出来的异常必须处理 (try catch)
        System.out.println(demo.division3(6, 0));
    }
}

/**
 * 异常案例演示
 */
class ExceptionDemo {
    private double result = 0; 
    /**
     * try, catch
     */
    public double division1(int number1, int number2) {
        try {
            result = number1 / number2;
        } catch (ArithmeticException exception) {
            exception.printStackTrace();
        }

        return result;
    }

    /**
     * throws
     */
    public double division2(int number1, int number2) throws Exception {
        result = number1 / number2;
        return result;
    }

    /**
     * throw
     */
    public double division3(int number1, int number2) {
        if (number2 == 0) {
            throw new ArithmeticException("除数不能为 0");
        } else {
            result = number1 / number2;
        }
        return result;
    }
}

3. 自定义异常

package demo04;

public class MyExceptionMain {
    public static void main(String[] args) {
        int a = 1;

        if (a == 1) {
            new MyException("自定义异常");
        }
    }
}

class MyException extends Exception {

    public MyException(String str) {
        System.out.println(str);
    }
}