);
}
判断条件 arr.length 此length为数组属性 后面字符串的str.length() 和集合的list.size() 为方法
数组的操作常见的两个异常 1 数组越界异常 （数组的下标超出了arr.length-1） 2 空指针异常
arr的指向为null时出现
作者: Pisces_Tiger 时间: 2017-4-4 12:56
方法、
修饰符 返回值类型 方法名（参数类型 参数1，参数类型 参数2，...）{
语句体
return 表达式/变量（与返回值类型相同）
修饰符： 权限访问修饰符（public protected default private）
public 任意访问 如果不在同一个包内 只需要导包即可
protected 同一包内 或跨包的子类访问
eg： cn.itcast.person 包内person类定义了 protected show(){} 方法
cn.itcast.student包内的student类继承了person show（）方法的最低访问为
protectd 当然也可以public 如果定义为 default show（） 则会报错
default 只能实现本包内的调用
private 私有 只能本类内调用
在eclipse中常常在一个文件中会定义多个类 但是只能有一个 是public修饰 其他的类不能是public修饰 也不能用protcted private等修饰 可用abstract fianal修饰
方法的重载（overload） 和 方法的重写（override）
重载： 1 方法名相同
2 参数的个数或参数类型不同
eg：
int add（int a， int b）
float add （int a， float b）
int add（int a， int b ， int c）
上面均属于方法的重载 跟返回类型无关 只要方法名相同 、参数类型不同 就是重载
方法的重写
方法名完全一致 大括号里面的内容不同 即实现的功能不同
作者: Pisces_Tiger 时间: 2017-4-4 15:25
类的介绍
类的基本组成要有属性 和 功能
属性就是成员变量 功能就是成员方法
一个完整类的几要素
student 类为例
1 成员变量 一般定义为private
eg： private String name
private int age;
2 构造方法
构造方法： 1. 访问修饰符 public修饰
2. 方法名与类名相同
构造方法参数 可以是 无参 有参 全参
public Student（）{
}
这里this解决了成员变量与局部变量同名的冲突
this指当前调用此方法的对象
附注1 ： this存活在对象中 不是类中 所以当方法用static修饰 要注意是不能用this的
附注2： this（）和super（）这两个方法在构造方法中不能同时使用 因为super（）r和this（） 都要在方法的第一行被调用
附注3： super（）方法在构造方法中是默认被调用 如若被this（）方法取代 说明this（）方法里一定实现了对父类构造方法的调用
public Student(String name){
this.name = name;
}
public Student(String name, int age){
this.name = name;
this.age = age;
}
3. get 和 set 方法
通过创建set和get方法 可以实现变量的私有化 将set get方法设为公有做为用户方位私有变量的接口 实现类的封装
public void setName（String name）{
this.name = name；
}
public String getName（）{
return name;
}
4 成员方法
类本身具有的功能 这里的学生功能可以做一个学习功能
public study（）{
System.out.println（"学生在学习"）；
}
作者: Pisces_Tiger 时间: 2017-4-4 16:14
ArrayList
数组存储任意类型（基本类型和引用类型）
集合只存储引用类型 存储基本类型会自动装箱 封箱
Collection --》 List--》
1 ArrayList 底层为数组结构 查询慢 增删慢 数组中允许有重复对象
2 LinkedList 底层为链式结构 查询慢 增删快
3 Vector 类同ArrayList 只不过ArrayList 非线程安全 Vector线程安全
ArrayList的遍历
Iterator it = list.iterator();
while(it.hasNext){
System.out.println(it.next());
}
for(int i = 0; i < list.size（） i++){
System.out.println(list.get9(i));
}
--》 Set Set是在HashMap的基础上实现的 以Map的key作为对应的存储项 存储数值不允许重复
1. HashSet 存储元素唯一 、无序、 不重复
2.LinkedHashSet HsahSet的子类 存储元素唯一、 有序 、不重复
================================================
HashSet的遍历
while(it.hasNext){
System.out.println(it.next());
}
Map
1.HashMap 以键值对的形式存储 （key，value）
======================================
HashMap的遍历
1 Set<String> set = map.keySet()
Iterator it = set.iterator();
while(it.hasNext){
String key = it.next();
System.out.println(map.get(key));
}
2 Set<Map.Entry<String,String>> entrySet = Map.entrySet();
Iterator<Map.entry<String,String>> entry = entrySet.iterator();
while(entry.hasNext()){
String key = entry.next().getKey();
String value = entry.next().getValue();
}
3
for(Map.Entry<String,String> entry : entrySet){
String key = entrySet.getKey();
String value = entrySet.getValue();
}
作者: Pisces_Tiger 时间: 2017-4-4 17:00
IO流
字符流
输入流 文件不存在 会异常报错
FileReader fr = new FileReader(fileName);
输出流 如果文件不存在 会自动创建
FileWriter fw = new FileWriter(fileName);
1字符读取 或者 2 字符数组读取
1 int ch；
while((ch = fr.read()) != -1){
fw.write(ch);
fw.flush();
}
fr.close();
fw.close();
2 char[] chs = new char[1024];
while((chs = fr.read(chs)) != -1){
fw.write(chs,0,len);
fw.fiush();
}
fr.close();
fw.close();
====================================================================================
高效流 /缓冲流
BufferedReader br = new BufferedReader(new FileReader(fileName));
BufferedWriter bw = new BufferedWriter(new FileWriter(fileName));
String str;
while((str = br.readLine()) != null){
bw.writer(str);
bw.newLine();
bw.fiush();
}
br.close();
br.close();
作者: xinsz08 时间: 2017-4-4 22:56
基础班要学这么多吗，感觉难不难
作者: 大Z啊 时间: 2017-4-5 22:12
楼主，javaee基础班只学两周就结束了吗？
作者: g1336855116 时间: 2017-4-5 23:08
支持露珠。。
作者: Pisces_Tiger 时间: 2017-4-19 10:06
继承
定义一个类B时,发现已有类A与要定义的类B相似，并且类B属于类A的一种时，可以将类B定义为类A的子类。
当多个类有着共性内容，可以将共性内容向上抽取，抽取到一个新的类中，这个新类和多个类形成一个关系叫做继承。
子类继承父类后，自动拥有父类所有可继承的属性和功能。
注意事项
java只支持单继承，不支持多继承，支持多层继承。(后面的接口可以多继承)
所有的类都直接或者间接继承了Object类，Object类没有父类
构造方法不能被继承
方法重写
当子类继承父类后，自动拥有父类所有可继承的属性和功能。但是子类觉得父类方法不够强大时，可以对父类方法按照自身逻辑
进行重写。 也叫方法复写，方法覆盖。
注意事项
1.可以使用@override检验是否为方法重写
2.子类方法权限必须大于等于父类方法权限
3.推荐和父类方法一样
this：本类对象的引用
super:本类对象中父类的引用
this和super
this.属性名 访问本类成员变量
this.方法名(参数) 访问本类其他方法
this(参数) 访问本类其他构造方法(注意必须在构造方法的第一行使用)(了解即可)
super.属性名 访问父类成员变量(非私有)
super.方法名(参数) 访问父类成员方法(非私有)
super(参数) 访问父类构造方法(非私有)(注意必须在构造方法的第一行使用)
注意：
this和super调用构造方法时不可以在同一个构造方法中同时使用，因为都需要定义在第一行。
调用构造方法时，必须要保证有这个构造方法才能够调用，如果没有这个构造方法则不能调用。
抽象类
抽象方法:没有方法体的方法叫做抽象方法
抽象类:有抽象方法的类必须是抽象类
抽象类的使用
1.抽象类不能创建对象
2.定义子类继承抽象类
3.子类重写父类方法
4.创建子类对象 调用方法
抽象类细节：
1.抽象类可以没有抽象方法
2.抽象类可以有具体的方法
3.抽象类必须是一个父类
4.子类必须重写所有抽象方法，否则子类也是一个抽象类
5.抽象类有构造方法，子类需要使用构造方法为成员变量赋值
抽象类出现的意义
抽象类定义了一类事物最基本的属性和行为。强制子类必须实现其功能。子类必须重写其抽象方法
作者: Pisces_Tiger 时间: 2017-4-19 10:13
接口
(1)当抽象类中的方法都是抽象的时候，java就提供了一种新的表现形式：接口。接口是功能的集合 接口不能创建对象
(2)格式：
父接口：
public interface Inter
{
}
子类：
public class InterImpl implements Inter
{
}
(3)接口的特点：
A:不需要被abstract修饰。
B:类实现接口,可以单实现,还可以多实现。
C:接口可以继承接口,可以单继承，也可以多继承。
D:接口与父类的功能可以重复，均代表要具备某种功能。
(4)抽象类和接口的区别:
A:成员的区别
抽象类：
成员变量：可以是变量，也可以是常量。
构造方法：有构造方法，用于子类实例化使用。
成员方法：可以是抽象的，也可以是非抽象的。
接口：
成员变量：只能是常量。
默认修饰符：public static final
成员方法：只能是抽象的。
默认修饰符：public abstract
推荐：默认修饰符请自己永远手动给出。
B:类和接口的关系区别
类与类：
继承关系,只能单继承。可以多层继承。
类与接口：
实现关系,可以单实现,也可以多实现。
类还可以在继承一个类的同时实现多个接口。
接口与接口：
继承关系,可以单继承,也可以多继承。
C:体现的理念不同
抽象类里面定义的都是一个继承体系中的共性内容。
接口是功能的集合,是一个体系额外的功能，是暴露出来的规则。
多态
(1)同一个对象，在不同时刻表现出来的不同状态。
举例：水(水,冰,水蒸气)
猫(猫,动物)
(2)前提：
A:有继承或者实现关系。
B:有方法的重写。
C:有父类(接口)的引用指向子类对象。
(3)多态中的成员使用特点：
Fu fz = new Zi();
多态时，所有表现形式都是父类的表现形式，
只有调用方法时，运行的是子类重写的方法
A:成员变量
编译看左边，运行看左边。
B:成员方法
编译看左边，运行看右边。
class Fu {
int num=4;
void show() {
System.out.println("showFu");
}
}
class Zi extends Fu {
int num=5;
void show() {
System.out.println("showZi");
}
}
class T {
public static void main(String[] args) {
Fu f=new Zi();
System.out.println(f.num);
f.show();
}
(4)多态中的转型：
A:向上转型
把子类对象赋值给父类(接口)的引用 自动类型提升 int a = 0; double b =a;
Fu fz = new Zi();
B:向下转型
把父类(接口)的引用强制转换成子类对象
double b = 10.0;
int a = (int)b;
Fu fz = new Zi();
Zi zf = (Zi)fz;
注意:Fu fu = new Fu() 不能向下转型 会报ClassCastException 类型转换异常
(5)多态的好处及弊端：
A:好处
提高了程序可维护下和可扩展性。
B:弊端
不能使用子类特有内容。
要想使用，要么向下转型，要么重新创建子类对象。
(6)多态的三种形式：
A:具体的类多态 父类 变量名 = new 子类();
B:抽象类多态 父抽象类 变量名 = new 子类();
C:接口多态 接口 变量名 = new 实现类();
instanceof 关键字
格式： 对象名 instanceof 类名
返回值： true, false
作用： 判断指定的对象 是否为 给定类创建的对象
Animal a1 = new Cat();
Animal a2 = new Dog();
method(a1)
public static void method(Animal a){
if(a instanceof Cat){
向下转型
调用猫特有方法
}
}
作者: Pisces_Tiger 时间: 2017-4-19 10:25
final：
final是最终修饰符，可以修饰类、成员方法、变量。
final修饰的类无法被继承。
final修饰的方法无法被重写。
final修饰的变量无法被再次赋值，变为了常量。
final修饰的引用数据类型变量，可以修改对象里面的属性内容，不可改变地址值
final修饰的成员变量，不能使用默认值，没有意义，必须在创建对象之前完成赋值。
可以显示赋值，可以在构造方法中赋值。
显示赋值： final int a = 10；
构造方法赋值：
class Person{
final int a；
public Person{
a 10；
}
}
static:
静态修饰符，被static修饰的内容属于类不专属于某个对象，多个对象共享使用这一个成员
使用static修饰的成员可以用类名直接访问，建议这样使用：
类名.静态方法名(参数);
类名.静态常量名;
静态修饰的成员只能直接访问静态修饰的成员，不能出现this、super,因为类是优于对象产生
（再次强调： this super只是存在于对象当中
this是当前对象的引用 谁调用 this指向谁）
内部类的概念：定义在一个类的内部的一个类叫内部类 分为：成员内部类与局部内部类
匿名内部类：
是局部内部类的一种
匿名内部类完成两件事：
1：定义了一个类型的匿名子类
2：定义类后，即刻创建了该类对象
目的：为了创建某个类的子类对象
格式：new 父类/接口() {
重写方法
};
包：软件组织文件的基本方式,用于将相同功能的类放到同一个包下，方便管理
在类的最前边使用package定义类所在包，注意：声明的package包必须与这个文件所在的文件夹一致
包的访问：(前提 类用public修饰)
同一个包下，随意访问
不同包下：
可以直接使用全名使用
为了方便，可以选择导包后，再直接使用类名本身，不加包名 在package后，class前使用import导入类
如果是lang包下的类，可以不导包，直接使用
代码块：一块执行代码的区域
局部代码块： 主要用于限定变量的作用范围
构造代码块（又叫成员代码块）：每次创建对象调用
静态代码块：第一次创建对象调用，再创建其他对象时不再重复调用
第一次访问静态成员 也会调用
类第一次加载时会调用，只会调用一次。
即 静态代码块只会在类加载时执行一次 其他时候不会再被调用
执行顺序 （静态代码块 成员代码块 构造方法）
静态代码块 > 成员代码块 > 构造方法
作者: newu 时间: 2017-4-19 11:46
方法、,不错,真是太棒了！
作者: DreamBoyMrsLin 时间: 2017-4-20 00:07
好好加油 希望你能一直坚持下去 到就业班毕业
作者: Pisces_Tiger 时间: 2017-4-21 20:07
java.lang.Object 所有类的超类
Object类中的方法子类都有
在Object类中
public String toString() 返回对象的字符串表现形式 数据类型 + @ + 地址值(哈希值)
子类一般都会重写此方法，因为看地址值没有意义，一般都需要看对象的属性值，返回属性值。
java.lang.Object类
boolean equals(Object obj) 比较两个对象是否相等 在Object类中 比较的是地址值
子类一般都会重写此方法 不再比较地址值，而是比较属性值。
注意：不是所有的运算符都可以操作引用数据类型
==可以比较引用数据类型，但是==永远比较地址值
throw关键字 抛出异常
定义在方法内 后跟异常的对象
编译时异常 ( checkedException必须处理 两种方式 下面会讲到)
编译期报错 必须处理 两种方式都可以
运行时异常 （uncheckedException 可以不处理）
编译期不报错，运行时报错 可以处理 也可以不处理 推荐不处理
因为如果出现运行时异常，一般情况都是代码有问题 ，需要修改代码
如果出现运行时异常 程序中断 ，下面代码不会执行。
异常处理的第一种方式 声明异常
throws关键字 声明异常
定义在方法的声明上 后跟异常的类名
声明异常的细节
可以声明多个异常 多个异常用,隔开
如果想写的方便，可以声明抛出多个异常的共同父类
第二种异常的处理方式
try{
可能出现异常的代码
}catch(异常的类名 变量名){
代码块中写什么不重要，只要执行了catch代码块 就处理了异常
一般情况都会打印异常的信息
}finally{
必须执行的代码
}
多catch处理异常
try{
}catch(异常的类名 变量名){
}catch(异常的类名 变量名){
}catch(异常的类名 变量名){
}....
多catch处理异常的细节
多个异常有没有顺序？
没有直接的继承关系时，没有顺序
NullPorterExceptionextends RuntimeException
ArrayIndexOutOfBoundsExceptionextends IndexOutOfBoundsException extends RuntimeException
如果有直接的继承关系 有顺序 小的写在前面 越大的越往后放
ArrayIndexOutOfBoundsExceptionextends IndexOutOfBoundsException extends RuntimeException extends Exception
可以直接抓一个Exception 别的都可以不写
try{
return i;
}catch(){
}finally{
++i;
必须执行的代码(无论是否出现异常 ，无论是否捕获异常 ，都会执行)
}
1. 此时返回的i值不变 不是++i的值
2. 方法中已经出现返回语句返回值A，再在finally中修改A值，则最终的返回值仍为修改前A的值。但在该方法中A的值已经被修改了
3. 当执行return结束方法，这时发现有finally没有执行，将返回的结果保存起来，再次执行 finally，执行finally之后，将保存的结果返回
异常后 方法重写的细节 (这里的抛异常指声明异常 第一种方式)
如果父类方法有异常 子类方法需不需要抛异常
子类方法可以不抛异常
子类方法可以抛异常，但是一定要小于等于父类的异常
如果父类方法不抛异常，子类需不需要抛异常
子类不可以抛异常 如果子类里边有异常 只能tryCatch处理
Throwable的三个方法
异常信息
String getMessage() "文件没找到"
String toString() java.io.FileNotFoundException: 文件没找到
voidprintStackTrace() 打印异常的详细信息
继承Exception 编译时异常
继承RuntimeException运行时异常
写构造方法即可
自定义异常的使用和正常java提供的异常没有任何区别 java提供的异常怎么处理
自定义异常就怎么处理
常见RuntimeException
//ArrayIndexOutOfBoundsException
//NullPointerException
// ClassCastException
// ArithmeticException
作者: Pisces_Tiger 时间: 2017-4-21 20:09
http://sdual.boxuegu.com/
java.util.Date
时间原点 1970-1-1 00:00:00
构造方法
public Date() 返回当前时间的日期
public Date(毫秒值) 返回指定时间的日期对象 参数毫秒值 指的是从1970 1 1 经过的毫秒值
方法
long getTime() 获取时间的毫秒值 从1970到 日期对象的所经历的毫秒值
void setTime(long 毫秒值) 设置当前对象的毫秒值
java.text.DateFormat 日期格式化类 抽象类
SimpleDateFormat extendsDateFormat
构造方法
public SimpleDateFormat() 默认的格式 17-4-21 上午9:07
public SimpleDateFormat(String s) 给定的格式
日期转换为指定格式的字符串
String format(Date date)
将指定格式的字符串转换成日期
Date parse(String source)
//将日期解析成指定格式的字符串
Date date = new Date();
DateFormat df = newSimpleDateFormat(“yyyy.MM.dd 一年中的第D天 E”);
String str = df.format(date);
//将指定格式的字符串解析成日期
String str2 = “1999-01-10”;
DateFormat df2 = newSimpleFormat(“yyyy-MM-dd”)；
Date date2 = df2.parse(str2);
java.util.Calendar 日历类 抽象类
创建对象的方法
static Calendar getInstance() 返回的是当前日历
方法
int get(int i) 返回给定字段的时间
void add(int field, int amount) 根据日历的规则，为给定的日历字段添加或减去指定的时间量。
Date getTime() 将日历对象转换为日期对象
void set(int field, int value) 将给定的日历字段设置为给定值。
void set(int year, int month, intdate) 直接设置年月日
Calendar cal = Calendar.getInstance();
Date date = cal.getTime();
long time = cal.getTimeMillis();
cal.add(Calendar.YEAR,-1);
cal.add(Calendar.DATE,1);
//数字0-11 代表 1-12月
c.set(Calendar.MONTH,11);
//1999年9月10日
c.set(1999,08,10)
自动拆箱装箱
Integer i1 = new Integer(500);
Integeri2 = new Integer(500);
System.out.println(i1== i2);//false
System.out.println(i1.equals(i2));//true
Integeri3 = 500;//new Integer(500);
Integeri4 = 500;//new Integer(500);
System.out.println(i3== i4);//false
System.out.println(i3.equals(i4));//true
//byte常量池细节 当值在-128 127之间时 会出现
//先判断有没有这个值 如果没有 则创建对象 如果有 ，直接赋值
Integer i5 = 127;//new Integer(100)
Integer i6 = 127;//i6 = i5;
System.out.println(i5 == i6);//true
System.out.println(i5.equals(i6));//true
java.util.Arrays 数组工具类 方法都是静态
static void sort(int[] a) 数组排序
static String toString(int[] a) 返回数组的字符串表现形式 int[] arr = {3,8}
[3, 8]
java.lang.System 系统类 不可以创建对象 所有方法全部都是静态
静态方法
static void exit(int status) 终止虚拟机 0
static void gc() 暗示垃圾回收器回收垃圾
static String getProperty(String key) 获取系统属性
System.getProperty(“java.home”);
System.getProperty(“java.version”);
System.getProperty(“os.name”);
System.getProperty(“os.version”);
staticvoid arraycopy(Object src, int srcPos,
Objectdest, int destPos, int length)
获取当前时间毫秒值
1.Date类getTime()
2.Calendar类long getTimeInMillis()
3.System类static long currentTimeMillis()
static void arraycopy(Object src, int srcPos,
Objectdest, int destPos, int length)
Object src:要复制的数组数据源
intsrcPos:从数据源中的第几个索引开始复制
Object dest:要讲数据复制到的数组 数据目的
intdestPos:复制的数据放入到目标数组的开始索引
intlength:复制几个
int[] score = {3,8,2,5,0};
数学工具类 java.lang.Math
static int abs(int a) 返回绝对值
static long round(double a) 四舍五入
static int round(float a)
static double ceil(double a) 向上取整
static double floor(double a) 向下取整
static int max(int a, int b) 两个数最大值
static int min(int a, int b) 两个数最小值
static double pow(double a, double b) a的b次幂
[] 代表 其中任选一个
?0-1
* 任意次
+ 至少1次
{n}代表 出现n次
{n,}代表至少出现n次
{n,m}代表出现 n - m
作者: 灬Wonder 时间: 2017-4-23 10:52
1111111111111111111111111
作者: Pisces_Tiger 时间: 2017-5-2 00:30
java.lang.Object 所有类的超类
Object类中的方法 子类都有
在Object类中
public String toString() 返回对象的字符串表现形式 数据类型 + @ + 地址值(哈希值)
子类一般都会重写此方法，因为看地址值没有意义，一般都需要看对象的属性值，返回属性值。
java.lang.Object类
boolean equals(Object obj) 比较两个对象是否相等 在Object类中 比较的是地址值
子类一般都会重写此方法 不再比较地址值，而是比较属性值。
注意：不是所有的运算符都可以操作引用数据类型
==可以比较引用数据类型，但是==永远比较地址值
throw关键字 抛出异常
定义在方法内 后跟异常的对象
编译时异常 ( checkedException必须处理 两种方式 下面会讲到)
编译期报错 必须处理 两种方式都可以
运行时异常 （uncheckedException 可以不处理）
编译期不报错，运行时报错 可以处理 也可以不处理 推荐不处理
因为如果出现运行时异常，一般情况都是代码有问题 ，需要修改代码
如果出现运行时异常 程序中断 ，下面代码不会执行。
异常处理的第一种方式 声明异常
throws关键字 声明异常
定义在方法的声明上 后跟异常的类名
声明异常的细节
可以声明多个异常 多个异常用,隔开
如果想写的方便，可以声明抛出多个异常的共同父类
第二种异常的处理方式
try{
可能出现异常的代码
}catch(异常的类名 变量名){
代码块中写什么不重要，只要执行了catch代码块 就处理了异常
一般情况都会打印异常的信息
}finally{
必须执行的代码
}
多catch处理异常
try{
}catch(异常的类名 变量名){
}catch(异常的类名 变量名){
}catch(异常的类名 变量名){
}....
多catch处理异常的细节
多个异常有没有顺序？
没有直接的继承关系时，没有顺序
NullPorterException extends RuntimeException
ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException extends RuntimeException
如果有直接的继承关系 有顺序 小的写在前面 越大的越往后放
ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException extends RuntimeException extends Exception
可以直接抓一个Exception 别的都可以不写
try{
return i;
}catch(){
}finally{
++i;
必须执行的代码(无论是否出现异常 ，无论是否捕获异常 ，都会执行)
}
1. 此时返回的i值不变 不是++i的值
2. 方法中已经出现返回语句返回值A，再在finally中修改A值，则最终的返回值仍为修改前A的值。但在该方法中A的值已经被修改了
3. 当执行return结束方法，这时发现有finally没有执行，将返回的结果保存起来，再次执行 finally，执行finally之后，将保存的结果返回
异常后 方法重写的细节 (这里的抛异常指声明异常 第一种方式)
如果父类方法有异常 子类方法需不需要抛异常
子类方法可以不抛异常
子类方法可以抛异常，但是一定要小于等于父类的异常
如果父类方法不抛异常，子类需不需要抛异常
子类不可以抛异常 如果子类里边有异常 只能tryCatch处理
Throwable的三个方法
异常信息
String getMessage() "文件没找到"
String toString() java.io.FileNotFoundException: 文件没找到
void printStackTrace() 打印异常的详细信息
继承Exception 编译时异常 必须处理（上面的两种方式）
继承RuntimeException 运行时异常 可以不处理
写构造方法即可
自定义异常的使用和正常java提供的异常没有任何区别 java提供的异常怎么处理
自定义异常就怎么处理
常见RuntimeException
//ArrayIndexOutOfBoundsException
//NullPointerException
// ClassCastException
// ArithmeticException
作者: Pisces_Tiger 时间: 2017-5-2 00:39
本帖最后由 Pisces_Tiger 于 2017-5-2 10:39 编辑
java.util.Date
时间原点 1970-1-1 00:00:00
构造方法
public Date() 返回当前时间的日期
public Date(毫秒值) 返回指定时间的日期对象 参数毫秒值 指的是从1970 1 1 经过的毫秒值
方法
long getTime() 获取时间的毫秒值 从1970到 日期对象的所经历的毫秒值
void setTime(long 毫秒值) 设置当前对象的毫秒值
java.text.DateFormat 日期格式化类 抽象类
SimpleDateFormat extends DateFormat
构造方法
public SimpleDateFormat() 默认的格式 17-4-21 上午9:07
public SimpleDateFormat(String s) 给定的格式
日期转换为指定格式的字符串
String format(Date date)
将指定格式的字符串转换成日期
Date parse(String source)
//将日期解析成指定格式的字符串
Date date = new Date();
DateFormat df = new SimpleDateFormat(“yyyy.MM.dd 一年中的第D天 E”);
String str = df.format(date);
//将指定格式的字符串解析成日期
String str2 = “1999-01-10”;
DateFormat df2 = new SimpleFormat(“yyyy-MM-dd”)；
Date date2 = df2.parse(str2);
java.util.Calendar 日历类 抽象类
创建对象的方法
static Calendar getInstance() 返回的是当前日历
方法
int get(int i) 返回给定字段的时间
void add(int field, int amount) 根据日历的规则，为给定的日历字段添加或减去指定的时间量。
Date getTime() 将日历对象转换为日期对象
void set(int field, int value) 将给定的日历字段设置为给定值。
void set(int year, int month, int date) 直接设置年月日
Calendar cal = Calendar.getInstance();
Date date = cal.getTime();
long time = cal.getTimeMillis();
对当前日期减一年
cal.add(Calendar.YEAR,-1);
对当前日期加一天
cal.add(Calendar.DATE,1);
//数字0-11 代表 1-12月
c.set(Calendar.MONTH,11);
//1999年9月10日
c.set(1999,08,10)
自动拆箱 装箱
Integer i1 = new Integer(500);
Integer i2 = new Integer(500);
System.out.println(i1 == i2);//false
System.out.println(i1.equals(i2));//true
Integer i3 = 500;//new Integer(500);
Integer i4 = 500;//new Integer(500);
System.out.println(i3 == i4);//false
System.out.println(i3.equals(i4));//true
//byte常量池细节 当值在-128 127之间时 会出现
//先判断有没有这个值 如果没有 则创建对象 如果有 ，直接赋值
Integer i5 = 127;//new Integer(100)
Integer i6 = 127;//i6 = i5;
System.out.println(i5 == i6);//true
System.out.println(i5.equals(i6));//true
java.util.Arrays 数组工具类 方法都是静态
static void sort(int[] a) 数组排序
static String toString(int[] a) 返回数组的字符串表现形式 int[] arr = {3,8}
[3 , 8]附加方法：
static int[] copyof(int[] original, int newLength) 复制指定数组 小于源数组长度截取 大于源数组长度 填充0
类似方法 :system的静态arraycopy方法(下面讲到)
static asList(T... a) eg： int[] arr = {3,8,2,5,0}
可变参数 List<Integer> list = Arrays.asList(arr);
java.lang.System 系统类 不可以创建对象 所有方法全部都是静态
静态方法
static void exit(int status) 终止虚拟机 0
static void gc() 暗示垃圾回收器回收垃圾
static String getProperty(String key) 获取系统属性
System.getProperty(“java.home”);
System.getProperty(“java.version”);
System.getProperty(“os.name”);
System.getProperty(“os.version”);
static void arraycopy(Object src, int srcPos,
Object dest, int destPos, int length)
获取当前时间毫秒值
1.Date类getTime()
2.Calendar类long getTimeInMillis()
3.System类static long currentTimeMillis()
system的静态arraycopy方法
static void arraycopy(Object src, int srcPos,
Object dest, int destPos, int length)
Object src:要复制的数组 数据源
int srcPos:从数据源中的第几个索引开始复制
Object dest:要讲数据复制到的数组 数据目的
int destPos:复制的数据 放入到目标数组的开始索引
int length:复制几个
int[] score = {3,8,2,5,0};
数学工具类 java.lang.Math
static int abs(int a) 返回绝对值
static long round(double a) 四舍五入
static int round(float a)
static double ceil(double a) 向上取整
static double floor(double a) 向下取整
static int max(int a, int b) 两个数最大值
static int min(int a, int b) 两个数最小值
static double pow(double a, double b) a的b次幂
[] 代表 其中任选一个
? 0-1
* 任意次
+ 至少1次
{n}代表 出现n次
{n,}代表至少出现n次
{n,m}代表出现 n - m
作者: Pisces_Tiger 时间: 2017-5-2 00:40
1. 知识点：泛型
要求：会使用泛型
泛型的好处是什么？泛型用于什么上？
泛型的好处：
1.提高了程序的安全性
2.将运行期遇到的问题转移到了编译期
3.省去了类型强转的麻烦
泛型的常见应用：
1.泛型类
2.泛型方法
3.泛型接口
3. 请简述List<? extends T>和List<? superT>之间有什么区别？
答案：
List<? extends T> ：向下限制
List<? super T> ：向上限制
?extends T ： 代表接收的泛型类型为T类型或T子类类型
? super T ：代表接收的泛型类型为T类型或T父类类型
java.util.Collection集合层次的根接口
ArrayList implements List extends Collection
Collection接口中的内容 是共性内容 所有集合都具备
* 常用方法
* boolean add(E e) //添加元素
* boolean remove(Object o) //删除元素
* void clear() //清空集合
* boolean contains(Object o) //判断是否包含某元素
* boolean isEmpty() //判断是否为空
* int size() //获取集合长度
*Object[] toArray() //将集合转换为数组
Collection使用迭代器遍历
方法
Iterator<E>iterator() 获取当前集合对象的专属迭代器
方法虽然是抽象的 但是Collection子类一定会重写返回Iterator的实现类对象 可以通过多态的方式获取到Iterator对象 使用Iterator的方法
Iterator接口
booleanhasNext() 判断是否有下一个元素
Enext() 获取下一个元素 调用一次 取出一个元素
当迭代集合中元素时 ，使用集合对象 修改了集合的长度 会报此异常
* ConcurrentModificationException
（看最后的eg2）
while(it.hasNext()){
String thisName = it.next();
if("柳岩".equals(thisName)){
集合c添加对象 改变集合长度 报异常
c.add("大郎");
集合不可以改变长度 但是迭代器可以
it.remove();
}
}
含有泛型的类
定义格式：修饰符 class 类名<代表泛型的变量> { }
使用格式：创建对象时，确定泛型的类型
n 例如，ArrayList<String> list = new ArrayList<String>();
含有泛型的方法定义格式：修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }
使用格式：调用方法时，确定泛型的类型
public <MOMO> void method(MOMO mm){
//MOMO类型在方法中可以使用
System.out.println(mm);
}
含有泛型的接口定义格式：修饰符 interface接口名<代表泛型的变量> { }
使用格式：
1、 定义类时确定泛型的类型
Public class MyClass4Interface implements MyInterface<String>{
@Override
public voidmethod(String e) {
// TODO Auto-generated method stub
}
}
2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型
public class MyClass24Interface<E> implements MyInterface<E>{
@Override
public void method(E e) {
// TODO Auto-generated method stub
}
}
=============================================================
eg1：
list.add("aaa");
list.add("ddd");
list.add("bbb");
list.add("ddd");
list.add("ccc");
// System.out.println(list.toArray());
System.out.println(list);
这里的删除是优先删除第一个
list.remove("ddd");
System.out.println(list);
==============================================================
eg2： list.add("aaa");
list.add("eee");
list.add("ddd");
list.add("ccc");
Iterator<String> it =list.iterator();
while((it.hasNext())){
String str = it.next();
// 报concurrentmodificationexception异常
// list.remove("ccc");
// 除了删除倒数第二个 其他位置的删除都异常
// list.remove("ddd");
System.out.println(str);
如果删除最后一个元素 删除后 在此进入循环 在it.next()时异常
删除倒数第二个元素，删除后直接跳出循环
删除其他位置的元素 ，删除后报异常
作者: Pisces_Tiger 时间: 2017-5-2 00:41
List集合的特点
有序 有索引 元素可重复
ArrayList implements List
public boolean add(E e)：向集合末尾处，添加指定的元素
public void add(int index, E e)：向集合指定索引处，添加指定的元素，原有元素依次后移
public boolean remove(E e)：将指定元素对象，从集合中删除，返回值为被删除的元素
public E remove(int index)：将指定索引处的元素，从集合中删除，返回值为被删除的元素
public E set(int index, E e)：将指定索引处的元素，替换成指定的元素，返回值为替换前的元素
public E get(int index)：获取指定索引处的元素，并返回该元素
List接口有两个实现类
ArrayList
LinkedList
java.util.ArrayList
实现类List
特点
有序 有索引 可重复
底层数据是数组 查询快 增删慢
线程不安全 效率高
boolean contains(Object o) 判断集合是否包含某个元素
判断两个元素是否相等的依据为 对象equals方法
java.util.Vector
实现List
特点
有序 有索引 可重复
底层数据是数组 查询快 增删慢
线程安全 效率低
java.util.LinkedList
实现了List接口
特点
有序 有索引 元素可重复
底层数据是链表 查询慢 增删快
线程不安全 效率高
public void addFirst(E e)将指定元素插入此列表的开头。
public void addLast(E e)将指定元素添加到此列表的结尾
public E getFirst()返回此列表的第一个元素
public E getLast()返回此列表的最后一个元素。
public E removeFirst()移除并返回此列表的第一个元素
public E removeLast()移除并返回此列表的最后一个元素
java.util.HashSetimplements Set
特点
无序 唯一
底层数据是哈希表 查询和增删都比较快
hashCode()与equals()方法
先比较hashCode方法
如果hashCode不同 添加到集合
如果hashCode相同 继续比较equals
如果 相同 不添加了
如果 不同 添加到集合
java.util.Set extends Collection
特点
元素唯一
HashSet 无序唯一
LinkedHashSet 有序唯一
java.util.LinkedHashSet implementsSet
特点
有序 唯一
底层数据是链表 + 哈希表
链表来保证有序 哈希表保证唯一 都是使用hashCode和equals方法保证元素唯一
java.util.HashSet存储自定义类型
保证元素唯一性 需要自定义类型重写hashCode和equals方法 alt+shift+s+ h
hashCode()与equals()方法
先比较hashCode方法
如果hashCode不同 添加到集合
如果hashCode相同 继续比较equals
如果 相同 不添加了
如果 不同 添加到集合
作者: Pisces_Tiger 时间: 2017-5-2 00:42
java.util.Map<K,V> 接口
Map集合是双列集合的顶层接口
K:Map集合的键 键是唯一的
V:Map集合的值 值可以重复
常用方法
V put(K key ,V value) 向集合中添加元素 一般返回的是一个null值 当键重复时，新值会覆盖掉旧值，返回值返回的是 旧值
V get(Object key); 根据key返回值
Vremove(Object key)根据 key删除键值对元素
两个实现类
HashMap
无序 键唯一
LinkedHashMap
有序 键唯一
Map集合的遍历
Map集合的第一种遍历方式 根据键找值
Set<K> keySet()返回一个包含所有键的Set集合
1.创建集合对象 添加数据
2.调用Map集合keySet方法，获取所有键的Set集合
3.遍历Set集合，依次获取每个key，调用Map集合get(Object key)获取所有的值
Map集合第二种遍历方式
方法
Set<Map.Entry<K,V>> entrySet() 返回键值对关系对象（结婚证）的 Set集合
Map.Entry
getKey
getvalue
1.创建Map对象 添加数据
2.调用entrySet方法 返回所有结婚证(键值对关系对象 Enry对象)的Set集合
3.遍历Set集合 一次获取每个结婚证(Entry对象)
4.根据结婚证(Entry对象) 找到 夫(key) 找到妻（value）
Map存储自定义类型 自定义类型作为Map的键
先比较hashCode
如果hashCode不同 添加到集合
如果hashCode相同 比较equlas
相同 不添加
不同 添加
Map集合存储自定义类型 保证键的唯一 需要自定义类型 重写hashCode和equals方法
java.util.LinkedHashMap extendsHashMap
特点
有序 键唯一
JDK1.5 新特性 可变参数
前提
方法的参数的数据类型确定 参数的个数不确定
格式
数据类型...变量名 可变参数的本质就是数组
可变参数的注意事项
1.一个方法只能有一个可变参数
2.一个方法如果有多个参数时，可变参数要放到最后
java.util.Collections 集合的工具类
static void shuffle(List list) 打乱集合顺序 只能传入List集合
static void sort(List list) 为集合排序 默认为自然排序 12 3 a b c
作者: Pisces_Tiger 时间: 2017-5-2 00:43
java.io.File 文件 目录 路径的抽象表现形式 文件:File 存储数据
目录:Directory 文件夹 存储文件 区分文件
路径：Path 路径 定位文件或文件夹
特点 ：平台无关性
File的静态常量
staticString pathSeparator 与系统有关的路径分隔符
windows下是 “;” unix下是 “:”
staticString separator 与系统有关的默认名称分隔符
Windows下是 “\” Unix下是 “/”
Uri 统一资源标识符
包括url
thrunder:sssss
ed2k:
mailto:123@qq.com
Url 统一资源定位符
http:\\www.baidu.com
File类构造方法
new File(“e:\\project\\a.txt”);
new File(“e\\project”,”a.txt”)
new File(new File(“e:\\project”),”a.txt”); == new File(dir,”a.txt”)
绝对路径
从盘符开始的路径都是绝对路径
d:\\work\\abc 唯一性
相对路径
d:\\work\\abc
d:\\work
d:\\work\\day04
父路径是唯一的 ，但是子路径是无限的
java.io.File
File的创建方法
不可以通过一个文件的文件名是否有后缀 来区分文件和文件夹
windows操作系统不区分大小写
文件夹和文件即使类型不同 也不可以重名
boolean exists()
判断构造方法中的路径是否存在
返回boolean类型 存在为true 不存在为false
boolean isDirectory() 判断是否是文件夹
boolean isFile() 判断是否是文件
返回boolean类型 如果返回true则是文件
但是如果返回false可能是文件夹 也可能构造方法中路径不存在
使用时，需要先判断 路径是否存在，判断后，除了文件就是文件夹
File的删除方法
boolean delete() 删除文件或文件夹 返回boolean类型删除成功为true删除失败为false
删除的是文件 ，如果文件中有数据 也可以删除
删除的是文件夹，如果文件夹中有文件或者嵌套了文件夹，是删除不了的
注意：java中的删除叫做永久性删除 不走回收站
运行有风险，操作需谨慎
File getAbsoluteFile() 推荐
String getAbsolutePath()
获取绝对路径的方法，但是返回值类型不同
File的list开头的方法
String[] list() 返回当前文件夹下 所有的文件的文件名的数组 包括
隐藏文件
String[] strs = file.list();
File[] listFiles() 返回当前文件夹下所有文件对象
File[] files = file.listFiles();
static File[] listRoots() 返回当前系统的盘符
eg:
遍历文件夹及子文件夹下的所有文件 递归方法
File file = new File(“E:\\project”);
Public static void getAll(File file){
File[] files =file.listFiles();
For(File f : files){
If(f.isDirectory()){
getAll(f);
}else{
Syso(f);
}
}
}
Eg2:
遍历给出文件夹及子文件夹下后缀为.java的文件 使用递归和过滤类
File file = new File(“E:\\project”);
Public static void getAll(File file){
File[] files =file.listFiles(new MyFileFileFilter());
For(File f : files){
If(f.isDirectory()){
getAll(f);
}else{
Syso(f);
}
}
}
Class MyFileFilter implements FileFilter{
@override
Public Booleanaccept(File pathname){
Booleanb1 = false;
Booleanb2 = false;
If(pathname.isFile()){
B1= pathname.getName().endsWith(“.java”);
}
If(pathname.isDirectory){
B2= true;
}
Return b1 || b2 ;
}
作者: wyn5130607 时间: 2017-5-2 23:54
加油吧加油
作者: maweiqiangmwq 时间: 2017-5-2 23:56
加油，一起努力
作者: maweiqiangmwq 时间: 2017-5-3 00:14
加油，楼主一起共勉哈
作者: mtime 时间: 2017-5-5 23:21
{:8_492:}{:8_492:}{:8_492:}{:8_492:}{:8_492:}{:8_492:}{:8_492:}{:8_492:}
作者: nhsjhello 时间: 2017-5-7 11:13
做成思维导图就跟方便了！
作者: Pisces_Tiger 时间: 2017-5-13 14:26
java.io.OutputStreamWriter extends Writer字符流转换成字节流的桥梁
特点可以指定编码表 可以使用父类的write方法 写一个字符 一个字符数组 字符数组一部分 及字符串
构造方法
OutputStreamWriter(OutputStream out)
OutputStreamWriter(OutputStreamout, String charsetName)
参数
OutputStream out 需要的是字节输出流的超类 ，可以传入其任意子类
FileOutputStream
String charsetName 指定的编码表 不写默认是GBK 可以指定编码表
编码表 不区分大小写 不要乱写
java.io.InputStreamReader extends Reader 字节通往字符的桥梁
特点 可以指定编码 可以使用父类的read方法 读一个字符 读一个字符数组
构造方法
InputStreamReader(InputStream in)
InputStreamReader(InputStreamin,String charsetName)
参数
InputStreamin 需要的是字节输入流的超类，可以传入其任意子类
FileInputStream
StringcharsetName 指定的编码表 不写默认是GBK 可以指定编码表
编码表 不区分大小写 不要乱写
===================================================================================
java.io.ObjectOutputStream 序列化流 将对象写入硬盘的文件
构造方法
ObjectOutputStream(OutputStream out)
参数
OutputStream out 需要的是字节输出流的超类 ，可以传入其任意子类对象
FileOutputStream
方法
voidwriteObject(Object obj) 写对象
java.io.ObjectInputStream 反序列化流 读取文件中的对象
构造方法
ObjectInputStream(InputStream in)
参数
InputStream in 需要的是字节输入流的超类，可以传入其任意子类对象
FileInputStream
方法
ObjectreadObject() 读对象
标记型接口 实现Serializable接口允许序列化和反序列化
静态内容不能序列化 因为我们是对象的序列化 ，而静态内容不属于对象
transient:瞬态关键字 作用唯一 不让该字段序列化
==================================================================================
打印流
字节打印流PrintStream
字符打印流PrintWriter
打印流的特点
1.打印流只负责输出目的
2.打印流永远不抛IO异常 可能抛其他异常
3.它为其他流添加了功能
PrintStream 构造方法可以接收 字符串File对象 所有字节输出流
PrintWriter 构造方法可以接收 字符串 File对象 所有字符输出流 所有字节输出流
打印流可以开启自动刷行
前提
1.构造方法接收的必须是流对象
PrintWriter(OutputStream out,boolean autoFlush)
PrintWriter(Writer out, booleanautoFlush)
参数
boolean autoFlush 如果为true则开启自动刷行 如果为false则不开启
2.只有3个方法可以开启自动刷行 printf println format
===============================================================================
java.util.Properties
特点
1 、Hashtable的子类，map集合中的方法都可以用。
2、该集合没有泛型。键值都是字符串。
3. 可以直接和IO流结合使用
添加元素的方法
setProperty(String key, String value) 添加元素
String getProperty(String key) 根据键获取值
Set<String> stringPropertyNames() 获取所有键的集合
Properties和IO流结合使用
voidload(InputStream inStream) 将文件中的键值对直接读入到集合
voidload(Reader reader)
参数
只要是输入流即可
voidstore(OutputStream out, String comments) 将集合中的键值对写入到配置文件
voidstore(Writer writer, String comments)
参数
只要输出流就可以
String comments 修改配置文件的解释
org.apache.commons.io.FileUtils
staticString readFileToString(Filefile)
staticvoid writeStringToFile(File file,String data)
staticvoid copyFile(File srcFile, FiledestFile) 复制文件
static void copyDirectoryToDirectory(File srcDir, FiledestDir) 复制文件夹 可以复制多级
PrintWriter pw= new PrintWriter(newFileWriter("e:\\project\\a.txt",true),true);
第一个true表示字符流的追加写 第二个true表示自动刷新
PrintWriter pw2 = new PrintWriter(newFileOutputStream("e:\\project\\a.txt",true));
第一个true表示字节流的追加写
作者: Pisces_Tiger 时间: 2017-5-13 14:28
总结：
final String file = "e:\\project\\a.txt";
// 字节流
InputStream in = new FileInputStream(file);
OutputStream out = new FileOutputStream(file,true);
// 缓冲字节流
BufferedInputStream bis =new BufferedInputStream(new FileInputStream(file));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file,true));
// 字符流
FileReader fr =new FileReader(file);
FileWriter fw = new FileWriter(file,true);
// 缓冲字符流
BufferedReader br = new BufferedReader(new FileReader(file));
BufferedWriter bw = new BufferedWriter(new FileWriter(file,true));
// 转换流可设置编码格式字节转字符InputStreamReader 字符转字节OutputStreamWriter
InputStreamReader isr = new InputStreamReader(new FileInputStream(file),"GBK");
OutputStreamWriter isw = new OutputStreamWriter(new FileOutputStream(file,true),"GBK");
BufferedReader br2 = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
BufferedWriter bw2 = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file,true)));
// 打印字符流打印字节流PrintStream 省略
PrintWriter pw = new PrintWriter(new FileOutputStream(file,true),true);
PrintWriter pw2 = new PrintWriter(new FileWriter(file,true),true);
// Properties 简况
Properties p = new Properties();
p.setProperty("age", "18");//类似于 map.put(k,v);
p.getProperty("age"); // map.get(key)
p.stringPropertyNames(); // map.keySet();
p.load(in);
p.load(bis);
p.store(out, "");
p.store(bos, "");
Map<Integer,String> map = new HashMap<Integer,String>();
map.put(1, "Lily");
map.put(2, "Lucy");
map.put(1, "Tom");
map.put(1, "Jim");
Set<Integer> keys = map.keySet();
for(Integer num : keys){
String thisValue = map.get(num);
}
Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
for(Map.Entry<Integer, String> entry : entrySet){
entry.getKey();
entry.getValue();
}
作者: Pisces_Tiger 时间: 2017-5-13 17:05
java.lang.Thread 线程类
开启线程步骤 (第一种方式 继承Thread)
1.定义一个类 继承Thread类
2.重写Thread类的run方法(线程任务)
3.创建子类对象
4.调用start方法
String getName() 返回线程名
void setName(String name) 设置线程名
static Thread currentThread() 返回当前线程对象的引用
start和run方法区别
如果调用的run方法 程序还是一个单线程的程序
只有调用start方法 JVM会启用开启的线程 自动调用run方法
Threadt = new Thread(){
@Override
public void run() {
System.out.println("!!!");
}
};
t.start();
线程创建的第二种方式 (实现Runnable)
1.定义一个类实现Runnable接口
2.重写run方法
3.创建Thread对象 ，在构造方法中传入Runnable实现类对象
Thread(Runnabletarget)
4.调用start方法开启线程
Runnabler = new Runnable() {
@Override
public void run() {
System.out.println("###");
}
};
Threadt2 = new Thread(r);
t2.start();
匿名内部类创建线程
作用：创建一个类/接口 子类/实现类对象的快捷方式
new 父类/接口(){
重写方法
};
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("bb");
}
}).start();
Thread类的sleep方法
static void sleep(longmillis) 休眠几毫秒
作者: Pisces_Tiger 时间: 2017-5-13 17:07
解决线程的安全隐患的方式采取同步的方式 同步代码块
synchronized(任意对象){
可能会出现问题的代码块
}
public void run() {
while(true){
synchronized (this) {
if(i>0){
try {
Thread.sleep(10);
}catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖出了第"+i+"张票");
i--;
}
}
}
}
同步方法
public static synchronized void sell(){
// synchronized(SubThread.class) {
if(i>0){
try {
Thread.sleep(10);
}catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖出了第"+i+"张票");
i--;
}
// }
}
解决线程的安全隐患的方式 采取同步的方式
同步代码块
synchronized(任意对象){
可能会出现问题的代码块
}
同步方法
在方法的声明上加入关键字synchronized
同步方法有锁吗？ 有 锁是谁？ this
同步方法可以是静态的吗？ 可以 静态的同步方法锁还是this吗？ 绝对不是
那是谁？ 类名.class
效率和安全
线程 安全 效率低
线程不安全 效率高
JDK1.5
使用Lock接口来解决线程安全问题
java.util.concurrent.locks.Lock 接口
实现类ReentrantLock
void lock() 获取锁
void unlock() 释放锁
int i = 100; //100张票
Lock l = new ReentrantLock();
@Override
public void run() {
while(true){
l.lock();
if(i>0){
try {
Thread.sleep(10);
System.out.println(Thread.currentThread().getName()+"卖出了第"+i+"张票");
i--;
}catch(InterruptedException e) {
e.printStackTrace();
}finally {
l.unlock();
}
}
}
}
作者: Pisces_Tiger 时间: 2017-5-13 17:12
java.net.InetAddress IP地址 静态方法(创建对象)
static InetAddress getLocalHost() 返回本地主机
static InetAddress getByName(Stringhost) 返回指定主机的IP对象 IP地址 主机名 网址
方法
String getHostName() 返回当前IP下的主机名
String getHostAddress() 返回当前IP下的字符串IP
InetAddress address = InetAddress.getLocalHost();//tom-PC/192.168.107.56
StringhostName = address.getHostName(); //tom-PC
StringhostAddress = address.getHostAddress();//192.168.107.56
InetAddress address2 = InetAddress.getByName("tom-pc");//tom-PC/192.168.107.56
InetAddress address3 = InetAddress.getByName("127.0.0.1");///127.0.0.1
InetAddress address4 = InetAddress.getByName("www.baidu.com");//www.baidu.com/119.75.218.70
UDP协议发送端 发送端套接字 java.net.DatagramSocket
构造方法
DatagramSocket() 创建发送端对象
方法
void send(DatagramPacket p) 发送数据包
发送端的数据包 java.net.DatagramPacket
构造方法
DatagramPacket(byte[]buf, int length, InetAddress address, int port)
length不能超过字节数组的长度 一般设置为buff.length
创建数据包对象 封装数据 接收端地址 及端口号
1.创建发送端对象DatagramSocket
2.准备数据
3.创建数据包的对象封装 封装数据 接收端地址 及端口号
4.调用DatagramSocket的send方法发送数据包DatagramPacket
5.关闭资源
DatagramSocket ds = new DatagramSocket();
byte[] buf = "你好".getBytes();
DatagramPacketdp = new DatagramPacket(buf,buf.length, InetAddress.getLocalHost(), 6666);
ds.send(dp);
ds.close();
UDP的接收端 接收端套接字 java.net.DatagramSocket
构造方法
DatagramSocket(int port)创建接收端对象
方法
void receive(DatagramPacket p) 接收数据包
接收端数据包java.net.DatagramPacket
构造方法
DatagramPacket(byte[] buf,int length) 接收长度为length的数据包
1.创建接收端对象
2.创建DatagramPacket接收端数据包的对象
3.调用DatagramSocket的receive接收数据包
4.拆包
DatagramPacket
int getLength() 获取长度
int getPort() 获取端口
InetAddress getAddress() 获取ip
5.关闭资源
DatagramSocket ds= newDatagramSocket(6666);
//接收数据包最大为64k
byte[] buf = new byte[1024*64];
DatagramPacketdp = new DatagramPacket(buf, buf.length);
ds.receive(dp);
InetAddressaddress= dp.getAddress();
//获取接收数据的真实长度
int len = dp.getLength();
buf = dp.getData();
System.out.println(new String(buf,0,len));
ds.close();
作者: Pisces_Tiger 时间: 2017-5-13 17:13
TCP的服务端 服务端 java.net.ServerSocket
ServerSocket(int port) 创建服务端对象
方法
Socket accept() 获取连接服务端的Socket对象
1.创建ServerSocket对象
2.调用accept获取连接服务端的客户端对象
3.调用Socket的获取字节输入流的方法接收你好
4.调用Socket的获取字节输出流的方法发送不好
5.关闭资源
ServerSocket server= newServerSocket(8888);
Socketclient = server.accept();
InputStreamin = client.getInputStream();
//在服务器创建新的文件名
String fileName ="com.itheima" + System.currentTimeMillis() + newRandom().nextInt(9999)+".txt";
BufferedOutputStreambos = new BufferedOutputStream(new FileOutputStream(new File("e:\\project",fileName)));
byte[] buf = new byte[1024];
int len = -1;
while((len = in.read(buf)) != -1){
bos.write(buf, 0, len);
}
//接收完成后给客户端发送提示
OutputStreamout = client.getOutputStream();
out.write("接收完毕".getBytes());
out.close();
bos.close();
in.close();
client.close();
TCP客户端 客户端 java.net.Socket
构造方法
Socket(InetAddress address, int port)
Socket(String host, int port) 创建客户端对象 绑定服务端ip地址及端口号
方法
InputStream getInputStream() 获取输入流
OutputStream getOutputStream() 获取输出流
1.创建客户端对象绑定服务端的ip和端口
2.获取输出流 输出"你好"
3.获取输入流 用来接收服务端发送的"不好"
4.关闭资源
Socket client= newSocket("127.0.0.1",8888);
OutputStreamout = client.getOutputStream();
BufferedInputStreambis = new BufferedInputStream(new FileInputStream("e:\\project\\socket.txt"));
byte[] buf = new byte[1024];
int len = -1;
while((len = bis.read(buf)) != -1){
out.write(buf, 0, len);
}
//告知服务器发送完毕 必须有
client.shutdownOutput();
//接收服务端的提示
InputStreamin = client.getInputStream();
len = in.read(buf);
System.out.println("接收到的data"+new String(buf,0,len));
in.close();
bis.close();
out.close();
client.close();
作者: Pisces_Tiger 时间: 2017-5-13 17:27
文件上传多线程版本, 服务器端ServerSocket server = new ServerSocket(8888);
final Socket client = server.accept();
while(true){
new Thread(){
public void run(){
InputStream in = null;
BufferedOutputStream bos = null;
OutputStream out = null;
try {
in = client.getInputStream();
String fileName = "com.itheima"+System.currentTimeMillis()+new Random().nextInt(9999)+".txt";
bos = new BufferedOutputStream(new FileOutputStream(new File("e:\\project",fileName)));
byte[] buf = new byte[1024];
int len = -1;
while((len = in.read(buf)) != -1){
bos.write(buf, 0, len);
}
out = client.getOutputStream();
out.write("接收ok".getBytes());
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
if(out != null){
out.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if(bos != null){
bos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if(in != null){
in.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if(client != null){
client.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}.start();
}
作者: Pisces_Tiger 时间: 2017-5-13 17:29
定义一个类 类具备 私有成员变量 空参数构造方法 get/set方法 //实现Serializable接口 我们称这样的类叫做 JavaBean
获取字节码文件对象
1.Object类中的方法
Class getClass() 获取字节码文件对象
2.每种数据类型 都有一个静态的class属性 包括基本数据类型
3.Class类的静态方法
staticClass forName(String className)
Person p = new Person();
Classc = p.getClass();
Classc2 = Person.class;
Class c3 = Class.forName("com.itheima.bean.Person");
反射获取构造方法
Class类中方法
Constructor<?>[]getConstructors() 返回当前字节码文件对象的所有public修饰的构造方法
Constructor<T>getConstructor(Class<?>... parameterTypes) 返回指定了参数的构造方法
参数
Constructor 用来描述构造方法的类 返回回来的就是Constructor的对象
Class<?>...parameterTypes 可变参数 是构造方法参数类型 如果参数不写 则返回空参构造方法
Constructor
T newInstance(Object... initargs) 运行构造方法创建对象
返回值T 是泛型 没有泛型就是Object类型
参数 为构造方法要使用的实际参数 参数不写则运行的是空参构造方法
Constructor con = c.getConstructor();
Objectobj= con.newInstance();
Constructorcon2 = c.getConstructor(String.class,int.class);
Objectobj2= con2.newInstance("Lily",18);
// getDeclaredConstructor获取私有构造函数
Constructorcon3 = c.getDeclaredConstructor(String.class);
// 允许暴力访问
con3.setAccessible(true);
Objectobj3= con3.newInstance("Jim");
反射获取成员变量(因为成员变量都是私有的，所以用的很少)(了解)
Class类中方法
FieldgetField(String name) 返回指定变量名的成员变量
Field[] getFields() 返回所有public修饰的成员变量
Field类中的方法
void set(Objectobj, Object value) 为指定对象的成员变量赋值 obj为要赋值的对象 value为要赋的值
1.获取字节码文件对象
2.通过字节码文件对象获取字段对象
3.调用set方法为字段赋值 注意 需要给定一个对象 可以通过快捷方式反射创建
Field[] fields = c.getDeclaredFields();
for(Field field : fields){
System.out.println(field);
}
// 获取私有字段
FieldnameField = c.getDeclaredField("name");
FieldageField = c.getDeclaredField("age");
// 允许暴力访问
nameField.setAccessible(true);
ageField.setAccessible(true);
// 设置字段值
nameField.set(obj, "Tom");
ageField.set(obj, 18);
// 获取字段值
System.out.println(nameField.get(obj));
System.out.println(ageField.get(obj));
// System.out.println(obj);
作者: Pisces_Tiger 时间: 2017-5-13 17:30
反射获取成员方法
Class类中方法
Method[] getMethods() 获取所有公共方法
Method getMethod(String name, Class<?>... parameterTypes) 获取指定方法名的公共方法
name 方法名
Class<?>... parameterTypes 可变参 方法需要的参数类型 如果不写为空参方法
Method类中方法
Object invoke(Object obj, Object... args) 对带有指定参数的指定对象调用由此 Method 所表示的方法
obj 要运行哪个对象的方法
args 方法的实际参数
1.获取字节码文件对象
2.通过字节码文件对象获取方法对象
3.调用invoke方法运行当前方法 注意 需要给定一个对象 可以通过快捷方式反射创建
Method setMethod = c.getMethod("setName", String.class);
setMethod.invoke(obj, "Jim");
Method setMethod2 = c.getMethod("setAge", int.class);
setMethod2.invoke(obj, 18);
Object obj = c.newInstance();
FileReader fr = new FileReader("prop.properties");
Properties p = new Properties();
p.load(fr);
Set<String> keys = p.stringPropertyNames();
for(String key : keys){
String methodName = "set" + key.substring(0, 1).toUpperCase() + key.substring(1);
Method setMethod = c.getMethod(methodName, String.class);
setMethod.invoke(obj, p.getProperty(key));
}
作者: Pisces_Tiger 时间: 2017-5-13 17:31
单元测试
@Testeclipse自带jar包 Ctrl+1导入使用
注解
JDK提供的注解
@Deprecated表示被修饰的方法已经过时
@Override重写方法 1.5支持父类不支持接口 1.5之后支持接口
@SuppressWarnings抑制警告 需要给属性值 all 所有警告都抑制
自定义注解 关键字@interface
成员
publicabstract 返回值类型属性名()[defualt 属性值];
返回值类型
基本类型，字符串，Class,注解，枚举，一维数组
public @interface Annotation {
public abstract intage();
public abstract String name();
}
注意：需要加上元注解才可以使用(不需要背单词能够使用快捷键写出即可) @Retention 用于确定被修饰的自定义注解生命周期
RetentionPolicy.SOURCE 被修饰的注解只能存在源码中，字节码class没有。用途：提供给编译器使用。
RetentionPolicy.CLASS被修饰的注解只能存在源码和字节码中，运行时内存中没有。用途：JVM java虚拟机使用
RetentionPolicy.RUNTIME被修饰的注解存在源码、字节码、内存（运行时）。用途：取代xml配置
@Target 用于确定被修饰的自定义注解使用位置
ElementType.TYPE修饰类、接口
ElementType.CONSTRUCTOR 修饰构造
ElementType.METHOD修饰方法
ElementType.FIELD修饰字段
//自定义注解要做元注解声明 Retention 生命周期 Target注解作用的位置
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.METHOD})
public @interface Annotation02 {
public abstract int age(); //default 10;
public abstract String name(); //default "Lily";
public abstract Annotation AnnotationDemo() default @Annotation(age=19,name="hellp");
public abstract String[] names() default {"JIm","Tom"};
}
注解使用 使用格式
@注解类名( 属性名= 值 , 属性名 = 值 , .....)
应用在类，方法，构造方法 字段上
注意
如果属性名为value，且当前只有一个属性，value可以省略。
如果属性类型为数组，设置内容格式为：{ 1,2,3 }
一个对象上，注解只能使用一次，不能重复使用。
解析
java.lang.reflect.AnnotatedElement
booleanisAnnotationPresent(Class annotationClass) 当前对象是否有注解 传入判断注解的字节码文件对象
TgetAnnotation(Class<T> annotationClass) 获得当前对象上指定的注解 传入获取注解的字节码文件对象 返回要获取的注解类型
public classAnnotationTest {
@Annotation02(age = 30,name = "hello")
public void method(){
System.out.println("此方法被Annotaion02注解");
}
@Test
public void method2(){
Classc = AnnotationTest.class;
Method[]methods = c.getMethods();
for(Method method : methods){
boolean b = method.isAnnotationPresent(Annotation02.class);
// System.out.println(method.getName());
if(b){
System.out.println(method.getName());
// 获取方法上注解的实例
Annotation02 anno = (Annotation02) method.getAnnotation(Annotation02.class);
// 输出注解中携带的信息
System.out.println(anno.name());
}
}
作者: Pisces_Tiger 时间: 2017-5-13 17:32
类加载器 全盘负责委托机制
全盘负责：A类如果要使用B类（不存在），A类加载器C必须负责加载B类
委托机制：A类加载器如果要加载资源B，必须询问父类加载是否加载。
获取类加载器
ClassLoaderloader = 类名.class.getClassLoader();
动态代理
调用者------类
调用者-----代理类-----类
ObjectproxyObj = Proxy.newProxyInstance(参数1,参数2,参数3);
参数1：ClassLoader，负责将动态创建类，加载到内存。当前类.class.getClassLoader();
参数2：Class[] interfaces,代理类需要实现的所有接口（确定方法）,被代理类实例.getClass().getInterfaces();
参数3：InvocationHandler,请求处理类，代理类不具有任何功能，代理类的每一个方法执行时，调用处理类invoke方法。
invoke(Object proxy ,Method ,Object[]args)
参数1：代理实例 与你无关
参数2：当前执行的方法
参数3：方法实际参数。
public class ProxyDemo{
// 传入被代理的对象 匿名对象使用obj 用final修饰
// 返回值object为 生成的代理对象
public Object getProxy(final Object obj){
// 被代理对象的类加载器 被代理对象实现的接口 要实现的InvocationHandler子类
ObjectnewProxy = (Object)Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),newInvocationHandler(){
@Override
// 返回值Object 为method执行后的返回结果
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Classc = obj.getClass();
Method[]methods = c.getMethods();
if("add".equals(method.getName())){
System.out.println("执行add");
}
if("remove".equals(method.getName())){
System.out.println("执行remove");
}
if("get".equals(method.getName())){
System.out.println("执行get");
}
return method.invoke(obj, args);
}
});
return newProxy;
}
}
测试：
public classProxyTest {
public static void main(String[] args){
ProxyDemoproxy = new ProxyDemo();
List<String>list = newArrayList<String>();
list = (List<String>)proxy.getProxy(list);
list.add("hello");
list.add("world");
list.get(0);
}
}
作者: Pisces_Tiger 时间: 2017-5-13 17:32
Xsl全名：xml schema instance
Web-app web.xml的根节点标签名称
Version 版本
Xmlns web.xml文件用到的命名空间
Xmlns：xsi 指web.xml遵守xml规范
Xsi：shemaLocation 具体用到的schema资源
XML
可扩展的标记语言
作用
1.存放数据
2.配置文件
语法
文档声明
<?xmlversion="1.0" encoding="UTF-8"?>
1.文档声明必须为<?xml开头，以?>结束；
2.文档声明必须从文档的0行0列位置开始；
3.文档声明只有2个属性：
version版本
encoding编码
元素
<bean></bean>
1.必须开始结束
2.标签由开始标签，元素体、结束标签组成<hello>大家好</hello>
3.
元素体 可以是文本 也可以是标签<b><a>
你好</a></b>
4.空元素<c />
5.元素命名 区分大小写 不用特殊符号 不要xml开头
6.必须有根元素
属性
<beanid=”” className=””>
1.出现在开始标签
2.属性名="属性值"
3.一个元素多个属性不可相同
4.属性名无特殊符号 字母开头
注释
<!---->
转义字符(不用记)
< <
> >
" "
' '
& &
CDATA
<![CDATA[
纯文本
]]>
DTD
引用DTD
本地dtd
<!DOCTYPEbeans SYSTEM "bean.dtd">
公共dtd
<!DOCTYPEbeans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"
"http://www.springframework.org/dtd/spring-beans-2.0.dtd">
元素声明(了解)
？ 0-1次
* 任意次
+ 至少1次
()分组
| 或
, 顺序
属性声明(了解)
属性的语法：（attribute）
<!ATTLIST元素名
属性名 属性类型 约束
属性名 属性类型 约束
...
>
元素名：属性必须是给元素添加，所有必须先确定元素名
属性名：自定义
属性类型：ID、CDATA、枚举…
ID: ID类型的属性用来标识元素的唯一性
CDATA：文本类型
约束：
#REQUIRED：说明属性是必须的；required
#IMPLIED：说明属性是可选的；implied
能根据约束写标签即可
Schema
引用Schema
<beansxmlns="http://www.itcast.cn/bean"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.itcast.cn/beanbean-schema.xsd"
></bean>
能根据约束写标签即可
xml解析 DOM解析原理
将xml加载进内存 形成DOM树 并得到一个document对象
dom4j
常用API如下：
1.SaxReader对象
a)read(…) 加载执行xml文档
2.Document对象
a)getRootElement()获得根元素
3.Element对象
a)elements(…) 获得指定名称的所有子元素。可以不指定名称
b)element(…) 获得指定名称第一个子元素。
c)getName()获得当前元素的元素名
d)attributeValue(…) 获得指定属性名的属性值
e)elementText(…) 获得指定名称子元素的文本值 不实用
f)getText()获得当前元素的文本内容
作者: z1ab147 时间: 2017-5-14 11:30
收藏了,以前学的都忘得差不多了,连配环境变量都忘了...
作者: 吴君如 时间: 2017-5-14 20:45
回复回复
作者: fujian0212 时间: 2017-5-20 14:21
顶顶顶顶顶顶顶顶
作者: 風中雨来 时间: 2017-5-21 16:24
加油，谢谢分享
作者: unscdf117 时间: 2017-5-21 18:48
- - 6666666666666666
作者: 烽火狼烟 时间: 2017-5-26 09:03
都在这里晒笔记啊 牛
作者: liximing2017 时间: 2017-5-26 16:47
貌似是从JavaSE开始的啊。加油。
作者: lavender298 时间: 2017-5-26 23:06
多交流,更有利于学习,...
作者: MosLY 时间: 2017-5-29 00:10
厉害了,我的哥...
作者: Pisces_Tiger 时间: 2017-6-3 11:18
BeanUtils
setProperty(Objectobj,String name,Object value)
Student stu = new Student();
BeanUtils.setProperty(stu, "name", "Lily");
BeanUtils.setProperty(stu, "age", 18);
System.out.println(stu);
getProperty(Object obj,String name)
Studentstu = new Student("Lilei",20);
Stringname = BeanUtils.getProperty(stu, "name");
Stringage = BeanUtils.getProperty(stu, "age");
System.out.println(name);
System.out.println(age);
populate(Object bean, Map<String,String[]> properties)
Student stu = new Student();
Map<String,String[]>map = new HashMap();
map.put("name", new String[]{"Jim"});
map.put("age", new String[]{"18"});
BeanUtils.populate(stu, map);
System.out.println(stu);
饥饿单例模式
private static final Singleton01 single = new Singleton01();
private Singleton01(){
}
publicstatic Singleton01 getSingle(){
returnsingle;
}
懒汉单例模式
private static SingletonDemo02 single;
private SingletonDemo02(){
}
public static SingletonDemo02getSingle(){
// 如果创建 就不在进入同步代码块 提高效率
if(single == null){
synchronized(SingletonDemo02.class){
// 避免同步时创建多个对象
if(single == null){
single = new SingletonDemo02();
}
}
}
return single;
}
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |