java基础复习
1、 抽象类可以有构造器，可以有一个非抽象的父类
2、 垃圾回收机制回收的是堆里面的内存，栈里面的数据自动入栈自动出栈
3、 引用类型的数据在堆当中，内存中操作的只有栈，new关键字在堆里面分配一块内存
4、 java中是值传递
5、 String是不可变字符，即一旦分配了内存，此内存的值将不会改变，又将String赋值是，会重新分配一块内存，字符串池： StringBuffer
6、 在堆中的东西叫对象
? 运行时异常：
n ArithmeticException 当出现异常的运算条件时，抛出此异常。例如，一个整数“除以零”时，抛出此类的一个实例。
n ArrayIndexOutOfBoundsException用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引。
n ArrayStoreException试图将错误类型的对象存储到一个对象数组时抛出的异常。如：
u Objectx[] = new String[3];
u x[0]= new Integer(0);
n ClassCastException视图将对象转换为不是实例的子类时，抛出该异常。如：
u Objectx = new Integer(0);
u System.out.println((String)x);
n illegalArgumentException表明向方法传递了一个不合法或不正确的参数
n NegativeArraySizeException如果应用程序视图创建大小为负的数组，则抛出该异常
? 编译时异常：
n NoSuchMethodException无法找到某一特定方法时，抛出该异常
7、 unicode码范围
汉字：[\u4e00,\u9fa5]
数字：[0x30,0x39]
小写字母：[0x61,0x7a]
大写字母：[0x41,0x5a]
8、 final类
l final类能够修饰非抽象类、非抽象类成员方法和变量（静态变量、实例变量、局部变量）
l final类不能被继承，没有子类
l final方法可以被继承，但不能被子类的方法覆盖
l final成员变量表示常量，声明成员变量时，必须赋值（要么在声明的时候赋值，要么在构造器中赋值），赋值后不能被改变
u publicfinalint E; //final空白,必须在初始化对象的时候赋初值
public Test3(int x) {
E= x;
}
l final不能用于修饰构造方法2.5
9、 static只能修饰成员变量，表示所有对象共享这个数据
l static能够修饰成员变量和方法，内部类，也可以形成静态static代码块，不能修饰局部变量
l 被static修饰的成员变量可以直接用类名来调用，语法如下：
u 类名.静态放大名（）；
u 类名.静态变量名；
l 静态方法中不能用this和super关键字，不能直接访问不带static的成员变量和成员方法
l 因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract
l 先运行静态代码块，再运行构造器
10、static和final一块表示什么
l staticfinal用来修饰成员变量和成员方法，可理解为全局变量（java中没有全局变量的概念）
l staticfinal修饰变量，表示一旦给值就不可修改，并且通过类名就可以访问
l staticfinal修饰方法，表示不可覆盖，并可通过类名直接访问
l staticfinal修饰一些容器类型（ArrayList、HashMap）的变量，不可以改变容器变量本省，但可以修改容器中存放的对象
11、类成员变量分类
被static修饰的变量叫静态变量或者类变量；
没有被static修饰的变量叫实例变量。
12、命令行参数
java主类参数（即命令行参数）
eclipse中java输入命令行参数，在选定的类中，点击右键run as—Runconfigurations—Arguments-Program arguments-Variables-选择string_prompt
13、Integer.valueOf(String)将字符串转换成Integer包装类
14、一个.java文件中可以有很多类。不过注意以下几点：
a、public 权限的类只能有一个（也可以一个都没有，但最多只有1个）
b、这个.java文件的文件名必须是public类的类名（一般的情况下，这里放置main方法是程序的入口。）
c、若这个文件中没有public的类，则文件名随便是一个类的名字即可
d、用javac 编译这个.java文件的时候，它会给每一个类生成一个.class文件
15、面向对象、面向过程
面向对象的三大特性：封装、继承、多态
面向过程：C语言的底层语言的特性
16、类和对象：
一个类中可以有多个对象，类是对对象的描述
一个类中的成员：
字段：封装private
方法：类的行为
构造器：与类同名，没有返回值。作用：初始化成员变量。默认构造器：无参且同名没有返回值，当一个类显示的表明构
造器，则类不自己建立默认构造器
内部类
17、类之间的关系：继承耦合度最高
A．继承（is-a）: 单继承多实现 extends 优点：减少了代码的冗余、缺点：耦合度太高
B．实现:
C．组合(has-a):
合成:个体和整体的关系，个体与整体生命周期相同，公司和部门的关系
聚合：个体和整体的关系，生命周期不同，学生和学校的关系
关联：双向关联
Class Person{
Petpet;}
ClassPet{
Personowner;
}
D．依赖(use-a):一个类作为另一个类方法的参数或者是返回值，称为依赖
18、java设计原则
低耦合高内聚
可扩展性和可维护性
19、继承：
子类中的成员：
1）从父类中继承的可视化（非私有的）的成员（字段、方法），不能继承父类的构造器
2）子类所特有的成员（字段、方法、构造器）
3）重载父类的成员（方法） 多态
重载的条件：
a）发生在同一个类或者父子类之间
b）方法名称相同，参数列表（参数的个数，参数的数据类型、参数的顺序）不同
c）返回值无所谓
d）访问权限无所谓
歧义重载：
ma(12,34)//歧义重载，编译错误
publicvoid ma(int i,double j){//打印1}
publicvoid ma(double i,int j){//打印2}
构造器重载：
this：
this.成员（字段、方法）：调用本类的字段、方法
this(参数列表):调用本类的其他构造方法，必须在构造方法的第一句
public Person(int age){
this(age,””);//调用下面那个构造器
}
publicPerson(int age,String name){
this.age= age;//调用本类的字段
this.name= name;
}
super：父类的对象
super.成员：调用父类的成员（方法、字段）
super(参数列表)：调用父类的构造方法，必须位于子类构造方法的第一句
如果父类中没有无参的构造器，在子类中必须显式的调用父类带参数的构造方法（super（参数类表或者this（参数列表）））； 如果父类有无参的构造器，则子类中可以不用显式调用父类的构造器，因为系统默认调用super（）;
4）重写父类的成员（方法） 多态
重写的条件 ：
a）发生在父子类之间
b）方法名称相同，参数列表（参数的个数，参数的数据类型、参数的顺序）相同
c）返回值必须相同
d）子类覆盖方法的访问权限大于等于父类被覆盖方法的访问权限
e）子类不能抛出比父类异常更大的异常（RuntimeException例外）
5）隐藏父类的成员（字段）
多态对象：调用隐藏成员，调用的是父类的
调用覆盖成员，调用的是子类的
20、static:类成员
字段：所有对象共享
方法：静态方法不能直接访问非静态的成员，如果需要访问，产生实例访问；
非静态方法能够直接访问静态成员和非静态成员
静态方法中不能有this、super关键字
块：内存中只执行一次，通常用来初始化静态成员
内部类
21、final：终态的
变量：不能第二次赋值，而且必须有初始值
方法：不能被重写
类：不能被继承
22、abstract：
抽象方法必须在抽象类中，抽象类中不一定要有抽象方法
抽象类没有实例
抽象类可以有父类，父类可以是抽象类也可以是非抽象类
抽象类有构造器，不能用来产生本类实例，构造器用来间接产生子类实例时使用
abstract不能与static、final、private一起使用
23、异常处理：
1）try{}catch（）finally{}
2）throws 方法声明后 throws 异常类
3）throw 句子（通常是if）后throw 异常类的实例
4）自定义异常类 extends Exception或者RuntimeException
24、方法重写(override)和 重载(overlord)的区别
重写override：子类中出现与父类中签名相同的方法、访问修饰符要等于高于父类、返回值类型，参数列表都相同
重载overlord：一个类内部出现两个及两个以上方法名相同、参数列表不同(参数类型，参数个数，参数类型的顺序)的方法
25、动态多态和静态多态
动态多态（运行时多态）：运行过程中才知道调用那个方法，指的是方法重写
静态多态（编译时多态）：编译时就知道所调用的方法，指的是方法重载
26、如果父类中没有空参构造
那么子类必须同super()的方式显示的调用父类构造
建议：如果父类中出现带参构造，那么必须手动添加空参构造
例：下列代码的运行结果是（ B）
classA{
public A(int a){System.out.println（“A”）;}
}
class B extends A{
publicB(){
super(5);//必须加上这一块，用super（）显示的调用父类中的方法
}
public voidma(){System.out.println(“ma”);}
}
public class test{
public static void main(String[]args){
B b=new B（）;
b.ma();
}
}
A. 打印输出ma
B. 编译错误
C. 打印输出A
D. 打印输出A ma
27、 static：
表示静态的，修饰的内容属于类成员；被该类的所有对象共享，建议使用类名.的方式访问；修饰的内容在类加载的时候，执行；只能访问被static修饰的内容；修饰的内容只在类加载的时候执行一次。
可以修饰的内容：修饰属性、修饰方法、作为代码块使用 jdbc 加载驱动的时候
static{
Class.forName("");//作为代码块使用
}
特点：
1.修饰的内容属于类成员
2.修饰的方法，不能被重写，可以被重载
3.修饰的内容，执行一次
例：public class HelloWorld{
public staticvoid main(String args[]){
method();
}
public voidmethod(){
try{
System.out.println("hello我执行");
}
finally{
System.out.println("我就不执行");
}
}
}
编译运行后，输出结果是什么？(D )
A."hello 我执行"
B."我就不执行"
C."hello 我执行"
"我就不执行"
D.代码不能编译
因为main方法是用static修饰的静态方法，调用的方法也必须用static修饰，而method();方法没有被static修饰
28、hashcode()返回的是对象的内存地址对应的int类型数据，但是我们可以重写hashCode()方法，返回的就不再是内存地址。
hashcode()相同的对象，这两个对象不一定相同；如果两个对象相同，则hashcode()一定相同。
29、java中的访问修饰符
public： 所有
protected： 自己、同一包中、子类可以访问
default： 默认什么都不加，就是default，自己、同一包中可以访问，但是比protected级别要低即限制更多
friendly： 自己、同一包中可以访问
private： 自己
例：以下代码的运行结果是：( C )
1. abstract class abstrctIt {
2. abstractfloat getFloat ();
3. }
4. public class AbstractTest extends AbstractIt {
5. privatefloat f1 = 1.0f;
6. privatefloat getFloat () {return f1;}
7. }
A. 编译成功
B. 第6行产生错误，导致运行失败
C. 第6行产生错误，导致编译失败
D. 第5行产生错误，导致编译失败
默认什么不加的访问修饰符是default，default比private限制少（即更高级），比protected限制多，所有第六行重写方法用的private访问修饰符比父类低级，所有会出现编译失败
30、Math.random()获取[0,1)的值，取不到1；
用法：（int）Math.random()*n+1;取到1到n之间的整数
31、数组、集合、字符串之间的转换
a. Arrays.asList() //将数组转换成集合
例：List list = Arrays.asList(names);//将数组转换成集合。
b.String.valueOf() //将数组转换成字符串、也可将整数转换成字符串
例：char []ch1 = {‘a‘,‘c‘,‘a‘,‘b‘,‘a‘};
String str2 = String.valueOf(ch1);
例：int num = 123456;
String str =String.valueOf(num);
c.toCharArray()将字符串转换成数组
例：String str = "gdfgdfgd";
char[] ch = str.toCharArray();
d.Arrays.toString()将字符数组变成字符串特定格式输出，如[1,2,3]
例：String str1 = Arrays.toString(ch);
System.out.println(str1);
e.str.reverse();将字符串反转
例：StringBuffersb =new StringBuffer("adfsdsd");
sb.reverse();
f.
32、replace();函数
例1：//将字符串"abcdabcdabdcadcbadcb"的字符出现的次数输出
Stringnum = "abcdabcdabdcadcbadcb";
String t = num.replace("a","");
System.out.println(num.length()-t.length());
replaceAll()，用正则表达式
例2：//将字符串中的数字去除
String num1 = "ab23c7da45bc5da65bd5c67ad7cb9adcb";
String t1 = num1.replaceAll("[0-9]", "");
System.out.println(t1);
例3：//计算字符串的长度，一个字符算两个
byte[]b =str.getBytes();
System.out.println(b.length);//若出现一个汉字代表3个字节的情况，将Utf-8换成GBK就可以了
String m = str.replaceAll("[\u4e00-\u9fa5]", "xx");
System.out.println(m.length());
33、DecimalFormat（）;将数字转换成特定的格式
例：//数组格式化 int num = 1234567; 换成123，4567
int num = 1234567;
DecimalFormat f =new DecimalFormat("#,####");
String t =f.format(num);
System.out.println(t);
例： //将数组转换成123,4567.89的格式
doubled = 1234567.88898890;
DecimalFormat f =new DecimalFormat("#,####.##");
System.out.println(f.format(d));
34、String类型是否可以被继承，为什么？
不能被继承，因为是被final修饰的类
35、String类型是否是基本类型，比较String类型变量时，== 和equals有何区别？
不是，是引用类型
a.如果 String类型是直接赋值 == 和 equals 效果相同
String a = “abc “;
String b = “abc”;
a ==b 和 a.equals(b)都为true
b.如果String是通过new构建的 == 和equals效果不同
String a = new String（“abc”）；
String b = new String（“abc”）；
a ==b 结果为false
a．equals（b）结果为true
36、char类型中是否可以存放一个汉字，为什么？
可以，char类型中存放的数据以Unicode码存放。
37、Random()函数
//获取1-35之间的随机数
//第一种方法
Random r = new Random();
int n = r.nextInt(35)+1;
//第二种方法Math.random()是取得[0,1)之间的随机小数，取不到1。
int n =(int) (Math.random()*35+1);
java工具类
Object：引用类型的根，是所有类的超类，是java中唯一一个没有父类的类
1、toString():将对象转成字符串
2、equals（）和==的区别：
==：可以判断基本数据类型和引用数据类型
引用数据类型，表示两个对象的引用是否相等，即栈里面引用的地址是否相等
equals：可以判断引用数据类型
引用数据类型：表示两个对象的引用是否相等，但是包装类、String、Date、File除外（这些判断的是对象的值是否相等，即堆内存里面的值是否相等）
Stringstr1 = “abc”；
//创建一个字符串池中的对象，如果里面有此对象了就不再创建了，直接用即可
Stringstr2 = “abc”；
Stringstr3 = new String(“abc”)；
Stringstr4 = new String(“abc”)；
//可能产生两个或一个对象，在堆内存中首先new出一个对象，再复制到字符串池当中，如果字符串池中有此对象，即不复制。所有堆内存中的对象是肯定存在的，字符串池中的对象不一定
System.out.println(str1==str2)；true
System.out.println(str3==str4)；false
//str3在堆内存中new出一个内存、str4在堆内存中重新new出一个内存，在堆内存中相当于等号的右边。在栈内存中，指向堆内存中的引用值不一样，所有为false
System.out.println(str1==str3)；false
//str1是在堆内存中的字符串池里，为“abc”，str3在堆内存new出一个对象‘abc‘占用一块内存，并且复制到字符串池中，如果字符串池中有abc了，即不复制。
System.out.println(str1.equals(str2));true
System.out.println(str3.equals(str4));true
System.out.println(str1.equals(str3));true
//equals在String类型比较的堆内存的值是否相等，str1字符串池中的内存为abc，str3在堆内存中new出的对象是abc，这两个对象虽然分配的内存不同，但是值相等，所以为true
3、重写equals方法必须先重写hashcode方法
相等的对象必须具有相同的哈希码，具有相同哈希码的对象不一定相等
3、clone（）克隆
浅表克隆：复制原对象的所有变量的备份,但是引用类型的变量指向原对象的数据
必须实现一个接口implements Cloneable
重写Object类的克隆方法clone()
深表克隆：复制原对象的所有变量的备份，包括引用类型
4、反射Class.forName(“com.A”);
破坏了底层的封装性
5、包装类
byteByte
shortShort
longLong
floatFloat
doubleDouble
BooleanBoolean
intIntegar
charCharacter
包装类与字符串转换：
xxxValue（）：转换成其他基本类型
包装类-à字符串 toString（）
System.out.println(i.toString());
字符串-à整形 parseXxx（）
int i4 =Integer.parseInt(“123”);
double i5 =Double.parseDouble(“123.456”);
装箱和拆箱：JDK1.5只会自动装箱和拆箱
装箱：基本数据类型转换为引用数据类型
Integer i5 = 10;
拆箱：引用数据类型转换为基本数据类型
Integer i5 = 10;
int i6 = i5;
6、String类
charAt（）方法：一般与for循环一起，遍历字符串
Stringstr = “Hello Java,Hello World”;
for(int i=0;i<str.length();i++){
System.out.println(charAt(i));
}
concat()方法;拼接字符串，将指定字符串连接到此字符串的结尾
str.concat(“s”); //得到Hello Java,Hello Worlds
startWith()方法;测试此字符串是否已指定的前缀开始，boolean
str. startWith(“Hello”); //true
format()方法:将字符串按照某种格式输出
inti=1;intj=2;
System.out.println(String.format("%d+%d=%d",i,j,i+j));//1+2=3
indexOf(String)方法:输出字符串第一次出现的索引，没有的话输出-1
System.out.println(str.indexOf("Hello"));//0
lastIndexOf()方法:输出字符串最后一次出现的索引
replace(old String, new String)方法:替换字符串
split()方法:分割字符串
substring(int start,int end)方法:截取字符串
toCharArray()方法:变成字符数组
trim()方法:去掉字符串两端的空格，字符串中间的去不掉
toUpperCase()方法:将字符串转化为大写
7、StringBuffer和StringBuilder区别
StringBuffer线程安全的，同步的，效率比较低，JDK1.0之后出现
StringBuilder线程不安全，不同步的，效率比较高，JDK1.5之后出现
8、StringBuffer方法
StringBuffersb = new StringBuffer（“aaa”）;
append 追加字符串
sb.append(“bb”).append(“bb”);
delete 删除
sb.delete(1,2).delete(1,2);
insert 插入
sb.insert(1,”22”).insert(1,false);
setCharAt 修改
sb.setCharAt(1,’Q’);
replace 替换
sb.replace(1,3,”MMM”);
reverse 反转
sb.reverse();
10、Math方法
Math.ceil(2.4);//3取比值大的最小整数
Math.ceil(-2.4);//-2
Math.floor(2.5);//2取比值小的最大整数
Math.round(2.5);//3四舍五入
Math.round(-2.5);//-2
Math.random()//范围是[0,1)
Math.random()*40+60;//取60到99的成绩
Random方法：范围是[0,1)
Randomran = new Random();
for(inti=0;i<10;i++){
intscore = ran.nextInt(41)+60;//从60到100
System.out.println(score);
}
11、Date方法
SimpleDateFormat类：改变时间的格式
SimpleDateFormatsdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Datedate = new Date();
//将日期格式转换成指定的字符串
Stringtime = sdf.format(date);
System.out.println(time);//现在的时间以yyyy/MM/dd HH:mm:ss格式输出
//将格式化的字符串转换成日期对象
Datedate = sdf.parse(“1995/07/12 03:00:00”);
System.out.println(date);
TimeZone（）设置时区
TimeZonetime=TimeZone.getTimeZone("America/Los_Angeles");
Calendar c2=Calendar.getInstance(time,Locale.US);
Date d=c2.getTime();
GregorianCalendar单独获取年、月、日
GregorianCalendar gc =newGregorianCalendar(2017,3,5);
System.out.println(gc.get(Calendar.MONTH));
System.currentTimeMillis();通常用于循环运算的时间
long startTime = System.currentTimeMillis();
for(){}
longendTime = System.currentTimeMillis();
longtime = endTime- startTime//计算出运算的时间
集合：
1、集合和数组的区别：
数组：可以包含基本数据类型或者引用数据类型的对象，数据定长的，访问较快
集合：只能包含引用数据类型的对象，不定长。
2、集合分类：
Set:集 无序，不重复，父接口为Collection
add（）;添加元素
addAll（Collection）;添加子集合
contains（）;是否包括元素
containsAll（）;是否包含子集合
isEmpty();Boolean判断集合长度是否为0
remove（）;移除元素
removeAll（）;移除一个子集合
size（）;集合的大小
toArray（）;将集合转换成数据
Set集合的遍历 Iterator 迭代器
Setset = new HashSet();
Iteratorit = set.iterator();
while(it.hasNext()){
Objectobj = it.next();
System.out.println(obj);
}
Set集合的遍历 增强for循环
for(Object obj:set){
System.out.println(obj);
}
HashSet和TreeSet的区别：
HashSet：内部对象散列存取，顺序和输入的顺序不同
TreeSet：元素会进行升序排序（元素是可比较的），顺序和输入的顺序也不同
List:列表 有序，重复，父接口为Collection
add（）;添加元素
addAll（Collection）;添加子集合
add（key，元素）;插入元素
get（key）;获取元素
indexOf(元素);返回元素的索引值，如果没有则返回-1
remove(key);移除元素
removeAll（）;移除一个子集合
set（key,元素）;修改元素
toArray();转换成数组
List集合的遍历 普通for循环
Listlist = new ArrayList();
for(inti;i<list.size();i++){
Object obj = list.get(i);
System.out.println(obj);
}
List集合的遍历 增强for循环
for(Object obj:list){
System.out.println(obj);
}
List集合的遍历 Iterator 迭代器
Iterator it = list.iterator();
while(it.hasNext()){
Objectobj = it.next();
System.out.println(obj);
}
ArrayList和LinkedList区别：
ArrayList底层物理存储为线性的（数组的存储方式），查询效率高，删除、添加等操作效率比较低
LinkedList底层物理存储为链表的，查询效率低，删除、添加效率高
ArrayList和Vector区别：
两者底层物理存储为线性的
ArrayList：线程不安全，不同步的，数据不安全，效率比较高
Vector：线程安全的，同步的，数据安全，效率比较低
Map:字典 键值对存储 key唯一，value可重复
put(key,values);添加元素
putAll(map);添加集合
remove（key）;移除一对元素
size();集合长度
containkey(key);是否包含某个键
containvalue（value）;是否包含某个值
Map集合的遍历 keySet()
Set set = map.keySet();
Iterator it = set.iterator();
while(it.hasNext){
Object key = it.next();
Object value = map.get(key);
System.out.println(key+”:”+value);
}
Map集合的遍历 entrySet()
Iterator it = map.entrySet().iterator();
while(it.hasNext()){
Map.Entry entry = (Map.Entry)it.next();
System.out.println(entry.getKey()+”:”+entry.getValue());
}
HashMap和Hashtable的区别：
HashMap：键值对允许为null，线程不安全，不同步，效率比较高
Hashtable：键值对不允许为null，线程安全，同步，效率比价低
HashMap和TreeMap的区别：
HashMap：基于哈希，是无序的
TreeMap：基于树型结构的，按照键升序排序
3、Collections类：
Collections.sort():只针对List集合，集合中的元素必须是可比较的，如果为引用类型，则必须实现Comparator、Compareable（常用）接口
Collections.shuffle（list）：打乱顺序
Collections.rotate（list,int i）:根据指定的长度，轮换指定列表中的长度
Collections.reverse(list):反转集合
泛型：数据类型参数化
1、public<T> void arr(T t1,T t2){
Ttemp = t1;
t1= t2;
t2= temp;
}
2、泛型：安全的，避免了数据类型转换的风险
3、泛型约束：entends：如果有多个约束则使用&连接，约束只能有一个类，可以有多个接口
4、通配符？
上届通配符：？ extends A：表示A或者A的子类
下届通配符：？ super A：表示A或者A的父类类型
List<String>list = new ArrayList<String>();
List<?extends Object> listobj = list;//成立
List<Object>listobj = list;//不成立 在泛型中<String>和<Object>是同级关系
文件
1、构造方法
Filefile1 =new File("D:\\a.txt");
File file2 =new File("d:\\UI","a.txt");
File file3 = new File("D:\\UI");
Filefile4 =new File(file3,"a.txt");
2、mkdirs()创建多层文件夹
File file5 = new File("D:\\UI\\aaa");
if(!file5.exists()){
file5.mkdirs();
}
3、getAbsolutePath()打印文件路径
getPath()打印文件路径
System.out.println(file5.getAbsolutePath());//D:\UI\aaa
4、getName()()获取文件名//aaa
5、getParent()获取文件目录，不包含文件名//D:\UI
6、isHidden()文件是否被隐藏//false
7、isDirectory()判断是否是文件夹//true
8、isFile() 判断是否是文件
9、exists() 判断是否存在
10、newDate(file5.lastModified()) 获取最后一次修改的日期
11、length() 文件的字节数
12、file5.list() 文件名的遍历
String[]str =file5.list();
for(String s :str){
System.out.println(s);
}// 3.doc
5.FEM
e.txt
13、file5.listFiles() 文件的遍历
File[]files = file5.listFiles();
for(File f :files){
if(f.isFile()){
System.out.println("文件"+f.getName()+"\t"+new Date(f.lastModified()));
}else{
System.out.println("文件夹"+f.getName());
}
}//文件3.docFri Feb 24 10:33:28 CST2017
文件5.FEM Fri Feb 24 10:33:37 CST 2017
文件e.txt Fri Feb 24 10:33:32 CST 2017
14、File.listRoots(); 盘符的遍历
File[] f1 = File.listRoots();
for(Filef :f1){
System.out.println(f.toString());
}// C:\
D:\
文件IO流
1、 字节流
FileInputStream 输入流 读文件
BufferedInputStream输入流读文件
FileOutputStream输出流写入文件
BufferedOutputStream输出流写入文件
字符流
FileReader输入流读文件
DataInputStream输入流 读文件
FileWriter输出流 写入文件
DataOutputStream输出流 写入文件
2、FileInputStream 读取英文文件
FileInputStreamfis = new FileInputStream("D:\\UI\\bbb.txt");
intch = 0;
while((ch= fis.read()) != -1){ //read从此输入流中读取一个数据字节，返回值为int
System.out.print((char)ch);
}
fis.close();//此程序不能读中文
3、FileInputStream 读取中文文件
FileInputStreamfis = new FileInputStream(“D:\\UI\\bbb.txt”);
byte[]bt = new byte[1024]; //将字节读入字节数组
intlen = 0;
while((len= fis.read(bt))!=-1){
System.out.print(newString(bt,0,len));
}
4、FileOutputStream 写入文件
//搭建管道
FileOutputStream fos = new FileOutputStream(“D:\\UI\\bbb.txt”);
//读写操作
fos.write(98);//相当于b
fos.write(‘a‘);
String str = "ssdsdfsf"; //写入字符串
byte[] b = str.getBytes();
fos.write(b);
fos.flush();//强制性的刷新缓冲区
//关闭流
if(fos != null){
fos.close();
}
5、DataOutputStream 写入boolean、double等类型的文件
FileOutputStream fos = null;
DataOutputStream dos = null;
fos =new FileOutputStream("D:\\UI\\bbb.txt");
dos =new DataOutputStream(fos);
dos.writeBoolean(true);
dos.write(‘a‘);
dos.writeDouble(12.34);
for(inti=0;i<10;i++){
doubled = Math.random();
dos.writeDouble(d);
}
dos.flush();
dos.close();
fos.close();
6、DataInputStream读取boolean、double等类型的文件
FileInputStream fis =null;
DataInputStream dis = null;
fis =new FileInputStream("D:\\UI\\bbb.txt");
dis =new DataInputStream(fis);
booleanbool =dis.readBoolean();
System.out.println(bool);// true
for(inti=0;i<10;i++){
doubleb =dis.readDouble();
System.out.println(b+"\t");
}
dis.close();
fis.close();
// -6.414939283240485E-86
4.7384486223731214E285
7.602269187305488E-298
-1.4027415471626017E-278
9.32553721042958E-38
-1.0852988920338364E40
4.6544251087746895E49
1.0777059597027002E40
4.954807472569955E232
4.957881657894938E232
7、序列化和反序列化
序列化：将对象的数据存储到文件 ObjectOutputStream
反序列化：将文件中的数据重新读到对象 ObjectInputStream
例题：在程序中创建一个Student类型的对象，并把对象信息保存到d:\\io\\student.txt文件中，然后再从文件中把Student对象的信息读出显示在控制台上。
//先建立Student类
publicclassStudentimplementsSerializable {//编写一个可序列化的类 implements Serializable
privateintid;
private String name;
private String birth;
public Student(intid, Stringname, String birth) {
super();
this.id = id;
this.name = name;
this.birth = birth;
}
@Override
public String toString() {
returnid+""+name+" "+birth;
}
}
//再进行序列化，即将Student对象写入文件，直接抛出异常范例
publicclass SObjectOutputStreamTest throws IOException{
publicstaticvoid main(String[] args) {
Students1 = new Student(1,"we","1987-3-4");
Students2 = new Student(2,"you","1988-3-9");
FileOutputStreamfos = null;
ObjectOutputStreamoos = null;
fos = new FileOutputStream("D:\\io\\student.txt");
oos = new ObjectOutputStream(fos);
oos.writeObject(s1);
oos.writeObject(s2);
oos.close();
fos.close();
}
}
//进行反序列化，将文件中的语句读出到控制台，用try catch抓住异常范例
publicclass SObjectInputStreamTest {
publicstaticvoid main(String[]args) {
FileInputStream fis = null;
ObjectInputStream ois = null;
try {
fis = new FileInputStream("D:\\io\\student.txt");
ois = new ObjectInputStream(fis);
Student s1 = (Student)ois.readObject();
Student s2 = (Student)ois.readObject();
System.out.println(s1.toString());
System.out.println(s2.toString());
} catch (FileNotFoundException e) {
e.printStackTrace();
}catch (IOException e) {
e.printStackTrace();
}catch (ClassNotFoundException e) {
e.printStackTrace();
}finally{
try {
if(ois!=null){
ois.close();
}
}catch (IOException e) {
e.printStackTrace();
}
try {
if(fis!=null){
fis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
多线程
1、 进程：一个应用程序的一次运行，包含多线程
多线程：一个应用程序运行过程中的某些独立的片段
2、 进程与线程的区别（优缺点）
进程：进程间切换耗费系统资源，数据安全（独立的代码和数据空间）
线程：线程间切换系统耗费比较小，数据不安全（共享代码和数据空间）
3、 编写线程（掌握）
a． 继承Thread类
publicclass ThreadTest1 {
publicstaticvoid main(String[] args) {
ThreadDemotd = new ThreadDemo();
td.start();
for(inti=0;i<1000;i++){
System.out.println("the main is:"+i);
}
}
}
publicclass ThreadDemoextends Thread {
@Override
publicvoid run() {
for(inti=0;i<1000;i++){
System.out.println("the run is:"+i);
}
}
}
b． 实现Runnable接口（推荐，因为java类和类是单继承的）
publicclass RunnableTest {
publicstaticvoid main(String[] args) {
RunnableDemord = new RunnableDemo();
Threadthread = new Thread(rd);
thread.start();
for(inti=0;i<1000;i++){
System.out.println("the main is:"+i);
Thread.sleep(500);
}
}
}
publicclass RunnableDemoimplementsRunnable{
@Override
publicvoid run() {
for(inti=0;i<1000;i++){
System.out.println("the run is:"+i);
Thread.sleep(500);
}
}
}
4、CPU调度
抢占式
轮时间片
5、让线程从运行状态进入到阻塞状态
Thread.yield();//暂停
Thread.sleep(500);//休眠
join();//在A线程中加入B线程，待B线程运行完后，再运行A线程
6、线程其他方法
setName（）：给线程起名字，默认的名字Thread-X；x从0开始
getName（）：得到线程的名字
Thread.currentThread().getName()：得到当前运行线程的名字
setPriority();设置线程的优先级数值
getPriority();获得线程的优先级数值
setDaemon(true);设置为守护线程
7、用户线程和守护线程的区别
用户线程（前台线程）：必须执行完毕
守护线程（精灵线程、后台线程）：线程体执行完毕也可，执行不完毕也可以，例如垃圾回收
8、线程同步：
加锁同步：一个对象只能有一把锁
语句加锁 synchronized（对象）{}：可以对本类对象（this）和其他类对象（new 类）加锁；某个方法中的某些句子加锁，无法得知哪些方法是被synchronized保护的
方法加锁 synchronized void methodA（）{}：只能对本类对象加锁；整个方法的所有语句加锁；可以显示得知方法是被synchronized保护的
9、死锁：两个线程，彼此在等待对方占据的锁
锁的几种归还方式：
a．基本上执行完同步的程序代码后，锁会自动归还
b．用break语句跳出同步的语句块，不过这对于写在方法声明的synchronized没有作用
c．遇到return语句
d．遇到了异常
10、线程的生命周期
网络编程（java.net）
1、七层协议：
2、两台电脑之间的通信
ip：ipv4（32位）、ipv6（128位）
端口:1521（oracle）、8080（Tomcat默认的端口）、21（ftp）、80（默认的）
协议：
UDP：传输层，用户数据的协议，无连接的协议，不可靠的，不能够准确到达，效率比较高，适用于数据量比较大并且允许出错的，比如网络视频
TCP/IP:传输层 ，有连接的协议，可靠的、准确的到达，效率比较低
http：https：ftp等在应用层
http协议：明文无状态的
https：密文
3、客户端和服务器端
基于UDP的
客户端：
Socket client = new Socket("10.25.116.222",8088);
服务器端：
ServerSocketserver = ServerSocket(8088);ji
Socket s =server.accept();
4、 端口号范围是0-65535，用户普通网络程序用1024以上
5、 InetAddress此类表示互联网协议ip地址
InetAddress address = InetAddress.getByName(“主机名”);
6、getHostName（）获取此IP地址的主机名
getHostAddress（）获取IP地址字符串
getByName()通过主机名获取ip地址
getLocalPort()获取本程序所用接口
JAVA7新特性
1、数值型的数据赋值可以使用下划线_ 增加可读性
不能写在小数点后;
不能在数值型数据的开始
不能在数值型数据的最后添加
Doublepi = 3.1415_9265
Intbillion = 1_000_000_000
2、 可以声明n进制数据
Int i1= 0b0100;//4二进制前方放0b
Inti2 = 07; //7八进制前方放0
Inti3 = 0x00ad;//十六进制前方放0x
3、switch:表达式：
jdk1.7以下byte、short、char、int；
jdk1.7以上在上面基础上加上String
4、try（IO流）{
Stringstr=br.readLine();
}catch (ArithmeticException | IOException e) {//catch里可以有多个异常类，不能是父子关系
e.printStackTrace();
}//不用关闭流了，自动资源管理器
5、泛型
List<String>list = new List<String>();//jdk1.7以下
List<String>list = new List< >(); //jdk1.7以上
6、新加G1垃圾回收器 提高效率
7、NIO2
Files.copy(Paths.get(文件一),Paths.get(文件二));//直接复制文件
File.createFile();//创建新文件
File.move();//移动
File.delete();
//用WatchService类型实现文件监控
WatchServicewatchService = FileSystems.getDefault().newWatchService();
JDBC
1、编写jdbc程序的步骤：
1）添加数据库的驱动jar包 ojbc5.jar或者ojdbc6.jar或者classes12.jar
工程名右击—Build Path—Add External Archives—数据库安装路径—jdbc-ojdbc6.jar
2）创建驱动类对象 OracleDriver对象
//创建反射机制
Class.forName(“oracle.jdbc.driver.OracleDriver”);
3）连接数据库 Connection
Stringutl = “jdbc:oracle:thin:@YLMF123-3131857:1521:orcl”;
Stringuser = “scott”;
Stringpassword = “tiger”;
Connectionconn = DriverManager.getConnection(url,user,password);
4）操作数据库
//第一种方法Statement会引起注入，不推荐使用
String sql = "select deptno,dname,loc from dept";
Statement stmt = conn.createStatement();
ResultSet rs =stmt.executeQuery(sql);//发送sql语句到数据库，然后将查询到的结果返回到ResultSet
//int I = stmt.executeUpdate(sql);//查询影响的行数
while(rs.next()){
intdeptno =rs.getInt(1);//列的索引从1开始计
String dname = rs.getString(2);
String loc = rs.getString(3);
System.out.println(deptno+"\t"+dname+"\t"+loc);
}
//第二种方法PreparedStatement防止注入 推荐使用
String sql = "insert into dept(deptno,dname,loc) values(?,?,?)";
pstmt = conn.prepareStatement(sql);
intdeptno = 35;
String dname = "sdfs";
String loc = "北京";
pstmt.setInt(1, deptno);//第一个问号放deptno
pstmt.setString(2, dname);
pstmt.setString(3, loc);
pstmt.executeUpdate();//执行删除、插入、修改语句，executeQuery执行查询语句
5）关闭数据库
rs.close();
stmt.close();
conn.close();
2、批处理：
stmt.addBatch(sql1);
stmt.addBatch(sql2);//可以执行多句sql语句
executeBatch();//执行
String sql="insert intodept(deptno,dname,loc) values(?,?,?)";
pstmt=conn.prepareStatement(sql);
pstmt.setInt(1, 51);
pstmt.setString(2, "电信部");
pstmt.setString(3, "上海");
pstmt.addBatch();
pstmt.setInt(1, 52);
pstmt.setString(2, "实施部");
pstmt.setString(3, "广州");
pstmt.addBatch();
pstmt.executeBatch();
3、事务
conn.setAutoCommit（false）：设置为手动提交事务
conn.commit()：提交
conn.rollback()：回滚,catch里面
4、元数据
DatabaseMetaData：数据库的元数据
DatabaseMetaDatadmd = conn.getMetaData();
dmd.getUserName();//获得数据库名称
dmd.getURL();//获得接口名jdbc:oracle:thin:@YLMF123-2141651:1521:orcl dmd.getDriverName();//当前驱动Oracle JDBC driver
ParameterMetaData：参数的元数据
ResultSetMetaData：结果集的元数据
ResultSetMetaDatarmd = rs.getMetaData();
intcount = rmd.getColumnCount();//获取结果集有多少列
for(int i=0;i<count;i++){
System.out.println(“列标题”+rmd.getColumnLable(i)+”数据类型”+rmd.getColumnTypeName(i));
}
5、DAO:
1)实体类：一个对象相当于数据库表中的一行
privateintdeptno;
public Dept() {}
publicint getDeptno() {
returndeptno;
}
publicvoid setDeptno(intdeptno) {
this.deptno =deptno;
}
@Override
public String toString() {
return"Dept [deptno=" +deptno +",dname=" +dname + ", loc=" +loc +"]";
}
2)操作接口：可扩展
publicinterface DeptDao {
void insertDept(Dept dept);
void updateDept(Dept dept);
void deleteDept(intdeptno);
List<Dept> getAllDepts();
DeptgetDeptByDeptno(intdeptno);
}
3)操作类：
publicclass DeptDaoImplimplementsDeptDao {
@Override
publicvoid insertDept(Dept dept) {
Connection conn = null;
PreparedStatement pstmt = null;
try {
conn = DbUtils.getConnection();
String sql = "insert into dept(deptno,dname,loc)values(?,?,?)";
pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, dept.getDeptno());
pstmt.setString(2, dept.getDname());
pstmt.setString(3, dept.getLoc());
pstmt.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
}finally{
DbUtils.closeStatement(pstmt);
DbUtils.closeConnection(conn);
}
}
}
4)工具类：将重复的代码包装成工具类
publicclass DbUtils {
privatestaticfinal StringURL ="jdbc:oracle:thin:@YLMF123-2141651:1521:orcl";
privatestaticfinal StringUSER ="scott";
privatestaticfinal StringPASSWORD="tiger";
private DbUtils(){}//构造方法
static{
try {
Class.forName("oracle.jdbc.driver.OracleDriver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
publicstatic Connection getConnection(){
Connection conn = null;
try {
conn = DriverManager.getConnection(URL,USER,PASSWORD);
} catch (SQLException e) {
e.printStackTrace();
}
returnconn;
}
publicstaticvoid closeConnection(Connectionconn){
try {
if (conn !=null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
1、属性
align：对齐方式
bgcolor：背景颜色
target:
_blank在新窗口打开 _self默认，在相同的框架打开
_parent在父框架集中打开 _top在整个窗口打开
framename在指定的窗口打开
2、注释
<!--注释 -->
3、文件路径
同一目录下：文件名
上级目录：../
下级目录：从目标文件开始的文件目录
4、表格
tr行、td列、th表头
<tableborder="1" align="center" width="80%"bordercolor="green" cellspacing="0" cellpadding="10pt"><!—cellpadding代表文字和行之间的距离-->
<caption>学生成绩表</caption>
<tr><th>姓名</th><th>年龄</th><th>成绩</th></tr>
<tr><td>张三</td><tdrowspan="2">21</td><td>34</td></tr>
<tr><td>李四</td><td>56</td></tr>
<tr><tdcolspan="3">王五</td></tr><!—colspan代表列合并，rowspan代表行合并 -->
</table>
5、表单form
表单域input
type：text文本框、password密码、radio单选按钮、checkbox：复选框
是否需要在本书再版时立即通知您：
<input type="radio"checked="true">是
<input type="radio">否
submit提交按钮、reset重置按钮、button普通按钮
<input type="submit" value="提交">
hidden隐藏域（用来传送数据，不安全）
file：文件上传（两个条件：method=”post”、enctype=”multipart/form-data”）
name：表单域的名字
value：表单域的初始值
size：表单元素的长度，只适用于text、password
maxlength：表单元素中可以输入的最大字符数，只适用于text、password
checked：boolean属性，指定按钮是否是被选中的，只适用于radio、checkbox
readonly：只读的，只适用于text，数据能提交到后台
disabled：表示表单域不能用，数据不能提交到后台
多行文本textarea
<textarea cols=”20” rows=”5”></textarea>//表示可以输入5行20列
下拉列表框select
<select name=”city” multiple>//可以选中多项
<optionvalue=”beijing”>北京</option>
<optionvalue=”shanghai”>上海</option>
<optionvalue=”qingdao” selected=”true”>青岛</option>//默认选中
</select>
<fieldset style=”width:200”>
<legend align=”left”>小标题</legend>
用户名：<inputtype=”text”>
密码：<inputtype=”password”>
</fieldset>
6、框架frame
frameset：分割窗口
rows分割行cols分割列
frameborder：是否显示框架，0不显示、1显示，默认为1
framespacing：框架间的间距
frame:框架
src：指定框架显示的HTML文件的位置
noresize：设置不可以调整窗口的大小
bordercolor：框架边框的颜色
<frameset rows=”10%,80%,*”>
<framesrc=”header.html” noresize>
<framesetcols=”20%,*”>
<framesrc=”left.html” noresize>
<frame src=”table.html” noresize name=”right”>
</frameset>
<framesrc=”footer.html” noresize>
</frameset>
<noframes>
<body>浏览器版本较低，请升级后访问</body>
</noframes>
marginheigth：窗口内的内容与窗口上下边缘的距离
scrolling：是否显示滚动条，no-不显示、yes-显示、auto-默认自动设置
noframes不支持框架的浏览器
注意：<body></body>标签与<frameset></frameset>标签不能同时使用，不过，如果添加包含一段文本的
<noframes>标签，就必须将这一段文字嵌套于<body></body>标签内
1、增强代码可读性
<-- JavaScript代码 //-->
2、语法结构
1）大小写敏感
2）一句话结束最好加;
3）注释 // /**/
4）弱类型
3、变量命名
1）以字母、下划线_或美元符号$开头
2）余下的字符可以是字母、下划线_或美元符号$、数字
3）最长为255个字符
4）不能有空格、大小写敏感
5）不能使用JavaScript中的关键字或者保留字命名
4、JS变量类型
Undefined：未定义的类型、String、Boolean、Null、Number五种
可以使用typeof（object）来获取变量类型
5、声明 var 变量名[=初始值]
vari = 10;
varj;
alert(typeof(i));//判断i的类型 number
docement.write(123);
6、类型转换
字符串>数值>布尔值 低级与高级相加，强制转换成高级的
字符串à数值
parseInt（）、parseFloat（）、Number（）
7、运算符
算术运算符+、-、*、/、%、++、--(前置先自增再运算、后置先运算后自增)
比较运算符 ==、>、>=、<、<=、!=
逻辑运算符 &&、||、!非
赋值运算符 =、+=、-=、*=、/=
8、try{}catch(){}
try{vara=c}catch(e){alert(e);}