黑马程序员技术交流社区

标题: 笔记 [打印本页]

作者: zhouxiaomeng 时间: 2018-4-15 08:26
标题: 笔记
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常用方法

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

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2