黑马Java EE面试总结

想要过黑马面试的你，你一定要看 黑马毕向东的视频。面试都是提问视频里面的问题。我将我的总结罗列出来，希望大家可以查漏补缺

面向对象特征： 封装，继承，多态
 封装：把属性隐藏，提供公共方法对其访问(private 封装特性的一种)
 面向对象举例： 利用对象的方法  指挥者
 面向过程: 一步一步执行过程     执行者
 
构造函数的作用:可以以用于给对象进行初始化
构造函数与自定义函数区别
 ①写法上   无返回值
 ②调用时机 构造函数对象创建 已定义函数由对象调用
 
什么时候使用静态static
 静态变量：对象之间共享数据
 静态函数：访问静态变量
 
默认构造函数的访问权限
 默认构造函数的访问权限和所属类一致
 即：类被public修饰，那么默认构造函数也带public修饰
   private        private
 
API文档生成
 javadoc 
 
静态代码块
 特点：随着类的而执行，且只执行一次
 
单例模式：一个类在内存中只存在一个对象
 1.为避免其他程序过多创建该类对象，禁止其他程序创建该对象
 2.为其他程序可访问该类对象，只好该类创建该类对象
 3.对外提供接口，让其他类获取该类对象
 
 实现：
  构造函数权限 private
  对象是static属性  （保证内存只存一份）
  接口 static，对象是static
  
 单例模式：饿汉模式  先初始化对象（类一加载进入内存，就已经创建好了对象）
     懒汉式    也称延迟加载。（类加载进内存，对象还未存在，只有调用传递对象接口，对象才被创立）
 /*
 class Single    //饿汉式
 {
  private Single(){};
  static Single single = new Single();
  static Single getInstance(){
   return single;
  }
 }
 
 
 class Single  //多线程中有安全问题  懒汉式
 {
  private Single(){};
  static Single single = null;
  static Single getInstance(){
   if(single == null){
    single = new Single();
   }
    return single;
  }
 }
 
 懒汉式 解决方案双重否定
 class Single  //多线程中有安全问题  懒汉式
 {
  private Single(){};
  static Single single = null;
  static Single getInstance(){
   if(signal == null)
   {
    synchronize(Single.class){
     if(single == null){
      single = new Single();
     }
      return single;
    }
   }
  }
 }
 */
 
继承
 所属关系（谁是谁中的一员）
如何使用继承体系中的功能
 要使用体系，首先查阅体系父类的描述，因为父类中定义的是该体系中"共性功能"
 通过了解共性功能，就可以知道该体系的基本功能。
为什么在具体调用时，要创建最子类的对象？
 ①可能是应为父类不能创建对象
 ②创建子类对象可以使用更多的功能，包括父类的+自己特有的

*重写(也称覆盖)*
覆盖
 子类覆盖父类权限 只能大于等于
 静态只能覆盖静态  （生存周期不一样）

final
 修饰类 避免被继承，被子类复写功能
 方法 不可被复写
 变量 只能赋值一次即可修饰成员变量，也可修饰局部变量

抽象类可不定义抽象方法：重要是不让抽象类实例对象

接口定义
 常量 public static final
 方法 public abstract
 记住：接口中成员都是public的
 
多态的成员函数（非静态）的特点：
 编译器：参阅引用型变量所属的类是否有调用的方法 有 通过，无 错误
 运行期：参阅对象所属的类中是有调用的方法
多态中，成员变量的特点：
 编译和运行，都参考左边
 
内部类的访问规则：
 ①.内部类可以直接访问外部类中的成员，包括私有
  之所以可以直接访问外部类的成员，是因为内部类持有了一个外部类的引用， 格式 外部类名.this
 ②.外部类要访问内部类，必须建立内部类对象
内部类访问格式：
 当内部类定义在外部类的成员位置上，且非私有。创建内部类的格式
  外部类名.内部类名 变量名 = 外部类对象.内部类对象;
  Outer.Inter inter = new Outer.new Inter();
内部类在成员位置上，就可以被成员修饰符所修饰:比如 private public protected static
 static 内部类具有static特性（jvm将静态内部内载入内存，是将静态内部类代码整块载入）
 当内部类被sta修饰后，可直接访问外部类中的stati成员。
 
 在外部其他类中，如何直接访问static内部类的非静态成员呢？
  new Outer.inter().function();
 在外部其他类中，如何直接访问static内部类的静态成员呢？
  Outer.inter.function();  //不能加new，因为static内部类的static成员已经在静态数据区了，即唯一性的存在了

 *当内部类中定义了静态成员，该内部类必须是static                  //载入内存，时间问题
 *当外部类中给的静态方法访问内部类时，内部类也必须是static        //载入内存，时间问题
内部类定义在局部时:
 ①不可以被成员修饰符修饰
 ②可以直接访问外部类中的成员 //因为持有外部类中的引用
 ③不可以访问它所在的局部中变量。只能访问被final修饰的局部变量
 
异常
 严重问题 Erroe类
 非严重的 Exception类
Throwable
 |-- Error
  |--RuntimeException
 |-- Exception
异常信息打印
 e.getMessage() //打印异常信息
 e.toString() //异常名称+异常信息
 e.printStackTrace() //异常名称,异常信息,异常出现的位置
      /jvm默认异常处理机制 就是调用 printStackTrace()
自定义异常类
 最好继承Exception，继承Throwable，另立门户
继承Exception原因：
 异常体系有一个特点，因为异常类和异常对象都被抛出
 他们都具有可抛行，这个可抛性是Throwable这个体系独有特点
 只有这个体系中的类和对象才可以被throws和throw操作
 throws 抛出异常类 throw 异常对象
RuntimeException
 如果在函数内抛出该异常(或子类)，函数可不用声明，编译一样通过
 如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过
 *之所以不用再在函数声明，是因为不需要让调用者处理，当该异常发生，希望程序停止。因为在运行时
出现了无法继续运算的情况，希望停止程序后，对代码进行修正
 
RuntimeException 异常发生，无法在继续进行运算

catch用于处理异常，如果没有catch就代表异常没有被处理过，如果该异常是检测时异常，那么必须声明
class Demo
{

 int div(int a,int b) throws FunException{
  try{
   if(b < -1)
    throw new FunException();
   return  a/ b;
  }finally{
   
  }
 }
}
13718154947

class FunException extends Exception
{

}

异常在子类覆盖中的体现
 ①子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者子类
 ②如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子类
 ③如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常
  如果子类发生了异常（非父类的异常），就必须进行try处理（子类自己内部处理），绝不能抛出
 
当函数内容有throw抛出异常对象，并未进行try处理，必须要在函数上声明否则编译失败
 *注意RuntimeException除外
 
Exception和Error区别 
Exception：
1．可以是可被控制(checked) 或不可控制的(unchecked)。
2．表示一个由程序员导致的错误。
3．应该在应用程序级被处理。

Error：
1．总是不可控制的(unchecked)。
2．经常用来用于表示系统错误或低层资源的错误。
3．如何可能的话，应该在系统级被捕捉。
 
异常有两种：
 编译时检测异常
  该异常在编译时，如果没有处理（没有抛也没try），编译失败
  该异常被标识，代表可以被处理
 运行时异常（编译时不检测）
  编译时，不需要处理，编译器不检测
  该异常的发僧，建议不处理，让程序停止。需要对代码进行修正
 
finally说明：
 finally中，通常是关系资源代码，因为资源必须释放
 finally只有一种情况不会执行。当执行System.exit(0) finally不会执行
 
异常的处理原则
 ①异常处理方式有两种try或者throws
 ②调用到抛出异常的功能时，抛出几个，就处理几个
 ③异常处理的顺序 小->大
 ④catch内需要定义针对性的处理方式。不要简单的定义printStackTrace。也不要不写
 
I/O
字符流 易于文本数据
字节流 字符流之间转换 InputStreamReader   OutputStreamWriter （可以设置字符编码）
/*
 面试提问的一个问题：传图片 用字节流（字符流有自己特定编码格式，与图片格式违背）
*/
flush，close区别
 close 刷新后，会将流关闭
 flush 刷新后，流可继续适用
window中换行 \r\n
readLine  不包含行终止符
 原理：底层是read方法的封装，当遇到换行符就跳转到下一行继续读取
InputStreamReader  interstream->reader
OutputStreamWriter  outputstream -> write     转换流

操作数据是否是纯文本
 是：字符流
 否：字节流
 
FileReader InputStreamReader
 FileReader 固定字符编码
 InputStreamReader 字符编码可指定
 
File类 //用来将文件或者文件夹封装成对象

mkdir()   // 创建文件夹
mkdirs() //多级目录
list() //调用list方法的file对象必须封装为一个目录（）目录必须存在

Properties load方法

集合
List
Set
Map
 
 获取
  get(object key)
  size()
  values()
  //下面两个需要重点关注
  put() //会覆盖前一个键值相同的元素，并覆盖其value值
  entrySet() 
  keySet()

Hashtable  //非null对象都可用于键或值
 用作键的对象必须实现hashCode方法和equals方法
 

Map
 |--Hashtable 底层哈希数据结构,不可以存入null键null值 该集合是线程同步的  效率低
 |--HashMap：底层是哈希数据结构,可以存入null键null值,该集合是非线程同步的  效率高
 |--TreeMap  二叉树结构，可以用于给map集合中的键值进行排序
map集合两种去处方式
 Set<K> keySet():将map中所有的键存入到set集合。因为set集合有迭代器。通过迭代器把键值输出，
根据get方法，获取每个值
 Set<Map.Entry<k,v>> entrySet:将map集合中的映射关系存入到set集合中Map.Entry<K,V>
  
ListIterator  双向迭代器

集合变数组
 问题：指定类型的数组到底要定义多长
  当指定类型的的数长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size
  当指定型的的数组长度大于了集合的size，就不会新创建数组，而是使用传递进来的数组
 所以最好创建一个刚刚好的数组 toArray(new list.size()) 
 这么做的目的：限定对集合元素的操作
reserverOder() //集合逆序
reverseOrder(Comparator<T> cmp) //逆序比较器返回

Arrays.asList //将数组变成集合，但不可以使用集合的增删方法
 因为数组的长度是固定的
  如何增删 报UnsupportedOperationException
 
 
 
网络编程

网络模型 TCP/IP参考模型
TCP/UDP区别
 UDP 将数据及源和目的封装在数据包中，区需要建立连接
  每个数据报的大小限制在64K内
  因无连接，是不可靠协议
  不需要建立连接，速度快
 TCP 建立连接，形成传输数据的通道
  在连接中进行大数据量传输
  三次握手，是可靠协议
  必须建立连接，效率会稍低