JAVASE基础知识

JAVASE基础知识

OOP的三大特性

封装

  • 把数据和方法封装在一起，数据被保护在内部，只能通过被授权的操作（方法）操作数据
  • 属性私有，get/set

IDEA

  • Debug

    • Step over：程序向下执行一行（跳过方法）

    • Step into:向下执行一行（进入自定方法，不会进入官方类库方法）

    • Froce step into：在调试时进入任何方法

    • step out：跳出方法

集合

  • HashSet和TreeSet去重机制：

    1. HashSet去重机制：hashCode()+equals()，底层先通过存入对象，计算对象的Hash值确定索引。若索引处没有数据，则存入；若有，通过equals方法逐个比较，不存在则存入，存在则丢弃。

    2. TreeSet去重机制：若你传入了一个Comparator匿名对象，就使用实现的compare去重，如果方法返回0，说明是相同的元素/数据，就不添加。若你没有传入一个Comparator匿名对象，则以你添加的对象实现的Comparable接口的compareTo去重。

泛型

  • 使用细节：

    1. 给泛型指向数据类型时，要求是引用类型，不能是基本数据类型

    2. 在给泛型指定具体类型后，可传入该类型或者其子类类型

    3. 泛型使用形式

      List<Integer> list1 = new ArrayList<Integer>();
List<Integer> list  = new ArrayList<>();//也可采用此种写法、
List list3 = new ArrayList();//默认给它的泛型是[<E> E是Object]

  • 自定义泛型

    • 自定义泛型类

      • 基本语法

        class 类名<T,R...>{
    成员
}

      • 注意细节：

        1. 普通成员可以使用泛型（属性、方法）
        2. 使用泛型的数组，不能初始化
        3. 静态方法中不能使用类的泛型
        4. 泛型类的类型，是在创建对象时确定的
        5. 如果在创建对象时，没有指定类型，默认为Object

    • 自定义泛型接口

      • 基本语法

        interface 接口名<T,R...>{
    
}

      • 注意细节

        1. 接口中，静态成员也不能使用泛型
        2. 泛型接口类型，在继承接口或实现接口时确定
        3. 没有指定类型，默认为Object

    • 自定义泛型方法

      • 基本语法

        修饰符 <T,R...>返回类型 方法名（参数列表）{
    
}

      • 注意细节

        1. 泛型方法，可以定义在普通类中，也可以定义在泛型类中

        2. 当泛型方法被调用时，类型会确定

        3. 修饰符后没有<T,R..>的方法不是泛型方法，而是使用了泛型

          public void eat(E e){}

          class Fish<T,R>{
    public void run{}//普通方法
    public<U,M> void eat(U u,M m){}//泛型方法,可以使用类声明的方法，也可以使用自己声明的泛型
    public<K> void eat(T t,K k){}
    public void hi(T t){}//使用了类声明的泛型
    
}

  • 泛型的继承和通配符

    • 继承
      1. 泛型不具备继承性
      2. :支持任意型泛型
      3. :支持A类和A类的子类，规定了泛型的上限
      4. :支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

JAVA绘图

多线程

  • 进程：进程时程序的一次运行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存亡和消亡的过程。
  • 线程相关概念
    1. 线程由进程创建，是进程的一个实体
    2. 一个进程可以有多个线程
    3. 单线程：同一个时刻，只允许执行一个线程。
      多线程：同一个时刻，可以执行多个线程。
    4. 并发：同一个时刻，多个任务交替进行
      并行：同一个时刻，多个任务同时执行
  • JAVA中的线程相关操作
    • 创建线程的两种方式
      1. 继承Thread类，重写Run方法
      2. 实现Runnable接口，重写Run方法
      3. 从JAVA设计来看，继承Thread类和实现Runnable接口来创建线程本质上没有区别，但实现Runnable接口方式
        更加适合多个线程共享一个资源的情况。
    • 线程常用方法
      • get/setName 返回/设置该线程名字
      • start 使该线程开始执行，JVM底层调用该线程的start0方法
      • run 调用线程对象run方法
      • set/ getPriority 更改/获取线程的优先级
      • sleep 在指定的毫秒数内让当前进程休眠
      • interrupt 中断线程
      • 注意：strat底层会创建新的线程，调用Run；线程优先级的范围；sleep：线程的静态方法，使当前线程休眠；interrupt是中断线程，并没有结束线程，故一般用于中断正在休眠的线程
      • yield：线程的礼让。让出CPU，让其他线程执行成功，但礼让的时间不确定，也不一定礼让成功
      • join: 线程的插队。插队的线程一旦插队成功，则先执行完插入的线程的所有任务
    • 用户线程和守护线程
      • 用户线程：也叫工作线程，当线程的任务执行完或通知方式结束
      • 守护线程: 一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束（常见的守护线程：垃圾回收机制）
    • JAVA中的线程状态
      • NEW：尚未启动的线程处于此状态
      • RUNNABLE：在JVM中执行的线程处于此状态
      • BLOCKED：被阻塞等待监视器锁定的线程处于此状态
      • WAITING：正在等待另一个线程执行特定动作的线程处于此状态
      • TIMED_WAITING：正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
      • TERMINATED：已推出的线程处于此状态
        线程的七种状态
    • 线程同步机制
      1. 在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多只有一个线程访问，保证数据的完整性。
      2. 线程同步，即当有一个线程对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成该操作。
    • 同步具体方法-synchronized
      1. 同步代码块
         synchronized(对象){
     //得到对象的锁，才能操作同步代码
     //需要被同步代码
 }
      2. synchronized还可以放在方法声明中，表示整个方法为同步方法
          public synchronized void m(String name){
      //需要被同步的代码
    }
      • 互斥锁
        • 基本介绍：
          1. JAVA语言中，引入了对象互斥锁的概念，保证共享数据操作
          2. 每个对象都对应一个可称为“互斥锁”的标记，这个标记用来任一时刻，只能有一个线程访问对象
          3. 关键字synchronized来与对象互斥锁联系，当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问
          4. 同步的局限性：导致程序的执行效率降低
          5. 同步方法(非静态)的锁可以是this，也可以是其他对象(要求是同一个对象)
          6. 同步方法（静态的）的锁为当前类本身
        • 注意事项和细节：
          1. 同步方法若没有用static修饰，默认对象为this
          2. 若用static修饰，默认为当前类.class
          3. 分析落地步骤：
          > 1. 需要先分析上锁的代码
          > 2. 选择同步代码块或同步方法
          > 3. 要求多个线程的锁对象为同一个即可！

文件

文件相关概念

  • 文件：保存数据的地方
  • 文件流：文件在程序是以流的形式来操作的
    • 流：数据在数据源（文件）和程序（内存）之间经历的路径
    • 输入流：数据从数据源（文件）到程序（内存）的路径
    • 输出流：数据从程序（内存）到数据源（文件）的路径
      文件流示意图

常用文件操作

  • 创建文件对象相关构造器和方法
  • 相关方法
    • new File(String pathname)
    • new File(File parent,String child)
    • new File(String parent,String child)
    • createNewFile()
    • JAVA文件操作相关函数分为字节流函数与字符流函数

InputStream字节输入流

  • InputStream抽象类是所有类字节输入流的超类
  • 常用子类：
    1. FileInputStream：文件输入流
    2. BufferedInputStream：缓冲字节输入流
    3. ObjectInputStream：对象字节输入流

节点流和处理流

  • 节点流：从一个数据源读写数据（FileReader、FileWriter）
  • 处理流：“连接”在已存在的流（节点流或处理流）之上，为程序提供强大的读写功能（BufferedReader、BufferedWriter）
  • 区别和联系：
    1. 节点流是底层流、低级流，直接跟数据源相连
    2. 处理流包装节点流，既可以消除不同节点流的的实现差异，也可以提供更方便的方法来完成IO
    3. 处理流对节点流进行包装，使用了修饰器设计模式，不会直接与数据源相连

处理流

  • BufferReader和BufferWriter属于字符流，是按照字符来读取数据的
  • 关闭时，只用关闭外层流即可
  • 对象流-ObjectlnputStream和ObjectOutputStream
    • 看一个需求
      1. 将int num = 100这个int数据保存到文件中，注意不是100数字，而是int 100,并且，能够从文件中直接恢复int 100
      2. 将Dog dog = new Dog(“小黄”, 3)这个dog对象保存到文件中，并且能够从文件恢复.
      3. 上面的要求， 就是能够将基本数据类型或者对象进行序列化和反序列化操作
    • 序列化和反序列化
      1. 序列化就是在保存数据时，保存数据的值和数据类型
      2. 反序列化就是在恢复数据时， 恢复数据的值和数据类型
      3. 需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一:
        • Serializable //这是一个标记接口，没有方法
        • Externalizable //该接口有方法需要实现，因此我们一般实现上面的Serializable接口
      4. 细节：
        1. 读写顺序要一致
        2. 要求实现序列化或反序列化对象,需要实现Serializable
        3. 序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性
        4. 序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
        5. 序列化对象时，要求里面属性的类型也需要实现序列化接口
        6. 序列化具备可继承性,也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化
posted @ 2022-02-06 12:13  fiv3  阅读(44)  评论(0)    收藏  举报