Java基础快速复习

本篇博客写的都是自己复习Java的时候所记录的一些笔记(还是比较篇概念的内容)，所以可能内容不是很全面、或许也很杂，内容都是从基础一点点往后增加的。

1.数据类型：由低级到高级转型

  (byte,char,short)-->int-->float-->long-->double-->boolean
    /**
     * 类型转换 1.强制类型转换:我就是要这么干 2.自动类型转换:只能从小到大进行，无法逆
     * 向,并且具有前后兼容性
     */

2.数据类型所占字节

   byte      1字节   8位
    char      2字节  16位
    short     2字节  16位
    int       4字节  32位
    float     4字节  32位
    long      8字节  64位
    double    8字节  64位
    boolean          1位

3.二进制:计算机机器计算规则

    好处:1.计算方便
        2.运算规则简单
        3.适合逻辑运算
        4.易于进行转换

        1.基本数据类型: 
        byte,char,short,int,float,long,double,boolean
        2.引用数据类型: 对象类型
        3.数组

        堆内存,栈内存的区别:
        1.栈内存运行速度快
        2.堆内存体积大
        3.栈内存主要存放基本数据类型,堆内存主要存放引用数据类型

4. 变量

    /**
     * 局部变量：
     * 定义在方法体内部的属于局部变量, 
     * 这个变量只能在自身方法体内使用 一旦方法执行完成，
     * 局部变量自动销毁(如果方法是静态方法，该局部变量不会销毁) (存放于栈内存中)
     * 成员变量: 作用于整个类 (存放于堆内存中)
     * 静态变量：作用于整个包 
     */

5.运算符

    /**
     * 加法是把左右两边的数据转换成二进制进行运算
     *
     * 字符串连接符，不需要进行二进制转换
     *
     * 字符串和任何数据类型进行连接操作（+），结果都是字符串类型
     */

     /**
      * j=i++; 先给j赋值。然后在自加1
      * j=++i; 先i自加1，然后在给j赋值 
      */

     /**
      * & : 一假为假
      * | : 一真为真
      * ^ : 相同为假，不同为真
      * && : 前面的为真时，后面的不执行
      * || : 前面的为真时，后面的不执行
      * << : 左移位 运算速率快，但是只能乘以2的n次方 （6<<n）---->n代表2的几次方
      * >> : 右移位 运算速率快，但是只能除以2的n次方（这是整形之间的运算，需要取整）
      */

6.选择结构

     /**
      * switch语句
      * 当判断条件满足时，没有break的话会继续执行下一条语句，并且不在进行判断，
      * 直到遇到break为止
      * 代码先走case 语句 最后走default 
      */

###7.while循环

 /**
  * while 循环
  *    先判断在执行
  * do while
  * 不论如何 do while 至少执行一次
  */

###8.for循环

//初始表达式只执行一次，执行语句是在条件表达式之后执行。
for(初始表达式 ; 条件表达式 ; 循环后的表达式){
    System.out.println("执行语句");
}

###9.面向对象

 /**
  * 使用匿名对象的时候。只有在掉了对象的行为时才有实际意义
  * 调用属性没任何意义，并且都会在执行完毕之后被回收
  */

###10. 封装

 /** 封装：是指隐藏对象的属性实现细节，仅对外提供公共的访问方式
  * 特点：
  *  1.安全性高
  *  2.复用性强
  *  3.便于使用
  *  4.隔离变化
  * 封装的原则：将不需要对外提供的内容隐藏起来，把属性隐藏，提供公共方法让其访问
  */

###11.构造函数

 /** 
  * 静态成员变量与非静态成员变量之间的区别：
  * 1.存放的位置不同
  * 2.生命周期长短不同
  * 3.静态成员变量生命周期比非静态成员变量长
  * 什么时候使用静态：
  * 1.当几个对象之间具体共享的成员的时候
  * 2.当几个对像在初始化已经具备某些相同的属性或行为
  * 静态的好处：节省内存（单独开辟一个空间，存静态成员），方便使用：类名.静态成员
  *   坏处:访问局限性(静态区域只能访问静态成员)
  *   ｛
  *        构造代码块
  *   ｝
  */

//构造代码块：对对象进行初始化，运行在构造函数之前，对象一建立，立即运行，而且只能运行一次。静态代码块优先于构造代码块

###12. 继承

子类继承父类，就获得了父类的属性和行为(private除外)
为什么要使用继承： 1.提高代码复用性 2.为了多态的顺利进行
继承的关系是一种特殊的关系   子类 is a 父类
先有父类，再有子类，但是代码中，父类是由多个子类进行抽取得到的。

###13.成员变量

super：代表父类的对象
this ：代表本类对象
特殊情况：父类和子类没有同名成员时，使用super和this都是指父类对象
加载子类的.class文件之前会优先加载父类的.class文件

###14.成员方法

当子类和父类存在同名方法的时候：重写（覆盖）
这种覆盖不是严格意义上的覆盖，父类的方法在内存中还是存在的，
只不过这时候实例化的是子类对象，只能调用自身方法

重写是为了解决：当子类对象具备和父类相同的功能，
但是功能的内容不同时，我们可以用方法的重写来重新定义子类的功能内容，并且保留了父类的方法定义。
重写：提高了代码的可扩展性

//重写与重载的区别：1.方法的重载只看参数列表    2.重写子类和父类的方法格式必须一模一样

###15.构造方法

在子类构造方法中会默认添加一个隐式语句,super();回调父类的构造函数
子类中每个构造函数都调用了一次父类的构造函数super();
为什么Java要这么干：在子类创建对象之前，必须明确父类初始化的内容，防止安全隐患
用了this()，super就不会默认被添加，因为代码最终还是会走super()。
super()必须出现在构造函数的第一行。
this()回调本类空参构造;

###16.抽象(abstract)

这个功能不能含有方法体，因为这里面的功能存在很多模糊不清的东西。
特点：abstract能够修饰类和方法，不能够修饰变量
为啥出现抽象：我们抽取的过程中发现很多子类的方法名字相同，但是实现的功能不一样，我们父类无法对其进行描述，因为它是模糊不清的，这个时候我们只抽取方法的名字，没有方法体
特征：1.抽象类不能被实例化，不能用new来创建对象
     2.子类继承抽象类，子类必须重写抽象类中所有方法，不重写也行，只不过这时候子类也成了抽象类
     3.要想实例化抽象类，必须实例化重写了其所有抽象方法的子类
     4.子类要想真实存在，必须重写所有抽象方法，因为抽象类含有强制性
     5.抽象类其实和一般类一样，都是从子类向上抽取得到的。

     //不同之处在于：1.抽象类一般情况下比一般类要多几个抽象方法（HttpServlet它是一个抽象类，但是它没有抽象方法，这么做唯一的目的就是不让其进行实例化操作）。2.抽象类不能被实例化

###17.接口(interface)

方法都是抽象方法
成员格式固定： 成员变量：public static final
             成员方法：public abstract 
             (修饰符可以不写，系统会默认添加)
接口和抽象类一样，不能被实例化，要想实例化接口，必须实例化一个类（实现了该接口）
在JVM中，接口的编译生成的还是.class文件。
不支持多继承的原因：父类可能含有同名方法，会出现安全隐患。但是在多实现过程中，不存这种说法，接口的方法本身就是不具备方法体，是模糊不清的，所以说实现多个接口的类不管到底实现了哪个接口的方法。
Java中可以同时进行实现接口和继承，extends XXX implements XX
接口和接口的关系：继承，可以多继承
特点：
1. 是一种对外暴露的规则
2. 接口是程序功能的扩展
3. 接口可以多继承
4. 接口与接口有继承关系：多继承

###18.多态：多种形态 有两种：函数的多态，对象的多态

对象的多态：一种事物的多种表现形态
父类的引用指向了子类的对象 
1. 多态提高了代码的扩展性
2. 使用的局限性：不能使用子类特有的方法

###19.程序运行会有两个过程：编译过程和运行过程。（动态绑定，静态绑定）

(编译看左边，运行看右边)
非静态方法  编译过程中：查看引用类型变量是否含有该方法
           运行过程中：查看引用类型变量指向的对象方法

静态方法       编译过程和运行过程中：查看引用类型变量是否含有该方法

成员变量       编译过程和运行过程中：查看引用类型变量是否含有该变量

20.内部类：一个类定义在另一个类的内部类

    访问内部类分两种情况：
        1.内部类所在外部类访问
        2.外部其他类访问内部类
            外部类.内部类  变量名 = 外部类对象.内部类对象
            (Outer.Inner in = new Outer().new Inner())
    内部类可以访问外部类的所有成员，包括私有成员
    不论内部类是否被封装，外部类都能进行访问
    内部类的意义：1.为了让内部类对外部类所有成员具有访问权限，
                2.可以对内部类进行更好的封装，要想访问内部类对象，必须经过外部类的同意（外部类可以提供一个方法供其它类进行访问）   
当被static修饰的时候，可以直接使用外部类.内部类来创建对象。(Outer.Inner in = new Outer.new Inner())   如果内部类中有静态内容，那么该类也必须是静态的
内部类中调用外部类的成员，省略了：外部类.this
作为局部变量存在，只能在当前所在区域内进行调用。不能静态化

匿名内部类其实就是一种简写格式
定义匿名内部类的前提：内部类必须继承一个类或者实现一个接口

###21. 进程和线程

进程：是由系统创建的一个活动单元
线程：进程运行的最小单元，是由系统创建
CPU运行线程
线程的状态：
1. 被创建
2. 运行
3. 睡眠
4. 等待
5. 阻塞
6. 销毁

###22.实现Runnable的好处，打破了单继承的局限性，强烈使用实现而不使用继承

使用前提：
1. 必须是多个线程
2. 必须使用同一个锁
线程锁（synchronized）
synchronized (obj){ //obj—>锁旗标
共享数据代码块
}

###23.确定一个线程是否安全？

1. 找出使用多线程运行代码

   1. 是否操作了共享数据

   2. 操作共享是否会出现安全问题
      同步方法：
      因为非静态方法是被对象调用的，所以这个锁就是自己对象本身this
      静态方法：JVM首先将.java编译成.class，这时候.class是作为对象存在，所以使用的锁：类名.class
      死锁
      解决单例模式–>懒汉式线程不安全的方法。
      public class Single{
      private Single(){}

      private static Single lhs = null;
      
      public static Single getInstance(){
          if(lhs == null){
              synchronized (Single.class){
                  if(lhs == null){
                      lhs = new Single();
                  }
              }
          }
          return lhs;
      }
      

      }

###24. 线程等待换醒机制

wait(),notify()。必须持有锁
必须同一个锁

线程池：1.存放等待的线程
notify()：一般情况下跑到线程池去唤醒第一个等待的线程
wait(),notify()，notifyAll().这三个方法封装在Object类中的原因：
    这三个方法必须持有锁，这个锁是任意对象，在调用过程中，只有Object可以作为任意对象的父类。所以封装在Object类中，可以被任意锁调用

###25.线程中的Interrupt()方法

wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻。

 调用Interrupt()方法则其中断状态将被清除，它还将收到一个 InterruptedException。
 //join();加入，优先执行，A线程加入B线程，优先执行A线程，A线程执行完毕，执行B线程，与除AB外其他线程无关。

###26.String解析(类类型)

String str = "abc";//这样写是在常量池中开辟一个空间
String对象有一个特性：不可变(指的是对象)，赋值操作是针对该对象的引用进行的，让该对象的引用指向其他内存地址

String str1 = "abc";
String str2 = new String("abc");
//区别：第一句：创建了一个对象
       第二句：创建了两个对象 
equals()在String中对Object的方法进行了重写，比较的是字符序列

###27.集合

1. 集合可以存储不同类型的数据
2. 集合长度可变
3. 集合用来存储对象，对象是用来存储数据
4. 集合里面存放的都是对象的地址
List:它是有序的，可重复的，因为他有索引
ArrayList：底层是数组结构，查询快，增删慢，它是线程不同步的
LinkedList：底层是链表结构，查询慢，增删快
Vector：底层是数组结构，它是被淘汰的

TreeSet:底层是树状结构
数据是按字典顺序排列的

###28.集合泛型

/**
 * 泛型:广泛的类型
 * 在编写代码的过程中，使用集合强转的时候可能会出现ClassCastException(类型转换异常)
 * 因为在集合中存放的对象是任意的，使用对象的时候会有安全隐患
 * JDK1.5之后出现了泛型
 * 1.泛型好处在于:将程序运行时的异常转换成编译时的异常
 *                方便程序员编写代码，提高代码的安全性
 * 2.避免了强转操作
 * 泛型的格式:<类型>
 * 泛型的使用:在集合中使用的比较多,其实泛型的定义就是指定接收某一类型
 * 
 * 泛型出现之前与出现之后的对比:
 * 早期:定义Object去接收未知类型
 * 现在:当需要使用的引用数据类型不确定的时候,使用泛型去作为一个规则去接收数据(提高代码的扩展性)
 *          一旦这么定义,该类中所有使用到了该泛型的方法都必须遵守这个规则
 * 现在我想打破这个规则:
 * 1.之前都是泛型类
 * 2.可以使用泛型方法打破这个规则
 * 当方法需要使用未知类型的引用数据的时候，如果在类上定义泛型，会造成使用的局限性，为了打破这个局限性，
 * 我们在方法中单独定义泛型，让该方法使用的泛型脱离类的控制
 * 格式:修饰符 <泛型> 返回值 方法名(){}
 * 静态方法使用泛型:必须使用自己定义的泛型
 * 
 * 泛型的高级应用:
 * 占位符:  ?
 * 泛型限定: ? extends Person 定义上限,向下扩展
 *      : ? super Person  定义下限，向上延伸
 * 
 */
 ```

29.Map集合

  /**
     * Map<K,V>:映射,键值对
     * 一个映射不能包含重复的键；每个键最多只能映射到一个值
     * k--->key
     * v--->value
     * 1.containsKey(Object key) 查询是否含有该键
     * 2.containsValue(Object value) 查询是否含有该值
     * 3.get(Object key) 通过键查询值
     * 4.put(K key, V value) 添加
     * 5.putAll(Map<? extends K,? extends V> m) 添加
     * 6.V remove(Object key) 删除映射的同时会拿到该映射的Value值
     * 7.Collection<V> values() 拿到由该map中的值所组成的集合
     * 8.replace(K key, V value) 修改该映射
     * 
     * 需求，对map的映射进行修改，假设map存在一个映射关系  abc-->学生
     *                             将该映射修改为  abc--->老师   
     * 
     * Map
     * |--HashMap:底层是哈希表，null可以作为键或者值,是线程不同步的(运行效率高)
     * |--TreeMap:底层是二叉树结构,会进行一个排序,是线程不同步的(运行效率高)
     * |--HashTable:底层是哈希表，null不能作为键或者值,是线程同步的(运行效率低)
     * 
     * 需求:遍历一个HashMap
     * 特殊方法:
     * 1. Set<K> keySet() 将map中所有的键取出并存入一个set集合中
     * 2. Set<Map.Entry<K,V>> entrySet()  将map中的映射关系取出并存入一个set集合中
     *    Map.Entry<K,V>指的是一组键值对
     * 
     * map是如何保证唯一性的:通过hashCode()和equals()两个方法同时决定
     * 
     * 需求:有5个学生，将学生的姓名(String name)
     * 和地址(String add)存放进map中，形成映射
     * 学生有姓名和年龄属性,当姓名和年龄同时相等时，这是同一个学生，不存
     * 
     * 当自己创建的类生成的作为key存放进map的时候，需要重写hashCode()和equals()方法
     * 指定规则:什么时候键重复
     */

30. I/O流

    /**
     * I/O 流:I->Input  O->Output
     * I/O流：用于不同设备之间进行数据传输
     * 用java书写代码进行的I/O传输
     * I/O在java中的体现:存在一个体系:封装在了IO包里面
     * 数据传输分为:
     * 字节流(数据以字节的形式进行传输):
     * 
     * 字符流(数据以字节的形式进行传输):
     * 都是操作文件,文本以字符为主,创造出了字符流
     * 
     * ascII(老美) A - 65  a - 97
     * 
     * 汉字:GB2312编码表(存放了几千个汉字)
     * 汉字:GBK编码表(收纳了几万个汉字)
     * 汉字:18030编码表(56个名族)
     * 
     * 国际码表:utf-8(unicode)
     *
     * 字符流是基于字节流:只所以要使用字符流:方便
     * 
     * IO包:有四个基类
     * 字节流基类:InputStream,OutputStream
     * 字符流基类:Reader,Writer
     * 
     * 会有很多子类:FileInputStream
     * (以当前基类名字为后缀,前面的名字代码的是具体的操作对象)
     *          FileReader 
     * (以当前基类名字为后缀,前面的名字代码的是具体的操作对象)
     */
    /**
     * IO流: new FileWriter(fileName);这个构造方法:
     * 假如该文件存在于当前目录下，则新建一个该名字的文件，
     * 并且把之前那个文件覆盖掉 不论如何，都会新建一个文件
     * 在调用该构造方法的时候:如果指定路径不存在，则会产生FileNotFoundExeception
     */