Java基础知识

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();

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();

}

Html

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>

</table>

5、表单form

表单域input

type：text文本框、password密码、radio单选按钮、checkbox：复选框

是否需要在本书再版时立即通知您：

<input type="radio"checked="true">是

<input type="radio">否

submit提交按钮、reset重置按钮、button普通按钮

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

用户名：<inputtype=”text”>

密码：<inputtype=”password”>

</fieldset>

6、框架frame

frameset：分割窗口

rows分割行cols分割列

frameborder：是否显示框架，0不显示、1显示，默认为1

framespacing：框架间的间距

frame:框架

src：指定框架显示的HTML文件的位置

noresize：设置不可以调整窗口的大小

bordercolor：框架边框的颜色

<framesrc=”header.html” noresize>

<framesetcols=”20%,*”>

<framesrc=”left.html” noresize>

</frameset>

<framesrc=”footer.html” noresize>

</frameset>

<body>浏览器版本较低，请升级后访问</body>

</noframes>

marginwidth：窗口内的内容与窗口左右边缘的距离

marginheigth：窗口内的内容与窗口上下边缘的距离

scrolling：是否显示滚动条，no-不显示、yes-显示、auto-默认自动设置

noframes不支持框架的浏览器

注意：<body></body>标签与<frameset></frameset>标签不能同时使用，不过，如果添加包含一段文本的

<noframes>标签，就必须将这一段文字嵌套于<body></body>标签内

JavaScript

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);}

posted @ 2018-04-06 01:20 konglingbin 阅读(276) 评论(0) 编辑收藏举报

刷新页面返回顶部

konglingbin

Java基础知识

公告