16.数值型变量与字符串相连时会自动调用toString方法，将其转换为字符串形式，然后参与连接("adsasd"+booktime(int型));
17.字符串查找:indexOf(); lastIndexOf();没找着返回-1
18."asd" .length()返回结果试3，就是长度
查找lastIndexOf("")的值就是字符串长度
19.charAt()方法可将指定索引处的字符返回
20.截取字符串(获取字符串):str.substring(3,6(不写也可))
21.去除空格:trim()方法返回字符串的副本，忽略前导空格和尾部空格,中间的空格还在str.trim();
22.字符串替换str.replace(old,new);
23.startsWith()与endsWith()方法分别用于判断字符串是否已指定的内容开始或结束。这两个方法的返回值都为boolean类型.str.startsWith("aa");
24.若有相同的字符和长度，用equals方法，返回true
equalsIgnoreCase()忽略大小写
25.compareTo()方法按字典顺序比较两个字符串,基于unicode值，返回正值（前string位于参数字符串之后）、负值（前string位于参数字符串之前）、0（相等）
26.toLowerCase()、toUpperCase()方法转换大小写
27.字符串分割:str为"adasd,asdasd,sadasd"
str.split("," , 2); 按","号分割，，并将分割后的结果存放在字符串数组中。2的意思是返回的数组的个数，而不是切几次的意思。若要多个字符分割，则中间用“|”分隔开，见例子Division.java
28.格式化字符串：String类的静态format()方法用于创建格式化的字符串。
重要功能：日期、时间字符的格式化（见书91页的例5.22及之后）
Date date = new Date();
String year = String.format("%tY", date);
String month = String.format("%tB", date);
String day = String.format("%td", date);
System.out.println("今年是： " + year + "年");
System.out.println("现在是： " + month + "月");
System.out.println("今天是： " + day + "号"); //可以显示时间，具体的表在书92页
29.当然format方法还有格式化常规类型。见94页
String str = String.format("%d", 400/2);
30.正则表达式：str.matches(str1)通常被用于判断语句中，用来检查某一字符串是否满足某一格式，具体表见95页
String regex = "\\w+@\\w+(\\.\\w{2,3})*\\.\\w{2,3}";
if(str3.matches(regex))
{
System.out.println(str3 + "合法");
} //判断email地址是否合法
31.可变的字符串序列String-builder类(字符串生成器)：传统string类创建成功，长度固定，内容不能改变，+的使用会重新创建新的字符串，增加系统开销。可变字符串String-builder类大大提高效率。Stringbuilder aa = new Stringbuilder（"adsasd"）;
builder.append(j);//追加字符
builder类有很多方法：toString显示输出,append()追加，insert()插入，delete()删除
32.算程序运行时间。long starTime = System.currentTimeMillis();
33.以下是数组:java中将数组看成一个对象，数组作为对象允许使用new关键字进行内存分配，在使用数组之前，必须首先定义数组变量所属的类型。
int a[];
String[] b; //这两种都可以
a = new int[5]; //进行内存分配
b = new String[10];
System.out.println(a.toString() + b.toString()); //数组对象使用显示方法
也可以这样int a[] = new int[12]; //直接内存分配
34.初始化数组:
int arr[] = new int[]{5,5,53,21,1};
int arr1[] = {1,234,4}; //都可以
35.一维数组的各个元素仍然是数组，则为二维数组。二维数组常用于表，【】【】分别代表行、列
36.二维数组：
int myarr[][] = new int[2][];
myarr[0] = new int[4];
也可以这样：int myarr[][] = new int[3][4]； //这个是3行4列，而用的时候最大只能到myarr【2】【3】
37.遍历数组：遍历二维数组用双层for循环，通过数组的lengrh属性可获得数组的长度。
for(int k=0; k<b.length; k++) //注意：[3][4]的b.length是 3！！
{
for (int c=0; c<b[k].length; c++)
遍历二维数组用foreach简单：
for(int x[]: arr)
{
for(int j: x){}
38.java.util包的Arrays类包含了操作数组（排序和搜索等）的各种方法如下：（import java.util.Arrays包）
fill()方法对数组中的元素进行替换，该方法通过各种重载形式可完成任意类型的数组元素的替换。 Arrays.fill(arr, 1,3,8)： 从1~3中间都存8
Arrays.sort(arr)方法进行排序(升序):与String类型数组排序不同的是，String类型试根据字典顺序排，数字排在字母后面，大写字母排在小写字母前面。而这个方法是整型数组升序排序。
Arrays.copyOf(arr, int newlength)复制数组从起始至指定长度返回新数组、Arrays.copyOfRange(arr,2,3)复制指定长度任意定制的数组返回新数组、
数组查询：注：必须先排序Arrays.sort(arr)！！
Arrays.binarySearch(arr[],3,8,"4"或"4")二分搜索法来搜索指定数组(从指定位置搜索或直接值搜索)。返回的是目标所在的下标索引值（找到）或者(-1或插入点)（没找到）
39.数组排序算法：冒泡排序、直接选择排序、反转排序。
冒泡排序：小的像气泡，放到最前面，大的沉下去，放在最后面。由双层循环实现，外层循环用于控制排序轮数，一般为要要排序的数组长度减1(len-1)(因为最后一次循环只剩下一个数组元素，不需要对比)。内层循环主要用用于对比数组中每个临近元素的大小，以确定是否交换位置，对比和交换次数随排序轮数而减少。(len-i-1次)
每次排序一次，即可得出一个当前最大的数并沉底。例子见BubbleSort类.
直接选择排序:指定从最后一位排，每一轮找出最大的数放在最后(找出的是最大数的索引值，索引值与最后索引值对应的数值再进行互换)。两次循环
反转排序：一次循环，前后调换，执行到总长度的一半。
40.数组矩阵转置运算: int[i][j]变成int[j][i]就好了
41.以下是第七章（类和对象）:
多态：继承是子类继承父类，其实将父类对象（方法）应用于子类的特征就是多态。好比图形类（父类）中绘制图形的方法是抽象的，用在具体的子类中就是多态。日后维护绘制图形的方法是也只需要修改父类中的抽象接口，在子类中重写具体实现方法即可。
提到多态，就不得不提抽象类和接口。
抽象类(abstract class)：不能实例化对象。在多态的机制里，父类通常会被定义为抽象类，在抽象类中给出一个方法的标准，而不给出实现的具体流程，事实上这个方法也是抽象的。
接口(interface)：抽象类的一个变体，一个继承类可以
有多个接口。在多态的机制里，比抽象类更方便的方式是将抽象类定义为接口。由抽象方法组成的集合就是接口。然后通过具体的子类实现(implements)这个接口,方法重写！
42.权限修饰符：
pubilc、protected、private(可见分别为3可见、2可见、1可见; 包括本类、同包其他类、不同包其他类)
这么看来 public和protected修饰的类可以由子类访问,如果子类不允许通过继承产生的子类访问它的成员变量，那么必须使用private声明父类的这个成员变量。
如果没有声明修饰符，默认的是同包的类可以调用访问。
class AnyClass {
public void doString(){
即使下面是public，可是class是默认的，只能同包的类访问，所以doString()也是同包类访问，不再是public!
43.构造函数(方法)：在类实例化对象时同时调用的函数，没有返回值。
准确地说，使用new操作符调用构造方法创建对象。
public class A
{
private int i = 0; // 这个是类成员变量
public void show()
{
System.out.println("这个是类成员方法");
}
public A()
{
System.out.println("这个是构造函数，没有返回值");
}
}
A aa = new A(); //实例化同时调用构造函数
构造函数分无参和有参构造函数：
public A(){}
public A(int i, int j){}
A aa = new A(1,2); //调用2有参构造函数;
A aa = new A(); //调用1无参构造函数;
如果没有构造函数，实例化时默认的是调用无参构造函数！
44.静态变量、常量和方法(static)
有时，会需要两个类在同一个内存区域共享一个数据。例如，PI可能多个类都要用到，只是将这个常量设置为静态的，PI常量在内存中被共享。
被声明为static的变量、常量和方法被称为静态成员。静态成员属于类所有，区别于个别对象，可以在本类或其它类使用类名和“.”运算符调用静态成员。
静态变量、常量、成员还没有创建实例化对象时，就可以直接“类名.静态成员”。
注：静态成员不能使用this 关键字，必须用类名.静态成员。
静态成员同样遵循pubilc、protected、private修饰符的约束
注：在静态方法中不可以使用this关键字；
在静态方法中不可以直接调用非静态方法！！
不能将方法体内中的局部变量声明为static！
技巧：如果执行类时，希望先执行类的初始化动作，可以使用static定义一个静态区域，当这段代码被执行时，首先执行static块中的程序，并且只会执行一次。
public class eg
{
static
{
//some
} }
45.对象： TEST test = new TEST();
test对象被创建出来时，就是一个对象的引用，这个引用在内存中为对象分配了存储空间
每个对象都是相互独立的，在内存中占据独立的内存地址，并且每个对象都具有自己的生命周期，当一个对象的生命周期结束时，对象就变成垃圾，由java虚拟机自带的垃圾回收机制处理，不能在被使用
46."=="和equals区别：
"=="比较两个对象引用的地址是否相等，而equals（）方法是String类中的方法，比较两个对象引用所指的内容是否相等
47.对象的销毁：
（1）何种对象会被java虚拟机视为垃圾：
1.对象引用超过其作用范围，这个对象将被视为垃圾。{
Test aa = new Test();
}
//超过作用范围将消亡
2.将对象赋值为null。
Test aa = new Test();
aa = null; //对象被赋值null将消亡
（2）垃圾回收很完善，但只能回收由new操作符创建的对象，如果不是由new创建在内存中获取一块内存区域的，可能不能被识别，所以java提供了finalize（）方法，属于object类的方法，被声明为protected，用户可以在自己的类中定义这个方法。如果用户在类中定义了finalize方法，在垃圾回收时会首先调用该方法，在下一次垃圾回收动作发生之前，才能真正回收被对象占用的内存
垃圾回收或finalize方法不保证一定会发生，如java虚拟机内存耗尽时，不会执行垃圾回收。
由于垃圾回收不受人为控制，具体时间也不确定，所以finalize也就无法执行，为此，java提供了System.gc()方法强制启动垃圾回收器。
48.以下是包装类：
java.lang包Intrger、Character、Boolean等包装类，这些类都是Number类的子类，区别就是封装不同的数据类型，其包含的方法基本相同。
比如，Integer类在对象中包装了一个基本类型int的值，该类的对象包含一个int类型的字段，此外，该类提供了很多方法，能在int类型和String类型之间互相转换，同时还提供了其他一些处理int类型时非常有用的常量和方法。以下以Integer为例
(1) 构造方法:
Integer int = new Integer(3);//int获取
Integer int = new Integer("232");//Sring获取
(2)常用方法：
byteValue() //以byte类型返回该Integer值
equals() //返回boolean
intValue() //返回int
shortValue //返回short
compareTo(Integer anotherInteger) //返回int，在数字上比较两个Integer对象，如果相等，返回0；如果调用的对象小于anotherInteger值，则返回负值；如果调用的对象大于anotherInteger值，则返回正值；
toString()//返回一个表示该Integer值的String对象.
valueOf(String str) //返回保存指定的String值的Integer对象 返回Integer
parseInt(String str) //返回包含在由str指定的字符串中的数字的等价整数值 返回int
int myint = Integer.parseInt(str[i]);
3.设置的模板规则：0或#（区别？）：
0进行模板格式化时，当数字位不存在时，将显示0；
#进行模板格式化时，格式化后的数字位数与数字本身的位数一致。
51.Math类：所有方法（指数函数、平方根等方法）都被定义为static形式。
Math.sin(Math.PI/2); //....
Math.asin //反余弦
Math.sqrt(2) //2的平方根
Math.cbrt(2) //2的立方根
Math.toRedians(120.0) //取120度的弧度值
Math.toDegrees(Math.PI) //取π的角度
Math.pow(2,3) //2的3次方 ，指数
Math.exp(3) //e的3次方
Math.log(3) //Ln3
Math.log10(3) //log10(3)
取整操作：
Math.ceil()//返回大于等于参数的最小整数
Math.floor()//返回小于等于参数的最大整数
Math.rint()//返回最接近参数的整数，若同样接近，则取偶数
Math.round()//将参数加上0.5返回与参数最近的整数 其实就是4舍5入，负值是反的！！！
Math.long round()//将参数加上0.5返回与参数最近的整数，然后强制返回为长整型
取最大值、最小值、绝对值函数方法：
Math.max(a, b) //取a、b的最大值
Math.min(a, b) //取a、b的最小值
Math.abs(8) //返回整型参数的绝对值
52.随机数：
两种方式产生随机数：
(1).Math.random()方法
Math.random()方法只产生0~1(大于等于0，小于1)的随机小数，稍加处理，就可以产生任何随机数
(int)(Math.random()*n) //产生0~n(大于等于9，小于n)的随机数
m+(int)(Math.random()*（m-n)) //产生m~n(大于等于m，小于n)的随机数
(2).Random类提供的产生各种数据类型随机数的方法
java.util.Random类,可以通过实例化一个Random对象创建一个随机数生成器。
Random r = new Random();
r.很多方法: r. nextInt、nextDouble....
Random r = new Random();
System.out.println(r.nextInt()); //产生一个整数
System.out.println(r.nextInt(10)); //产生一个0~10(大于等于0，小于10)的整数
System.out.println(r.nextBoolean());
System.out.println(r.nextDouble());
System.out.println(r.nextGaussian()); //产生一个高斯分布的双精度值
53.大数字运算(BigInteger、BigDecimal):
java.math.BigInteger类和java.math.BigDecimal类
（1）.java.math.BigInteger类：
BigInteger b = new BigInteger("2");
具体的所有方法见代码例子number9中BigIntegerDemo类
（2）.java.math.BigDecimal类：
BigDecimal b = new BigDecimal("2.5"or2.5也可);
具体的所有方法见代码例子number9中BigDecimalDemo类
54.将计算结果保留到5位小数
DecimalFormat myFormat = new DecimalFormat(pattern);
55.第10章（接口、继承、多态）：
继承：extends: 子类调用父类（super）、重写父类方法（方法名相同的，可以修改返回类型、参数、方法体）
注：1.子类没有权限调用父类中被修饰为private方法。
2.子类与父类所有完全相同除了方法体不同时，重写变成了重构！
3.重写方法时，也还可以修改修饰权限！！修改方法的修饰权限只能从小的范围到大的范围改变。例如，protected只能修改成为public，而不可以是private
4.重写方法还可以修改方法的返回值类型。这种重写方式需要遵循 重写的返回值类型必须是父类中同一方法返回值类型的子类。
5.在继承的机制中，创建一个子类对象，将包含一个父类子对象。这个对象与父类创建的对象是一样的。两者的区别在于后者来自外部，而前者来自子类对象的内部。当实例化子类对象时，父类对象也相应被实例化，换句话说，在实例化子类对象时，java编译器会在子类的构造方法中自动调用父类的无参构造方法，但是有参的不能被自动调用，必须用super了（并且调用顺序是首先调用父类，以此往下直到最底下进行实例化的子类对象，所以在子类构造方法访问父类构造方法之前，父类已经完成实例化操作）。为了验证这个理论，来看例子Subroutine类.
6.如果使用finalize()方法对对象进行清理，需要确保子类的finalize方法的最后一个动作是调用父类的finalize方法，以保证当垃圾回收对象占用内存时，对象的所有部分都能被正常终止。
56.Object类：java.lang.Object类 所有类的父类（包括自定义类）
1. 常用的方法：clone()、finalize()、equals()、toString()等。
大部分方法都可以被重写，但getClass()、notify()、notifyAll()、wait()等方法不能被重写，因为被定义为final类型
2.一些方法的使用：
(1)getClass(): getClass.getname() //返回对象执行时的class实例，并用getname方法取得类的名称
(2)toString()方法,将一个对象返回为字符串形式，返回一个String实例。当这个类转换为字符串或与字符串连接时，将自动调用重写的toString方法。
(3)equals方法。
(4)在自定义的类中两个对象使用equals方法进行比较时，将返回false，因为equals方法的默认实现是使用“==”运算符比较两个对象的引用地址，而不是比较两个对象的内容，所以要想真正做到比较两个对象的内容，需要在自定义类中重写equals方法。
57.对象类型的转换：向上转型、向下转型
向上转型：调用父类方法,a是平行四边形，但也是四边形，向上转型，调用父类方法，子类参数向上转型。，总是安全的
向下转型：将抽象类转换为具体的类，这样的转型通常会出现问题。可以说子类总是父类的一个实例，但父类对象不一定是子类的实例。
将父类对象赋予子类对象，写法错误；但是将父类对象赋予子类对象，并强制转换为子类型，写法可以的
58.使用instanceof()操作符判断对象类型:
在执行向下转型之前需要养成一个良好的习惯，就是3.判断父类对象是否为子类对象的实例，这个判断通常使用instanceof操作符来完成，可以使用instranceof操作符判断1.是否一个类实现了某一个接口，2.也可以用它来判断一个实例对象（高）是否属于一个类（低）(父类对象是否属于一个子类！！)
q instanceof Parallelogram //返回的是boolean
进行父类向下转型时。一定要首先进行判断父类对象是否属于（这里的属于意思就是有无继承关系，有就是属于，返回true）子类（instanceof方法），然后再强制转换进行向下转换。
59.方法重载:名字一样，参数个数或类型不同，这其中返回值类型可以不同；但是仅仅是返回值类型不同不是重载，错误，不足以区分两个方法的重载。
定义不定长参数方法：
public static int add(int...a) //定义不定长参数方法: public static int add(int...a)
{
int s = 0;
for(int i=0; i<a.length; i++)
{
s += a[i];
}
return s;
}
写法是int...a,然后把它当做数组对待
