2019年8月review汇总

20190722笔记：

1.计算机程序: 程序一词来源于生活,用来描述一系列既定方式的过程;

    Java语言是用来描述计算机语言的其中一种

  Java开发技术
       JavaSE : Java基础、标准
       JavaEE : 基于企业级应用程序开发
       JavaME : 基于安卓端、游戏设备...
2.安装jdk环境变量
    jdk : 开发工具
    jre : 运行环境
    jvm : Java虚拟机

3.Java虚拟机与跨平台原理: 一次编译，随处运行
    注: 因为编译后的.class文件最终是运行在 jvm（Java虚拟机中）

4.使用记事本进行Java程序开发
    一、先创建记事本,将记事本的后缀更改成.java,再在后缀.java的文件中编写Java源程序
    二、在dos窗口下使用javac命令编译后缀.java的源文件,编译成功后会生成.class的二进制的半字节码文件
    三、使用java命令运行编译后的.class文件（.class后缀不需要写）

5.简单命令：
    javac 编译
    java  运行

6.使用eclipse开发工具进行Java程序开发
    一、先创建Java Project项目,在src源文件夹下创建Java源程序
    二、在Java源程序中编写Java代码
    三、运行编译后的.class文件

7.eclipse快速更改大小快捷键
    Ctrl + 加号=  (快速放大)
    Ctrl + 减号- (快速缩小)
    通过工具中的属性进行更改：
      window ——> Preferences ——> 搜索框中写 font ——> Colors and Fonts ——> 右边出现Basic ——> 展开点击最后一个Text

8.手写HelloWorld

显示编辑的文件的小工具:NodePad++

9.作业
    预习 第二章
    预习笔记 + ppt上的案例编码(至少写3遍)

20190724笔记：

一.变量:一个存储空间的表示
    变量组成部分:
        别名        --->    变量名
        数据值    --->    变量的值
        数据类型  ---->        变量的数据类型
  1.1.在程序使用变量
    Java是一门强数据类型语言
    数据类型有: 数值类型 和  非数值类型
    数值类型：
        整型：
            字节型  byte
            短整型  short
            整型     int [前期学习,int整型使用较多]
            长整型  long
         浮点型：
            单精度浮点型      float
            双精度浮点型    double
    非数值类型：
        字符串  String
        字符型  char
        布尔类型 boolean
二. Scanner类的使用                                    
     Scanner 作用: 从控制台接收用户输入的信息                     
      使用步骤:                                         
         1.先导包  import java.util.Scanner;               
         2.创建Scanner对象从控制台接收用户信息                        
            Scanner sc = new Scanner(System.in);      
         3.从控制台接收用户输入的信息                                
                sc.nextXxx();                             
                sc.nextDouble() : 从控制台接收的double类型的数据         
                sc.nextInt() : 从控制台接收了int类型的数据               

三. 数据类型转换
   1）自动类型转换：
     规则: 1.当表达式中的某一个操作数为double类型时,则整个表达式都提升为double类型
               2.数据类型要相互兼容
                   2.1.数值类型是相互兼容的
                   2.2.目标数据类型要大于源数据类型(比如:double类型比int类型大)
  2）强制类型转换
     语法: (数据类型)表达式
    注意: 强制类型转换会丢失数据的精确度

四、运算符的使用
    1.赋值运算符      = 
    2.算术运算符    
         +  - *  / 
          % ： 取余 
         ++ : 自增运算符
         -- : 自减运算符
    3.关系运算符
        == !=  >  < >= <=
         使用关系运算符进行比较的结果,一定是个boolean类型,boolean类型只有2个值: true和false
   4.逻辑运算符
   5.条件运算符(三元/三目运算符)
     语法:         条件成立 ? 执行结果1 : 执行结果2;
         条件运算符执行的顺序是: 如果条件成立,执行结果1 ,反之,条件不成立,执行结果2

20190727笔记：

1.&和&&的区别
  &和&&都是逻辑运算符号，&&又叫短路运算符
    区别如下
    int i=1;
    if(i==2 & i++==2){}　//i==2为false,但i++==2还会继续比较，所以i++被执行
    System.out.println(i);//i 打印出来为2
    int j=1;
    if(j==2 && j++==2){} //j==2为false,但j++==2不会继续比较，所以j++不被执行
    System.out.println(j);//j打印出来为1

    &　不管前面的条件是否正确，后面都执行
    &&　前面条件正确时，才执行后面，不正确时，就不执行，就效率而言，这个更好
    
2. short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错
       short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，需要强制转换类型）
       short s1 = 1; s1 += 1;（可以正确编译）
3.在一个问题中如果能同时使用多个if 和if-else  完成操作，你会选择什么？为什么？
       选择if-else，因为如果第一个条件满足的话后面的就不会继续判断，提高执行效率。
4.for循环的语法和执行顺序是什么？
    for(①；②；③){
        ④
    }   
        顺序为：  ① ② ④ ③
5.while  do-while  for 三种循环的语法和适用场景是什么？    
    while  语法：
        while(){}
        场景：循环次数不固定的时候使用。先判断后执行。

    do-while   语法：
          do{
        }while(条件);
        场景 ： 循环次数不固定的时候，先执行后判断。

    for :  语法   for(表达式1；表达式2；表达式3){
                执行的代码
            }
        循环次数固定的时候使用，先判断后使用。

    20190729笔记：
    1.断点调试步骤？
解：断电调试(debug)[图标：小甲壳虫]:
      使用程序调试目的：为了让一闪而过的程序，能通过断点调试逐步去执行，方便理解，观察，解决程序出现的问题。
      使用程序调试步骤：
      1.设置断点
      2.启动程序
      3.观察变量，分析问题
      4.解决问题，修改问题
      5.重新启动程序
2.双重循环特点？
解：双重循环：循环里又套用一个完整的循环结构。
    特点：外层循环执行一次，内层循环执行一遍。
3.跳转语句有哪些？以及使用场景？
    解：跳转语句的使用【使用场景】：
    1)break:循环结构中遇到break语句，将会跳出其所在的循环，执行该循环结构后的第一条语句。
    2)continue：结束本次循环，进入下一次循环的条件判断
     * break     switch,循环    遇到break跳出当前结构(switch,循环)(跳出break在的那个一层循环。不能跳出多层多个循环。)。 break结合选择结构一起使用。
    continue：遇到continue跳出当层结构，结束本轮循环，继续下一轮循环。
    //return：1)遇到return直接结束，后面的语句不会再执行了。2)遇到return 表达式，代表返回结果给调用的方法。
4.手写九九乘法表？
    解：//九九乘法表 print不换行，prinln换行
    public class Demo4 {
        public static void main(String[] args) {
            for(int i=1;i<=9;i++){
                for(int j=1;j<=i;j++){
                    System.out.print(j+"*"+i+"="+(i*j)+"\t");
                }
                System.out.println("");
            }
        }
    }
5.switch选择结构语法
解：switch (表达式) {
     case 常量 1:语句;break;
     case 常量 2:语句;break;
        …
     default:语句;
    }
  day20190731笔记：

1.数组的概念
         数组是具有相同数据类型的数据集合，相同的数据类型， 意味着数组中每个数据都是同一类型数据，或者属于基本数据类型中相同类型的数据，或者属于对象类型中相同类型的数据；如果按照维数来划分，数组可分为一维数组、二维数组和多维数组等，每一维代表一个空间的数据。
2.数组在平时的 程序代码中使用是否频繁？
         其实数组有一个缺点，就是一旦声明，就不能改变容量，这个也是其使用频率不高的原因。
3.数组有没有length()方法？String有没有length()方法？
      数组没有length()方法，有length 的属性。String 有length()方法。JavaScript中，获得字符串的长度是通过length属性得到的，这一点容易和Java混淆。
4.声明定义数组语法
解：    一维数组：数据类型[] 数组名=new 数据类型[数组长度];
    二维数组：数据结构[][] 数组名=new 数据结构[m][n];
5.手写插入算法
public class PPTTest3InsertDemo {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //创建键盘输入对象
        Scanner sc=new Scanner(System.in);
        //创建长度为6的数组
        int[] nums=new int[6];
        //通过下标赋值
        nums[0]=99;
        nums[1]=85;
        nums[2]=82;
        nums[3]=63;
        nums[4]=60;
        //定义一个变量，用来存储新增数字的下标，默认下标为最后一位。
        //循环遍历输出
        System.out.print("原数据循环遍历输出：");
        for(int i=0;i             System.out.print(nums[i]+" ");
        }
        int index=nums.length-1;
        //提示用户输入新增数字
        System.out.print("\n输入数字：");
        int num=sc.nextInt();
        //根据求最大值的方式，获取新增数字的下标
        for(int i=0;i             if(num>nums[i]){
                index=i;
                break;
            }
        }
        System.out.println("新增下标的位置是第"+index+"位");

        for(int i=nums.length-1;i>index;i--){
            nums[i]=nums[i-1];
        }
        //将新增的数字赋值给index下标
        nums[index]=num;
        //循环遍历元素后移之后的数组遍历
        System.out.println("循环遍历元素后移之后的数组遍历:");
        for(int i=0;i             System.out.print(""+nums[i]+" ");
        }
        }
}

    day20190801笔记：
1.GC是什么? 为什么要有GC
GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方， 忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。
2.解释内存中的栈(stack)、堆(heap)和静态区(static area)的用法;
    通常我们定义一个基本数据类型的变量，一个对象的引用，还有就是函数调用的现场保存都使用内存中的栈空间；    而通过new关键字和构造器创建的对象放在堆空间；程序中的字面量（literal）如直接书写的100、”hello”和常量都是放在静态区中。栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，理论上整个内存没有被其他进程使用的空间甚至硬盘上的虚拟内存都可以被当成堆空间来使用。
3.JVM内存组成结构
  JVM栈由堆、栈、本地方法栈、方法区等部分组成    
     堆： 所有通过new创建的对象的内存都在堆中分配，堆的大小可以通过-Xmx和-Xms来控制。
      堆被划分为新生代和旧生代，新生代又被进一步划分为Eden和Survivor区，最后Survivor由From Space和To Space组成。
    栈：每个线程执行每个方法的时候都会在栈中申请一个栈帧，每个栈帧包括局部变量区和操作数栈，用于存放此次方法调用过程中的临时变量、参数和中间结果。
    本地方法栈：用于支持native方法的执行，存储了每个native方法调用的状态。
    方法区：存放了要加载的类信息、静态变量、final类型的常量、属性和方法信息。JVM用持久代（Permanet Generation）来存放方法区，可通过-XX:PermSize和-XX:MaxPermSize来指定最小值和最大值。    
4.实现数组排序和查询相应元素的索引方法是什么?
         Arrays类的sort()方法实现排序功能; binarySearch()方法实现查找元素索引功能。
5.手写冒泡排序
        day20190803笔记：
1.什么是面向对象？
    面向对象是一种使用封装、继承、多态、抽象等思想进行软件的分析和开发的方法，而java就是一门面向对象编程的语言。
2.什么是类?
  现实世界是由很多对象组成的，基于对象抽出了类。
3.什么是对象?
   对象:真实存在的单个的个体，类:类型/类别，一类个体。
4.类的组成部分?
         生活中的类：根据对象相似的特征和相似的行为进行归类。例如：桌子、椅子。
         程序中的类 ：由两个部分组成：1.属性(成员变量)  ；2.方法(成员函数)
5.类和对象的关系?
   类是对象的抽象，而对象是类的具体实例。
   类是抽象的，不占用内存，而对象是具体的，占用存储空间;类和对象是抽象与具体的关系。
         day20190805笔记：   
1.包的作用
    类似操作的文件夹,为了方便管理区分同名的文件;
    创建包的关键字: package
    导包的关键字: import
    包的命名规则:
        > 包名全部小写
        > 包的命名方式采用网络倒置域名进行定义,一般包的命名层次不超过7层
            com/cn.kgc.kh76.demo
            com/cn.公司名称.部门名称.项目组.项目.个人
2.成员变量和局部变量的区别
    成员变量: 在类中直接定义的变量(属性),就叫成员变量;
    局部变量: 在方法中直接定义的变量,叫局部变量;
    区别:
        成员变量在使用前,没有赋值,Java程序会默认提供初始值;
        局部变量在使用前,没有赋值,程序直接编译错误,因为Java程序没有给局部变量
    赋初始值    
3.无参方法定义
    无参语法:
        public void 方法名(){          //无返回值方法
            //方法体
        }

        public 有返回值类型 方法名(){        //有返回值方法
            //方法体
            return 表达式;
        }
    有返回值类型: Java的8个基本数据类型、引用数据类型
4.类和对象总结
    4.1.类和对象关系: 抽象和具体的关系  
    4.2.定义类和创建对象的语法:
       定义类语法:
           public class 类名{
               //定义n个属性
               //定义n个方法
           }
    4.3.创建对象的语法:
           类名  对象名 = new 类名();
    4.4. 定义类的方法语法:
       public 方法返回值类型  方法名(){
           //方法体
       }
 
      方法返回值类型分两种情况:
      有返回值类型,定义的各种Java数据类型,强调:定义有返回值类型的方法,方法体必须return 返回
      无返回值类型  void
      4.5.方法调用
          同一个类中,相互之间直接调用方法名[ 强调: 方法之间可以直接调用方法,但不能在方法中定义方法   ]          
          不同类中,必须先创建对象,然后对象名.方法名() 调用 
5.有参方法定义 
     定义有参方法语法: 
         访问修饰符  返回值类型  方法名(形参列表){
             //方法体
         } 
     调用有参方法语法:
         不同类中,对象名.有参方法名(实参);         
     定义无返回值类型的有参方法:
         public void 方法名(数据类型 参数名1,数据类型 参数名2,...,数据类型n 参数名n){
             //方法体
         }
     定义有返回值类型的有参方法:
         public 有返回值类型  方法名(数据类型 参数名1,数据类型 参数名2,...,数据类型n 参数名n){
             //方法体
             return 表达式; 
         }         
 形参和实参概念:
     形参:形式上的参数,定义方法时传递的参数,由数据类型 参数名组成;
     实参:实际参数,调用方法时传递的参数,只有参数名;      
 强调注意: 调用方法时,实参列表必须和形参列表的个数、顺序、数据类型保持一一对应。

         day20190807笔记： 

    ！！！背书，画关键词，关键词必须记得。
1.定义有参方法
    语法: 访问修饰符   返回值类型  方法名(){
            //方法体
         }
2.使用构造方法赋值
    构造方法语法:
        访问修饰符  类名(){
            //方法体
        }     
       特点: 与类同名,没有方法返回值类,连void也没有
      作用:　赋初始值　和　创建对象,并赋值  
  强调:  当程序没有显示的定义了有参构造方法时,系统会默认提供无参构造方法;
       当程序显示定义了任意有参构造方法时,系统不会默认提供无参构造方法;
       建议程序在定义有参构造方法时,一定显示定义无参构造  
3.对象赋值的两种方式
    一、通过对象名.属性  赋值
    二、 通过有参构造方法赋值
4.方法重载: 同类,同名,不同参;
 完整概念:  同一个类中,方法名相同,形参的参数列表不同,与返回值类型和访问修饰符无关。 
     构造方法是特殊的方法重载; 
5.this的使用
    this:当前对象的引用;    
    this.属性;
    this.方法();
    //调用构造方法,注意调用的构造方法必须放在首行,且构造方法的调用只能在构造方法中执行
    this();        
6.值传递和引用传递的区别
     值传递的参数过程,是将值从一个参数传递给另一个参数,另一个参数的更改不会影响原先的参数;
     引用类型(数组、对象、接口)参数传递,是将当前对象引用由一个参数传递一个另一个参数,说白,它们操作的是
 同一份地址引用,另一个参数的更改会影响原先的参数; 
 强调注意:  String除外,传递的参数是String类型,将String参数传递作为值传递进行操作。

         day20190809笔记： 
    1. 面向对象3大特性: 封装、继承、多态
    封装
        概念: 隐藏程序内部的具体实现细节,对外提供接口,从而提高程序的安全性,
    以及高内聚、松(低)耦合
    
        使用封装的步骤:
            一、属性私有化,使用private访问修饰符进行修饰
            二、对外提供getter/setter方法,getter获取值,setter设置值
            三、在setter语句中进行逻辑语句控制判断
    继承
        目的: 减少代码量,方便后期维护、修改
        符合继承的关系: is-a
        如何使用继承:
            将多个程序类中的共同的特征抽取出来,形成一个公共的类,这个公共的类就叫父类;
            实现继承这个公共的父类的程序类,就叫子类;
        继承的语法:
            访问修饰符  class 子类   extends 父类{
                //成员
            }
        强调: 使用继承的关键字 extends
        
    》》 子类继承父类后构造的执行顺序: 一定是先父类再子类
        当子类构造没有显示调用父类任意构造方法时,系统会默认隐式调用父类无参构造方法;
        当子类构造显示调用了父类任意构造方法时,系统就不会默认隐式调用父类的无参构造方法,
    此时,程序执行时,只会调用执行子类构造调用的对应父类构造方法,且该调用的构造方法必须放在首行
 1.1.访问修饰符的使用
    public          公共的,范围最大
    protected        受包保护的
    默认的(friendly)  默认访问修饰符,不可显示定义
    private            私有的,范围最小,只能在本类被访问到

2.方法小结
    普通方法:
        无参无返回值方法
            public void 方法名(){
                //方法体
            }
        无参有返回值方法
            public 返回值类型 方法名(){
                //方法体
                return 表达式;
            }
        有参无返回值方法
            public void 方法名(数据类型  参数1,...,数据类型n 参数n){
                //方法体
            }
        有参有返回值方法
            public 有返回值类型  方法名(数据类型  参数1,...,数据类型n 参数n){
                //方法体
                return 表达式;
            }
    构造方法
        语法:
            访问修饰符  类名( ){ }
        
    静态方法static

         day20190810笔记：

1.所有类的基类是Object;
  Java是单根继承,子类只有一个直接父类,
  但Java有传承性,子类可以有多个间接父类;
2.使用继承之后,子类不能继承父类哪些成员:
    一、private私有化的
    二 、构造方法
    三、不同包中,默认访问修饰符修饰的成员
    
3.static 关键字的使用
    被static修饰的变量叫静态变量或者类变量;
    被static修饰的方法叫静态方法或者类方法;
    被static修饰的代码块,叫静态代码块;

强调: 
    被静态修饰的成员,直接通过  类名.成员(属性、方法);
    
    静态修饰的成员和非静态修饰的成员区别:
        静态成员可以在静态方法和实例方法中被调用;
        实例成员只能在实例方法中被调用,静态方法中不能【直接】调用非静态的成员;
3.1.static关键字的使用场景
    数据共享时,就可定义static进行修饰;  (比如: 自己杯子中的水定义成变量; 饮水机中的水是共有的,使用静态变量修饰 )
    数据不经常更改时,可定义成final进行修饰;
    当数据既是共享的又不易于更改时,就可定义成静态常量;    
3.2.静态变量和实例变量区别
    一 、所属性质不同: 静态变量属于类; 实例变量属于对象;
    二、 生命周期的不同: 静态变量根据类的消失而消失,实例变量是随着对象的消失而消失;
    三 、内存存储位置不同:静态变量存储在静态区,拷贝值只有一份;
                       实例变量存储在堆栈中,拷贝值可以有一份或者多份;
    四、调用实现的方式不同: 静态变量可使用  类名.静态变量或者 实例化对象,通过对象名.静态变量;(强烈建议使用 类名.静态变量);
                    实例变量,通过实例化对象名.实例变量 操作;
4.abstract关键字的使用
    被abstract修饰的类,叫抽象类;
    被abstract修饰的方法,叫抽象方法;
    抽象类不能被实例化;
    抽象方法没有方法体;
    抽象类中可以定义0~多个抽象方法,继承抽象类的子类,
该子类必须实现抽象父类中所有的抽象方法,除非该子类也是一个抽象类;
    抽象方法必须在抽象类中;
抽象类的使用场景:
    父类没有必要实现方法的具体细节;
    父类强制要求子类必须实现的功能方法;
5.方法重写
    实现方法重写的前提条件,一定发生在 父子类中,方法重写的前提必须存在继承关系;
    概念: 不同类中,方法名相同,参数列表相同,
        子类的访问修饰符不能严格于父类,
        子类的方法返回值类型与父类的方法返回值类型要么相同,要么是其子类;
    简写: 不同类,同名,同参,与方法返回值类型和访问修饰符有关;
注: 
    子类重写父类的常见方法:
        toString()、equals()
6.方法重载: 同类,同名,不同参,与方法返回值类型和访问修饰符无关;

             day20190812笔记：

1.面向对象的3大特性
    封装   继承   多态   
2.多态
2.1.概念:
    生活: 同一种事物,根据条件的不同,展现不同的形态体现
            100度以上        水蒸气
        水    常温下             水
            0度以下        冰
    程序: 同一个对象引用,根据不同的实例对象操作,所展现的不同结果
2.2.实现多态的前提条件:
    一 、 必有 继承关系
    二 、 必出现 方法重写
2.3.实现多态的方式
    一、以父类作为方法形参,实现多态
    二、以父类作为方法返回类型,实现多态
2.4.面向对象阶段的数据类型转换
    向上转型(小转大): 父类对象引用指向了子类实例化对象,执行实现方法重写
    向下转型(大转小): 父类对象引用不能调用子类特有功能方法时,此时就需要使用向下转型
2.5.使用多态的好处
    提高程序的可维护性、扩展性 、可重用性    
    扩展性:额外添加新的功能模块时,不会影响原先的程序
作业:
    汽车租赁系统
                 day20190814笔记：
    1、面向对象的3大特性
    封装        继承        多态
    电子宠物商城        宠物类   父类
                    昵称          
                    健康值        
                    亲密度
                extends      实现继承的前提条件符合 is-a关系               
                        鸟类
                        飞的方法
                            
    狗狗            企鹅              猫            麻雀        老鹰        喜鹊              飞机    超人      火箭
    品种             性别                颜色            重量        形状        颜色        
2.接口：    根据业务需求产生了一些公共的特性行为时,但这些公共的特性行为抽取出来之后,形成了一个公共类,让其他子类去继承,又不符合 is-a的关系,此时,需将这些公共的行为抽取出来形成接口,
实现接口的前提条件 符合 has-a的关系。
3.什么是接口?如何定义?
    3.1.接口提倡的是一种能力、约定;
    3.2.定义接口的关键字: interface;
    3.3.实现接口的关键字: implements
    3.4.接口中可以定义哪些成员: 
        公共的静态常量
        公共的抽象方法
    3.5.定义的接口可以继承多个接口,中间 用逗号隔开,
所以,从继承多个接口的角度看,Java也属于多继承
    3.6.接口特性
        一、定义接口关键字 interface,实现接口关键字 implements
        二、接口不能被实例化
        三、接口中只能定义公共的静态常量和公共的抽象方法
        四、接口和接口之间可以多继承,中间用逗号隔开
        五、实现类必须实现接口中所有的抽象方法,实现类可以实现多个接口,中间用逗号隔开。

                 day20190815笔记：

1.异常
    生活中,产生的一些突发状况,影响后续生活正常进行;
    程序中,程序在运行的过程中产生的突发情况,会影响终止程序运行;
    
2.解决程序中的异常(突发情况的)情况
    Java程序提供了 异常处理机制 进行解决程序异常;
    使用Java程序提供的异常处理机制的流程是:
        在程序运行时,先提前预估设定好程序可能出现的异常情况,
当程序在运行的过程发生了异常情况,通过异常处理机制进行处理,
处理完之后,程序继续正常执行

3.使用异常处理机制解决问题的常用关键字:try、catch、finally、throw 、throws
    try-catch-finally 作用:用来处理异常,捕获异常
    try            执行可能会出现异常的编码    
    catch        捕获出现的异常
    finally        不管是否出现异常情况,finally都会被执行
强调: 以上三个关键字可组合使用的场景:
    try{
        //执行可能会出现异常的编码
    }catch(异常信息){
        //处理异常
    }
    
    try{
        //执行可能会出现异常的编码
    }finally{
        //不管是否出现异常情况,finally都会被执行
    }

    try{
        //执行可能会出现异常的编码
    }catch(异常信息){
        //处理异常
    }finally{
        //不管是否出现异常情况,finally都会被执行
    }
注意:使用try-catch-finally 执行程序运行的情况分类:    分3种
    一、 程序运行时没发生异常情况,执行try-finally之后,程序正常结束    
    二、程序运行时发生异常情况,并捕获住了异常情况,执行try-catch-finally之后,程序正常结束
    三、程序运行时发生异常情况,但catch代码块没有捕获住该异常情况,执行try-finally之后,程序异常终止结束
    
    throw
    throws : 声明异常,也是异常处理
    throws声明异常的语法:
        方法名( )  throws 异常类1,...,异常类n
4.异常处理的方式
    try-catch    异常处理,自己定义功能,自己处理捕获异常
    throws         声明异常,自己定义功能,不主动处理捕获异常,
                让调用者进行处理(执行try-catch),
                如调用者也不处理异常,则再接着往上一层声明异常,
                声明异常的最顶层方法就是main方法程序入口,则有jvm(Java虚拟机)帮忙处理异常
5.日志配置文件(log4j)
    作用/目的: 将程序每时每刻的执行流程(过程)通过文件的形式保存、记录下来,
方便后期程序的维护
注：
    jar: jdk开发工具本身不具备的功能,其他插件提供的,jar也是用Java程序开发出来的
    lib包: 专门用来存放jar包的
    .properties: 专门编写配置文件信息的
创建log4j日志配置文件步骤:
    1.先添加log4j的开源jar包,将log4j的jar包加载到项目中
    2.创建后缀.properties配置文件,并进行编写日志配置文件信息
绿皮书：14,15,17

                day20190817笔记：

1、集合框架: Java提供了一套性能优良的接口和实现类,
位于 java.util 包中
Collection接口:    是List接口和Set接口的父接口;
    Collection接口中存储的是不唯一(可重复的)、无序的数据;
        List接口存储的是不唯一、有序的数据;
        Set接口存储的是唯一(不可重复)、无序的数据;
2.List接口下常用的实现类
ArrayList实现类:也叫动态数组,ArrayList改善优化了数组的缺点,
使用ArrayList实现类存储数据时,不需要指定长度(大小),程序默认初始开辟了10个容量大小,
后期会随着数据的添加动态扩容当前容量大小的1.5倍;
ArrayList的优点:循环遍历和随机访问数据的效率高;
ArrayList常用方法:
    boolean add(Object o)    在列表的末尾顺序添加元素，起始索引位置从0开始
    void add(int index,Object o)    在指定的索引位置添加元素。索引位置必须介于0和列表中元素个数之间
    int size()    返回列表中的元素个数
    Object get(int index)    返回指定索引位置处的元素。取出的元素是Object类型，使用前需要进行强制类型转换
    boolean contains(Object o)    判断列表中是否存在指定元素
    boolean remove(Object o)    从列表中删除元素
    Object remove(int index)    从列表中删除指定位置元素，起始索引位置从0开始
     注: ArrayList的底层结构是数组;
LinkedList实现类:底层是链表结构; 因为LinkedList实现类底层是双向链表结构,它没有初始容量,也不会自动扩容大小,它只根据双向链表的结构前后进行操作。
    LinkedList实现类特有的方法:
    快速添加、获取、删除:
        LinkedList集合对象名.addFirst(对象元素);/LinkedList集合对象名.addLast(对象元素);
        LinkedList集合对象名.getFirst();/LinkedList集合对象名.getLast();
        LinkedList集合对象名.removeFirst();/LinkedList集合对象名.removeLast();
    LinkedList实现类优点:新增、删除元素效率高;
3.Set集合框架接口
    Set接口没有下标,所以就不能使用 get(index)的方法获取存储在Set集合框架中的元素;
    Set接口下的实现类:
        HashSet实现类:底层结构是哈希表;HashSet默认初始容量（16）是根据HashMap实例为背景参照;
        TreeSet实现类:底层结构是二叉树(红黑树);
4.迭代器的使用
    专门针对集合框架诞生的
   常用的迭代器的方法:
           hasNext() : 判断访问获取下一个元素是否存;
           next(): 获取下一个元素
5.Map接口集合框架 : 键值对(key-value)数据存储,使用Map集合框架
    Map接口的实现类:
        HashMap实现类: 底层结构基于 哈希表+动态数组+双向链表,默认初始容量大小16
    Map接口的常用方法:
        Object put(Object key, Object val)    以“键-值”对的方式进行存储
        Object get(Object key)    根据键返回相关联的值，如果不存在指定的键，返回null
        Object remove(Object key)    删除由指定的键映射的“键-值对”
        int size()    返回元素个数
        Set keySet()    返回键的集合
        Collection values()    返回值的集合
        boolean containsKey(Object key)    如果存在由指定的键映射的“键-值对”，返回true
弄懂思路。
get是获取， set是设置，需要一个变量传递。
弄懂。
@全体成员 背诵面试宝典小绿书18、19、20、21、22、23
背诵，记住最重点的关键字。
  day20190819笔记：

实用类

1：枚举

enum 的全称为 enumeration， 是 JDK 1.5  中引入的新特性，存放在 java.lang 包中。

JDK1.5 之前，我们定义常量都是： public static fianl.... 现在又有了枚举，可以把相关的常量分组到一个枚举类型里，

枚举指由一组固定的常量组成的类型;

可以将枚举看成一种特殊的类，枚举的思想很简单，也很方便：它代表了一组固定的常量值。

声明枚举时必须使用 enum 关键字，然后定义枚举的名称，枚举声明的语法如下：

 

Public  enum  enumname{

    enum-body, //一般写常量

}

经典案例：使用枚举描述星期

public void doWhat(int day){

 

switch (day) {

case 1:

case 2:

case 3:

case 4:

case 5:

System.out.println("工作日，敲代码");

break;

case 6:

System.out.println("周六，继续代码");

break;

case 7:

System.out.println("周日，先睡觉，在敲代码");

break;

 

default:

System.out.println("你写错了，赶紧回去写代码");

break;

}

}

 

public static void main(String[] args) {

 

Test t = new Test();

t.doWhat(1);

 

另外一种方式：使用枚举

 

 

 

 

 

 

2：包装类

1：包装类介绍

Object 类中提供了很多有用的方法，这些方法只有对象才能调用，

基本数据类型不是对象，java中的基本数据类型int，double等不是对象，无法通过向上转型获取到Object提供的方法，而像String却可以，只因为String是一个对象。基本数据类型由于这样的特性，导致无法参与转型，泛型等过程。为了弥补这个缺陷，java提供了包装类。

Java为每种基本数据类型分别设计了对应的类，称之为包装类。

简单的理解：Java中的基本类型功能简单，不具备对象的特性，为了使基本类型具备对象的特性，所以出现了包装类，就可以像操作对象一样操作基本类型数据。

 

基本数据类型及对应的包装类
基本数据类型	对应的包装类
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

每个包装类的对象可以封装一个相应的基本类型的数据；

所有包装类都可将与之对应的基本数据类型作为参数，来构造它们的实例:

如：

Integer in = new Integer(12); // 创建了一个整数类型的对象，其值为12

注意：

 

Boolean类构造方法参数为String类型时，若该字符串内容为true(不考虑大小写)，则该Boolean对象表示true，否则表示false

当Number包装类构造方法参数为String 类型时，字符串不能为null，且该字符串必须可解析为相应的基本数据类型的数据，否则编译不通过，运行时会抛出NumberFormatException异常

2：包装类的常用方法

1：基本数据类型与包装类的转换

基本类型和对应的包装类可以相互装换：

1. 基本类型转为包装类称为装箱，例如把 int 包装成 Integer 类的对象；使用包装类的构造方法;或者使用valueof（）

 

1. 包装类转为基本类型称为拆箱，例如把 Integer 包装类型转为 int ; 使用intValue();

 

2：toString 基本类型->字符串

toString(): 以字符串形式返回包装对象表示的基本类型数据（基本类型->字符串）

String str = Integer.toString(88);

String str2 = Double.toString(88.9);

 

3：parseXXX(), 字符串->基本类型

parseXXX()：把字符串转换为相应的基本数据类型数据（Character除外）（字符串->基本类型）

long long1 = Long.parseLong("123");

boolean b = Boolean.parseBoolean("true");

 

4：valueOf(), 基本类型->包装类

所有包装类都有这样的方法：valueOf(type value)；作用是将一个基本类型转换为包装类；

Integer in = Integer.valueOf(12);

Double valueOf = Double.valueOf(12.3);

Boolean valueOf2 = Boolean.valueOf(true);

3：装箱和拆箱

1. 基本类型转为包装类称为装箱，
   1. 例如把 int 包装成 Integer 类的对象；使用包装类的构造方法;valueOf()方法
2. 包装类转为基本类型称为拆箱，
   1. 例如把 Integer 类的转为 int ; 使用intValue();

自动装箱：Integer i = 12;

自动拆箱：int num = i;

4：Math

Java的Math类封装了很多与数学有关的属性和方法。

Abs - 求绝对值

Max/min - 最大值最小值

random() - 生成一个0-1之间的随机数

 

 

5：Random 类介绍

Java语言中，随机数的产生是由类库中的Random类实现的。Random类是一个随机数产生器，构造方法Random()中使用当前的时间来初始化Random对象，因为没有任何时刻的时间是相同的，所以可以减少随机数序列相同的可能性。

Random rand = new Random();

int n=rand.nextInt();//生成一个整数类型的随机整数

 

Random类的nextInt()方法还可以在有限范围内产生随机数，其方法声明为：

public int nextInt(int n);

该方法返回一个伪随机数，它是从此随机数生成的序列中取出的、【0，n）之间均匀分布的整型值

6：String

字符串是java中使用最频繁的一种类型，使用String来表示。

注意：字符串是常量；它们的值在创建之后不能更改。

常用方法：

length() - 求字符串的长度

Equals() - 比较两个字符串是否相同

equalsIgnoreCase() - 忽略大小写比较

toUpperCase() - 转换为大写

toLowerCase() - 转换为小写

concat() - 字符串链接

public String[] split(String regex)：根据给定表达式的匹配拆分此字符串

 

 

 

 

方法名	说明
public int indexOf(int ch)	搜索第一个出现的字符ch（或字符串value），如果没有找到，返回-1
public int indexOf(String value)
public int lastIndexOf(int ch)	搜索最后一个出现的字符ch（或字符串value），如果没有找到，返回-1
public int lastIndexOf(String value)
public String substring(int index)	提取从位置索引开始的字符串部分
public String substring(int beginindex, int endindex)	提取beginindex和endindex之间的字符串部分
public String trim()	返回一个前后不含任何空格的调用字符串的副本

 

 

作业：

1：完成用户登录的功能，用户名为：lili, 密码为：123456

只有用户名和密码完全正确的情况下才能登录成功

2：提交作业系统，只能提交java文件，只有邮箱正确了才能提交，成功后提示作业提交成功

否则给出对应的错误提示如下：

提示：使用lastIndexOf完成文件后判断

 

3：切割字符串练习

 

 

 

4：统计一个字符串出现的次数

 

 

5：如下图

 

  day20190822笔记：

一、IO文件流
1.二进制文件输入/输出流
作用: 操作视频、音频、图像等
    DataInputStream
    DataOutputStream
2.序列化和反序列化
作用:用来操作存储的对象数据;
  序列化: 将程序中的对象数据写到指定磁盘中;
  反序列化:将指定磁盘中的对象文件读取到程序中; 
  二、 XML:可扩展标记语言,侧重点在于数据交互、存储、共享
    Html:超文本标记语言,侧重点在于数据显示,更友好的显示
2.1.如何定义xml
举例：

     
         <三国演义>
         罗贯中
         888
         三个国家打架的故事
     

xml的组成部分:
    标签元素:  
    文本元素: 在开始标签和闭合标签之间写到内容
    属性元素: 在标签内部定义的元素,由 属性="属性值" 组成

2.2.使用Java程序解析xml文件
    使用dom4j解析xml文件步骤:
        一、添加dom4j的jar,并将该jar包添加到项目中
注:
    使用原生dom解析xml文件,代码量多,方法繁琐, 基于原生dom封装了dom4j插件,
使用dom4j解析xml文件编码步骤相对少,方法简单有规律;    

  day20190824笔记：

1.什么是Java集合API？
答：Java集合API是用来表示和操作集合的统一框架，包括接口、实现类以及帮助程序员完成一些编程的算法。
2.Java集合框架的接口有哪些？
答:具体来说，Java集合框架有6个集合接口，最基本的是Collection接口，由三个接口Set、List、SortedSet继承，另外两个
接口是Map、SortedMap，这两个接口不继承Collection，表示映射而不是真正的集合。Collection为集合层级的根接口。
一个集合代表一组对象，这些对象即为它的元素。Java平台不提供这个接口任何直接的实现。  Set是一个不能包含重复元素
的集合。这个接口对数学集合抽象进行建模，被用来代表集合。  List是一个有序集合，可以包含重复元素。可以通过它的索
引来访问任何元素，更像长度动态变换的数组。Map是一个将key映射到value的对象.一个Map不能包含重复的key。

3.Iterator是什么？
答：Iterator接口提供遍历任何Collection的接口。我们可以从一个Collection中使用迭代器方法来获取迭代器实例。迭代器
取代了Java集合框架中的Enumeration。迭代器允许调用者在迭代过程中移除元素。

4.Iterator和Listlterator的区别是什么？
答：（1）Iterator可以遍历Set和List集合，而ListIterator只能遍历List。 
       （2）Iterator只可以向前遍历，而LIstIterator可以双向遍历。  
       （3）ListIterator从Iterator接口继承，然后添加了一些额外的功能，比如添加一个元素、替换一个元素、获取前面或后
面元素的索引位置。

5.对比HashMap和HashTable？
答：两者都是用key-value方式获取数据。Hashtable是原始集合类之一（也称作遗留类）。HashMap作为新集合框架的一
部分在Java2的1.2版本中加入。它们之间有以下区别：  
（1） HashMap允许key和value为null，而HashTable不允许。  
（2）HashTable是同步的，而HashMap不是。所以HashMap适合单线程环境，HashTable适合多线程环境。  
（3）HashMap提供对key的Set进行遍历，因此它是fail-fast的，但HashTable提供对key的Enumeration进行遍历，它不
支持fail-fast。
 （4）HashTable被认为是个遗留的类，如果寻求在迭代的时候修改Map，应使用CocurrentHashMap。

6.如何决定选用HashMap还是TreeMap？  
答：对于在Map中插入、删除和定位元素这类操作，HashMap是最好的选择。然而，假如你需要对一个有序的key集合进行
遍历，TreeMap是更好的选择。基于你的collection的大小，也许向HashMap中添加元素会更快，将map换为TreeMap进
行有序key的遍历。   

7.在HashTable中上下文同步是什么意思？  
答：同步意味着在一个时间点只能有一个线程可以修改哈希表，任何线程在执行hashtable的更新操作前需要获取对象锁，其
他线程等待锁的释放。  

8.哪些集合类提供对元素的随机访问？  
答：ArrayList、HashMap、TreeMap和HashTable类提供对元素的随机访问。   

面试宝典默写：
明天不默写面试宝典，默写咱前面学过的内容

1.Arraylist和linkedlist的区别

答：
2.string的常用方法？
答：
3.什么是序列化和反序列化

答： 序列化和反序列化操作
  作用:用来操作存储的对象数据;
  序列化: 将程序中的对象数据写到指定磁盘中;
  反序列化:将指定磁盘中的对象文件读取到程序中; 
      序列化 ObjectOutputStream 输出流
      反序列化 ObjectInputStream 输入流
强调注意:
 操作对象数据文件的当前类，必须实现序列化接口 Serializable
     实现序列化步骤：
         1.创建对象,并实现序列化接口 Serializable
        2.使用多态,创建字节输出流对象
        3.创建序列化对象(ObjectOutputStream)
        4.使用序列化对象名.writeObject(obj)将对象数据写到指定磁盘中
        5.关闭对应的所有文件流,遵循先开的后关步骤
     实现反序列化步骤：
        1.创建对象,并实现序列化接口 Serializable
        2.使用多态,创建字节输入流对象
        3.创建反序列化对象(ObjectInputStream)
        4.使用反序列化对象名.readObject()将磁盘中的对象文件读取到程序中
        5.关闭对应的所有文件流,遵循先开的后关步骤
4.实现反序列化的步骤

5.xml的组成部分
 答：    标签元素:  
    文本元素: 在开始标签和闭合标签之间写到内容
    属性元素: 在标签内部定义的元素,由 属性="属性值" 组成
 day20190826笔记：

day20190826笔记：
 day20190831笔记：

CSS笔记：

1.代码管理使用方式
    git 代码管理工具
    gitHub 代码管理平台(国外,服务器在国外,该代码管理平台都是英文)
    码云(中国的gitHub)
1.1. 通过git代码管理工具下载命令
     git clone  提供的链接地址
2.盒子模型
    标签(盒子):所有的标签默认都会有一定的内外边距;
    外边距(margin):标签之外的空白和间隙;
    内边距(padding):自身标签内部的空白和间隙;

3.盒子模型相关的样式
    margin 外边距  、 padding 内边距、                      
    list-style: none 样式列表 、    
    display: inline-block  行内块元素
    border: 1px solid green 盒子边框               
     box-sizing: border-box 是否计算额外盒子边框宽高            

    border-radius 圆角边框

    cursor: pointer; 将鼠标悬浮在li标签上时的鼠标箭头更改成小手形状

    box-shadow:[inset] 水平(x)轴    垂直(y)轴  盒子阴影的模糊度   盒子阴影的颜色;

4.浮动
    标准文档流: 网页布局时,会根据块级元素和行内元素的
特点从上至下按照瀑布式的方式进行排版布局(在网页中都是占用实际排版位置的),
该排版布局方式也是网页布局的默认排版方式;

注: 设置标签元素的浮动时,此时该元素会脱离标准文档流;
    脱离标准文档流: 排版布局时,在网页中不占用实际排版位置;

4.1. 使用浮动的缺点:    
        一 、 设置标签元素的浮动时,该元素会脱离标准文档流;
        二 、 出现父级容器边框塌陷

4.2.解决浮动导致的父级边框塌陷
    一 、设置固定高度(height),缺点是在频繁的调试高度
    二 、设置自适应高度,overflow:hidden属性,后期建议网页布局使用overflow:hidden设置自适应高度;
        注: overflow:hidden 的使用方式:
            方式一: height:指定高度 ; 和 overflow:hidden;一起使用,
                overflow:hidden; 该样式属性作为  裁剪使用;
            方式二: height:指定高度 ; 和 overflow:hidden;不同时出现使用,
                overflow:hidden;作为自适应高度;

5.html5/CSS3的新特性,flex属性
    display: flex; 使用方式:
    在父级容器上设置,和使用浮动一样的效果,
但display: flex;还在标准文档流中;

day20190902笔记：

1.定位元素
    相对定位 relative : 还在标准文档流中
    绝对定位absolute:设置绝对定位的元素会脱离标准文档流的
    固定定位fixed

设置绝对定位元素的规则:
   1.设置绝对定位的元素会脱离标准文档流,结合偏移量一起使用时,默认会根据浏览器的左上角进行移动,且原来的位置不会保留。
   2.如设置定位元素的子标签元素能找到基于子元素的父级定位元素,则设置的偏移量就会根据它最近的父级定位元素进行偏移。
设置相对定位：
                    设置定位的元素标签元素,得结合偏移量一起使用;
                    定义的相对定位元素结合偏移量根据浏览器的左上角进行移动。

  day20190905笔记：JavaScript_Chapter01_20190905

1.JavaScript: 是基于对象和事件驱动,具有安全性的一门浏览器脚本语言,也是一门弱类型语言,
简称js,js语法和Java类似,是一门解释性语言,属于边执行边解释的;

2.网页结构组成
    Html       CSS       JavaScript
    结构            样式          行为

3.JavaScript组成部分
    ECMAScript : js的前身 
    BOM : 浏览器对象模型
    DOM : 文档对象模型
    
4.使用js基本结构以及使用方式
    //行内js定义
    普通按钮,点击弹框

    //内部js定义
    
    
    //外部js定义
    
    
    
5.js的核心语法
    变量  
    数据类型
    运算符
    数组
    控制语句
    输入/输出
    注释
    语法规定
    
6.js的函数分: 系统函数 、自定义函数
    定义函数语法:                     
        function 函数名(){        
            //js语法             
        }                      
    调用函数语法:  事件名称 = 函数名();      
7.js的调试
    编译错误
    逻辑错误