就业班day05-day08总结

——Object        是类层次结构的根类，所有类都直接或间接继承了Object类。具备所有对象都具备的共性内容
                String  toString()        //返回该对象的字符串表示。方法返回：全类名@16进制哈希值。
                        输出一个对象就是默认输出这个对象的toString()方法
                boolean equals(Object obj)        //比较两个对象是否相同。此类底层比较引用地址
                        一般都覆盖此方法，根据对象的特有内容，建立判断对象是否相同的依据。通常有必要重写hashCode方法
                int hashCode()        //获取hash值（哈希码值）（通过内部地址转成整数10进制）
                        哈希算法、散列算法，计算出的数字唯一
                Class getClass()        //返回类的字节码文件对象。返回此Object的运行时类
——获取字节码对象的3种方式
    1. 类名.class        
    2. 对象名.getClass()
    3. Class.forName("全类名")
——System        类中属性方法都是static，包含有用的类字段和方法，final修饰不能被实例化
                PrintStream err        //"标准"错误输出流
                PrintStream out         //"标准"输出流。用来读取键盘录入的数据
                InputStream in         //"标准"输入流。将数据输出到控制台。此流只有一个，随着系统的关闭而关闭，如果close()则不能再in出来
                long currentTimeMillis()//获取当前系统时间与协调世界时(0时区 1970-1-1 0:0:0)的毫秒值
                arraycopy(Object src,int srcPos,Object dest,int destPos,int length)        //复制数组。srcPos，开始位置

——日期
        Date        //以毫秒值表示。创建的是当前系统时间对象（1970年至今）。表示特定的瞬间，精确到毫秒，可以表示任意时间
                构造函数(long date)                //毫秒-->Date。根据毫秒值创建日期对象
                setTime(long time)        //毫秒-->Date。设置毫秒值
                long    getTime()        //Date-->毫秒。获取毫秒值
                boolean after(Date d)        //测试此日期是否在指定日期之后
                boolean before(Date d)        //测试此日期是否在指定日期之前
                boolean equals(obj)                //比较两个日期是否相等
                int     compareTo(Date d)        //比较两个日期顺序
                String  toString()                //转成String
                String  toLocalString()        //已过时。转换成本地时间格式的字符串
        Calender 抽象类。日历，提供操作日期字段的方法
                static字段
                        Calendar getInstance()        //获取对象，默认当前时间
                        int YEAR                        年
                        int MONTH                        年中月（0-11）
                        int DAY_OF_MONTH        月中天
                        int HOUR                        小时(12小时制)
                        int HOUR_OF_DAY         小时(24小时制)
                        int MINITE                        分钟
                        int SECOND                        秒
                        int DAY_OF_WEEK         周中天（1-7，周日-周六）
                        int DAY_OF_YEAR         年中天
                        int DAY_OF_WEEK_IN_MONTH         月中周
                get(int field)        //获取给定日历字段的值
                set(int年,int月,int日)        //设置日期
                        (int field,int value)        //设置指定字段日期
                add(Calender.YEAR,-2)        //修改指定字段，如：减两年
                setTime(Date)        //Date --> Calendar 。使用给定Date设置此Calendar的时间
                Date getTime()        //Calendar --> Date。 获取Date对象
        DateFormat。抽象类。Date和字符串之间转换
                //格式化。Date->String。默认"18-3-20 下午5:24"
                String format(Date)               
                //解析。String->Date。字符串和DateFormat对象风格要一致。可能抛异常
                Date   parse(dateStr)        
        new SimpleDateFormat()        //默认模式构建对象。 "18-3-20 下午5:24"
                (String pattern)        //指定模式构建对象。如："yyyy-MM-dd"自定义格式
                        y年。M年中月。d月中天。
                        H天中时(0-23)。m时中分。s分中秒。S毫秒。
                        E星期中天数。

——包装类。封装了基本数据类型的类，方便操作基本数据类型，同时将基本数据类型的使用转换为了类的面向对象方式。
        基本类型-》字符串
                1、基本类型数值+""
                2、用String.valueOf(基本类型数值)
                3、包装类.toString(int)
                4、包装类对象.toString()
        字符串-》基本类型
                1、包装类中的静态方法 xxx parsexxx("xxxstr");        (character无此)
                2、包装类对象.intValue() 包装类对象转成基本类型（数值才有此方法）
        自动装箱(1.5特性)        把基本类型转成包装类类型，编译后底层还是调用方法，如果为null，会出现空指针异常
                如：Integer i=1; 简化书写。如果装箱的是一个字节（127之内），那么该数据会被共享，不会重新创建。所以两个简化书写值==比较127数值内相同数值为true
        自动拆箱        把包装类类型转成基本类型。 如：int i=Integer类型的变量;
        Integer
                构造方法
                  (int)
                  (数字格式String)        //String --> Integer
                static 方法
                        int    parseInt("")                //String --> int
                                (String s,int radix进制)//把字符串当成其他进制转成十进制
                        String toString(int)        //int --> String
                                (int i,int radix)        //radix：2-36。十进制转成其他进制
                        final int MAX_VALUE|MIN_VALUE        //int最大值|最小值
                        String toBinaryString(int i)//转成二进制
                        String toOctalString(int i)        //转成八进制字符串
                        String toHexString(int i)        //转成十六进制字符串
                对象方法
                        int         intValue()        // Integer --> int ，数值才有此方法
                        boolean compareTo(Integer i)        //比较大小，相等0，左边大1，右边大-1


——集合        长度可变；存储对象的容器；不可以存储基本数据类型值。
        数据结构。数据的组织和存储方式
                数组        数组长度一旦定义则不可改变；有索引；只能存储同一类型元素；可存储基本数据类型，也可存储引用数据类型
                        查询快，增删慢
                链表        由链子连接起来的一堆结点
                        每个结点存储下个结点地址值，查询慢，增删快
                栈(stack)                先进后出
                队列        先进先出
        集合体系：Hash不重复(需重写2方法)，Linked有序，Tree排序
                Collection接口        单列集合
                        List接口        有序，可重复，有索引，不同步
                                Vector                底层数组，内存空间连续分配，查询快，同步
                                ArrayList        底层数组，查询快，内存空间连续分配
                                LinkedList        底层链表，增删快
                        Set 接口        无序，不重复，无索引，不同步。
                                HashSet                        底层哈希表。保证唯一，元素需覆盖hashcode和equals方法
                                        LinkedHashSet        有序，不重复
                                TreeSet                 底层二叉树。可排序（两个接口Comparable和Comparator）
                Map 接口，双列集合。无序，K不重复，无索引
                        HashMap                不同步。可以存入null值和null键
                                LinkedHashMap        有序，不可重复
                        Hashtable        同步。不可以存入null值和null键
                                Properties
                        TreeMap                可排序，需具备比较性
                Iterator 接口。迭代器
                        ListIterator 接口，用于List的迭代器
                        
        |----Collection<E>接口        集合层次结构根接口。一次添加一个元素， 单列集合。
                添加
                boolean add(E e)        //添加成功返回true。因为collection可以重复，所用永远可以添加成功，返回true
                boolean addAll(Collection<? extends E> c)
                删除
                boolean remove(Object obj)        //成功返回true，equals判断
                boolean removeAll(collection coll)        //将两个集合中相同的元素删除
                clear()                //清空所有
                判断
                boolean contains(Object obj)                        //是否包含指定元素
                boolean containsAll(Collection<?> c)        //是否包含指定集合。因为可以和任意类型集合比，所以用<?>
                boolean isEmpty()        //判断集合是否有元素，有1个就返回true
                获取
                int size()                //返回集合元素个数
                Iterator<E> iterator()        //获取集合迭代器对象。
                        迭代器。由于父类无法使用子类特有方法(如get、set),所以使用迭代器
                转换。目的：集合转数组，可以对集合中的元素操作的方法进行限定，不允许增删
                Object[] toArray()        //转成数组
                T[] toArray(T[] a)        //传入T类型数组，将集合中元素存储到该数组中
                其他
                boolean  retainAll(collection coll)        //取交集
        
        |--List<E>接口        列表。不同步。有序(存储和读取顺序一致)，有整数索引，可重复
                add(index,E)        //指定索引位置添加元素
                E remove(index)        //删除指定元素并返回被删除的元素，索引不存在抛异常
                E get(index)        //根据索引返回元素，索引不存在抛异常
                E set(index,E)        //修改指定索引元素，并返回修改前的元素
                int  indexOf(object)
                int  lastIndexOf(object)
                list subList(from,to)
                ListIterator listIterator()|(index);        //获取列表迭代器|从指定位置开始迭代。可以在迭代过程中对元素的增删改查
        new Vector<E>                内部是数组数据结构；同步。（除了此几乎都不同步）
                Enumeration<E> elements()        //获取所有元素
        new ArrayList<E>        数组结构；查询快，增删慢。初始10容量；
        new LinkedList<E>()        链表结构；增删快，查询慢。
                addFirst(E)|addLast(E)                //添加元素
                E getFirst()|getLast()                //获取元素。如果链表为空抛出异常
                E removeFirst()|removeLast()//删除并返回元素。如果链表为空抛出异常
                E peekFirst()|peekLastt()        //获取元素。如果链表为空，返回null
                E pollFirst()|pollLast()        //获取并删除
                offerFirst()|offerLast()        //添加
        
        |--Set 接口。不同步
                特点：无序（存入和取出顺序不一致）；不重复（元素唯一，只可包含一个null元素）；无索引。
                去重原理
                        add()方法。首先会使用当前集合中的每一个元素和新添加元素进行比较
                        通过hashCode()方法比较哈希值是否相等，不相等则添加，否则
                        通过equals()方法进行比较内容是否相等，都不相等则添加，否则认为重复不添加
        new HashSet()        //内部数据结构是哈希表。不同步。
        new TreeSet()        //底层数据结构为二叉树。使用元素的自然顺序排序。
                (Collection<? extends E> c)        //构造包含指定collection元素的新TreeSet，按照其元素自然顺序排序
                (Comparator<? super E> c)        //构造空TreeSet，根据指定比较器进行排序
                对象实现排序的2种方式
                        1 元素具有排序功能，元素实现Comparable接口，重写compareTo(T o)方法
                        2 使用比较器，让集合自身具备比较功能
                                定义一个类作为比较器实现Comparator接口，重写compare(T o1,T o2)方法，把此比较器对象传递给TreeSet
                        重写方法返回值作用，当前元素与传入元素比，从小到大
                                返回<0：当前元素比传入元素小，当前对象小于指定对象
                                返回=0：当前元素与传入元素相等，当前对象等于指定对象，不存
                                返回>0：当前元素比传入元素大，当前对象大于指定对象
                                
        |----Map<K,V> 接口        双列集合。常用语处理有对应关系的数据
                特点：存储方式是键值对方式，一个键只能映射一个值
                        键不可重复（需重写hashCode()和equals()方法），值可以重复
                        键是无序的
                映射，添加，覆盖
                        V put(K,V)        //如果K存在则覆盖V并返回原来的V。如果K不存在返回null
                删除
                        V remove(Object key)        //删除。根据指定key删除 键值对，并返回key所对应的value，如果没有删除成功则返回null
                        clear()        //清空所有对应关系
                判断
                        boolean containsKey(Object key)                //判断是否包含键
                        boolean containsValue(Object value)        //判断是否包含值
                        boolean isEmpty()        //判断集合是否为空
                获取
                        int size()                        //获取键值对个数
                        V   get(Object key)        //通过键获取值，如果没有返回null。可以通过返回null判断是否包含指定键
                        Set<K> keySet()                //获取所有键的Set集合。因为键不可重复，所以返回Set
                        Collection<V> values()         //获取所有值的Collection集合。因为值可以重复，所以返回Collection
                                返回的实现类是Values内部类，没有索引，所以不可以操作索引
                        Set<Map.Entry<K,V>> entrySet()        //返回键值对的Set集合
                Map.Entry<K,V>        //静态内部接口。映射项（键-值）
                        K getKey()        //获取键
                        V getValue()//获取值
        new HashMap<K,V>()        内部结构是哈希表，不同步。允许null作为键值。
                K为自定义对象时，如果保证唯一，元素对象需要覆盖hashcode和equals方法
        new Hashtable<K,V>        内部结构是哈希表，同步。不允许null作为键值。
        new Properties()        持久的属性集。通常用于操作以键值对形式存在的配置文件。用于存储键值对型文件的配置信息，可以和IO技术相结合。
                特点：键和值都为字符串类型；数据可保存在流中，从流中加载数据。
                Object setProperty(String key,String value)        //存，键相同，值覆盖。
                String getProperty(key)                //取
                Set<String> stringPropertyNames()        //返回所有键
                结合流
                load(InputStream in)        //读取到此对象中。注意：文件数据是键值对。
                        (Reader reader)
                list(PrintStream out)        //从集合（流）中读取数据显示到目的out。用于调试
                        (PrintWriter out)        //将属性集写入流指向的文件
                store(OutputStream out,String 描述)        //写入。关联流，将信息写入文件。描述尽量不要写中文，文件中#注释信息，键=值 格式存入。
                         (Writer writer,String comments)        
        new TreeMap<K,V>()|(比较器) 可排序。内部结构是二叉树，不同步。可以对Map集合中的Key排序。
        
        |----迭代器。依赖于集合，提供遍历集合的安全方式。开发用for遍历，释放变量。
        Iterator<E> 接口，用于遍历集合。Iterator接口是对所有collection容器进行元素取出的公共接口。
                boolean hasNext()        //判断是否有元素可获取
                E                 next()                //返回下一个元素，如果没有，会报异常
                remove()        //删除迭代器当前指向的元素
        ListIterator<E> 接口。子类
                add(E)        //通过迭代器给list集合添加元素
                add(E)        //通过迭代器给list集合添加元素
                set(E)
                hasPrevious()        //返回是否有前一个元素
        并发修改异常
                并发：并行发生，即同时发生
                修改：指会改变集合长度的操作（增加、删除、清空）
                原因：迭代器是Collection的一个副本，如果出现不一样（个数），会抛出CuncurrentModificationExciption并发修改异常
               

——接口。java提供的一种机制
                概念：接口是一个比抽象类还抽象的类，接口中所有方法为抽象方法
                使用场景：当父类只是用于扩展子类的功而不能完全描述子类时，使用接口扩展功能
                语法：不可有变量、非抽象方法、构造方法
                public interface 接口名 [extends 接口1,接口2]{                //定义接口。编译后是.class文件。类换了一种表述。都是公共权限
                        [public static final] int NAME=2;        //只能定义常量,修饰符固定,不写默认补充。因为无法写代码初始化，所以只能是常量
                        [public abstract] void name([参数]);//只能定义抽象方法,修饰符固定[public abstract]，不写默认补充，建议手动写上。
                        default void name(){方法体}                        //默认方法，可以不被重写
                }
                调用常量
                        实现接口的对象名.NUM
                        实现接口的类名.NUM
                        接口名.NUM
                特点
                        接口不可实例化
                        实现了接口的类必须实现接口中所有方法，否则这个子类就是一个抽象类。
                        特殊的抽象类，表面相同，本质不同。当一个抽象类中的方法都是抽象的时候，用接口
                关系
                        类与类                继承关系，单继承，多层继承。
                        类与接口        实现关系，多实现。
                        接口与接口        继承关系，多继承，多层继承。
                优点
                        通过多实现打破单继承局限性
                        对外提供规则，使程序的功能扩展性强；
                        降低程序耦合性（可以实现模块化开发，定义好规则，每个人实现自己的模块，提高了开发效率）
                接口和抽象类区别
                        相同：不断向上抽取，抽取出抽象的概念；都不可创建对象
                        不同：与类关系：抽象类需要被继承，只能单继承；接口需要被实现，可以多实现。
                                成员变量：抽象类可以有成员变量、常量；接口只能有常量。
                                成员方法：抽象类可以有抽象方法和非抽象方法；接口只能有抽象方法。
                                构造方法：抽象类可以有构造方法；接口没有构造方法
                                抽象类的继承是is a 关系，定义体系的基本共性内容；接口的实现是like a 关系，定义体系的额外功能。
                注意：一个类实现两个接口，如果两个接口中有抽象方法同名，参数相同，返回值不同的方法。该类则无法同时实现这两个接口，应避免这种情况
                        两个同级接口中有两个同名常量，则编译报错，区分不清。应避免
                        父类和接口中有同名常量，则编译报错，模糊不清。可用 super.常量 调用父类常量，接口名.常量 调用接口常量
               

——<>泛型。(Generic type)里面必须放引用类型（JDK1.5）
                概念：泛型是一种广泛的类型，把明确数据类型的工作提前到编译时期，借鉴了数组特点
                好处：避免类型转换异常，确保类型安全；简化代码书写；
                规范：E元素、T数据类型、K键、V值、N数、S、U等。多个,分隔；
                泛型的类型擦除：泛型只是一种安全监测机制，只存在编译时期
                        源代码编译生成的class字节码文件不存在泛型，这称为泛型的类型擦除
                        因为 为了兼容之前运行的类加载器，里面的内容已经统一了。
                使用泛型：当类中操作的引用数据类型不确定时，使用泛型。
                定义：定义在 类|接口 后面
                        定义在方法上，<>放在返回值类型前 修饰词后
                                如：public <w> void show(w str)
                                当方法静态时，不能访问类上定义的泛型。只能将泛型定义在方法上使用
                        泛型的通配符：<?> 未知类型        特点：不对类型做操作的时候使用
                                如：public void name(collection<?> o){}
                        泛型的边界：定义在方法参数声明上
                                <? extends E>        接收E类型或者E的子类型对象。上界通配符。一般存元素，因为取出的都是按照上限类型来运算，不会出现类型安全隐患
                                <? super E>                接收E类型或者E的父类型对象。下界通配符。对集合中的元素进行取出操作


——可变参数  方法的形参可以传入不定数量个参数（0个或多个）
                格式：(类型... 变量名)        目的：简化书写（JDK1.5）
                原理：底层是一个根据形参数量创建长度的数组，通过JVM将形参转换为数组。
                注意：必须定义在参数的末尾处；参数的数量0个或多个；可变参数只能是同一种数据类型


——异常        不正常情况，代码编译或运行时发生的错误
        异常类：将对象封装成对象，描述不正常情况的类
        原则：1、功能内容可以解决用catch，解决不了，用throws抛出调用者解决。
                2、一个功能如果抛出了多个异常，那么调用时，必须对应多个catch进行针对性的处理
        异常处理方式：
                JVM默认处理异常
                        如果开发者不处理，JVM会把异常的类型，原因和位置显示在命令行。并且终止程序运行，后面的代码将不再执行
                手动处理异常
                1、捕获异常并处理。不会终止程序
                        try{}        //可能出现异常的代码。如果出现异常会跳入执行catch中语句，之后代码不执行
                        catch(异常类 变量){处理异常} //变量接收抛出的异常对象，捕获后执行catch中代码。只执行完毕跳入finally或跳出try...catch语句
                        catch(异常类 变量){处理异常} //多catch时，从上往下匹配，父类的异常放在最下面。否则编译失败
                        catch(异常类1 | 异常类2 变量){处理异常}        //(JDK1.7)当两个异常处理方式一样时，可以这样写
                        finally{}        //一定会被执行的代码，通常用于关闭（释放）资源。可不写
                2、抛出异常。交由调用者处理。
                        throws 异常类型         定义在方法上(包括构造方法)，抛出的是异常类，多个,隔开
        自定义异常类
                一个类继承Exception|RuntimeException，然后实现多个构造方法即可
                制造异常。throw 函数内，抛出的是异常对象。并且结束方法
                        throw编译时期异常，必须在方法声明处抛出(throws)，因为编译时期异常必须处理
                        throw运行时期异常不用
        注意：1、子类覆盖父类只能抛出父类的异常或者该异常的子类或者子集或者不抛。不能抛出新的异常
                2、如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛。包括接口。如果有异常，只能try
        体系java.lang.Throwable        
                Error                 不可处理异常。如：主板坏了。由JVM抛出的严重性问题，这种问题一般不针对性处理
                Exception         可以处理异常。编译时期异常（除运行时异常体系）,必须处理（try catch | throws）
                        RuntimeException        运行时期异常,可以处理（try catch）或不处理
        new Throwable()|("异常原因")        此类及其子类都具有可抛性，调用者知道并处理
                String getMessage()        //原因
                String toString()        //类型和原因
                printStackTrace()        //类型、原因和位置输出到控制台。异常时虚拟机就是调用此方法

——递归        函数编程手法，函数自身直接或间接的调用到自身。
                注意：递归要有出口(明确条件)，递归次数不宜过多，否则内存溢出。
                循环和递归
                        递归可以转换为循环
                        循环不一定可以转换为递归

6六溜