基础知识回顾

面向对象与面向过程的区别
- 面向对象的执行效率没有面向过程的执行效率快，因为对象被调用时需要实例化
- 面向过程没有面向对象易维护、扩展、复用
JAVA语言有哪些特点
- 面向对象：封装、继承、多态（后面详细解释）
- 平台无关：程序执行在JVM虚拟机中，通过JVM调用操作系统的资源
- 支持多线程：
- 支持网络编程：通过Socket实现网络编程
- 编译与解释并存源文件编译成.class文件，JVM执行.class文件
JVM、JDK、JRE 区别
- JVM: Java虚拟机（Java Vitual Machine），运行Java字节码文件（.class文件），可以在不同的操作系统上执行同一个字节码文件，实现一处编译，到处运行
- JDK Java开发环境(Java Develop Kit):包括JRE、基础类库、Java命令;主要创建和编译程序
- JRE Java运行环境（Java Runnable Environment）:基础类库、Java命令以及一些基础组件
JAVA与C++的区别
- 都是面向对象编程
- Java支持多线程和网络编程
- Java只支持单线程，但是提供接口和抽象方法
- Java不提供指针直接访问内存，内存相对安全
- Java可以实现自动内存管理，例如：垃圾回收机制
JAVA应用程序与小程序的区别
- Java应用程序：main()方法，作为程序的入口，由此来执行程序
- 小程序：没有main()方法，嵌在浏览器的init()或者run()方法中启动
字符型常量与字符串常量的区别
- 形式上：字符型常量是单引号引起的常量；字符型常量是双引号引起的常量
- 含以上：字符型常量相当于整数型（ASC值），可参与表达式运算；字符串常量代表是一个地址值（用了表达在内存中存储的位置）
- 占用内存大小：字符型常量占 2 个字符；字符串常量占若干字符
构造方法是否能被override（重写）
- 不可以
- 父类的私有属性和构造方法不能被继承和重写（override）；但是父类的构造方法可以被重载（overload）
JAVA程序的主类、应用程序、小程序的区别
- Java主类：带有main()方法的类就是主类，一个程序只有一个主类
- 应用程序：不一定要求是pulic类
- 小程序：主类继承于JApplet或者Applet中，必须是public类

* 重载（overload）与重写（override）的区别

重载（overload）：在一个类中，方法名一致，返回值类型和参数类型、个数都不同的两个或者两个以上的方法

代码示例：

    
package com.wuchao.foundation_test.blogTest.basis;
/**
@author wuchao
@class Overload
@module basis
@blame wuchao
@since 2020/7/20 8:22
重载示例
方法名一致
参数类型或者参数个数不同
返回值不同
*/
public class OverLoad {
  
public void setParameter(Integer id, String name){
  id = 0;
  name = "吴超";
}

public void setParameter(Integer id, String name, String sex){
  id = 0;
  name = "吴超";
  sex = "男";
}
}

重写（override）：

在子类和父类中，子类继承父类，并对父类中的某个方法的实现进行重写；要求子类方法与父类方法的方法名、参数类型以及个数一致，而返回值可以不同

代码示例

父类

 package com.wuchao.foundation_test.blogTest.basis.overloadAndoverride;
/**
@author wuchao
@class ParentClass
@module basis
@blame wuchao
@since 2020/7/20 9:10
*/
public class ParentClass {

  private Integer id;
  private String name;
  private Integer age;

public void setParentClass(Integer id, String name, Integer age){
  id = 0;
  name = "吴超";
  age = 10;
}
}

子类：

 package com.wuchao.foundation_test.blogTest.basis.overloadAndoverride;

/**
@author wuchao
@class ParentClass
@module basis
@blame wuchao
@since 2020/7/20 9:10
*/
public class ParentClass {
 
  private Integer id;
  private String name;
  private Integer age;

public void setParentClass(Integer id, String name, Integer age){
  id = 0;
  name = "吴超";
  age = 10;
}
}

* JAVA面向对象的三大特征
- 封装：将一个类中的属性（特征）和方法（行为），封装起来。只能通过此类的实例化对象的set()和get()方法赋值或者访问
- 继承
  - 只支持单继承
  - 子类具有父类的属性（特征）和方法（行为）
  - 子类也可以拥有自己的属性和方法
  - 子类可以通过自己的方式实现父类的方法（重写）
- 多态
  - 程序中所引用的变量以及引用变量所调用的方法，在程序编译期间无法确定，到运行时才可以确定。
  - 多出现在继承和接口实现中
*String、StringBuilder、StringBuffer的区别
- 可变性
  - String 不可变长字符串，添加新的字符需要创建一个新对象
  - StringBuilder、StringBuffer可变长字符串，可以通过append()方法添加新字符
- 安全性
  StringBuffer线程安全（例如append方法上有synchronized修饰）；String、StringBuilder线程不安全
- 执行性能
  String>StringBuilder>StringBuffer
*自动拆箱和装箱
- 拆箱
  - 将包装数据类型转化成基本数据类型
  - 代码示例
    1
    2
    3
    4
    5
    Integer i = 5;
    int j = i
    实现过程：
    Integer i = Integer.valueOf(5);
    int j = i.intValue();
- 装箱
  - 将基本数据类型自动包装成包装数据类型
  - 代码示例：
    1
    2
    int j = 5;
    Integer i = Integer.valueOf(j);
静态方法中为什么不能调用非静态变量
- 静态方法属于类，非静态变量属于对象，需要实例化的对象才可以调用，不同对象的成员变量也不同
- 而静态变量属于类，可以直接被静态方法调用
JAVA中定义一个无参构造的作用
- 对象实例化的时候使用
- 如果类中没有构造方法，对象实例化的时候会自动加载一个无参构造方法
- 如果父类没有无参构造，子类在调用super()方法时候会报错
import Java 与 Javax的区别
Javax是对Java的扩展
*接口和抽象类的区别
- 修饰符
  - 接口修饰符一般是public修饰
  - 抽象类需要使用Abstract修饰，public default protected都可以修饰
- 方法
  - 接口的方法没有方法体
  - 抽象类中的抽象方法没有方法体，有抽象方法的类一定是抽象类，抽象类不一定都是抽象方法
- 变量
  - 接口只能有静态变量，不能有非静态变量
  - 抽象类都可以
- 作用
  - 接口是为了扩展对象的行为，是对行为的抽象
  - 抽象类是为了将有共同属性和行为的类给抽象出来，是对类的抽象
*成员变量与局部变量的区别
- 作用域
  - 成员变量是对象的变量，可以对象可以随意调用
  - 局部变量是在方法中，方法结束，局部变量失效
- 修饰符
  - 都可以用final修饰
  - 局部变量不可以使用private修饰
- 内存存储位置
  *
- 赋值
  - 成员变量使用默认值赋初值
  - 局部变量不会使用默认值赋初值
对象实体与对象的引用有什么不同
- 对象实体是对象在内存的堆中存储的内容
- 对象的引用，只是一个内存地址，存在于内存栈中
什么是返回值类型，返回值类型在方法中的作用
- 返回值类型：用来接收方法执行完返回的结果
- 作用：接收方法执行结束返回的结果，以便其他的方法或者对象调用
类中构造方法的作用，类中没有声明的构造方法，怎么执行
- 作用：用于实例化对象
- 类中没有声明的改造方法，会自动创建一个无参的构造方法；通过此无参构造方法实例化对象
构造方法的特征
- 修饰符：一般是public
- 返回值类型：没有返回值类型，也不需要用void
- 方法名：与类名一致，大小写也一致
- 参数类型及个数：参数类型、个数、顺序，根据自己需求确定
- 在实例化对象时候才执行
*静态方法与实例方法的区别
- 归属
  - 静态方法属于类，在类被加载时候就会执行，而且只会执行一次
  - 实例方法属于实例化后的对象，对象调用该方法才会执行
- 修饰符
  - 静态方法必须要用final来修饰
  - 实例方法不需要final修饰
- 被调用
  - 静态方法：ClassName.methodName()或者objectName.methodName()
  - 实例方法：objectName.methodName()
- 参数
  - 静态方法需要静态的变量作为参数
  - 实例方法可以是静态变量也可以是非静态变量作为参数
对象相等与对象的引用相等的区别
- 对象相等是：对象在内存栈中的内存地址以及堆中的内容相等
- 对象引用相等：对象在内存栈中的内存地址相等
* == 与 equles的区别
- ==
  - 基本数据类型的数值相等
  - 引用数据类型的内存地址相等
- equals
  - 基本数据类型也是比较数值的大小
  - 如果类没有覆盖equals()方法，比较内存地址
  - 如果类覆盖了equlas()方法，比较的是对象的内容
*hashCode()与equals()
- HashCode()
  - 获取对象的hash值
  - 作用：标记在哈希表中索引的位置
- equals()
  - 重写equals()方法，比较对象的内存地址
  - 重写equals()方法之前，必须重写HashCode()方法，获取对象在哈希表中的索引值
简述线程、程序、进程的定义以及之间的区别
- 程序
  - 程序的执行过程就是进程从创建到销毁的过程
  - 一个指令和数据的文件
- 进程
  - 程序一次的执行过程，程序运行的基本单元
- 线程
  - 一个进程可能是一个或者多个线程
  - 同类的线程共享同一块内存区域
*线程的状态
- NEW 线程创建
- RUNNABLE 线程运行
- BLOCKING 线程阻塞
- WAITTING 线程等待
- TIME_WAITTING 线程等待（限时）
- TERMINATED 线程终止
- 图示
关于final关键字的总结
- 应用于类中：此类无法被继承
- 应用于方法中：方法锁定，无法修改
- 应用于变量中
  - 基本数据类型的值无法更改
  - 引用数据类型，引用的对象无法更改，不可以再引用其他的对象

*Java中的异常处理

Error 程序无法处理的错误
- VitualMachineError 虚拟机错误
  - StatckOverFlowError
  - OutOfMemoryError
- AWTError
Exception 程序可处理的错误
- 编译时候异常
  - IOException 文件异常
  - SQLException SQL异常
- RuntimeException 运行时异常
  - NullPointException 空指针异常
  - ArrayIndexOutOfBoundsException 数组越界异常
  - ClassCastException 类型装换异常
  - ArithmeticException 算术异常

throw和throws关键字区别

throw 将产生的异常抛出，是抛出异常的动作

代码示例：

package com.wuchao.foundation_test.blogTest.basis.exception;
/**
@author wuchao
@class ThrowException
@module exception
@blame wuchao
@since 2020/7/24 10:10
*/
public class ThrowException {
  public static void main(String[] args) {
     
    String s= "abc";
     if (s.equals("abc")){
          throw new NumberFormatException("数字格式不正确");
        }
     }
    }

throw 出现在出现在方法体
throw 是抛出了异常，执行throw是一定抛出了异常

throws 声明将要抛出哪种类型的异常

throws 出现在方法头上
throws 表示可能出现某种异常，不一定会有异常

代码示例:

package com.wuchao.foundation_test.blogTest.basis.exception;

/**
@author wuchao
@class ThrowsException
@module exception
@blame wuchao
@since 2020/7/25 9:44
*/
public class ThrowsExceprion  {

  public static void method() throws NumberFormatException{
            
    String s = "abc";
    System.out.println(Double.parseDouble(s));
   }

   public static void main(String[] args) {

     try{
        method();
       }catch (NumberFormatException n){
        System.out.println("非数据类型无法装换");
      } 
     }       
    }

如果字段不想被序列化，怎么办
- 可以在不想被序列化的字段前面添加 transitant
键盘输入的方法
- 使用Scanner类
- 使用BufferedReader
Java中的IO流
- 字节流(Stream)
  - 输出流(OutputStream)
    - 节点流
      - FileOutputStream 文件字节输出流
      - PipedOutpuStream 管道字节输出流
      - ByteArrayOutoutStream 字节数组输出流
    - 处理流
      - BufferedOutputStream 缓冲字节输出流
      - DataOutputStream 基本数据类型字节输出流
      - ObjectOutputStream 对象字节输出流（用于对象序列化）
      - PrintOutputStream 打印字节输出流
  - 输入流(InputStream)
    - 节点流
      - FileInputStream 文件字节输入流
      - PipedInputStream 管道字节输入流
      - ByteArrayInputStream字节数组输入流
    - 处理流
      - BufferedInputStream 缓冲字节输入流
      - DataInputStream 基本数据类型字节输入流
      - ObjectInputStream 对象字节输入流（用于对象序列化）
      - SequenceInputStream 合并流
- 字符流
  - 输出流(Writer)
    - 节点流
      - FileWriter 文件字符输出流
      - PipedWriter 管道字符输出流
      - CharArrayWtiter 字符数组输出流
    - 处理流
      - BufferedWriter 缓冲字符流
      - OutputStreamWriter 转换流
      - PrintWriter 打印流
  - 输入流(Reader)
    - 节点流
      - FileReader 文件字符输入流
      - PipedReader 管道字符输入流
      - CharArrayReader 字符数组输入流
    - 处理流
      - BufferedReader 缓冲字符输入流
      - InputStreamReader 转换流
- 图示：
BIO、NIO、AIO的区别
- BIO (Blocking IO)
  - 同步阻塞IO
  - 数据的读取与写入必须阻塞在一个线程中等待其完成完成
  - 线程执行IO操作时候，进入阻塞状态，无法执行其他操作，直到IO操作完成
- NIO（Non-Blocking IO）
  - 同步非阻塞IO
  - 线程执行IO时候，不进入阻塞状态，线程可执行其他操作，直到通过回调机制通知该线程执行IO的结果
- AIO（Asynchronized IO）
  - 异步非阻塞IO

常用的关键字

final
- 修饰类
  - 此类无法被继承
  - 此类的成员方法隐式的指定成final方法
- 修饰方法此方法不能被重写（Overrider）
- 修饰变量时是常量
  - 基本数据类型的变量，其数值一旦初始化不能被改变
  - 引用类型的变量，一旦初始化之后不能指向其他的变量
static
- 修饰成员变量和方法
  - 被static修饰的成员属于类
  - 被static修饰的变量是静态成员变量，存放在Java内存的方法区中2
  - 调用方法类名.成员方法或者类名.成员变量
- 静态代码块
  - 定义在类中的方法外
  - 静态代码块在非静态代码块之前执行（静态代码块->非静态代码块->构造方法）
  - 无论该类创建多少对象，静态代码块只执行一次
- 静态内部类
  - 他的创建不依赖外部类的创建（与非静态内部类的区别）
  - 不能使用任何外部类的非static的成员方法或者变量
- 静态导包
  - 代码
    1
    import static 包名
  - 不需要使用导入类的类名+成员方法/成员变量的方式调用，可以直接调用导入类的静态成员变量和方法

this

引用类的当前实例

代码示例：

  class Manager {
    Employees[] employees;

  void manageEmployees() {
  int totalEmp = this.employees.length; // 引用当前实例的变量
  System.out.println("Total employees: " + totalEmp);
  this.report(); // 引用当前实例的方法
}

  void report() { }
}

super

子类访问父类的变量和方法

代码示例：

public class Super {

protected int number;

protected showNumber() {
   System.out.println("number = " + number);
}
}

public class Sub extends Super {
  void bar() {
  super.number = 10; // 引用父类的变量
  super.showNumber(); //引用父类的方法
}
}

Collections工具类与Arrays工具类常用的方法