第五章——子类与继承
二、知识点详解
1、子类的继承性
class 子类名 extends 父类名{}
子类的成员中有一部分是自己定义的，有一部分是从父类继承的。
若子类与父类在一个包中，则子类自然地继承父类非private的成员变量或方法。
若子类与父类不再同一个包中，父类的private和友好访问权限的变量不会被子类继承，子类只能继承父类protected和public访问权限的成员变量作为子类的成员变量。
2、子类的对象
boolean isInstanceof = 中国人 instanceof 人类;//当instanceof左面的操作元是右面的类或者右面的子类创建的对象时，返回true
当用子类创建一个对象时，不仅子类中声明的成员变量被分配了内存，而且父类中的成员变量也都分配了内存空间。但只有被继承的那部分变量分配给了子类。
3、成员变量的隐藏和方法的重写
变量隐藏：
当子类所声明的成员变量的名字与父类成员变量的名字相同时，子类会隐藏所继承的成员变量。子类自己定义的方法操作同名成员变量，该成员变量是重新声明的变量。子类调用父类继承的方法中调用的同名成员变量是隐藏的从父类继承的成员变量。
方法重写：
规则：子类定义一个方法，该方法的类型与父类方法的类型一致，并且这个方法的名字、参数个数、参数类型和父类的方法完全相同，该方法就叫子类重写的方法。重写父类的方法时不能降低方法的访问权限（public>protected>友好的>private）。
4、super关键字
用super操作被隐藏的成员变量和方法
通过super.成员变量或方法可以调用被隐藏的父类成员变量或方法。
使用super调用父类的构造方法
当用子类的构造方法创建一个子类的对象时，子类的构造方法总是先调用父类的构造方法。由于子类不继承父类的构造方法，因此子类在其构造方法中需要使用super来调用其父类的构造方法。当子类没有明显写出super调用父类的某个构造方法时，会默认在子类构造方法中加入super();所有当父类有多个构造器时，应当含有一个无参构造器，避免子类省略super();时产生调用错误。
5、final关键字
final修饰的成员变量或局部变量为常量不能被修改，如果父类的方法被final修饰，则不允许被子类重写，只能继承（如同不能坏了老祖宗传下来的规矩）。如果类被final修饰，则该类不能被继承。
6、对象的上转型对象
父类声明，子类创建的对象为上转型对象。例如People xiaoming = new Chinese()，对象的上转型对象的实体由子类创建，但是该对象会失去原对象的部分属性与功能，相当于子类对象进行了简化。即小明是人类，简化省去了小明是中国人的特征。
所以上转型对象不能操作子类新增的成员变量，即谁声明听谁的话。上转型对象可以访问子类继承或隐藏的成员变量，也可以调用子类继承的方法或子类重写的实例方法，即简化了全新的，保留了改进的。
不能给父类创建的对象赋值给子类声明的对象，即父亲不能听儿子的。可以将对象的上转型对象强制转换到一个子类对象，就恢复原来的属性和方法。如果子类重写了父类的静态方法，那子类对象的上转型对象不能调用子类重写的静态方法，只能调用父类的静态方法。
7、继承和多态
8、abstract类和abstract方法
抽象类：用abstract修饰的类
抽象方法：用abstract修饰的方法
抽象方法只能声明，不能有方法体。且不允许使用final和abstract同时修饰一个方法或类。不允许用static修饰abstract方法。
抽象类中可以有抽象方法，抽象类只能被继承不能创建对象。继承抽象类的子类必须重写父类的抽象方法（去掉abstract修饰），而final方法不能被继承，所以抽象类中的抽象方法不能被final修饰。如果抽象类继承抽象类则可以继承父类的抽象方法，也可以重写父类的abstract方法。
抽象类虽然不能创建对象（new），但可以声明对象。作为上转型对象。
9、开闭原则
对扩展开发，对修改关闭
三、题库考查知识点整理
1、子类继承的方法只能操作子类继承和隐藏的成员变量。
2、不可以同时用final和abstract修饰同一个方法。
3、不允许使用static修饰abstract方法。
4、所谓子类继承父类的成员变量作为自己的一个成员变量，就好象它们是在子类中直接声明一样，可以被子类中自己定义的任何实例方法操作。
5、如果在子类中想使用被子类隐藏的成员变量或方法就需要使用关键字super。
6、子类不继承父类的构造方法。
7、 如果在子类的构造方法中，没有显示地写出super关键字来调用父类的某个构造方法，那么编译器默认地有：super();调用父类的无参数的构造方法（如果父类没有这样的构造方法，代码将出现编译错误）.
8、在子类的构造方法中显示地写出super时,super关键字形成的语句必须是子类构造方法的第1条语句。
9、如果一个类中有abstract方法，这个类必须是abstract类。
10、代码无法通过编译。（原因是，父类People已经没有了不带参数的构造方法，而子类Student构造方法默认调用People类的不带参数的构造方法）。
11、子类重写父类的方法时，不允许降低方法的访问权限，但可以提高访问权限。
12、如果子类是abstract类，允许子类将父类的非abstract方法重写为abstract方法。
13、如果一个非抽象类是某个抽象类的子类，那么它必须重写父类的抽象方法，即给出方法体（将abstract方法重写为非abstract方法）。
14、abstract子类也要继承abstrat父类的abstract方法 。
15、类中的类方法（static方法）只能操作类变量（static变量），不可以操作实例变量。
16、编译器不提示程序使用了空对象（让一个空对象去调用实例方法），但程序在运行时会出现NullPointerException异常。
17、子类对象的上转型对象操作子类继承的方法或子类重写的实例方法，其作用等价于子类对象去调用这些方法。
18、super关键字形成的语句不一定是子类构造方法中的第1条语句。显示的写出才作为第一句。不写则无。
19、abstract类可以没有abstract方法。
20、abstract方法的abstract关键字，必须放在方法的类型的前面，不可以插在方法类型和方法名字之间。
21、子类重写或新增的方法也能直接操作被子类隐藏的成员变量。
22、如果子类可以继承父类的某个方法，那么子类就有权利重写这个方法。
23、类所声明的变量被称为对象，对象（变量）负责存放引用，以确保对象可以操作分配给该对象的变量以及调用类中的方法。分配给对象的变量被习惯地称做对象的实体。
24、写的话，super关键字形成的语句必须是子类构造方法中的第1条语句。
25、子类声明的成员的变量的名字和从父类继承来的成员变量的名字相同，子类就会隐藏掉所继承的成员变量。方法的修饰(如果有)，例如public,abstract，必须放在方法的类型的前面，不可以插在方法类型和方法名字之间。
26、java.lang包中的Object类是所有其他类的祖先类。
类声明的成员的变量的名字和从父类继承来的成员变量的名字相同，子类就会隐藏掉所继承的成员变量。方法的修饰(如果有)，例如public,abstract，必须放在方法的类型的前面，不可以插在方法类型和方法名字之间。
26、java.lang包中的Object类是所有其他类的祖先类。
第六章——java接口与实现
一、知识结构框架
二、知识点详解
1、接口
定义方式：使用interface定义接口，接口的定义与类的定义相似，class改为interface作为接口的声明。
- 声明：interface
- 接口体：没有变量和普通的方法，只有常量和抽象方法（方法默认被public abstract修饰）。
2、实现接口
类实现接口：与继承类似，使用implements声明该类实现一个或多个接口。
重写接口的方法：若一个非抽象类实现了某个接口，则这个类必须重写这个接口中的所有方法。重写时要去除abstract修饰符，给出方法体，使用public修饰（不能降低权限）。
注意：程序可以用接口名访问接口的常量，如果一个类实现了接口，那么该类可以直接在类体中使用该接口的常量。如果一个类声明实现了一个接口，若其为抽象类，则可以不重写借口的方法。即抽象类可以重写也可以直接拥有接口的方法。
接口修饰：如果interface前加public关键字修饰，则该接口称为public接口，可以被任何一个类实现。若无public，则称为友好接口，友好接口可以被与该接口同一个包中的类实现。
若父类实现了某个接口，则子类自然实现该接口，不用再次声明，接口可以被接口使用extends继承，子接口将继承父类接口中的全部方法和常量。
3、接口回调
接口属于引用型变量，接口变量可以存放实现该接口的类的实例的应用，即可以存放对象的引用。这句话的意思是，接口与类相似属于引用型变量，可以用接口名声明创造一个接口变量，该接口变量存放着对象的引用。
指针回调：在C语言中表示变量的地址在某一时刻存放存放在一个指针变量中，通过指针变量间接操作该变量中存放的数据。该处“回调”借用此定义。
定义：接口回调指可以把实现某一接口的类创建的对象的引用赋值给该接口声明的接口变量，则该接口变量可以调用被类实现的接口方法。实际上，当接口变量调用被类实现的接口方法时，就是通知相应的对象调用这个方法。
理解：将实现某个接口的类创建的对象，赋值给该接口声明的变量。这个变量就可以调用被类实现的接口方法，将此调用称为接口的回调。
4、接口与多态
不同的类在实现同一个接口时可能具有不同的实现方式，则接口回调时可能具有多种形态。
体现在：实现接口重写方法的多样性，从而导致接口回调的多样性。
5、接口参数
如果一个方法的参数是接口类型，我们就可以将任何实现该接口的类的实例的引用传递给该接口参数，那么接口参数就可以回调类实现的接口方法。
6、abstract类与implements接口的比较
- abstract类和接口都可以有abstract方法，但是抽象类也可以有非abstract方法，而接口只能有abstract方法
- abstract类中可以有常量也可以存在变量，但是抽象类中只能有常量，不能存在变量
三、题库考查知识点整理
1、在接口中，编译器认为int MAX = 100;就是 public static final int MAX = 100;
2、在接口中，protected void start();会导致编译出错。
3、接口中会默认给方法添加public abstract修饰词，默认给变量添加public static final修饰词。
4、类声明class Stu extends People implements Com 意思是Stu类是People类的子类，父类People实现Com接口。
5、一个接口可以继承多个接口。
6、一个类声明实现一个接口，但没有重写接口中的所有方法，那么这个类必须是抽象类。
7、接口中的常量不可以不指定初值，因为编译器不会提供默认值。所以在接口中，int MAX;会导致编译出错。
8、如果一个非abstract类实现某个接口，该类必须重写接口中的全部abstract方法。可以用接口名直接访问接口中的常量。能用abstract修饰接口。
9、一个类声明实现一个接口，但没有重写接口中的所有方法，那么这个类必须是抽象类。子接口将继承父接口中的全部方法和常量。接口变量中可以存放实现该接口的类的实例的引用(对象的引用)。
10、把实现某一接口的类创建的对象的引用赋值给该接口变量，那么该接口变量就可以调用被类实现的接口方法。接口中的常量必须指定初值。
11、任何一个类都可以实现public接口。如果一个类和友好接口在同一个包里，就允许它实现该接口。
第七章——内部类与异常类
一、知识结构框架
二、知识点详解
1、内部类
内部类：一个类中定义一个类
外嵌类：包含内部类的类称为内部类的外嵌类
关系：
内部类的外嵌类的成员变量在内部类中仍然有效，内部类中的方法也可以调用外嵌类的方法
内部类的类体中不可以声明类变量和类方法（static），但是内部类可以被修饰为static内部类，外嵌类的类体可以用内部类声明对象作为外嵌类的成员
内部类仅供其外嵌类使用 ，其他类不可以用某个类的内部类声明对象
内部类的字节码文件名：外嵌类名$内部类名
static内部类是外嵌类中的一种静态数据类型，程序可以在其它类中使用static内部类来创建对象。但static内部类不能用来操作外嵌类中的实例成员变量。
2、匿名类
和子类有关的匿名类：
直接使用一个类的子类的类体创建一个子类对象。即创建子类对象时，除了使用父类的构造方法外还有类体，此类体被认为是一个子类去掉声明后的类体称为匿名类。
//new 类名(){类体};一般new 类名()为创建对象，但此处是省略了父类的声明直接创建了一个子类
new 类名(){
匿名类的类体
};
匿名类特点：匿名类可以继承父类的方法也可以重写父类的方法
使用匿名类时，必然是在某个类中直接用匿名类创建对象，因此匿名类一定是内部类
匿名类可以访问外嵌类中的成员变量和方法，匿名类的类体中不可以声明static变量和static方法
由于匿名类是一个子类，没有类名，所以在用匿名类创建对象时，要直接使用父类的构造方法
和接口有关的匿名类：java允许直接使用接口名和一个类体创建一个匿名对象，该类体被认为是实现接口的类去掉声明后的类体。
//该处new 接口名()：实际是创建一个实现该接口的类去掉声明后保留类体
new 接口名(){
匿名类的类体
};
3、异常类
try-catch语句
try{
}
catch(Except e){
}
自定义异常类
自己书写一个子类继承父类Exception，即为异常类的扩展
throws：在方法名后书写，后接一个异常类名
throw：后接该异常的对象，如果异常发生，将抛出异常，导致方法结束
断言
断言语句用于调试代码阶段。在调试代码阶段让断言语句发挥作用，这样就可以发现一些致命的错误，当程序正式运行时就可以关闭断言语句，但仍把断言语句保留在源代码中，如果以后应用程又需要调试，可以重新启用断言语句。
assert booleanExpression;
assert booleanExpression:messageException;
三、题库考查知识点整理
1、E$1.class是匿名类的字节码（编译器编译器给该匿名类的名字是E$1）。
2、和类有关的匿名类一定是该类的一个非抽象子类。
3、内部类的类体中不可以声明类变量(static)变量。
4、非匿名内部类可以实现接口。
5、内部类可以是final类。
6、一个方法在声明时不可以使用throw关键字声明要产生的若干个异常。
7、接口匿名类（和接口有关的匿名类）不可以是抽象类。
8、匿名类有构造方法。
9、内部类的外嵌类的成员变量在内部类中仍然有效。内部类中的方法也可以调用外嵌类中的方法。外嵌类的类体中可以用内部类声明对象，作为外嵌类的成员。
10、可以用private或protected修饰内部类。内部类仅供它的外嵌类使用，其他类不可以用某个类的内部类声明对象。static内部类不能操作外嵌类中的实例成员变量。
11、非匿名内部类也可以有（内部）子类。不可能用匿名类声明对象，但却可以直接用匿名类创建一个对象。匿名子类（和子类有关的匿名类）可以继承父类的方法也可以重写父类的方法。
12、匿名子类（和子类有关的匿名类）的类体中不可以声明static成员变量和static方法。接口匿名类（和接口有关的匿名类）的类体中不可以声明static成员变量和static方法。匿名类一定是内部类。
13、try~catch语句可以由几个catch组成，分别处理发生的相应异常。一个方法在声明时可以使用throws关键字声明要产生的若干个异常。throw的作用就是抛出异常.throw和throws是两个不同的关键字。
14、匿名子类（子类有关的匿名类）一定是final类。匿名子类（子类有关的匿名类）一定不是抽象类。接口匿名类（和接口有关的匿名类）一定是final类。
15、匿名类只一个不带参数的构造方法（编译器会给匿名类一个名字和构造方法）。匿名类一定是final类。匿名类一定是内部类。
抽象类。接口匿名类（和接口有关的匿名类）一定是final类。
17、一个方法在声明时可以使用throws关键字声明要产生的若干个异常。匿名类一定是final类。
第八章——常用实用类
一、知识结构框架
二、知识点详解
（一）关于字符串
String类
1、常量对象
String常量也是对象，即字符串是String常量，被放入常量池中，受常量池的保护其中的数据在程序运行期间不允许被改变。
2、String对象
凡new运算符构造的对象都不再常量池中，所以s和t虽然实体相同，但是引用不同。
用户无法输出String对象的引用,输出的是该对象的实体，即字符串
构造方法：
- String(char a[])
- String s = new String("别骂了");
//等同于
char a[] - {'别','骂','了'};
String s = new String(a);
- String(char a[],int startIndex,int count)
从字符数组中的索引startIndex开始取count个字符
3、引用String常量
String常量是对象，因此可以把String常量的引用赋值给一个String对象
String a,b;
a = "java";
b = "java";
//此处a和b具有相同的引用，则具有相同的实体
a==b;//此处为true
4、字符串的并置
String a,b,c;
a = "ja";
b = "va";
c=a+b;//此处c为"java"
5、String类的常用方法
int length();
boolean equals(String 李兴华java基础笔记 s);//判断是否与s相等
boolean startsWith(String s);//判断是够以s开始
int comparaTo(String s);//比较字符序列的大小，返回差值
boolean contains(String s);//是否包含s
int indexOf(String s);//找到该字符串第一次出现的位置（未找到返回-1）
int lastIndexOf(String s);//找到该字符串最后一次出现的位置（未找到返回-1）
int indexOf(String s,int startpoint);//从startpoint开始找，找到该字符串第一次出现的位置（未找到返回-1）
String substring(int start，int end);//获得新的String对象，从start到end。end不写表示复制到末尾
String trim();//取掉前后空格得到新的String对象
6、对象的字符串表示
即重写toString方法，也可以用super.toString调用object的toString方法。
7、字符串、字符数组、字节数组
字符串与字符数组
字符串与字节数组
字符串的加密算法
//加密
String encrypt(String sourceString,String password){
char[] p = password.toCharArray();
int n = p.length;
char[] c = sourceString.toCharArray();
int m = c.length;
for(int k=0;k<m;k++){
int mima = c[k] + p[k%n];
c[k] = (char)mima;
}
return new String(c);
}
8、正则表达式以及字符串的替换与分解
正则表达式
特殊意义的字符：正则表达式中的元字符
[xxx]：该元字符代表方括号里的任何一个字符
[abc]:代表abc中的任何一个;
[^abc]:代表除了abc以外的任何字符;
[a-zA-Z]:代表英文字母的任何一个;
[a-d]:代表a~d的任何一个;
[[]]:并【或】;
[&&[]]:交【且】;
[&&[^]]:差;
- 限定修饰符用法
字符串替换
字符串分解
StringTokenizer类
不适用正则表达式分解String对象的字符串
StringTokenizer fenxi = new StringTokenizer("you are welcome");//使用默认分割标记
StringTokenizer fenxi = new StringTokenizer("you*#are*#welcome","*#");//使用自定义分割标记
while(fenxi.hasMoreTokens()){
System.out.print(fenxi.nextToken);
}
Scanner类
String xxx = "电费78水费88煤气费99";
Scanner scanner = new Scanner(xxx);//创建一个Scanner对象
scanner.useDelimiter("[^0.]+");//设置分隔符
int sum;
while(scanner.hasNext){//判断是否有下一个
sum += sannner.nextInt;
}
Scanner scanner = new Scanner(System.in);
char key = ' ';
boolean loop = true;
while (loop){
key = scanner.next().charAt(0);//接收一个字符
case 'a':
System.out.println("输入一个数：");
nt value = scanner.nextInt();
break;
case 'e':
scanner.close();
loop = false;
System.out.println("程序退出");
break;
}
StringBuffer类
三个构造方法：
方法：
StringBuffer s = new StringBuffer();
s.append(String str);//添加str
s.charAt(int n);//得到序列索引为n的字符
s.setCharAt(int n,char ch);//将n处的字符替换为ch
s.insert(int index,String str);//将参数str指定的字符序列插入到参数index指定的位置
s.reverse();//翻转字符序列
s.delete(int startIndex,int endIndex);//从当前字符序列中删除一个子字符序列（从start到end），并返回当前对象的引用
s.replace(int startIndex,int endIndex,String str);//将从start到end的序列换成str
（二）关于时间与日期
Date类
//时间显示
Date nowTime = new Date();
System.out.println(nowTime);
//格式化显示
Date date = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(date);
Calendar类
Calendar calendar = Calendar.getInstance();//初始化一个日历对象
calendar.get(Calendar.Month);//返回月份的整数
calendar.get(Calendar.DAY_OF_WEEK);//返回星期几的整数
calendar.getTimeInMillis();//返回毫秒计时
三）关于数学
Math类
public static long abs(double a); //返回a的绝对值。
public static double max(double a,double b); //返回a、b的最大值。
public static double min(double a,double b); //返回a、b的最小值。
public static double random(); //产生一个0到1之间的随机数（不包括0和1）。
public static double pow(double a,double b); //返回a的b次幂。
public static double sqrt(double a); //返回a的平方根。
public static double log(double a); //返回a的对数。
public static double sin(double a); //返回正弦值。
public static double asin(double a); //返回反正弦值。
BigInteger类
public BigInteger add(BigInteger val); //返回当前大整数对象与参数指定的大整数对象的和。
public BigInteger subtract(BigInteger val);//返回当前大整数对象与参数指定的大整数对象的差。
public BigInteger multiply(BigInteger val);//返回当前大整数对象与参数指定的大整数对象的积。
public BigInteger divide(BigInteger val);//返回当前大整数对象与参数指定的大整数对象的商。
public BigInteger remainder(BigInteger val);//返回当前大整数对象与参数指定的大整数对象的余。
public int compareTo(BigInteger val); //返回当前大整数对象与参数指定的大整数的比较结果，返回值是1、-1或0，分别表示当前大整数对象大于、小于或等于参数指定的大整数。
public BigInteger pow(int a); //返回当前大整数对象的a次幂。
public String toString(); //返回当前大整数对象十进制的字符串表示。
public String toString(int p); //返回当前大整数对象p进制的字符串表示。
Random类
//构造方法：
public Random();
public Random(long seed);//使用参数seek指定的种子创建一个Random对象
//随机数生成器random调用不带参数的nextInt()方法：
Random random=new Random();
random.nextInt();
//返回一个0至n之间（包括0，但不包括n）的随机数 随机数生成器random调用带参数的nextInt(int m)方法（参数m必须取正整数值）例如：
random.nextInt(100);//返回一个0至100之间的随机整数(包括0，但不包括100)。
//随机得到true和false两个表示真和假的boolean值，随机数生成器random调用nextBoolean()方法,例如：
random.nextBoolean();//返回一个随机boolean值。
数字格式化
格式化模式
format方法中的“格式化模式”是一个用双引号括起的字符序列(字符串),该字符序列中的字符由格式符和普通字符所构成。
例如："输出结果%d,%f,%d"中的%d和%f是格式符号 .
format方法返回的字符串就是“格式化模式”中的格式符被替换为它得到的格式化结果后的字符串。
例如：String s = String.format(“%.2f”,3.);那么s就是“3.14”.
值列表
format方法中的“值列表”是用逗号分隔的变量、常量或表达式。 例如：
String s=format("%d元%0.3f公斤%d台",888,999.,123); 那么,s就是"888元999.778公斤123台"。
格式化顺序
format方法默认按从左到右的顺序使用“格式化模式”中的格式符来格式化“值列表”中对应的值，而“格式化模式”中的普通字符保留原样。
例如，假设int型变量x和double型变量y的值分别是888和3.，
那么对于String s = format(“从左向右：%d,%.3f,%d”,x,y,100);
字符串s就是：从左向右：888,3.142,100
格式化整数
格式符
%d:格式化为十进制
%o:格式化为八进制
%x：格式化为小写的十六进制整数
%X:格式化为大写的十六进制整数
修饰符
+：强制添加上+号
,:按千分组
数据的宽度
%8d：宽度为8，右对齐
%-8d：宽度为8，左对齐
%08d：宽度为8，右对齐，0来填充
格式化浮点数
格式符
%f:将值格式化为十进制浮点数，小数保留6位
%e：将值格式化位科学计数法的十进制浮点数
修饰符
+：格式化正数时，强制加上+
，：整数部分按千分组
限制小数位数与数据的宽度
%.nf:限制小数的位数
如：%.3f：保留三位小数
%nf:数据的宽度n，右对齐，空格填充
%-nf:数据宽度为n，左对齐，空格填充
%0nf：0填充，宽度为n，右对齐
三、题库考查知识点整理
单选：
1、String 类是final 类，不可以有子类。
2、int m =Short.parseShort(“567”);
3、程序标注的【代码】的输出结果是bird。
4、程序标注的【代码】的输出结果是你好。
5、无编译错误，在命令行执行程序：“java E I love this game”，程序输出this。
6、无编译错误，在命令行执行程序：“java E go on”，运行异常:ArrayIndexOutOfBoundsException: 2。
7、“9dog”.matches("ddog")的值是true。12hello567 .replaceAll( []+ , @ )返回的字符串是@hello@。"hello "是正确的字符串常量。
8、" ea"是正确的字符串常量。"'hello"是正确的字符串常量。" atural"是正确的字符串常量。
9、表达式"java".equals(“java”)的值是true。表达式"Bird".compareTo(“Bird fly”)的值是负数。表达式"I love you".contains(“you”)的值是true。
10、default966 .matches( [^bc]+[789]{1}[6]{2} )的值是true。表达式"RedBird".indexOf(“Bird”)的值是3。表达式"RedBird".indexOf(“Cat”)的值是-1。
11、Integer.parseInt(“12.9”);会触发NumberFormatException异常。表达式"bird".contentEquals(“bird”)的值是true。表达式"Bird" == "bird"的值是false。
12、表达式 3.14 .matches( [0-9]+[.]{1}[0-9]+ )的值是true。表达式"0".startsWith(“2203”)的值是true。表达式"0".endsWith(“286”)的值是true。
13、程序标注的【代码】的输出结果是bird。
14、程序标注的【代码】的输出结果是：你好。
15、 String str2 = new String (a); //B错误代码：不能存放数组
16、 int index = str.indexof(“BC”); //A错误代码：O要大写
17、 boolean boo= str.startWith(“Java”); //D错误代码：startsWith
18、int m = “java”.compareto(“java”); //C错误代码：To的T大写
19、 String s = str.subString(0,3); //C错误代码：subsString
20、 boolean bn = str.equal(""); //A错误代码：equals
21、 int m = str.equals(""); //A错误代码：boolean不能转换为int
22、 int n = s.length ; //D错误代码length()
多选：
1、String 类是final 类，不可以有子类。String 类在java.lang中
2、错误：String 类在java.util包中。“abc”=="abc"的值是false .“abc”.equals(“Abc”)的值是true
3、int m =Short.parseShort(“567”);
4、错误：int m =Float.parseFloat(“567”);byte m =Integer.parseInt(“2”);float m =Float.parseDouble(“2.9”);
5、“9dog”.matches("ddog")的值是true。12hello567 .replaceAll( []+ , @ )返回的字符串是@hello@。"hello "是正确的字符串常量。
6、错误：new Date(1000)对象含有的时间是公元后1000小时的时间
7、" ea"是正确的字符串常量。"'hello"是正确的字符串常量。" atural"是正确的字符串常量。
8、错误："hello"是正确的字符串常量。
9、default966 .matches( [^bc]+[789]{1}[6]{2} )的值是true。表达式"RedBird".indexOf(“Bird”)的值是3。表达式"RedBird".indexOf(“Cat”)的值是-1。
10、错误：表达式"RedBird".lastIndexOf(“Bird”)的值是4。
11、Integer.parseInt(“12.9”);会触发NumberFormatException异常。表达式"bird".contentEquals(“bird”)的值是true。表达式"Bird" == "bird"的值是false。
12、错误：表达式"Bird".equals(“bird”)的值是true。
13、表达式 3.14 .matches( [0-9]+[.]{1}[0-9]+ )的值是true。表达式"0".startsWith(“2203”)的值是true。表达式"0".endsWith(“286”)的值是true。
14、错误：表达式"D:/java/book".lastIndexOf("/")的值是8。
15、String对象的字符序列是不可修改的。StringBuffer对象的字符序列是可修改的。表达式" ABC".length()的值是5。random.nextInt(100);//返回一个0至100之间的随机整数(包括0，但不包括100)。
16、错误：Random对象的nextInt(int n)方法随机返回[0，n]之间的一个整数
17、表达式 java88_hello_99 .matches( [a-zA-Z|0-9|_]+ )的值是true.表达式 abcdef你好 .matches( [0-9.]+ )的值是true.
18、错误：表达式 hello*? .matches( [a-zA-Z|0-9|_]+ )的值是true。表达式 hello .matches( [0-9.]+ )的值是false.
第十章——输入、输出流
一、知识结构框架
二、知识点详解
（一）File类
获取文件本身的信息，不涉及对文件的读写操作
1、构造方法：
File(String filename);
File(String directoryPath,String filename);
File(File f, String filename);
2、常用方法：
public String getName() 获取文件的名字。
public boolean canRead() 判断文件是否是可读的。
public boolean canWrite() 判断文件是否可被写入。
3、创建、运行与删除
import java.io.File;
import java.io.IOException;
public class 文件的创建运行与删除 {
public static void main(String[] args) throws IOException {
//创建与删除
File file1 = new File("bbb.txt");
file1.createNewFile();
file1.delete();
//从idea运行微信
File file2 = new File("C:\Program Files (x86)\Tencent\WeChat","WeChat.exe");
Runtime ec = Runtime.getRuntime();
ec.exec(file2.getAbsolutePath());
}
}
（二）文件字节输入、输出流
相关构造器与方法：
输入流:FileInputStream(String name); FileInputStream(File file);
读取方法:int read(); int read(byte b[]); int read(byte b[],int off,int len)
关闭流:close();
输出流:FileOutoutStream(String name); FileOutoutStream(File file);
写入方法:void weite(int n); void write(byte b[]); void write(byte b[],int off,int len)
关闭流:close();
1、输入流
四个步骤：
(1)设定输入流的源
(2)创建指向源的输入流
(3)让输入流读取源中的数据
(4)关闭输入流。
例子
try {
//设定输入流的源
File user = new File("商业计划书.txt");
//指向源的输入流
FileInputStream in = new FileInputStream(user);
//让输入流读取源中的数据
int t = in.read();
System.out.println(t);
//关闭流
in.close();
}catch (IOException e){
e.printStackTrace();
}
2、输出流
四个步骤：
(1)给出输出流的目的地
(2)创建指向目的地的输出流
(3)让输出流把数据写入到目的地
(4)关闭输出流。
try {
//创建指向目的地的输出流
FileOutputStream out = new FileOutputStream("商业计划书.txt");
//使用输出流写字节
byte abc[] = "我拿青春陪你赌".getBytes();
out.write(abc);
//关闭流
out.close();
//向文末加入
byte b[] = " 最后你却让我输".getBytes();
FileOutputStream out2 = new FileOutputStream("商业计划书.txt",true);
out2.write(b,0,b.length);
out2.close();
}catch (Exception e){
e.printStackTrace();
}
（三）文件字符输入、输出流
相关构造器与方法：
输入流:FileReader(String name); FileReader(File file);
读取方法:int read(); int read(byte b[]); int read(byte b[],int off,int len)
关闭流:close();
输出流:FileWriter(String name); FileWriter(File file); FileWriter(String name,boolean append); FileWriter(File file,boolean append);
写入方法:void weite(int n); void write(byte b[]); void write(byte b[],int off,int len)
关闭流:close();
File sourceFile = new File("商业计划书.txt");
File targetFile = new File("青春赞歌.txt");
char c[] = new char[28];
try {
//分别创建输入内容的输入流，和写入内容的输出流
Writer out = new FileWriter(targetFile,true);
Reader in = new FileReader(sourceFile);
//读取并写入输入流的内容到指定输出流out
int n = -1;
while ((n = in.read(c))!=-1){
out.write(c,0,n);
}
//资源关闭
out.flush();
out.close();
}catch (IOException e){
e.printStackTrace();
}
（四）缓冲流
相关构造器与方法：
输入流:BufferedReader(Reader in)；
读取方法:readLine(); 读取文本行
相关方法:newLine(); 向文件写入一个回行符
关闭流:close();
输出流:BufferedWriter(Writer out)；
写入方法:write(String s,int off,int len); 把字符串s写到文件中
关闭流:close();
（五）随机流
相关构造器与方法：
随机流：RandomAccessFile(File file，String mode)；
读写方法：
（1）八种基本类型数据对应的读/写方法
boolean readBoolean() void writeBoolean(boolean b)
byte readByte() void writeByte(int n)
char readChar() void writeChar(int n)
short readShort() void writeShort(int n)
int readInt() void writeInt(int n)
long readLong() void writeLong(long l)
float readFloat() void writeDouble(double d)
double readDouble() void writeFloat(float f)
int read() void write(int n)
int readUnsignedByte() int readUnsignedShort()
（2）字节数组、字符串及其他方式的读写方式
int read(byte[] b) / void write(byte[] b) 读/写一个字节数组。
int read(byte[] b,int off,int len) / void write(byte[] b,int off,int len) 从数组的off位置开始，读/写len个字节。
String readUTF() / void writeUTF(String s) 以与机器无关的UTF-8编码方式把str写入文件。
String readLine() 从文本文件中读入一行。
void writeChars(String s) 以字符方式写入一个字符串。
void writeBytes(String s) 以字节方式写入一个字符串。
相关方法：
（3）有关文件位置方法
long getFilePointer() 获得文件的当前位置。
void seek(long pos) 定位文件到pos位置。
int skipBytes(int n) 从当前位置跳过n个字节。
（4）其他方法
void setLength(long newLength) 设置文件长度。
long length() 获得文件的长度。
void close() 关闭文件。
FileChannel getChannel() 获得与该流连接的文件通道对象。
FileDescriptor getFD() 获得与该流连接的文件描述符对象。
try {
//创建随机流
RandomAccessFile in = new RandomAccessFile("青春赞歌.txt","rw");
//读取文件长度
long length = in.length();
//设定读取位置
long position = 0;
//定位文件到当前位置
in.seek(position);
while (position<length){
//读取
String str = in.readLine();
//重新编码
byte b[] = str.getBytes("iso-8859-1");
//转换为字符串
str = new String(b);
//更新当前读写位置
position = in.getFilePointer();
System.out.println(str);
}
}catch (IOException e){
e.printStackTrace();
}
（六）对象流与序列化
构造方法：ObjectInputStream(InputStream in)； ObjectOutputStream(OutputStream out)
相关方法： writeObject(Object obj) 将一个对象obj写入到一个文件； readObject() 读取一个对象到程序中
序列化：一个类如果实现了Serializable接口，那么这个类创建的对象就是所谓序列化的对象。
（八）Scanner解析文件
基本使用框架：
File file = new File("hello.java");
Scanner sc = new Scanner(file);
sc.useDelimiter(正则表达式);
三、题库考查知识点整理
1、BufferedWriter流可以指向FileWriter流。
2、FileOutputStream输出流按字节写出数据。
3、如果程序要写入一个文件，可以创建指向文件的FileWriter输出流。
4、创建FileInputStream 对象，即文件字节输入流可能触发FileNotFoundException异常。
5、FileNotFoundException类是IOException类的子类。
6、FileInputStream流的int read(byte b[]) 方法从源中试图读取b.length个字节到字节数组b中，返回实际读取的字节数目。如果到达文件的末尾，则返回-1。
7、BufferedReader流的源必须是字符输入流（FileReader）。
8、FileOutputStream流顺序地写文件，只要不关闭流，每次调用write方法就顺序地向目的地写入内容，直到流被关闭。
9、FileInputStream流顺序地读取文件，只要不关闭流，每次调用read方法就顺序地读取源中其余的内容，直到源的末尾或流被关闭。
版权声明：
本文来源网络，所有图片文章版权属于原作者，如有侵权，联系删除。
本文网址：https://www.bianchenghao6.com/h6javajc/24764.html