复习不足2

final

    最终修饰符 可以修饰 类 方法 变量
    修饰类   类不能被继承
    修饰方法 方法不能被重写
    修饰变量 只能赋值一次 不能2次赋值 是常量
    
    1.final修饰引用数据类型变量 变量的地址值不能改变 但是属性值可以变
    2.final修饰成员变量 不能使用默认值 创建对象之前赋值 
                     直接显示赋值 
                     所有构造方法中赋值

接口 

    接口是功能的集合 描述的是功能 接口中都是抽象方法(JDK1.8之前)
    定义格式 
        public interface 接口名{
             抽象方法;
        }
    接口的使用 
        1.接口不能创建对象
        2.使用类实现接口  
        3.重写抽象方法 
        4.创建实现类对象 调用方法
        
        实现的动作类似继承 就是关键字不同 
        public class 类  implements 接口{
              重写方法
        }
    接口的成员特点 
         接口没有构造方法 
         接口中的成员变量 被public static final修饰 是常量
         接口中的成员方法 被public abstract修饰 
    
    接口的特点 
        类与类 单继承 
        类与接口 多实现
        接口与接口 多继承 
        类可以在继承一个类的同时 实现多个接口
        
    接口与抽象类的区别
        成员区别 
             构造方法 
                 接口没有构造方法
                 抽象类有构造方法 给子类使用
              成员变量 
                 接口没有变量 只有常量
                 抽象类既可以有变量 也可以有常量
              成员方法 
                 接口中的方法都是抽象的 
                 抽象类中 既可以有抽象方法 也可以有具体的方法
        思想的区别
            抽象类描述的是一类事物的共性内容 
            接口描述的是功能

多态 

    多态的前提 
         1.继承或者是实现关系 
         2.需要有方法重写
    多态的格式 
        父类引用指向子类对象 
        具体类  变量 = new 子类对象();
        抽象类  变量 = new 子类对象();
        接口  变量 = new 实现类对象();
        
     多态后访问的成员特点 
        成员变量  
              编译时 到父类中找 如果有编译通过 没有报错
              运行时  打印的父类成员变量的值
              编译时  看左边
              运行时  看左边 
        成员方法 
             编译时 到父类中找 如果有编译通过 没有报错
             运行时  子类重写后的方法 
             
             编译时 看左边 
             运行时 看右边
        
        多态后 一切都是父类的表现形式 只有方法运行的子类重写后的方法.
        
     向上转型 
         多态本身就是向上转型 
         Fu fz = new Zi();
     向下转型 
         向上转型后 不能访问子类特有功能
         要想访问 需要向下转型
         Zi zf = (Zi)fz;
            
         需要注意 
            Fu fu = new fu();
            Zi  zi = (Zi)fu; //抛运行时异常  ClassCastException 类型转换异常
            
     instanceof关键字 
     boolean b = 对象 instanceof 类型;
     
     if(对象 instanceof 类型){
        向下转型 避免出现类型转换异常
     }

static 静态修饰符

            可以修饰类的成员 被static修饰的成员 属于类 而不单属于某个对象
            被所有对象所共享

     static 静态的访问
             对象名.属性名;              不推荐
             对象名.方法名(实际参数);     不推荐

             类名.属性名;
             类名.方法名(实际参数);

     static的注意事项
           静态内容随着类的加载而加载 优先于对象出现
           所以静态只能直接访问静态 不能直接访问非静态
           静态中不能使用this/super

局部代码块

         限制变量的作用域范围
     成员代码块
         定义在类中方法外的代码块
         创建对象时执行 也称为构造代码块
     静态代码块
          类加载时执行 类只加载一次 静态代码块只执行一次
                            1.创建对象
                            2.创建子类对象
                            3.访问静态成员
                            4.访问子类静态成员

     类的加载
          加载
          连接
          初始化
             静态代码块执行

    静态代码块> 构造代码块>构造方法

修饰词

public 公共权限   可以修饰 类  方法 成员变量  任意地方都可以访问  一个文件中只能有一个public修饰的类
            public修饰的类 类名必须与文件名相同
     protected  受包含的权限  可以修饰 内部类  方法 成员变量  当前包与其他包的子类可以访问
     默认   包权限   可以修饰类  方法 成员变量  当前包下可以访问
     private 私有权限  可以修饰 内部类 方法 成员变量  当前类可以访问

     final 最终修饰符 可以修饰 类  方法 成员变量 局部变量
           final修饰类不能继承 修饰的方法不能被重写 修饰的变量是常量

     static 静态修饰符  可以修饰  内部类 方法 成员变量

     abstract 抽象修饰符  可以修饰 类  方法

     final和abstract能不能一起使用?
             final和abstract修饰类 不能一起使用 final修饰的类不能继承 而abstract修饰的类 要求必须继承
             final和abstract修饰符方法 也不能一起使用 final修饰不能重写 而abstract修饰的方法 要求子类必须重写
     static和abstract能不能一起使用?
            如果修饰内部类 可以一起使用
            但是如果修饰方法 不能一起使用 假设可以的话 就会出现类名直接运行一个抽象方法 调用抽象方法没有意义
     final和static能不能一起使用?
           可以

     private和abstract能不能一起使用?
             如果修饰内部类 可以一起使用
             如果修饰方法 不能一起使用 private修饰的方法 子类看不到  而abstract要求子类重写 冲突.

     native 本地修饰符 可以修饰方法 如果被native修饰的方法 说明这个方法不是用java语言编写
            用c语言编译 这个方法 与操作系统进行交互  我们看不到源码.

如果父类没有空参构造方法
        //子类继承就会报错 因为子类的中含有空参构造
        //并且在空参构造方法的第一行默认有super()调用父类的空参构造
        //如果父类没有空参构造方法 则报错

 java.lang.Object

 java中所有类的根类 所有的类都直接或者间接继承自Object类
          构造方法
              public Object()
          方法
              public String toString()返回该对象的字符串表示。  类名+@+地址值(哈希值)
                                      在Object类中打印的是地址值 ,我们查看地址值没有用
                                      子类一般都会重写此方法 返回对象的属性值

 Object类方法
        boolean  equals(Object obj)   指示其他某个对象是否与此对象“相等”。
                                      如果不重写此方法 比较的是两个对象的地址值
                                      子类一般都会选择重写此方法  不再比较地址值 而是比较属性值

        == 如果比较基本类型 比较的是基本类型的数值是否相等
           如果比较引用类型 比较的是地址值是否相同

Object类
         public int hashCode() 获取对象的哈希值
              哈希值:可以理解为一个唯一值 相当于人一出生的身份证号  可以理解为是逻辑地址

        结论
          如果不重写Object类的hashCode方法 比较两个对象的hashCode就是比较两个对象的地址值
              如果重写了Object类HashCode方法 比较两个对象的hashCode就是比较两个对象的内容
                      如果想确定内容是否真的相同
                           可以先比较两个对象的hashCode
                                      不同 说明这两个对象的内容一定不同
                                      相同 不能说明这两个对象一定相同 需要继续比较equals
                                                      不同  一定不同
                                                      相同

 java.lang.String

           特点
              1.所有字符串字面值 都是字符串对象 "abc"
              2.字符串是常量  一旦创建 不能改变
              3.因为不可改变 所以可以共享

  字符串的比较
          构造方法
              public String();
              public String(String str)

      字符 字节数组 转换为字符串
           String 构造方法
                  public String(char[] chs);
                  public String(char[] chs,int start ,int length)
                  public String(byte[] bytes)
                  public String(byte[] bytes,int start ,int length)

      将字符串转换为字符数组
           String 类
                public char[] toCharArray();
      将字符串转换为字节数组
           String 类
                 public byte[] getBytes();

String类
       public  char charAt(int index) 根据索引找字符

    长度
         数组
             length属性
         集合
             size()方法
         字符串
             length()方法

  String 类
         方法
           int  indexOf(int ch) 查找当前字符 在字符串中第一次出现的索引位置
           int indexOf(int ch,int fromIndex) 从fromIndex开始查询

           int lastIndexOf(int ch)  查询指定字符 在字符串中最后一次出现的索引
           int lastIndexOf(String str)

 字符串截取
          String substring(int startIndex)  从开始索引截取到末尾
          String substring(int startIndex,int endIndex)  [start,end)

 字符串大小写转换
          String toUpperCase() 字符串转大写
          String toLowerCase() 字符串转小写
      字符串判断开头和结尾
         boolean startsWith(String s) 判断开头
         boolean endsWith(String s) 判断结尾

 String 类
           String concat(String s) 字符串拼接
           String trim() 去掉字符串两端的空格

String replace(char oldChar,char newChar) 将字符串中 oldChar 替换成newChar

       String repalce(String oldString,String newString)

 java.lang.StringBuffer   线程安全  效率低
      java.lang.StringBuilder  线程不安全 效率高
              构造方法
                   public StringBuilder() 创建一个空的缓冲区
                   public StringBuilder(String str) 创建一个存储了str的缓冲区
              方法
                  public StringBuilder append(Object obj) 向容器中追加数据
                                                            10 ---"10"
                                                            引用类型 ----自动调用引用类型的toString方法 添加
                   String toString() 将StringBuilder类型转换为字符串

                   StringBuilder reverse() 将缓冲区中的数据反转

 java.util.Date 日期类

     时间原点:1970年1月1日 00:00:00
     1秒 = 1000毫秒
          构造方法
               public Date() 当前日期对象
               public Date(long time) 指定毫秒值的日期对象
          方法
              long getTime() 获取日期对象的毫秒值
              void setTime(long time) 设置毫秒值

 java.text.DateFormat
           方法
             String format(Date date) 将日期转换为字符串
             Date parse(String s) 将字符串 解析为日期对象

           常用子类
           java.text.SimpleDateFormat
                构造方法
                      public SimpleDateFormat()   23-4-5 上午10:39
                      SimpleDateFormat(String pattern)  指定模式
                                y --- 年
                                M ---月
                                d --- 日
                                H ---- 时
                                m ---- 分
                                s ---- 秒
                                E ---- 星期

  java.util.Calendar 日历类 抽象类

           静态方法创建对象
              public static Calendar getInstance() 获取当前日历对象 实际上返回的是 子类对象

           方法
              int get(int field) 返回给定日历字段的值。

        0-11 代表 1- 12月
        外国每周第一天 是周日

 java.util.Calendar
            方法
                Date getTime() 将日历对象转为日期对象
                void add(int field, int amount)根据日历的规则，为给定的日历字段添加或减去指定的时间量。
                 void set(int field, int value)  将给定的日历字段设置为给定值。
                  void set(int year, int month, int date)

  java.lang.System 系统类

           构造方法私有 所有方法静态
                static void exit(int status)   退出虚拟机  0代表正常退出
                public static void gc() 运行垃圾回收器

  获取毫秒值

     1.Date类的getTime方法
     2.Calendar类的 getTimeInMillis()
     3.System类静态方法 currentTimeMillis()

 System类
         static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

         Object src:源数组
         int srcPos:源数组开始索引
         Object dest:目标数组
         int destPos:目标数组的开始索引
         int length :要复制的个数

java.util.Arrays  数组工具类

           构造方法私有 所有方法静态
              静态方法
                  public static void sort(int[] arr)  排序
                  public String toString(int[] arr) 将指定的数组转换为字符串 [3,8,2,5,0]
                  public static int binarySearch(int[] arr ,int key) 二分查找

 Arrays
        static int[] copyOf(int[] original, int newLength) 数组复制

  java.math.BigInteger

                大整数运算
                构造方法
                      public BigInteger(String s);

java.math.BigDecimal

           可以进行精确的小数计算
           构造方法
               public BigDecimal(String str)

 字符串与基本类型转换

          String --- int
                 Integer静态方法
                    int     parseInt(String num)

      基本类型  ---->String
           String s = 基本类型数值+ "";

           String 方法
              static String valueOf(int num)

  基本类型 ---->包装类型

     int ---> Integer
          构造方法
               public Integer(int n)
               public Integer(String s);

      Integer ---->int
           Integer方法
             int intValue()

异常

Throwable
          Error    错误  不能处理
          Exception 异常 编译时异常  编译时 就报错 必须处理 不处理代码 编译不通过
              RuntimeException 运行时异常 编译时 不报错 运行时才报错

   异常的第一种处理方式

     try{
        可能出现异常的代码
     }catch(异常的类名  变量名){
         打印异常的信息
     }catch(异常的类名 变量名){

     }..

     多catch处理异常 有没有顺序
           如果多个异常之间没有继承关系 没有顺序
           如果有继承关系 有顺序   小的在前 大的在后

  try{

     }catch(){

     }finally{
        无论是否有异常 无论 是否捕获了异常  finally中的内容 一定会被执行
     }

  异常处理的第二种方式    声明异常

     throw 异常的对象    抛出异常 在方法内使用

     throws 异常的类名  声明异常 在方法的声明上使用

编译时异常
           Exception及其子类   编译时就报错 必须处理 不处理代码无法运行
     运行时异常
         RuntimeException及其子类  编译时 不报错 运行时 才报错  可以处理 也可以不处理 推荐不处理
                          因为对于运行时异常来说 基本上都是代码写的有问题 需要改代码

 打印异常信息的方式
     Throwable
         String getMessage()   获取异常的简短信息  文件没找到
         String toString()  获取异常的简短信息  java.io.FileNotFoundException: 文件没找到
         void printStackTrace() 直接打印异常的详细信息

  异常后方法重写的注意事项
          1.父类方法抛异常 子类方法能不能抛异常?
                      可以不抛
                      也可以抛异常 但是 抛出的异常 必须和父类方法抛出的异常相同 或者是其子类异常
          2.父类方法不抛异常 子类方法能不能抛异常?
                      子类重写方法不能抛异常 如果子类方法中有异常 必须try catch

 java.util.Collection 集合层次的根接口

           方法
            - public boolean add(E e)：  把给定的对象添加到当前集合中 。
            - public void clear() :清空集合中所有的元素。
            - public boolean remove(E e): 把给定的对象在当前集合中删除。
            - public boolean contains(Object obj): 判断当前集合中是否包含给定的对象。
            - public boolean isEmpty(): 判断当前集合是否为空。
            - public int size(): 返回集合中元素的个数。
            - public Object[] toArray(): 把集合中的元素，存储到数组中

          常用实现类
             ArrayList

  集合和迭代器
          Collection
               public abstract Iterator<E> iterator()  获取迭代器  方法是抽象方法 但是任意一个Collection的实现类都会
                                                       重写此方法 方法的返回值类型是Iterator接口 一定会返回接口的实现类对象

          Iterator接口
                boolean hasNext()  判断是否有元素
                E next()   获取元素

  定义一个集合 存储4个元素 柳岩 唐嫣 金莲 大郎
      迭代集合 判断 如果遇到金莲 添加一个西门庆

      ConcurrentModificationException
          并发修改异常
              当迭代器在迭代的同时 集合修改了自身的长度 就会抛出此异常

增强for循环  JDK1.5
         作用
             用来遍历数组 或 集合
         原理
             一个增强for循环 底层使用的就是一个迭代器
         注意:迭代的同时 不能修改集合的长度

         格式
              for(数据类型 变量名:集合或数组){

              }

   泛型

        定义泛型
            泛型可以定义在 接口 类 方法上 将数据类型作为参数传递
        定义泛型的好处
             可以预先使用未知的类型

        使用泛型
             我们创建集合 指定集合中元素的类型 就是在使用泛型

        使用泛型的好处
            1.明确知道集合中存储元素的类型
            2.将运行时异常 提前到编译时报错
            3.避免强制类型转换的麻烦

 泛型类
         public class 类名<泛型变量>{

         }
         创建对象时 确定泛型的数据类型

     泛型方法
         public <泛型变量>返回值类型 方法名(形参){

         }
       调用方法 传递参数时 确定泛型的数据类型

  泛型接口
          public interface 接口名<泛型变量>

        1.定义实现类时 直接确定泛型的数据类型
        2.定义实现类时 不确定泛型的数据类型 实现类也是泛型类 创建实现类对象时 确定类型

java.util.List 接口

         特点
             有序 有索引 元素可重复
                             判断元素相同的依据是对象的equals方法
        方法
             - public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
            - public E get(int index):返回集合中指定位置的元素。
            - public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
            - public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
       常用的实现类
          ArrayList
              底层数据结构是数组
              查询快 增删慢
          LinkedList
             底层数据结构是链表
              查询慢 增删快

 java.util.ArrayList

         特点
             有序 有索引 元素可重复
             底层数据结构是数组
             查询快 增删慢
         构造方法
              public ArrayList() 构造一个初始容量为10的空列表
              public ArrayList(int initialCapacity)  创建一个指定初始容量的列表
              public  ArrayList(Collection<? extends E> c) 创建一个ArrayList 存储Collection<? extends E> c集合中的元素

  java.util.LinkedList

         特点
              有序  有索引 元素可重复
              底层数据结构是链表
              查询慢 增删快

        特有方法
            - public void addFirst(E e):将指定元素插入此列表的开头。
            - public void addLast(E e):将指定元素添加到此列表的结尾。
            - public E getFirst():返回此列表的第一个元素。
            - public E getLast():返回此列表的最后一个元素。
            - public E removeFirst():移除并返回此列表的第一个元素。
            - public E removeLast():移除并返回此列表的最后一个元素。
            - public E pop():从此列表所表示的堆栈处弹出一个元素。
            - public void push(E e):将元素推入此列表所表示的堆栈。

  java.util.Collections 集合工具类

            构造方法私有 所有方法静态
                  方法
                      public static void shuffle(List list) 打乱集合中元素的顺序
                      public static void sort(List list) 对集合中元素进行排序 自然排序  集合中的元素 必须实现自然排序接口 Comparable 重写compareTo方法

  Collections
         方法
             public static void sort(List list,Comparator c) 传入比较器 指定比较规则

        匿名内部类
              作用:临时创建一个类子类对象的快捷方式
              格式
                  new 父类/接口(){
                        重写方法
                  }

 java.util.Set

         特点
             元素唯一

         方法和Collection一致

         常用实现类
              TreeSet
                 排序  唯一
              HashSet
                 无序 唯一
              LinkedHashSet
                  有序 唯一

 java.util.TreeSet

          构造方法
              public TreeSet() 空参构造  集合中的元素必须实现自然排序接口Comparable接口 重写CompareTo方法
                                如果CompareTo方法 返回值为0  说明两个元素相同 不添加到集合

              public TreeSet(Comparator c) 带参构造 需要传入一个比较器指定比较规则 如果传入比较器 自然排序不生效
                                            此时 Set集合中的元素可以不实现Comparable接口
                                            如果重写的compare方法 返回0 说明两个元素相同   不添加到集合

 TreeSet集合 如何保证元素唯一
          1.如果实现Comparable接口  compareTo方法 返回0 说明元素相同 添加失败
          2.如果使用比较器   compare方法 返回0  说明元素相同 添加失败

 java.util.HashSet

 存储自定义类型 如果想保证元素唯一 必须重写hashCode和equals方法
         特点
             无序 唯一
                     先比较对象的hashCode
                             不同 添加到集合
                             相同 继续比较equals
                                    不同  添加到集合
                                    相同 不添加

  java.util.LinkedHashSet  extends HashSet

            特点
                 底层数据结构是 链表+ 哈希表
                         链表保证元素有序  哈希表保证元素唯一
                                              先比较hashCode
                                                    不同 添加到集合
                                                    相同 继续比较equals
                                                         不同 添加
                                                         相同 不添加

 java.util.Map<K,V> 双列集合顶层接口

     K: key 键 键是唯一的
     V:value 值 值是可以重复的

        方法
             public V put(K key, V value):  把指定的键与指定的值添加到Map集合中。 返回值一般是null值 如果键相同 值会覆盖 会返回被覆盖的值
             public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
             public boolean containsKey(Object key) 判断是否包含指定键
             public V remove(Object key ) 根据键删除一对元素 并返回被删除的值

        常用实现类
             TreeMap
                 键 排序 唯一
             HashMap
                 键 无序 唯一
             LinkedHashMap
                 键 有序 唯一

  Map集合的第一种遍历方式
          核心方法
              Set<K> keySet() 获取存储所有键的Set集合

       1.定义Map集合 添加数据
       2.调用keySet方法 获取存储所有键的Set集合
       3.遍历Set集合 依次获取到每个元素(Map集合的key)
       4.调用Map集合的get方法 根据键找到对应的值

 Map集合的第二种遍历方式

             核心方法
                  Set<Map.Entry<K,V>> entrySet()  获取到存储结婚证(键值对映射关系对象)的Set集合

     1.创建Map集合 添加数据
     2.调用entrySet 获取到存储结婚证(键值对映射关系对象)的Set集合
     3.遍历Set集合 依次获取到每个结婚证 对象
     4.调用结婚证对象的方法 获取到 键 和值
                K getKey()
                V getValue()
 java.util.HashMap
          底层数据结构是哈希表   允许null键和null值
               键 无序 唯一
                      先比较hashCode
                            不同  元素不相同
                            相同  继续比较equals
                                   相同
                                   不同
          HashMap集合 自定义类型作为键 需要重写hashCode和equals方法 保证键的唯一

  java.util.TreeMap
          特点
            底层数据结构是红黑树  不允许null键 允许null值
                键 排序  唯一

          构造方法
               public TreeMap() 如果是空参构造 集合中的键 必须实现自然排序接口
               public TreeMap(Comparator c)  如果带参构造 需要传入一个比较器对象  键是否实现自然排序接口都可以

               public TreeMap(Map<? extends K,? extends V> m)

 java.util.Properties

          特点
             1.继承自Hashtable 实现了Map接口
             2.没有泛型 键String 值String
             3.唯一一个可以和IO流直接结合使用的集合

          方法
              setProperty(String key,String value)  添加元素  相当于  put
              getProperty(Object key) 根据键找值  相当于 get
              Set<String> stringPropertyNames() 获取存储键的Set集合  相当于 keySet