JavaSE总结章---笔记(持续更新)

package Demo;

/**
 * REVIEW 基础语法
 *
 * 注释  分为
 *     单行注释： //
 *     多行注释:  /**加/
 *     文档注释： /** *加/  就是现在在注释的
 *
 *
 * 标识符：
 *      关键字 ：一下仅举例，详细可百度JAVA关键字
 *
 *          abstract(表明类或者成员方法具有抽象属性)、assert(断言，用来进行程序调试)、boolean(基本数据类型之一，声明布尔类型的关键字)、
 *
 *          break(提前跳出一个块)、byte(基本数据类型之一，字节类型)、case(用在switch语句之中，表示其中的一个分支)、
 *
 *          catch(用在异常处理中，用来捕捉异常)、char(基本数据类型之一，字符类型)、class(声明一个类)....
 *
 *
 * 数据类型：
 *      分为基本数据类型、引用数据类型
 *
 *      基本数据类型：
 *
 *          整数：                    浮点数：                         字符：——>联想到ASCII码， UTF-8 , Unicode码
 *            byte  占1个字节               float  占4个字节                char   占2个字节
 *
 *            short 占2个字节               double 占8个字节           转移值符：
 *                                                                        \u0000, \n ,\r ,\t ,\*
 *            int   占4个字节
 *                                    布尔值：
 *            long  占8个字节               boolean 占1个字节
 *
 *          0b开头为二进制  、0 八进制  、0x十六进制
 *
 *       引用数据类型：
 *
 *          类：栈指向堆
 *
 *
 *          接口：
 *
 *
 *          数组：
 *
 *
 *  类型转化：
 *      自动类型转换：
 *                  低转高  ，子类转父类
 *
 *      强制类型转换：
 *                  高转低  (低)高
 *
 *
 *  变量与常量：
 *      定义：type varName =value;
 *
 *      作用域：
 *           类变量   static
 *
 *           实例变量
 *
 *           成员变量
 *
 *      常量：
 *          final
 *
 *      命名规范：
 *          1.见名知意
 *
 *          2.驼峰命名(变量，方法)
 *
 *          3.类：首字母大写，再驼峰命名
 *
 *          4.常量：大写+下划线
 *
 *          5.尽量不要用拼音命名
 *
 *
 *  运算符：(有点忘了)
 *        算数运算符 ：  +   -   *   /   %   ++  --
 *
 *        赋值运算符 ： =
 *
 *        关系运算符 ：>  >=   <  <=   !=  instanceof
 *
 *        逻辑运算符 ：&&  ||  !
 *
 *        位运算符   ：%   |   ^   ~   >>   <<   >>>
 *
 *        条件运算符 ：  a?b:c
 *
 *        扩展运算符 ： += 、-= 、*= 、/=
 *
 *
 *  包机制：
 *        域名倒写
 *
 *        package
 *
 *        import
 *
 *
 *  JavaDoc：
 *        JDK帮助文档
 *
 *        javadoc：常用的标识
 *               @author  作者
 *
 *               @Version 版本
 *
 *               @Since   最早支持java到哪个版本
 *
 *        和方法、类相关的
 *               @param
 *
 *               @return
 *
 *               @throws
 *
 *
 *
 */
public class First {
}

import java.util.Scanner;
/**
 * REVIEW 流程控制
 *
  * Scanner：
 *      用户交互
 *
 *      基础语法
 *
 *      先new一个scanner对象  Scanner scanner = new Scanner(System.in);
 *
 *      然后:
 *          1)首先需要判断输入的是什么类型的值
 *
 *          2)再根据判断输出
 *
 *      Scanner类中的hasnext()与hasNextLine()通常用在if..else判断中，用来判断是否还有输入的数据  ；
 *
 *      Scanner类中的next()与nextLine()方法获取接收输入的字符串，在读取前一般需要用 next()和next()
 *              同理  nextint(),nextFloat()....
 *
 *
 * 顺序结构：
 *      程序默认执行的结构，自上而下的执行代码
 *
 *
 * 分支结构：
 *      if()     单选择结构
 *
 *      if-else 、if-elseif  多选择结构
 *
 *      switch   jdk支持了String类型 、   case穿透  、 default
 *
 *
 * 循环结构：
 *      while() 、 do{}while()    ——>  避免死循环
 *
 *
 *      for  、增强for循环
 *
 *
 *      可记次数的用for、不可记次数的用while
 *
 *
 * break、continue：
 *      break:跳出循环
 *
 *      continue:终止当前轮循环
 *
 *      return：结束方法的运行
 *
 */

public class Second {
    public static void main(String[] agrs){
        Scanner scanner=new Scanner(System.in);

        int a;

        System.out.println("请输入您的字符串");



        if(scanner.hasNext()){
            String i=scanner.nextLine();
            System.out.println(i);
        }

        a=scanner.nextInt();
        System.out.println("输出您刚才输入的数字"+a);

        scanner.close();


    }

}


/**
 * REVIEW 方法
 *
 * 什么是方法：
 *
 *      语句块的集合
 *
 *      main方法是由系统去进行调用的，位于栈的最底层
 *
 *
 * 方法的定义：
 *
 *      修饰符  返回值  方法名(参数名){return 返回值;}
 *
 * 方法分为静态方法，加了static
 *      非静态方法，没有加static
 *
 *
 * 方法的调用：
 *
 *      如果是调用静态方法，则使用 类名.方法   即可调用成功
 *
 *      如果是调用非静态方法，则需要实例化这个类 new
 *
 *      对象方法(1.先new一个自己这个对象  A a=new A()  2.再用  对象名.方法名  来调用输出   A.方法名)
 *
 *
 *  总结理解：
 *      可以看出静态的方法是已经存在了的，所以可以直接进行调用，而非静态的方法不存在，所以需要进行实例化使之存在，才可以进行调用
 *
 *
 *  方法的结束：
 *      return
 *
 *
 *  方法的重载：
 *
 *      方法名相同，参数列表不同(个数不同、或类型不同、参数排列顺序不同等等)；
 *
 *      方法返回类型可以相同也可以不同
 *
 *
 *   命令行传参：
 *
 *      在cmd中给main方法传参
 *
 *
 *   可变长参数：
 *
 *      ...  必须放在最后一个参数    如 public void test(int... i){}
 *
 *      一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明
 *
 *
 *    递归思想：(常考) 能不用就不用，因为调用自己太多次容易影响机器的性能    百度letcode题库
 *
 *      自己调用自己，给自己一个出口
 *      //作业：做出一个计算器，可以做到简单的加减乘除
 *      1.4个方法加减乘除
 *      2.用switch+循环去进行交互
 *      3.传递出需要交互的两个数
 *      4.输出结果
 */
public class Third {
    //递归思想
    public static void main(String[] args) {
        System.out.println(f(5));

    }

    public static int f(int n){
        if (n==1){
            return n;
        }else {
            return n*f(n-1);
        }
    }
}


/**
 * REVIEW 数组(数据结构)
 *
 * 数组的定义：
 *      将声明和创建放一块
 *      dataType[] arrayRefVar=new dataType[arraySize]
 *    即
 *      int[] a =new int[10]
 *
 *      new int {5}
 *      {1,2,3,4,5}
 *      必须同一个类型
 *
 * 数组的使用：
 *
 *      通过下标拿到值
 *
 *      数组下标越界： ArraysindexoutofBounds
 *
 *      增强for循环的遍历
 *
 *
 * 二维数组：
 *
 *       int[][]
 *
 *
 *  Arrays工具类
 *      获取数组的长度：  arrays.length
 *
 *
 *
 *  排序算法：   ——>up西部开源
 *
 *        冒泡排序
 *
 *        选择排序
 *
 *        插入排序
 *
 *        快速排序
 *
 *        归并排序
 *
 *        希尔排序
 *
 *        堆排序
 *
 *        基数排序
 *
 */

public class Fourth {
    public static void main(String[] args) {
    int[] a=new int[10];
    System.out.println(a.length);   //  得到  10
        a[0]=3;
        for (int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }                                   //方法一：遍历数组里的数 得到10个数，第一个是3，后面的都是0

        for(int c : a ){
            System.out.println(c);      //方法二：通过增强for遍历数组里的数
        }

        printT(a);    //调用下方的printT方法  输出c数组中的所有值
        System.out.println();


        int[] reverse = reverse(a);  //先将c数组反转后赋值给新建的reverse数组
        printT(reverse);             //再调用reverse数组给printT方法输出
        }


    //打印数组元素
    public static void printT(int[] nums1){
        for (int i=0;i<nums1.length;i++){
            System.out.print(nums1[i]+" ");
        }
    }

    //反转数组

    public static int[] reverse(int[] r){

        int[] result =new int[r.length];

        for (int i=0,j=r.length-1;  i<r.length ; i++,j--){
            result[j]=r[i];
        }

        return result;
    }
}


/**
 * REVIEW 面向对象
 *
 * 什么是面向对象(OOP)：
 *
 * 面向对象易维护、易复用、易扩展。 因为面向对象有封装、继承、多态性的特性，所以可以设计出低耦合的系统，使系统更加灵活、更加易于维护。
 * 但是，面向对象性能比面向过程低。
 *
 * 面向对象的本质：以类的方式组织代码，已对象的组织(封装)数据
 *
 * 类与对象：
 *
 *       类是抽象的，所以需要对他进行实例化，即 new
 *
 *       类是对象的抽象：模板Class
 *
 *       对象是类的具体
 *
 *       关于一个类，即使它什么都不写，也会存在一个方法
 *
 *
 *
 * 构造方法：(详细见Demo03)
 *
 *       构造器：
 *       1.和类名相同
 *       2.没有返回值
 *
 *       每个类中的开头都会存在一个无参构造，即 public xxx(){xx};
 *
 *       若在这个类中写了一个有参构造，即 public xxx(xxx){xx};
 *
 *       那么这个无参构造就不存在了
 *
 *
 *       构造的重载：(关注无参构造)
 *
 *            默认的无参构造
 *
 *
 *            重点！！！！  如果手动定义了一个有参构造则需要重新定义一个无参构造    即 public X(){}       这样才能在main方法里对X实例化
 *
 *            这里需要注意：在类里， 首个方法定义一个无参构造的方法比较好，因为这样对于后面的super关键字使用等有作用。
 *
 *
 *            单例模式需要构造器私有！  即 不能让别人new出来
 *
 *        使用new关键字，本质是在调用构造器    alt+insert
 *
 *    
 *    关于 重载 与 重写 的区别
 *
 *      重载：就是同样的一个方法能够根据输入数据的不同，做出不同的处理
 *
 *      重写：当子类去继承自父类的方法时，输入数据一样，当要做出有别于父类的响应时，你就得覆盖父类方法
 * 			重写可以根据接口去实现方法
 *
 *  new对象：
 *
 *        栈指向堆
 *
 *        栈存放引用
 *
 *        堆存放具体的对象
 *
 *
 *
 *
 *  三大特性(封装、继承、多态)
 *
 *  封装(数据的隐藏)：
 *
 *    通常，应禁止访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
 *   
 *    但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。  
 * 
 *      封装的核心：private
 *
 *      属性私有、get、set    (alt+insert)
 *
 *          即当你在public A方法中去new了一个private的对象，你需要在这个public方法中  xx.setxx();  再通过 对象名.getXX() 获得
 *
 *          且私有的属性无法继承，只能通过get和set获取
 *
 *
 *
 *  继承：
 *
 *      Java是单继承！     通过接口interface实现多继承
 *
 *      extends
 *
 *      Object
 *
 *      子类继承了父类，子类就会拥有父类的全部特性，全部方法(若父类中有私有的方法，这个私有的方法能被继承，但是无法被访问/调用)
 *
 *      方法的重写
 *
 *      this       ——>  指的是当前这个类里的对象  而非指传入的参数
 *
 *      super      ——>  指的是父类里的对象       而非指传入的参数
 *
 *  super注意点：
 * 	    1.super调用的是父类的构造方法，必须在子类构造器方法的第一行(即你在子类的方法中使用super时，必须是将super)
 *
 * 	    2.super只能出现在子类的方法或者构造方法中
 *
 * 	    3.super 和 this不能同时调用构造方法！   如果要同时调用，则需要保证
 *
 *    对比 this
 *
 * 	  代表的对象不同：
 * 		this: 本身调用者的这个对象
 * 		super： 代表父类对象的引用
 *
 * 	  前提：
 * 		this：没有继承也可以使用
 * 		super：只能在继承条件才可以使用
 *
 * 	  构造方法：
 * 		this()：本类的构造
 * 		super：父类的构造
 *
 *
 *     一个类，不管怎么写，只要你重写了有参构造，一般都要在类下面先加上一个无参构造方法 ，如 public a(){xxx}  ,因为这样对于后面的继承，
 *     子类用到super时才不会报错，但如果在类的下方是先写了一个有参构造方法，则用到super的子类需要对应传入参数才不会报错
 *
 *
 *
 * 	 方法的重写(Override)：当父类的功能，子类不一定需要，或者不一定满足，此时   ——>子类重写父类的方法     (快捷键 Art+Insert)
 *
 *      需要有个前提：  方法是非静态的(即没有static关键字声明)，并且需要有继承关系，然后子类去重写父类得方法！！
 *
 *      1.方法名必须相同
 *
 *      2.参数列表也必须相同
 *
 *      3.修饰符：范围可以扩大但不能缩小：   public > protected > default > private
 *
 *	    4.抛出的异常：范围，可以被缩小，但不能扩大； ClassNotFoundException  --> Exception(大)
 *
 *      总结：
 *      当A继承B
 *
 *      A中有静态方法test  ，B中有静态方法test
 *      此时在A中    A a=new A();      B b=new A();
 *
 *      此时调用a.test  ==>得到A类中test方法中的代码体结果        调用b.test  ==>得到B类中test方法中的代码体结果
 *
 *
 *      若A中有非静态方法demo   ，B中有非静态方法demo
 *      此时在A中    A a=new A();      B b=new A();    且在A类对demo进行重写
 *
 *      则此时调用a.test  ==>得到A类中重写demo方法中的代码体结果        调用b.test  ==>得到的也是A类中重写demo方法中的代码体结果
 *
 *
 *
 *  多态：(方法的多态)   (参考Demo06)
 *
 *      父类的引用指向子类的对象
 *
 *      如 Student类继承Person类
 *      在A类中就可以
 *      Person person =new Student();
 *
 *      1.父类引用指向子类的对象   Person person = Student;
 *
 *      2.把子类转换为父类，向上转型
 *
 *      3.把父类转换为子类，向下转型；(强制转换，可能会丢失一些方法，不是很好)
 *
 *      4.方便方法的调用，减少重复的代码！
 *
 *
 *      insteadof关键，如果匹配，可以进行类型之间的转换
 *
 *      首先 A a =new B();  然后 看的是A与B的关系(父子关系)
 *      Systemui.out.print(a insteadof B);    如果他们之间有关系，则会得到true
 *
 *      Systemui.out.print(a insteadof C);    因为A和C没有关系，所以会得到false
 *
 *
 *   修饰符：
 *
 *      public     //公用的
 *
 *      protected  //受保护的
 *
 *      private    //一般会设置属性为私有的   在这个声明里定义的属性，需要通过get和set去进行获取/设置
 *
 *      final      //被final定义的类  无法被继承；断子绝孙= =    被final定义的属性  为常量
 *
 *      static     //静态    集中在定义 静态方法，  也有静态代码块 例如   static{} 详情见下面的Fifth类代码
 *
 *
 *
 *   抽象：
 *      abstract   //抽象类   (不算十分重要，具体可见Demo07)
 *
 *      ---用在方法上，则它就是抽象方法： 只有方法名字，没有方法的实现！   重点： 即这个方法没有代码体{}  如：public abstract void doSomething();
 *
 *      ---用在类上，它就是抽象类，  并且这个类不能new，只能通过它的子类去实现它的方法  (一般就是继承这个抽象类然后重写方法，达到节约代码的目的)
 *
 *      注：1.抽象类里可以有抽象方法/非抽象方法  ，但是 有抽象方法的类 必定是抽象类
 *
 *         2.抽象类不可以被实例化，不能被new来实例化抽象类
 *
 *         3.抽象类可以包含属性，方法，构造方法，但是构造方法不能用来new实例，只能被子类调用
 *
 *         4.抽象类只能用来继承
 *
 *         5.父类如果是抽象类，那么父类里的抽象方法，子类里必须都重写, 因为抽象类里的抽象方法是没有代码体的，也就是个空有名字的方法而已
 *
 *           若这个子类也是抽象类，那么由它的子子非抽象类去重写 父类，父父类里的所有抽象方法
 *
 *
 *
 *   接口：(它不是类，可以理解为和类是同等级)   interface代表接口
 *
 *      而且接口一般都是有一个实现类的， 这个实现类一般为xxxImpl，即后缀 Impl  (仅仅是见名知意的作用)
 *
 *          如有这么几个接口 +最后一个 类(其实就是实现类)
 *
 *          public interface InterFaceA { void aaa();}
 *
 *          public interface InterFaceB { void bbb();}
 *
 *          public interface InterFaceC { void ccc();}
 *
 *          class TestClass implements InterFaceC{
 *
 *          @Override
 *          public void aaa() {System.out.println("TestClass.aaa()");}
 *
 *          @Override
 *          public void bbb() {System.out.println("TestClass.bbb()");}
 *
 *          @Override
 *          public void ccc() {System.out.println("TestClass.ccc()");}
 *          }
 *
 *          //此时这个 TestClass就是实现类，这个类必须要实现前面多个接口里的方法，也就是必须要重写这些方法
 *
 *
 *
 *   因此：1)首先通过interface来定义接口A，
 *
 *        2)然后类通过 implements 可以实现多个接口中的方法，间接实现多继承, 并且需要重写接口中的方法
 *
 *        如 public class UserServiceImpl implements UserService,TimeService,A{}
 *
 *        详细可以参考(Demo08)
 *
 *
 *   接口的作用：
 *      1.约束
 *
 *      2.定义一些方法，让不同的人去实现
 *
 *      3.接口里面定义本身就是抽象的，即已经是有public 、abstract 、static final这些声明修饰符了，无需再进行其他别的修饰符声明
 *
 *      4.接口本身并不是类，所以并不能被实例化( 即无法去new() ),接口也没有构造方法
 *
 *      5.类通过 implements 可以实现多个接口中的方法，间接实现多继承
 *
 *      6.并且这个实现类 需要重写接口中所有的 (抽象) 方法
 *
 *      如 public class UserServiceImpl implements UserService,TimeService{}
 *
 *      注意： 这里需要在UserServiceImpl实现类里将UserService、TimeService接口里的(抽象)方法进行重写
 *
 *
 *      只有一个方法的接口叫做 函数式接口 ，可以使用 lambda 表达式简化
 *
 *
 *      接口比抽象类更抽象
 *
 *      一个类可以实现多个接口  如 public class UserServiceImpl implements UserService,TimeService{}
 *
 *
 *
 *   内部类：(在一个A类中再定义一个B类，这个B类就称为内部类)
 *
 *       局部内部类
 *
 *       静态内部类
 *
 *       匿名内部类(重点)  (即直接 new A().xxx()   这样来调用方法)
 *
 *
 *
 */
public class Fifth {

    {
        System.out.println("这是一个匿名的方法");
    }

    static{
        System.out.println("这是一个静态代码块");
    }

    public Fifth(){
        System.out.println("构造方法");
    }


    public static void main(String[] args) {
        Fifth fifth = new Fifth();
        System.out.println("==========");
        Fifth a = new Fifth();
    }

    //最后得到

    /**这是一个静态代码块
    *  这是一个匿名的方法
    *  构造方法
    *  ============
    *  这是一个匿名的方法
    *  构造方法
    *
    * 所以一般类执行是先执行静态代码块，再执行匿名方法，最后才执行构造方法
    *
    * 但是静态代码块只会执行一次
     */
}





/**
 * REVIEW   Throwable(最高的等级的异常)
 *
 * Throwable异常下 分为两个部分
 *
 * 1： Error  (这种为不可预见的错误)，所以不常出现，当然出现就十分严重了
 *
 * 2： Exception
 *
 * 其中主要是 Exception 又分出了  IOException   和   RuntimeException
 *
 * RuntimeException下的小异常就是本次笔记中主要介绍的常见异常
 * 包括：
 *
 *
 *
 *
 * 异常的处理机制：   抛出异常  、  捕获异常
 *
 *   异常处理：
 *
 *       Throwable：
 *              Exception：
 *                  运行型异常   ——>  1/0  ClassNotFound  、Nullpoint  、UnknowType、ArraysindexoutofBounds...
 *
 *                  检查型异常
 *
 *              Error：
 *                  AWT错误(前端push界面图，用的很少了)
 *
 *                  JVM错误     ——>StackOverFlow栈溢出(递归到死就会出现)  、OutOfMemory(JAVA内存溢出，即内存占用满了不断溢出)
 *
 *       五个关键字：
 *              try{A}        一般来说 try 和catch是一起出现的   ;  A 指的是运行的代码体，然后会判断是否会有报错
 *
 *              catch(B){}     B指的是异常，但是异常判断等级在多个catch时需要先小后大的写
 *
 *              finally{}     处理善后工作  ，可以写也可以不写
 *
 *              throw         主动/手动抛出异常    如在 一个方法里做判断 if(b==0){ throw new ArithmeticException();}  //主动的抛出异常
 *
 *              throws        方法抛出异常
 *
 *       自定义异常：
 *              背景：平时使用Java内置的异常类可以描述在编程时出现的大部分异常情况。
 *
 *              而 除此之外，一般是跟着项目团队做开源大框架项目时，用户可以自定义异常
 *
 *              用户自定义异常类，只需 继承Exception类即可
 *
 *
 *        实际应用总结：
 *              1.处理运行时异常，采用逻辑去处理规避同时辅助 try -catch处理
 *              
 *              2.在多重catch块后面，可以加一个catch(Exception)来处理可能会被遗漏的异常
 *              
 *              3.对于不确定的代码，也可以加上try-catch，处理潜在的异常
 *              
 *              4.尽量去处理异常，切忌只是简单的调用printStackTrace{}去打印输出
 *              
 *              5.具体如何处理异常，根据业务需求和异常类型决定
 *              
 *              6.尽量添加finally语句块，以达到释放占用资源的作用
 *
 *
 */



/**
 * REVIEW 常用类
 *
 * Object类：
 *
 *      hashcode()
 *
 *      toString()
 *
 *      clone()
 *
 *      getClass()
 *
 *      notify()
 *
 *      wait()
 *
 *      equals()
 *
 *
 * Math类：
 *
 *      常见的数学运算
 *
 *
 * Random类：
 *
 *      生成随机数   UUID
 *
 *
 * File类：
 *
 *      创建文件
 *
 *      查看文件
 *
 *      修改文件
 *
 *      删除文件
 *
 *
 * 包装类：
 *
 *      自动装箱和拆箱
 *
 *
 * Date类：
 *
 *      Date
 *
 *      SimpleDateFormat ：yyyy-MM-dd-HH-
 *
 *      Calendar(建议使用)
 *
 *
 * String类：
 *
 *      不可变性 final     操作量较少
 *
 *
 * StringBuffer( 多线程，数据量较大，但是效率低，安全)
 *
 *      可变长   append()
 *
 *
 * StringBuilder(单线程，数据量较大，但是效率高，相比StringBuffer没那么安全)
 *
 *      可变长
 *
 */
public class Seventh {
}