A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© zhouxiaomeng 初级黑马   /  2018-4-15 08:26  /  731 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

day05序:
秋风清,秋月明;
落叶聚还散,寒鸦息复惊;
相思相念知何日;
此时此夜难为情;

一.        Object类: 属于lang包下,不需要导入,直接使用,是所有类的根类,是超类;
1.1        Object的toString方法:
                重写stoString方法:任何类都可以重写toString方法自定义出书内容,经常开发调试用
                用IDE方式(快捷键)
                //创建学生对象,写这个题的时候一定要记得,在类中用IDE的快捷方式来重写toString方法;
                Student s = new Student("小明",20);
                System.out.println(s.toString());
                //直接传进去一个对象,在底层系统会自动将s转换调用我们已经重写的toString方法,底层的原理是一样的
                System.out.println(s);
               
        getClass:返回字节码对象;
        getName:获取类名;
               
1.2 获取字节码对象的方式
                1.对象.getClass();返回一个Class对象;
                2.通过类名调用 类名.class 属性;
                3.通过Class类的静态方法 forName("类的全名") 记得加""双引号;返回一个Class对象;有可能类全名写的不对,所以要抛出异常:ClassNotFoundException
        *结论:同一个类的字节码都是一样的,地址值相同;
               
1.3        eqauls方法:
                使用==来比较两个对象是否相等,比较两个地址值是否相等.重写equals方法用快捷键

二.        System类:lang包下的类,不需要导包;包含类的字段和方法;不能实例化(不能创建对象)
        常用静态方法:
                1.arraycopy(Object src,int srcPos,Object dest,int destPos,int length):复制源数组到指定唱歌歌元素的一个新数组中;
                        Object src:源数组(被复制的数组);
                        int srcPos:从源数组指定的哪个索引开始复制;
                        Object dest:新数组 目标数组;
                        int destPos:指定目标数组从哪个索引开始复制;
                        int length:复制长度(目标数组接收元素的个数);
               
                2.currentTimeMillis():返回当前系统时间,返回值为long类型;返回毫秒值,从0时区1970-01-01-00:00:00开始计算至今过了多少毫秒;
       
       
       
        3.exit(int a):终止虚拟机的运行.参数为状态码,
        *惯例:        非0的状态码表示异常终止;
                        0的状态码表示正常终止;
三.        Data:表示特定的瞬间,精确到毫秒;它可以通过方法设定自己表示的时间,可以表示任何时间;
        注意不要导错包 有两个包,一个是sql的,一个是util的,我们用的是util的包;
       
        构造方法:
                Date():创建一个表示当前系统时间的Date对象;
                Date(long Date):根据"指定时间"创建Date对象,long Date代表毫秒值;是在1970-1-1 00:00:00的基础上加时间;
       
        成员方法:
                void setTime(long time):毫秒值---Date 参数为long
                long getTime(): Date---毫秒值  无参数,返回值为long类型;

四. SimpleDateFormat类:转换成符合我们习惯的时间类型;
        构造方法:
                SimpleDataFormat();无参构造,使用默认的模式进行对象的构建
                SimpleDataFormat(String pattern);有参构造,创建对象同时指定格式
        *注意:解析的字符串模式必须和构建对象的模式一样;
        shift+alt+m:封装方法;
        成员方法:
                格式化:format(Date date):Date---String;返回一个字符串
                解析:parse(String):String---Data;返回一个long毫秒值
        常见日期模式:
        y:年
        M:年中的月
        d:月中的日;
        D:年中的日;
        E:星期中的天数
        H:一天中的小时数(0-23)24小时制;
        k:小时(12小时制)
        m:小时中的分钟数;
        s:分钟中的秒数;
        S:毫秒数;
       

五.        Calendar类:日历类,提供了一些操作年日时的方法:
                               
        创建对象:Calender c = Calender.getInstance();
                静态字段:
                YEAR:年份:
                MONTH:月份;
                DAY_OF_MONTH:日期;
                HOUR_OF_DAY:小时;
                MINUTE :分钟;
       
        成员方法:
                获取:int get(int) 返回给定日历字段的值;
                修改;set(int field,int value)把指定的字段修改成指定的值
                添加;add(int field,int amount),在指定的字段上加上指定的值,可以增加,可以减少,Wie负数则为减少;

六.        1.1包装类:由于基本数据类型只能做简单的操作和运算,所以JAVA为我们封装了基本数据类型,每种基本数据类型提供了包装类;
        包装类就是封装了基本数据类型的类,为我们提供了更多复杂的方法和一些变量;
        8种基本数据类型
        byte Byte
        short Short
        int Integer;我们学习Integer,其他类型使用与此类似;
       
        Integer:
                成员方法:
                        String --- int/Integer
                                方式1:int intValue()
                                方式2:parseInt(String s)        最常用
                        int/Integer --- String
                                方式1:int值+"";最常用;
                                方式2:String a = i.toString;
                                方式3:静态方法Integer.toString;
                构造方法:
                                Integer(int value)
                                Integer(String s)
                               
        1.2        装箱和拆箱;
                1.自动装箱;
                2.自动拆箱;
               
七.        正则表达式 是一种用于匹配字符串的规则;




SimpleDataFormat
        格式化:
                Data----String;
        2049-8-26         2049年8月26日
               
        解析 :
                String ---- Data
                "2049-8-26"---

============================
day6 序:
        今夜我不关心人类,我只想你,Java!       
                                                        ----行走的搬运工.
                                                       
一.        集合和迭代器
        集合的体系结构:由于不同的数据结构,所以Java给我们提供了不同的集合;
        但是不同的集合他们的功能都是相似的,不断的向上提取,将共性抽取出来,这就是集合体系结构形成的原因.
        体系结构:
                        怎么学习?最顶层往下开始学习,印象最顶层包含了所有的共性;
                        怎么使用?使用最底层,因为最底层是具体的实现;
        Collection 最顶层
        List
        ArrayList 最底层中的一个;
       
1.1        Collection是根接口,因为是接口,所以不能实例化(创建对象),可以用多态创建子类的对象;
        常用的功能:
        add();返回值为boolean类型,ArrayList中的此方法永远都会返回true,因为可以重复添加;
        clear():清空集合;
        contains():判断是否包含,返回boolean类型;
        isEmpty():判断是否为空,返回boolean类型;
        remove();删除元素,删除成功返回true,没有删除成功,返回false;
        size();返回集合中的元素个数;
        toArray();将集合转成成Object类型的数组;
               

1.2        迭代器Iterator  *不太熟悉,要多练习!
        集合的遍历方式:
                1.toArray();把集合转船成数组,然后遍历数组;
                2.iterator():可以返回一个迭代器对象,我们可以通过迭代器对象来迭代集合;
                Iterator:可以用于遍历集合;创建对象:Inerator it = c.iterator();
                E next():返回下一个元素;
                boolean hsNext();判断是否有元素可以获取;
                代码1:
                        //迭代器对象调用.hasNext()判断是否能获取到下一个元素,如果能获取到,就迭代打印it.next();
                        while(it.hasNext()){
                        System.out.println(it.next());
                }
                代码2:
                public static void main(String[] args) {
                //创建集合对象,泛型为Student
                Collection<Student> c = new ArrayList<>();
                Student s1 = new Student("zhangsan",18);
                Student s2 = new Student("lisi",19);
                c.add(s1);
                c.add(s2);
                //创建迭代器;
                Iterator<Student> it = c.iterator();//用集合对象去调用iterator方法
                //迭代器遍历集合;
                while(it.hasNext()){
                        Student s = it.next();
                        System.out.println(s.getName());
                }
        }
       
               
        迭代器并发修改异常: 迭代器是依赖于集合的相当于集合的副本,当迭代器在操作的时候,如果发现和集合不一样,则抛出异常;
        解决方案:
                        在使用迭代器遍历集合的时候,使用迭代器来进行修改;
                       
1.3.        List接口;元素存取有序,元素可以重复,有索引;
                常用方法:
                add();增加
                remove();删除;
                *不太熟悉,要多练习!
               
                ListIterator l =list.listIterator();
                while(l.hasNext()){
                        String s = (String)l.next();
                        if(s.equals("java")){
                                l.add("android");
                        }
                }
               

       

二.        增强for和泛型

2.1        泛型:是一种广泛的类型,把明确数据类型的工作提前到编译时间,避免了类型转换的问题;
        可以减少黄色警告线,简化我们代码的书写;
        什么时候使用泛型?:
                查API,当我们看到<E>,就使用泛型;约束元素的类型;表示集合中的数据类型
2.2        增强for循环,foreach:作用:遍历数组h或者集合;
                格式:
                        for(元素类型 变量:集合或者数组对象){
                                可以直接使用变量;
                        }
                在增强for循环中不能修改集合长度,否则会出现并发修改异常;原因是增强for底层有迭代器;
               
               
三.常见的数据结构(理解的知识点)
3.1 常见的数据结构(数组):查找快,增删慢;ArrayList底层是数组;


3.2        常见的数据结构(链表):查找慢,增删快;
        链表:有链子连接起来的一堆结点;
        结点:地址值,值,下一个结点地址值;
3.3        常见的数据结构(栈和队列);       
                栈:先进后出FILO first in last out,后进先出;压栈,类似弹夹压子弹;
                队列:先进先出FIFO first in first out,后进后出,符合现实生活的逻辑;


四.List子体系

4.1        List接口:        Collection的子接口;有序的(存储和读取的顺序是一直的)
                                有整数索引;
                                允许重复;
                List的特有功能:
                                add();记得查下这个add和ArrayList的add有区别吗? 在指定索引位置添加指定元素;
                                get();根据索引返回元素;使用时注意索引别越界;
                                remove();删除指定元素,并返回;使用时注意索引别越界;
                                set();将指定索引位置上的元素替换为指定元素,并将原先的元素返回;
        LinkedList:
                        addFirst();将元素添加到索引为0的位置;
                        addLast();将元素添加到索引为size()-1的位置;
                        getFirst();获取第一个元素;;
                        getLast();获取最后一个元素;
                        removeFirst();删除第一个元素,并返回;
                        removLast();删除最后一个元素,并返回;
=====================================
day07 序:今日无序
       
本日课上练习目录:
1.使用HashSet储存字符串并遍历(三种遍历方式:1.转数组,2.迭代器;3.增强for);
2.

       
一.        Set体系:与List接口平级,继承自Collection接口,元素存取无序,元素不可重复,无索引;
                Set集合的特点:
                        无序(存储和读取的顺序有可能不一样);
                        不允许重复(要求元素唯一);通常用来做去重的操作;
                        没有索引;
        注意:无序是指存入顺序和去除的顺序不一样,而不是说每次取出来的是随机顺序,存入后每次取出来的顺序都一样,但是和存入的顺序不一样;
        *add()方法判断对象是否重复根据两个方法:
                1.hashCode();
                        1.1 判断哈希值不相同,则认为是不重复;
                        1.2 判断哈希值相同,则需要继续使用equals()方法判断;
                2.equals();
                        如果判定不相同,则认为不重复;
                        如果判定相同,则认为重复;
                       
二.        Collections工具类;里面提供了一些操作集合特别便捷的方法;
        Collection和Collections的区别:
                Collection是集合体系的最顶层,包好了集合体系的共性;
                Collections是工具类静态,不需要创建对象,也不能创建对象;方法都是用于操作Collection
                常用方法:
                binarySearch;二分查找法,查找指定元素的指定列表的索引位置;需要集合是已经排序;
                copy:是把源列表中的数据覆盖到目标列表;注意目标列表的长度至少等于源列表的长度;
                fill();使用指定对象填充指定列表的所有元素;
                revrse();反转;
                shuffle:傻否,随机置换;
                sort():按照列表中元素的自然顺序进行排序,元素要具有比较性;
                swap();将自定列表中的两个索引的位置进行互换;
       
       
二.        Map接口:双列集合的顶层,和Collection是属于同级,以键值对方式存储,键不可重复,值可以重复,键是无序,一个键只能映射一个值;
        Maphe Collection的区别;
                Map:是一个双列集合,常用于处理有对应关系的数据,key是不可以重复的,我们也称之为夫妻对集合;
                Collection:是单列集合,Collection有不停的子体系,有的允许重复
        Map的常用功能:
                映射功能:
                        put();将key映射到value,如果key存在,则覆盖value,并将原来的value返回
                删除功能:
                        clear();清空所有的对应关系,
                        remove:删除功能,有返回值;根据指定的key删除对应关系,并返回key所对应值,如果没有删除成功则返回null
                判断功能:
                        containsLey;判断指定的key是是否存在
                        containsValue:判断指定的value是是否存在
                        isEmpty();盘算是够有对应关系;
                获取功能:
                        get();根据指定的key返回对应的value;
                        size();返回对应关系的个数
                遍历功能:
               
        重要方法:
                keySet():获取所有的key;
                values方法:获取所有的value;
        Map的第一种遍历方式:利用keySet();
                首先召集所有的丈夫
                遍历所有的丈夫
                获取每一个丈夫
                让每个丈夫找他自己的媳妇
               
        Map的第二种遍历方式:利用entrySet();
                通过结婚证对象来湖区丈夫和媳妇
       
       
三.        可变参数:当前参数不确定时,类型要明确,Java可以帮我们把参数转成数组;
        形参:数据类型...形参名;
        *注意:
                        在可变参数之后不可再追加参数,但是可以在前面追加;
                        参数的数量自定义,可以给多个,甚至可以一个都不给;
                       
四.Map嵌套;多练习

=================================
day08笔记

一.        异常产生和异常处理;
        异常包含了,错误的类型,原因以及位置;
        异常的体系结构:
                Throwable(最顶层)
                        Error:出现了不能处理的问题;
                        Exception:可以处理的问题;
                                        1.编译时异常;编译时期就发生的异常;
                                        2.RuntimeException运行时异常;运营时才会发生异常;
        常见异常:
                空指针异常;
                索引越界异常;
               
        自己异常的处理方式:
                        1.捕获处理;
                                try...catch语句
                                try{
                                        有可能出现问题的代码
                                        可以有多行代码
                                }catch(创建异常对象){
                                        处理异常;
                                }
                               
                                try...catch的执行顺序:
                                        首先执行try语句
                                                如果发现异常,异常下面的代码不再执行,直接跳入catch语句中,catch语句结束后,整个try...catch结束;
                                                如果没有发现异常,不再执行catch语句
                                       
                        2.抛出去throws
                                当我们                                   不想处理异常,或者没有能力处理的时候,我们可以选择抛出异常;谁调用方法,谁处理异常;
                                使用关键字throws在方法的声明处抛出异常;
                处理多个异常,
                        可以使用try...catch语句;
                        使用一个try和多个catch;
                        多个catch之间的顺序
                                多个catch之间可以有子父类
                                平级之间没有顺序关系;
                                *如果有子父类,父类异常必须放在后面;
       
        JVM处理异常的方式:
                        如果出现异常我们没有处理,jvm会帮我们进行处理,他会把异常的类型/原因/位置显示在命令行,
                        并且终止了程序,异常后面的代码将不再执行;

        finally 组合try...catch使用,用于释放资源等收尾工作,无论try...catch如何执行,都会执行finally
       
        ***如何自定义异常类***;
                        非常简单 写一个类去继承Exception或者RuntimeException,然后实现多个构造即可;
       
       
二. Throwable常用方法
       



三. 递归
        在方法本身不断的调用方法自己;
        递归注意事项:
                递归一定要有出口,内存溢出;
                递归次数不宜过多,内存溢出;


0 个回复

您需要登录后才可以回帖 登录 | 加入黑马