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//计算出运算的时间
