byte 字节型 范围 -128——127  1字节
                        short 短整数型 正负3万左右   2字节
                        int 整形 范围 正负21亿左右  4字节
                        long 长整数型         8字节
                        boolean 布尔型 true(对) false(错)       
                        浮点型(小数型) float          double
                        定义变量格式： 数据类型  变量名 = 想要赋的值；
                        算术运算符：+(加号 相加 连接字符串) -(减号 相减) *(乘号 相乘) /(除号 相除) %(取模 相除后取余数) 变量名++  ++变量名
                        --变量名 变量名-- (如果++或者--在前面 那么这行代码运行前先加上1或者减1再调用， 如果是++或者--在后面先调用完这行代码再加1或者减1)
                        赋值运算符：+= -= *=  /= %=  列：a+=1  等价于 a=a+1
                        比较运算符(得到的返回值都是布尔类型)：==(比较两遍是否相等) >(大于)  <(小于) <=(小于等于) >=(大于等于)  !=(不等于)
                        逻辑运算符 (返回值也都是布尔类型)  &&(并且 两边条件都满足返回值为true) ||(或，两边只要有一边条件满足就是true) ！(取反，只要加了这个符号 原本是true 用了就变成false)
                        三元运算符(可以用if语句无损调换) 需要变量接受  数据类型 变量名= 判断条件？选项A：选项B;
                       
                        注：逻辑运算符 执行第一边条件判断 已经满足或者不满足时 后面的将不再运行
                       
                       
                       
                        方法：
                       
                       
                       
                        方法定义：
                        一般静态方法：public static 返回值 方法名(){
                                return 返回值;
                        }
                       
                       
                        方法的重载：方法名一样  但是参数不同(可以是个数 也可以是类型不同，只要符合一点就是方法重载，与参数名称无关，与返回值类型无关)
                       
                       
                       
                       
                       
                       
                       
                       
                       
                        判断格式语句：
               
                        if(判断条件){
                                如果条件成立执行这里，条件不成立 继续执行下一行代码}
                       
                        标准if语句
                        if(判断条件){
                                语句体1(条件成立执行这里)
                        }else{条件不成立执行这边        }
                       
                        扩展if语句
                       
                        if(条件判断){
                                条件成立运行语句体1
                                则不运行下面代码
                        }else if(条件判断){
                                        条件成立运行语句体2
                                则不运行下面代码
                        }else if(条件判断){
                                        条件成立运行语句体3
                                则不运行下面代码
                        }else{结束语句，收尾语句，可以省略}       
                       
                        switch选择语句
                       
                        switch(表达式){
                                case 常量值1：
                                语句体1;
                                break;
                               
                                case 常量值2：
                                语句体2;
                                break;
                               
                                case 常量值3：
                                语句体3;
                                break;
                               
                                ........
                               
                            default
                            语句体;
                            break       
                        }
                        当表达式与case后面的常量值相等时，将会运行满足case的语句体，如果都不满足 就运行 default 下的语句体
                        注：switch 语句下的判断顺序可以颠倒 当如果满足case条件 但是case条件下没有写 break 将会穿透下个case 直至碰到break;
                       
                        循环控制语句： break  (遇到break语句退出当前循环)
                                      continue (遇到continue 会跳出本次循环 )
                       
                       
                       
                       
                        循环语句：
                       
                        for 循环语句(一般使用于循环次数已经确定的情况下)
                       
                        for(初始化语句(定义初始化变量);条件判断;步进语句(定义的变量++)){
                                循环体
                        }
                        注： 初始化语句 和步进语句可以不写.
                       
                        while 循环语句 (一般使用于循环次数不确定的情况下)
                       
                       
                        初始化语句
                        while(条件判断){
                                循环体
                                步进语句
                        }
                       
                       
                        do while 语句(至少执行一次)
                       
                        初始化语句
                        do{
                                循环体
                                步进语句
                        }while(条件判断)
                       
                        数组的三种初始化：
                        动态创建(指定长度)：
                        数据类型[]  数组名 = new 数据类型[数组的长度];
                       
                        静态创建(指定数组的内容):
                        数据类型[] 数组名= new 数据类型[]{元素1,元素2,元素......}
       
                       
                        静态的省略格式
                    数据类型[] 数组名={元素1,元素2,元素3........}
                       
                        数组元素的获取
                       
                        如果直接打印数组的名字获取到的将是数组的地址值
                       
                        要访问数组内的元素的格式是:
                       
                        数组名[数组的索引值]  数组的索引值是从0开始的
                       
                        要给数组内元素赋值的格式是：
                       
                        数组名[数组的索引值]=要赋的值;  注：如果是动态数组，那么创建完毕后数组都有默认值 整数型为0 浮点为0.0  字符类型为\u0000 如果为布尔类型为false 如果是引用类型那么为null;
                        如果数组作为方法的参数 其实传递的是数组值，如果作为方法的返回值，返回的也是地址值。
                        如果一个方法想有多个返回值是可以用数组进行返回。
                       
                       
                        面向对象： 强调对象 关注对象的功能.
                        面向过程： 强调过程 每一个步骤都亲力亲为.
                       
                        类的定义：类是相关的 行为和 属性的集合  属性：状态信息(成员变量)  行为：该事物能做什么(成员方法);
                        类是对象的抽象化 ，对象是类的实例化;
                       
                        创建对象的格式:  类名 对象名=new 类名();
                        两个对象如果使用同一个地址值的话,内容会共享
                        如果将类作为方法参数或者返回值，传递 或者返回的都是地址值;
                       
                        成员变量和局部变量的区别：
                        定义位置不同        成员变量定义在类中 方法外
                                            局部的变量定义在方法内
                        作用的范围不同                 成员变量可以作用整个类中
                                            局部变量作用在定义的方法内 方法外不能使用
                                                               
                        java封装的体现： 方法本来就是一种封装
                        面向对象封装的体现：
                        private 也是一种封装的方法                                
            使用方法 ：变量名前加上private                       
                       
                        this 关键字：
                        当局部变量与成员变量冲突时 可以用this修饰  使用格式：
                        this.成员变量名
                        this.成员方法名
                        this.构造方法
                       
                        super 关键字
                        当局部变量或者本类的变量，还有父类变量冲突时  可以用this. 和super. 修饰
                        super.成员变量名
                        super.成员方法名
                        super.构造方法
                       
                        一个标准类(java bean)
                        需要有 用private 修饰过的成员变量
                        有有参和无参的构造方法
                        get set方法;
                       
             API使用方法：
                         1搜索方法 2查看构造方法 3查看使用方法.
                         Scanner使用方法：(录入输入)
                         Scanner 对象名=new Scanner（System.in）；括号填写System.in 的意思就是从键盘录入
                         对象名.nextInt()录入数字空格回车后算结束  对象名.next()录入字符串空格回车后算结束   对象名.nextline()录入整行字符串
                         
                         Random使用方法：(随机生成)
                         Random 对象名=new Random();
                         对象名.nexInt()(生成一个范围在INT里面的随机数)括号里面能填写范围 如果填写10那么就是 0-9
                         
                         
                         
                         ArrayList 创建集合  (比起数组差别, 集合在运行过程中可以改变长度,数组不行，集合只能放入引用类型 数组可以放入所有类型)
                         创建格式：
                         ArrayList<数据类型> 集合名=new ArrayList<>();  集合的数据类型只能填写引用类型 如果要填写int 需要包装
                         普通数据类型
                         包装后
                         byte             Byte
                         int              Integer
                         short            Short
                         long             Long
                         float            Float
                         double           Double
                         char             Character
                         boolean          Boolean
                         
                         
                         字符串：
                         字符串的三种创建方式：
                        String 变量名 = new String();//一般不用 String str = "";
                    String 变量名 = new String(new char[]{'A','B','C'});
                    String 变量名 = new String(new byte[]{65,66,67});
                    String 变量名 = "ABC";//最常用的方式
                        字符串常量池：
                        一但创建一个字符串"abc"  之后如果再创建一个为abc 的字符串 就会直接从常量池里面拿取
                        两者在堆中的常量池中的地址相同。
                        注：当程序运行时 如果赋值左边的值有常量 将会在编译前进行 左边的常量运算 然后再运行
                        字符串的比较：
                        1.用两个                                        ==号比较的时两个字符串的地址值。  返回值为布尔值
                        2.比较字符串的内容用：                                equals(字符串中的方法，需要先创建字符串的对象才可以使用)
                                                                        字符串a.equals(字符串b) 比较字符串a与字符串b的内容;返回值为布尔值
                                                                        字符串a.equalsIgnoreCase(字符串b) 忽略大小写进行字符串的对比，返回值为布尔值
                       
                        3.字符串长度的获取：                            字符串.length;  返回值为int
                       
                        4.拼接字符串：                                  字符串.concat(字符串b)  返回值为字符串
                       
                        5.字符串获取索引位置的字符：                    字符串.charAt(索引)（字符串的索引编号也是从0开始的）  返回值为char
                       
                        6.获取参数字符串在原字符串中第一次出现的索引          字符串.indexOf(参数字符串)  返回值为int
                       
                        7.截取索引位置开始（包括索引位置元素）到字符串的结尾 字符串.substring(索引编号) 返回值为String

                        8.截取从开始索引到结束的索引（属于左闭右开的包左不包右）        字符串.substring(索引开始位置编号,索引结束编号)
                       
                       
                       
                        替换
                        1.字符串转换字符数组：
                        char[] toCharAray(字符串);
                        2.把字符串转换成字节数组：
                        byte[] getBytes(字符串)
                        3.把字符串内的一个内容替换成一个新的内容
                        字符串 replace(旧内容,新内容)
                       
                       
                       
                         Static关键字介绍
                        一但使用了Static关键字
                        用了static 修饰方法或者变量 那么该方法变量将 属于类的。不再属于对象  要用类名调用 而不是对象名
                        打印数组
                        Arrays.toString(打印数组里面的所有元素 格式就是正常格式)；
                       
                        排序数组
                        Arrays.sort(数组); 如果是数字 按照升序进行排列  如果是字符串 按照字符串的首字母的先后顺序进行排序
                       
                       
                        math类
                        获取绝对值
                        Math.abs(需要获取绝对值的变量或者常量);
                        向上取整
                        Math.ceil(需要向上取整的变量或者常量);
                        向下取整
                        Math.floor(需要向下取整的变量或者常量);
                        四舍五入
                        Math.round(需要四舍五入的变量或者常量;);

               
                       
                        继承：
                        继承的意思就是，子类可以继承父类所有非私有的内容。并且还可以自己有内容
                格式为： class 子类名 extends 父类{
                               
                        }

                方法的覆盖重写：
             1.子类重写父类的方法 方法名和参数必须都是一致的 建议使用 @Override （注解 annotation）如果不符合方法覆盖重写 会编译报错
                 2.子类重写父类的方法 返回值要求 子类返回值类型的范围小于或者等于父类返回值类型的范围
                 3.子类重写父类的方法  修饰符要求子类的修饰符的范围大于或者等于父类的修饰符的范围
                 修饰符的范围大小的顺序  public > protected > 默认（什么都不写）> private
               
               
                super的三种用法
                 1.可以访问父类的成员变量
                 2.可以访问父类的成员方法
                 2.可以访问父类的构造方法
                 
                this 关键字是用来访问本类内容
                1. 在本类的成员方法中，访问本类的成员变量。
                2. 在本类的成员方法中，访问本类的另一个成员方法。
                3. 在本类的构造方法中，访问本类的另一个构造方法
                                        注意：this(参数...);必须是在第一个位置   super和this两种构造调用，不能同时使用。
                 
               
                继承的3个特点：
                      1.java里面  类是单继承的  接口是可以多继承的
                          2.类是可以多级继承（多层继承）
                          3.一个父类可以有多个子类
                 
                 
        抽象方法：
                    public abstract 返回值类型  方法名(参数列表...);
                抽象类：
            public abstract class 类名{}
      
         注意点：         
              1.抽象方法所在的类必须得是抽象类        抽象类中不一定有抽象方法
              2.抽象类里面是有构造方法 构造方法是给子类对象进行初始化 使用的
              3.抽象类不能创建对象；
              4.子类必须得覆盖重写父类里面的抽象方法或者是该类也是抽象类                       


      接口：
     接口就是公共的规范标准Interface   protocol（协议）
         定义格式：
           public interface Demo{   
                   接口内容 ;  
           }
          接口内容：
             java7：
                   1.常量
                     格式:
                            [public][static][final] 数据类型 变量名 = 数据值;
                               
                                注意点：
                                   1.[public][static][final]都是可以选择性省略 要求只要是在接口里面声明的变量 必须得用这三个关键字进行修饰
                                   2.必须对接口中定义的变量进程赋值操作（即初始化操作）
                                   3.软性要求 代码规范 接口里面定义的变量（常量）变量名字要求全部大写 每个单词之间使用下划线连接
                                  
                  
                   2.抽象方法
                        public abstract 返回值类型 方法名(参数列表);
                       注意：[public] [abstract]可以全部省略 也可以选择性的省略任意一个
                 java8：
                   3.默认方法
                    主要功能 就是用来解决接口升级的一个问题
                        格式：
                             [public] default 返回值类型 方法名(参数列表){
                                         方法体;
                                 }
                                 
                                 默认方法 只能在接口中定义 别的地方不能定义
                                 默认方法 调用的时候和成员方法的调用方式一致
                       
                       
                   4.静态方法
                      定义格式：
                             public static void show(){
                                         方法体;
                                 }
                     静态方法是不能被重写的
                         使用方式：
                            不能使用实现类创建的对象调用
                                直接使用接口名.静态方法(参数列表)
                  
                  
                 java9：
                   5.私有方法
                    定义的格式：
                            跟普通的方法相比的话唯一不一样的地方就是修饰符是private 其他的内容都一样
                                 普通的私有方法：
                                      private 返回值类型 方法名(参数列表){
                                                  方法体;
                                          }
                                 普通静态的私有方法
                                           private static 返回值类型 方法名(参数列表){
                                                          方法体;
                                                  }
                                功能：
                                    private修饰的方法只能在本类中使用
                                        可以对本类中重复的内容进行抽取
                  
                  
                  
                  
          接口的基本使用：
             1.接口不能直接用来创建对象使用
                 2.需要创建一个实现类 实现 implements 接口名 实现里面的抽象方法
                 3.使用实现类创建对象 使用对象调用方法
                 注意：实现类必须得覆盖重写接口中的所以的抽象方法 除非该类也是抽象类
        /*       
        在Java 9+版本中，接口的内容可以有：

        1. 成员变量其实是常量，格式：
        [public] [static] [final] 数据类型 常量名称 = 数据值;
        注意：
                常量必须进行赋值，而且一旦赋值不能改变。
                常量名称完全大写，用下划线进行分隔。

        2. 接口中最重要的就是抽象方法，格式：
        [public] [abstract] 返回值类型 方法名称(参数列表);
        注意：实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。

        3. 从Java 8开始，接口里允许定义默认方法，格式：
        [public] default 返回值类型 方法名称(参数列表) { 方法体 }
        注意：默认方法也可以被覆盖重写

        4. 从Java 8开始，接口里允许定义静态方法，格式：
        [public] static 返回值类型 方法名称(参数列表) { 方法体 }
        注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法

        5. 从Java 9开始，接口里允许定义私有方法，格式：
        普通私有方法：private 返回值类型 方法名称(参数列表) { 方法体 }
        静态私有方法：private static 返回值类型 方法名称(参数列表) { 方法体 }
        注意：private的方法只有接口自己才能调用，不能被实现类或别人使用。       

byte 字节型 范围 -128——127  1字节
                        short 短整数型 正负3万左右   2字节
                        int 整形 范围 正负21亿左右  4字节
                        long 长整数型         8字节
                        boolean 布尔型 true(对) false(错)       
                        浮点型(小数型) float          double
                        定义变量格式： 数据类型  变量名 = 想要赋的值；
                        算术运算符：+(加号 相加 连接字符串) -(减号 相减) *(乘号 相乘) /(除号 相除) %(取模 相除后取余数) 变量名++  ++变量名
                        --变量名 变量名-- (如果++或者--在前面 那么这行代码运行前先加上1或者减1再调用， 如果是++或者--在后面先调用完这行代码再加1或者减1)
                        赋值运算符：+= -= *=  /= %=  列：a+=1  等价于 a=a+1
                        比较运算符(得到的返回值都是布尔类型)：==(比较两遍是否相等) >(大于)  <(小于) <=(小于等于) >=(大于等于)  !=(不等于)
                        逻辑运算符 (返回值也都是布尔类型)  &&(并且 两边条件都满足返回值为true) ||(或，两边只要有一边条件满足就是true) ！(取反，只要加了这个符号 原本是true 用了就变成false)
                        三元运算符(可以用if语句无损调换) 需要变量接受  数据类型 变量名= 判断条件？选项A：选项B;
                       
                        注：逻辑运算符 执行第一边条件判断 已经满足或者不满足时 后面的将不再运行
                       
                       
                       
                        方法：
                       
                       
                       
                        方法定义：
                        一般静态方法：public static 返回值 方法名(){
                                return 返回值;
                        }
                       
                       
                        方法的重载：方法名一样  但是参数不同(可以是个数 也可以是类型不同，只要符合一点就是方法重载，与参数名称无关，与返回值类型无关)
                       
                       
                       
                       
                       
                       
                       
                       
                       
                        判断格式语句：
               
                        if(判断条件){
                                如果条件成立执行这里，条件不成立 继续执行下一行代码}
                       
                        标准if语句
                        if(判断条件){
                                语句体1(条件成立执行这里)
                        }else{条件不成立执行这边        }
                       
                        扩展if语句
                       
                        if(条件判断){
                                条件成立运行语句体1
                                则不运行下面代码
                        }else if(条件判断){
                                        条件成立运行语句体2
                                则不运行下面代码
                        }else if(条件判断){
                                        条件成立运行语句体3
                                则不运行下面代码
                        }else{结束语句，收尾语句，可以省略}       
                       
                        switch选择语句
                       
                        switch(表达式){
                                case 常量值1：
                                语句体1;
                                break;
                               
                                case 常量值2：
                                语句体2;
                                break;
                               
                                case 常量值3：
                                语句体3;
                                break;
                               
                                ........
                               
                            default
                            语句体;
                            break       
                        }
                        当表达式与case后面的常量值相等时，将会运行满足case的语句体，如果都不满足 就运行 default 下的语句体
                        注：switch 语句下的判断顺序可以颠倒 当如果满足case条件 但是case条件下没有写 break 将会穿透下个case 直至碰到break;
                       
                        循环控制语句： break  (遇到break语句退出当前循环)
                                      continue (遇到continue 会跳出本次循环 )
                       
                       
                       
                       
                        循环语句：
                       
                        for 循环语句(一般使用于循环次数已经确定的情况下)
                       
                        for(初始化语句(定义初始化变量);条件判断;步进语句(定义的变量++)){
                                循环体
                        }
                        注： 初始化语句 和步进语句可以不写.
                       
                        while 循环语句 (一般使用于循环次数不确定的情况下)
                       
                       
                        初始化语句
                        while(条件判断){
                                循环体
                                步进语句
                        }
                       
                       
                        do while 语句(至少执行一次)
                       
                        初始化语句
                        do{
                                循环体
                                步进语句
                        }while(条件判断)
                       
                        数组的三种初始化：
                        动态创建(指定长度)：
                        数据类型[]  数组名 = new 数据类型[数组的长度];
                       
                        静态创建(指定数组的内容):
                        数据类型[] 数组名= new 数据类型[]{元素1,元素2,元素......}
       
                       
                        静态的省略格式
                    数据类型[] 数组名={元素1,元素2,元素3........}
                       
                        数组元素的获取
                       
                        如果直接打印数组的名字获取到的将是数组的地址值
                       
                        要访问数组内的元素的格式是:
                       
                        数组名[数组的索引值]  数组的索引值是从0开始的
                       
                        要给数组内元素赋值的格式是：
                       
                        数组名[数组的索引值]=要赋的值;  注：如果是动态数组，那么创建完毕后数组都有默认值 整数型为0 浮点为0.0  字符类型为\u0000 如果为布尔类型为false 如果是引用类型那么为null;
                        如果数组作为方法的参数 其实传递的是数组值，如果作为方法的返回值，返回的也是地址值。
                        如果一个方法想有多个返回值是可以用数组进行返回。
                       
                       
                        面向对象： 强调对象 关注对象的功能.
                        面向过程： 强调过程 每一个步骤都亲力亲为.
                       
                        类的定义：类是相关的 行为和 属性的集合  属性：状态信息(成员变量)  行为：该事物能做什么(成员方法);
                        类是对象的抽象化 ，对象是类的实例化;
                       
                        创建对象的格式:  类名 对象名=new 类名();
                        两个对象如果使用同一个地址值的话,内容会共享
                        如果将类作为方法参数或者返回值，传递 或者返回的都是地址值;
                       
                        成员变量和局部变量的区别：
                        定义位置不同        成员变量定义在类中 方法外
                                            局部的变量定义在方法内
                        作用的范围不同                 成员变量可以作用整个类中
                                            局部变量作用在定义的方法内 方法外不能使用
                                                               
                        java封装的体现： 方法本来就是一种封装
                        面向对象封装的体现：
                        private 也是一种封装的方法                                
            使用方法 ：变量名前加上private                       
                       
                        this 关键字：
                        当局部变量与成员变量冲突时 可以用this修饰  使用格式：
                        this.成员变量名
                        this.成员方法名
                        this.构造方法
                       
                        super 关键字
                        当局部变量或者本类的变量，还有父类变量冲突时  可以用this. 和super. 修饰
                        super.成员变量名
                        super.成员方法名
                        super.构造方法
                       
                        一个标准类(java bean)
                        需要有 用private 修饰过的成员变量
                        有有参和无参的构造方法
                        get set方法;
                       
             API使用方法：
                         1搜索方法 2查看构造方法 3查看使用方法.
                         Scanner使用方法：(录入输入)
                         Scanner 对象名=new Scanner（System.in）；括号填写System.in 的意思就是从键盘录入
                         对象名.nextInt()录入数字空格回车后算结束  对象名.next()录入字符串空格回车后算结束   对象名.nextline()录入整行字符串
                         
                         Random使用方法：(随机生成)
                         Random 对象名=new Random();
                         对象名.nexInt()(生成一个范围在INT里面的随机数)括号里面能填写范围 如果填写10那么就是 0-9
                         
                         
                         
                         ArrayList 创建集合  (比起数组差别, 集合在运行过程中可以改变长度,数组不行，集合只能放入引用类型 数组可以放入所有类型)
                         创建格式：
                         ArrayList<数据类型> 集合名=new ArrayList<>();  集合的数据类型只能填写引用类型 如果要填写int 需要包装
                         普通数据类型
                         包装后
                         byte             Byte
                         int              Integer
                         short            Short
                         long             Long
                         float            Float
                         double           Double
                         char             Character
                         boolean          Boolean
                         
                         
                         字符串：
                         字符串的三种创建方式：
                        String 变量名 = new String();//一般不用 String str = "";
                    String 变量名 = new String(new char[]{'A','B','C'});
                    String 变量名 = new String(new byte[]{65,66,67});
                    String 变量名 = "ABC";//最常用的方式
                        字符串常量池：
                        一但创建一个字符串"abc"  之后如果再创建一个为abc 的字符串 就会直接从常量池里面拿取
                        两者在堆中的常量池中的地址相同。
                        注：当程序运行时 如果赋值左边的值有常量 将会在编译前进行 左边的常量运算 然后再运行
                        字符串的比较：
                        1.用两个                                        ==号比较的时两个字符串的地址值。  返回值为布尔值
                        2.比较字符串的内容用：                                equals(字符串中的方法，需要先创建字符串的对象才可以使用)
                                                                        字符串a.equals(字符串b) 比较字符串a与字符串b的内容;返回值为布尔值
                                                                        字符串a.equalsIgnoreCase(字符串b) 忽略大小写进行字符串的对比，返回值为布尔值
                       
                        3.字符串长度的获取：                            字符串.length;  返回值为int
                       
                        4.拼接字符串：                                  字符串.concat(字符串b)  返回值为字符串
                       
                        5.字符串获取索引位置的字符：                    字符串.charAt(索引)（字符串的索引编号也是从0开始的）  返回值为char
                       
                        6.获取参数字符串在原字符串中第一次出现的索引          字符串.indexOf(参数字符串)  返回值为int
                       
                        7.截取索引位置开始（包括索引位置元素）到字符串的结尾 字符串.substring(索引编号) 返回值为String

                        8.截取从开始索引到结束的索引（属于左闭右开的包左不包右）        字符串.substring(索引开始位置编号,索引结束编号)
                       
                       
                       
                        替换
                        1.字符串转换字符数组：
                        char[] toCharAray(字符串);
                        2.把字符串转换成字节数组：
                        byte[] getBytes(字符串)
                        3.把字符串内的一个内容替换成一个新的内容
                        字符串 replace(旧内容,新内容)
                       
                       
                       
                         Static关键字介绍
                        一但使用了Static关键字
                        用了static 修饰方法或者变量 那么该方法变量将 属于类的。不再属于对象  要用类名调用 而不是对象名
                        打印数组
                        Arrays.toString(打印数组里面的所有元素 格式就是正常格式)；
                       
                        排序数组
                        Arrays.sort(数组); 如果是数字 按照升序进行排列  如果是字符串 按照字符串的首字母的先后顺序进行排序
                       
                       
                        math类
                        获取绝对值
                        Math.abs(需要获取绝对值的变量或者常量);
                        向上取整
                        Math.ceil(需要向上取整的变量或者常量);
                        向下取整
                        Math.floor(需要向下取整的变量或者常量);
                        四舍五入
                        Math.round(需要四舍五入的变量或者常量;);

               
                       
                        继承：
                        继承的意思就是，子类可以继承父类所有非私有的内容。并且还可以自己有内容
                格式为： class 子类名 extends 父类{
                               
                        }

                方法的覆盖重写：
             1.子类重写父类的方法 方法名和参数必须都是一致的 建议使用 @Override （注解 annotation）如果不符合方法覆盖重写 会编译报错
                 2.子类重写父类的方法 返回值要求 子类返回值类型的范围小于或者等于父类返回值类型的范围
                 3.子类重写父类的方法  修饰符要求子类的修饰符的范围大于或者等于父类的修饰符的范围
                 修饰符的范围大小的顺序  public > protected > 默认（什么都不写）> private
               
               
                super的三种用法
                 1.可以访问父类的成员变量
                 2.可以访问父类的成员方法
                 2.可以访问父类的构造方法
                 
                this 关键字是用来访问本类内容
                1. 在本类的成员方法中，访问本类的成员变量。
                2. 在本类的成员方法中，访问本类的另一个成员方法。
                3. 在本类的构造方法中，访问本类的另一个构造方法
                                        注意：this(参数...);必须是在第一个位置   super和this两种构造调用，不能同时使用。
                 
               
                继承的3个特点：
                      1.java里面  类是单继承的  接口是可以多继承的
                          2.类是可以多级继承（多层继承）
                          3.一个父类可以有多个子类
                 
                 
        抽象方法：
                    public abstract 返回值类型  方法名(参数列表...);
                抽象类：
            public abstract class 类名{}
      
         注意点：         
              1.抽象方法所在的类必须得是抽象类        抽象类中不一定有抽象方法
              2.抽象类里面是有构造方法 构造方法是给子类对象进行初始化 使用的
              3.抽象类不能创建对象；
              4.子类必须得覆盖重写父类里面的抽象方法或者是该类也是抽象类                       


      接口：
     接口就是公共的规范标准Interface   protocol（协议）
         定义格式：
           public interface Demo{   
                   接口内容 ;  
           }
          接口内容：
             java7：
                   1.常量
                     格式:
                            [public][static][final] 数据类型 变量名 = 数据值;
                               
                                注意点：
                                   1.[public][static][final]都是可以选择性省略 要求只要是在接口里面声明的变量 必须得用这三个关键字进行修饰
                                   2.必须对接口中定义的变量进程赋值操作（即初始化操作）
                                   3.软性要求 代码规范 接口里面定义的变量（常量）变量名字要求全部大写 每个单词之间使用下划线连接
                                  
                  
                   2.抽象方法
                        public abstract 返回值类型 方法名(参数列表);
                       注意：[public] [abstract]可以全部省略 也可以选择性的省略任意一个
                 java8：
                   3.默认方法
                    主要功能 就是用来解决接口升级的一个问题
                        格式：
                             [public] default 返回值类型 方法名(参数列表){
                                         方法体;
                                 }
                                 
                                 默认方法 只能在接口中定义 别的地方不能定义
                                 默认方法 调用的时候和成员方法的调用方式一致
                       
                       
                   4.静态方法
                      定义格式：
                             public static void show(){
                                         方法体;
                                 }
                     静态方法是不能被重写的
                         使用方式：
                            不能使用实现类创建的对象调用
                                直接使用接口名.静态方法(参数列表)
                  
                  
                 java9：
                   5.私有方法
                    定义的格式：
                            跟普通的方法相比的话唯一不一样的地方就是修饰符是private 其他的内容都一样
                                 普通的私有方法：
                                      private 返回值类型 方法名(参数列表){
                                                  方法体;
                                          }
                                 普通静态的私有方法
                                           private static 返回值类型 方法名(参数列表){
                                                          方法体;
                                                  }
                                功能：
                                    private修饰的方法只能在本类中使用
                                        可以对本类中重复的内容进行抽取
                  
                  
                  
                  
          接口的基本使用：
             1.接口不能直接用来创建对象使用
                 2.需要创建一个实现类 实现 implements 接口名 实现里面的抽象方法
                 3.使用实现类创建对象 使用对象调用方法
                 注意：实现类必须得覆盖重写接口中的所以的抽象方法 除非该类也是抽象类
        /*       
        在Java 9+版本中，接口的内容可以有：

        1. 成员变量其实是常量，格式：
        [public] [static] [final] 数据类型 常量名称 = 数据值;
        注意：
                常量必须进行赋值，而且一旦赋值不能改变。
                常量名称完全大写，用下划线进行分隔。

        2. 接口中最重要的就是抽象方法，格式：
        [public] [abstract] 返回值类型 方法名称(参数列表);
        注意：实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。

        3. 从Java 8开始，接口里允许定义默认方法，格式：
        [public] default 返回值类型 方法名称(参数列表) { 方法体 }
        注意：默认方法也可以被覆盖重写

        4. 从Java 8开始，接口里允许定义静态方法，格式：
        [public] static 返回值类型 方法名称(参数列表) { 方法体 }
        注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法

        5. 从Java 9开始，接口里允许定义私有方法，格式：
        普通私有方法：private 返回值类型 方法名称(参数列表) { 方法体 }
        静态私有方法：private static 返回值类型 方法名称(参数列表) { 方法体 }
        注意：private的方法只有接口自己才能调用，不能被实现类或别人使用。