Section 1
Preview this deck
abstract 抽象
Front
| 5 | 0 | ||
| 4 | 0 | ||
| 3 | 0 | ||
| 2 | 0 | ||
| 1 | 0 |
Active users
0
All-time users
0
Favorites
0
Last updated
6 years ago
Date created
Mar 14, 2020
Cards (105)
Section 1
(50 cards)
abstract 抽象
可以修饰类，方法， ·abstract类：只能声明引用 ·可以定义属性成员方法 ·有构造方法 ·子类继承抽象类需要覆盖里面的所有抽象方法 abstract方法：只有声明没有{} 只能定义在抽象类中
多态的好处：
多态的好处：屏蔽不同子类之间的差异性，从而可以对不同子类进行统一操作。
Java数据类型的自动提升
当小数据类型的变量赋值给大数据类型变量的时候，发生类型自动提升： byte，short，int,long float,double, char, int ,long, float,double
instanceof的应用
①语法：引用名 instanceof 类名 ②作用：判断引用中存储对象类型，是否兼容于 后面的类 型容—true；不兼容—false；
+=面试题
【面试题】分析以下代码编译是否通过，通过写出结果，否则说明原因 1 byte b = 1; b = b+1; System.out.println(b)//编译不通过 2 byte a = 1 a + = 1; System.out.println(a);//编译通过，原因+=没有自动类型提升，打印结果为2
函数三要素
函数三要素：函数的返回值、函数名、形参列表 称为函数三要素。
java语言的特点
1.简单性（相对于其他c语言来说） 2.面向对象性（将客观现实生活中的问题放入程序中，让程序帮助用户解决客观存在的问题） 3.跨平台性（可以在不同的操作系统上运行）
面向对象
概念：客观复杂的事物在java程序中的一种表现形式 （一切客观事物皆是对象） 什么是对象： -程序是帮助用户处理客观存在的事物（程序用于模拟现实生活） -实现生活中的问题，实现现实生活的这些功能就是事物用计算机表达出来，
冒泡法
for（int i=1;i<a.length;i++){ for (int j=0;j<a.length-i;j++{ if（a[j] > a[j+1]) int t = a[j] a[j]=a[j+1] a[j+1]=t
覆盖 重写
Override 覆盖 重写 a.子类的方法名、参数列表、返回值类型和父类相同 b.子类的访问修饰符和父类相同 或是 比父类更广泛 宽
【面试题】：分析int类型的变量和float类型的变量哪一个存储的数据更宽泛，说明原因
float 使用科学家计数法进行存储，底层不精确但是可以存储超多19 位的数值，而整数的存储到lōng18 字节就已经是最大了 【科学计数法关注前部分的数据底层但是不精却就是近似的。损失精度 F前7位从左往右所有的7位。不管小数的事 long l = 1000000000000000000 18个是上限 float l = 没问题1.0*10^19】
创建对象过程（和赋值机会）
3次赋值的机会 1.分配空间 2.初始化属性 3.调用构造方法
访问修饰符
·private（私有的）同类 ·default（默认的）同包 ·protected （受保护的）不同包子类 ·public （公开的）所有
数组的扩容
三种方法： 1. ·申请一个更大长度的数组 int[ ]b=newint[a.length*2]; ·将原数组的内容赋值到新数组中 for(int i=0;i<a.length;i++){b[i] = a[i];} ·新地址覆盖旧地址 a=b 2.System.arraycopy(a,0,b,0,a.length) 3.java.util.Arrays.copyOf(a,a.length*2)
多态
父类型的引用 指向 子类型的对象
get/set
①为属性赋值（修改属性值）：set方法 public void set属性名（属性数据类型 变量名）{ this . 属性名 = 变量名； ②获取属性的值：get方法public 数据类型 get属性名（）{ return this . 属性名 }
访问修饰符可以修饰的内容
1.4个访问修饰符，都可以修饰属性、成员方法、构造方法（访问权限同上） 2.只有public和default可以修饰类
继承
继承是一种机制，通过继承机制可以让子类直接使用父类中属性和方法 继承的好处：代码的可复用性和可扩展性
Java的运行机制
先编译，后解释运行 将源文件（.java文件）-->通过编译器生成对应的字节码文件（.class文件)-->再通过解释器逐行翻译并运行
this（）
用在本类的构造方法中，调用本类其他构造方法
a++ 和 ++a 面试题： int c = a++ + （ - - a)
a++先使用，后加1 ++a先加1，后使用 a++:先使用a变量原有的数据，然后再将a的内容+1 （先使用，再加1） a 先把结果赋值给表达式，然后再进行加1 运算。先使用原有的数据，再加以操作。 ++a: 先将a的内容加一，再使用a的数据 （先加一，再使用）
构造方法 的要求
类名相同 没有void 可以重载 不允许手动调用 作用（给属性赋值，创建对象） 默认无参构造
数组概念
能都同时存储多个相同类型的数据，并且能够对数组中的数据（变量）进行统一操作 数组在内存空间中是连续的，数组的空间分配完之后，会 生成当前数组的首地址。
Scanner 不同类型的应用
1.输入一个整数： int a = sc.nextInt(); 2. 输入一个小数： double d = sc.nextDouble(); 3. 输入一个字符串：String str = sc.next(); String str = sc.nextLine(); 4.输入一个布尔类型：boolean b = sc.nextBoolean(); 5.输入一个字符：char c = sc.next().charAt(0);
局部变量 vs 成员变量
局部：方法内，从定义开始到代码块结束，不能命名冲突，没有默认值 成员：类以内方法外，作用范围类以内，可以和局部变量命名发生冲突，用this指向成员变量，有默认值，和数组的默认值相同（整数0 小数0.0布尔类型false char\u000 引用对象）
局部变量
局部变量：定义在函数内的变量 ·先赋值后使用 ·作用范围：定义开始到代码块结束 ·命名冲突：重合作用范围内不允许出现命名冲突
super（ ）
super（ ）/ super（实参）：用在子类的构造方法中，代表创建子类对象时，JVM需要先完成父类对象的创建，只是JVM利用父类的哪一个构造方法完成父类对象的创建。
super .
super . 属性名：访问父类的属性 super . 方法名（实参）：访问父类的成员方法
.引用之间的转换
父类型的引用 赋值给 子类型的引用 必须通过强制类型转换 大类型—>>小类型 子类型 引用名 = （子类型）父类型的引用
char自动类型提升为什么比short大
char本质还是整数，以二进制的形式存储 1.以正整数的形式进行存储：（0~65535）short*32768+32767 2. 用unicode形式存储
函数的作用
函数：实现特定功能的一段代码所组成，可通过名反复使用 1.减少代码冗余 2.提高复用性 3.提高代码可维护性 <体现了java简单性>
+ 和 引用类型
+两端如果是引用类型，是在做字符串拼接，如果一端是字符串也自动提升为字符串拼接 +=没有自动类型提升
.java中继承特点
java中的类是单继承关系，即一个类只能有一个直接的父类，但是 可以有多个间接的父类（多级继承） — — —》体现了Java语言特点的简单性 子类可以继承父类中的哪些内容（属性、成员方法）
覆盖的应用
当父类提供的方法实现部分不足以满足子类需求时，子类可以覆盖父类中的方法(根据自身功能，重新将方法实现部分写一遍)
java引用类型
类 数组 接口 集合 都是引用类型 以 String（字符串）为例： "abcdefg"
终止、跳出、返回关键字 break、continue、return
break：结束本层循环 continue：跳出本层循环，进入本层的下一次循环 return： 1.结束当前函数代码块 2.将函数返回值返回； 3.结束当前函数的调用（返回调用点）
static静态
属性 方法 静态代码块 ·属性：类变量，全类共有，与创建对象无关 直接用类名调用 ·方法：不能访问非静态成员和属性，可以访问静态成员和属性， 不能使用this super，可以继承，只能被静态方法覆盖 ·静态代码块：在类加载时，按照和静态属性定义的先后顺序，完成对静态属性的初始化工作
方法的重载
overload： i.方法名相同 ii.参数列表不同（类型、个数、顺序） iii.修饰符，返回值类型，异常没有要求 使用过程中，根据调用者传递的实际参数先进性精确匹配，然后再进行就近向上匹配
类和对象的关系
①类是对象的模板 ②对象是类的实例（对象根据类创造）
强制类型转换
当大数据变量赋值给小数据变量的时候需要强制类型转换 小数据类型 变量名 =（小数据类型） 大数据类型的变量名 结果（3种） a.小数类型转换整数类型：直接截断整数部分 b.大整数类型 给 小数类型赋值，数据合理，直接存储不损失精度， c.大整数类型 给小整数类型赋值，数据不合理，截位，字节截取，危险性更大
Switch ......case
switch 类型：byte short int char string switch(表达式）{ case 值1：语句1；break； case 值2 ：语句2；break； case 值3： 语句3;break； default：语句n;break； }
【面试】 1. 构造方法不允许被子类继承
a.语法角度：构造方法名必须和类名一致，子类和父类各有不同的类名 b.应用角度：子类中的信息多于父类中的内容，所以子类的构造内容比父类复杂，所以子类需要定义自身的构造方法
this。
调用当前对象的属性或是成员方法 this.通常可以省略，但是成员变量和局部变量命名冲突（在方法中）必须使用this. 区分成员变量（+this. 的是成员变量）
【面试题】 分析以下代码编译是否通过，通过写出结果，否则说明原因 byte b = 1; b = b+1; System.out.println(b)
1 默认int类型 byte和int类型相加，应该是int类型存储
面向对象三大特性
一、封装 二、继承 三、多态
创建对象的过程（继承体系下）
1.分配空间（本类+父类）；为所有的属性赋默认值 2.递归的构造父类对象； a.初始化父类的属性：为属性赋值的第二次机会 b.调用父类的构造方法：为属性赋值的第三次机会 3.初始化本类的属性；为本类属性赋值的第二次机会 4.调用本类（子类）构造方法；为本类属性赋值的第三次机会
Java基本数据类型
1.整数类型：（byte，1B -128~127；short，2B -32768~32767；int 4B -2147483648~2147483647；long 8B -922京~922京-1； 2.小数类型：float 4B 单精度；Double 8B 双精度 3.字符类型：char 2B 'A' 4.布尔类型：boolean 1B true/false
循环结构
1.通过某个条件，重复有序的执行代码 2.组成：变量初始化，循环条件，循环变量的改变，循环体 3种循环： 1.while循环：先判断在执行，循环0~n次，避免死循环 2.do while循环：先执行再判断，循环1~n次 3.for循环：先判断，在执行，0~n次 循环次数确定的时候用for，不确定的时候用while
选择法
for（int i=0;i<a.length-1;i++){ for (int j=i+1;j<a.length;j++{ if（a[i] > a[j]) int t = a[i] a[i]=a[j] a[j]=t
&& 和 & 短路 和 非短路
&& ：逻辑与 结果为布尔表达式，两个条件都为true，则结果为true（短路运算符） & : 逻辑与， 两边的条件都为True， 则结果为True；（非短路运算符） 短路vs非短路 短路，如果能通过左侧表达式的结果推算出整个表达式的结果，则不再做后面的运算
Section 2
(50 cards)
异常
程序的异常父类（Throwable）： 严重错误（Error）：我们不解决 一般问题（Exception）： 编译期异常：除了RunTimeException及其子类，必须 处理，否则编译不通过无法运行 运行期异常：RunTImeException及其子类，不解决， 是因为你代码写的不严谨
file删除功能
boolean delete（）：删除此抽象路径名表示的文件或目录，该路径不存在返回false表示删除失败 【注意】 1.如果创建文件或者文件夹没有写盘符，默认在当前项目下 2. 如果路径下面有子目录或者文件，那么无法直接删除 3.java删除不走回收站（不去垃圾桶，永久删除）
==的应用 和 equals的区别
i 如果==两端是基本数据类型的变量，则比较变量中存储的数值是否相同 ii 如果==两端是引用类型的变量，则比较变量中存储的对象的地址是否相同 equals方法的引用：Object中的equal方法默认比较两个引用中地址是否一致，如果希望他能比较两个对象的内容是否一致·，则需要覆盖equals方法，覆盖的步骤如下： public boolean equals(object o){ //将this 和 o进行比较 //(1)自反省：判断两个引用是否指向相同一个对象 if（this == o){ return true; } //2.判断o是否为空 if（o == null){ return false; } //3.判断两个引用中存储的实际对象类型是否一致 if（this.getClass() != o.getClass()){ return false; } //4.强制类型转换——》对下一个步骤准备 当前对象类型s = （当前对象类型）o; //5.将属性内容进行一一比较：基本数据类型：== 引用：equals比较 if（this.age == s.age &&this.name.equals(s.name){ return true; }else{ return false; } }
为什么一定要close（）关流
1.让流对象成为垃圾，能够被垃圾回收器回收 2.通知系统释放和该文件相关的资源
异常继承的语法要求（2）
1.如果父类方法抛出异常，那么子类覆盖后的方法只能抛出和父类相同的或者子类异常，不能比父类抛出更大的异常，也可以不抛出任何异常 2.如果父类方法没有抛出任何异常，那么子类覆盖后方法内部如果产生异常，那么只能捕获（try...catch），不能抛出（throws）
迭代器遍历代码
Collection c = new ArrayList(); c.add("路飞"，20)； c.add("索隆"，30)； Iterator it = c.iterator(); while(it.hasNext()){ Student s = (Student) it.next(); System.out.println(s.name+" "+s.age); } 【练习】集合 存储字符串 和 存储自定义对象， 使用迭代器遍历，和 toArray（）遍历 迭代器（hasNext（）和next（））
【面试题】写出String 和 StringBuilder的区别
写出String 和 StringBuilder的区别 String 不可变长性，效率慢 StringBuilder 可变长性，效率高
toString（）
返回对象的字符串的表示形式String public String toString(){ return "name ="+this.name+",age = "+this.age ; //this.可以省略 }
栈、堆、方法区、常量池
栈空间（局部变量） 堆空间（对象） 方法区（静态属性，常量）：常量池 区分有效数据和无效数据
内部类分类
成员内部类， 静态内部类， 局部内部类， 匿名内部类
【InputStreamReader / OutputStreamWriter】 和【FileReader/FileWriter】优缺点？【背】
· FileReader/FileWriter: ·优点简化代码 ·缺点：无法指定编译格式
集合和数组的区别【重点】
1.长度的区别： 数组长度固定 集合长度可变 2.存储元素的数据类型 数组可以存储基本数据类型和引用数据类型 集合只能存储引用数据类型
异常的 两种处理方法
1.捕获异常 try ... catch ... finally 2.抛出异常：throws
类加载
让jvm认识一个类 i.概念： JVM第一次使用一个类的时候，通过classPath（类路径）找到类对应的.class文件，对文件进行读取，读取到类的信息（包名，类名，父类，属性，方法，构造方法等），将读取到的信息 保存到JVM内存中，一个类只进行一次类加载。
.匿名内部类
①匿名内部类是特殊的局部内部类 ②特点： a.匿名内部类必须实现一个接口或是继承一个父类 b.基于匿名内部类只能创建该类的一个对象，而且匿名 内部类的定义个对象的创建一起完成 ③语法： interface IA{ void m1(); } 方法中定义匿名内部类 IA ia = new IA(){ public void m1(){ //实现部分。。。 } }； 优点：简化代码 缺点：可读性差
HashSet如何保证唯一性
首先执行hashcode（），判断每个对象哈希值是否相同 -相同：执行equals（），判断内容是否相同 ·内容相同：不存储 ·内容不相同：存储 -不相同：直接存 HashCode覆盖： public int hashCode(){ return this.age 2 + this.score 3 + this.name.hashcode(); } Equals覆盖 public boolean equals (Object obj){ if(this == obj){
PrintWriter
1.打印流的特点： 1.只有输出流没有输入流 2.可以操作任意类型的数据 3.PrintWriter可以自动刷新
throw 和 throws 区别？【了解】
throw 和 throws 区别？【了解】 throws： 后面跟的是异常类名 一次能够抛出多个异常 throw：后面跟的是异常对象 一次能够抛出一个异常、
线程1.继承Thread：
1.继承Thread： ①自定义类继承自Thread [extends Thread] ②重写 run （）方法； [public void run(){}] ③创建自定义类对象 [new MyThread] ④启动线程 [my.start()]
自动装箱和拆箱的底层
Integer i = 12;//自动装箱 int a = i;//自动拆箱 【注意】：【面试重点+难点】 自动的装箱底层原理默认调用 静态方法 Integer.valueOf(int i) public static Integer valueOf(int i){ if(i>=-128 && i<=127){ return... } return new Integer(i); }
接口的好处
1.扩充子类的能力 2.解耦合
类加载时机：
1.第一次创建该类对象，先进行类加载，再完成对象的创建 2.第一次访问静态代码块，导致类进行类加载 3.子类类加载会先加载父类
创建字符串对象的两种方式：【面试题目】
①String s1 = " Hello "; 【注意】：这种创建字符串的方式只会产生一个对象，串池中产生（用于共享） ②String s2 = new String(" World "); 【注意】：这种创建字符串的方式会产生两个对象，一个在堆空间中，另一个是在串池中产生。
BufferedReader / BufferedWriter 独有的方法
BufferedReader / BufferedWriter 独有的方法（readLine（）和newLine（）） 复制文件（一次复制一行）【掌握】 String s； while((s = 输入流.readLine())!= null){ 输出流.write（s）; 输出流.newLine（）； }
自定义异常的构造方法要求，Exception
1.继承RunTimeException,提供一个无参构造和一个带参构造，带一个参数String类型。 2.继承Exception，提供无参构造和一个带参构造，带一个参数String类型。
List集合的独有遍历（size（）和 get（））；
for(int i=0 ; i<集合名.size（）; i++){ System.out.println(集合名 . get()); }
file的构造方法
File(String pathName):根据一个路径得到file对象 File（String parent,String child）:根据父级目录加上子类目录/文件得到file对象 File（File parent,String child）:根据File对象加上子级的文件/目录得到file对象
序列化
ObjectOutputStream能够将java对象写到文件中 ObjectOutputStream能够将java对象写到文件中 必须实现Serializable 接口： 1.类中有很多的属性，不是所有的属性都需要被序列化， 当age的属性需要不被序列化怎么办？ 属性前面添加transient。 2.实现序列化需要添加固定的id 值
String类 方法
char charAt(int index):根据下标获取对应的字符 boolean contains（String s）：判断S是否包含在当前字符串中 boolean equals (String str):判断两个字符串内容是否相同 ④int length（）：获取字符串的长度 【注意】获取数组的长度：数组名.length 获取集合长度：集合名.length（） String trim（）：去除字符串前后的空格
写出StringBuilder 和 StringBuffer的区别
写出StringBuilder 和 StringBuffer的区别 StringBuffer :1 线程安全，效率慢 StringBuilder：5线程不安全，效率高 用的是append方法
不可变长特性（不可变长的字符串）【面试】 可变长字符串
3.不可变长特性（不可变长的字符串）【面试】 ①字符串是字面值的常量，一旦创建不允许改变，如果实现字符串的拼接，则会在原文本的基础上拷贝一个副文本，在副文本上进行操作 4.可变长字符串 ①StringBuffer：jdk1.0线程安全，运行效率慢 StringBuilder：jdk5.0线程不安全，运行效率高
flush 和 close 的区别 【背】
flush ：刷新，可以继续使用该流 close：先刷新，后关流
Final
Final：变量 方法 类 final变量：常量，一次赋值的机会，不能改变 final 方法：可以被继承，但是不能覆盖 final 类： 不能继承，无子类 String、Math、System都被final修饰
接口和抽象类的区别
关键字：abstract extends interface implement 属性方法： 构造方法： 继承关系：
collection 接口下的两个接口特点
List：有序（存储和取出的顺序是一致的），可重复 Set：无序，唯一（不可重复）
Collection 接口中的方法：
boolean add(Object e) boolean addAll(Collection c) :添加一个集合的元素【了解】 2.删除功能： void clear() :移除集合中所有的元素【了解】 boolean remove（Object o) :删除一个指定的元素 boolean removeAll(Collection c) 移除一个集合的元素【了解】 3.判断功能： boolean contains(Object o) :判断集合中是否包含指的元素 boolean isEmpty() :判断集合是否为空 4.获取方法： int size():获取集合的长度 [获取数组的长度：数组名 . length] [获取字符串长度的方法：对象 . length（）] boolean retainAll(Collection c) :交集【了解】 Iterator iterator() 使用迭代器遍历 5.转换功能 Object[ ] toArray(): 将集合转换数组
final ， finally ， finalize 的区别？
final ， finally ， finalize 的区别？【重点+背】【面试】 final：修饰类：类不能被继承 修饰方法：方法能被继承不能被覆盖 修饰变量：变量为常量只能赋值一次且不能改变 finalize：是object类中的一个方法，用于垃圾回收 finally：异常处理的一部分，用于释放资源，放在finally中的代码一般来说一定会执行，特殊情况：在执行之前退出jvm则不会执行
print（） 和 println( )
3.PrinterWriter如果启动了自动刷新，不需要flush 和 close方法数据可以写入文件 如何启动自动刷新？： PrintWriter （Writer out，boolean autoFlush）:当第二个参数为true表示启动自动刷新 print（）是调用String方法
String ——> int【开发应用重点】
a. int n = Integer.parseInt("128")//利用静态方法
static final abstract不能修饰构造方法
static final abstract不能修饰构造方法 1.static 构造方法创建对象用的，static和对象无关，所以static矛盾 2.final 构造方法不能被子类继承，谈不上覆盖 3.abstract 只有声明没有赋值，没有实现，不能达到构造方法的作用
三种list的区别
ArrayList：底层是数组, 查询快，增删慢 线程不安全，效率高 Vector：底层是数组实现，查询快，增删慢 线程安全，效率低 LinkedList：底层链表，查询慢，增删快 线程不安全，效率高
字符流的特点：
字符流的特点： 1.字符流 = 字节流+编码表 2.字节流操作中文不方便 3.编码 和 解码 的编码表方式使用一致就不会出现乱码
final finally finalize
final：修饰变量，方法，类：变量常量，一次赋值不能改变，方法可以被继承不能被覆盖，final类不能被继承，没有子类 finally：是异常的处理，finally中代码一定会执行，除非JVM在执行之前推出，释放资源 finallize：方法，垃圾回收器回收垃圾对象
泛型的好处：【重点+背】
1.将运行期间的问题提前到编译期 2.解决黄色警告线 3.避免强制类型转换
file重命名
boolean renameTo（File dest）：重命名 【注意】如果路径相同，修改名称 如果路径不同，则剪切并修改名称
【面试题】 思考：System.out.ptinlnt() 实现的原理
思考：System.out.ptinlnt() 实现的原理 ·System 类（首字母大写） 解析：System是类名（首字母大写） ·out 是静态属性，类型是对象类型 ·println()；是一个方法，是out对应的类型中的方法
字节输出流的使用步骤【背】
1.创建字节输出流对象 2.写数据 3.释放资源 1.FileOutPutStream fos = new FileOutPutStream("E:\\a.txt"); 2.byte[] bys = "hello,io".getBytes(); fos.write(bys); 3.fos.close();
Collection：集合
Collection 层次结构 中的根接口。 有一些存储有序的，另一些存储无序的 【重点】 有一些可以存储重复，另一些不能存储重复
获取长度，数组，字符串 ，集合
4.获取方法： int size():获取集合的长度 [获取数组的长度：数组名 . length] [获取字符串长度的方法：对象 . length（）]
DataOutputStream
【注意】写入的数据类型和读取的要保持一致，否则数据不对应
Section 3
(5 cards)