学习教材五六八九章
第五章 核心类
1 java.lang.Object: 所有类都直接或者间接地派生自这个类
下面是他的方法
- clone 创建并返回该对象的一个副本
- equals 将对象和传入对象进行对比
- finalize由垃圾收集程序在对象上调用该方法（在其他地方进行，不改动这个方法）
- getClass 返回对象的一个java.lang.Class对象。
- hashCode 返回对象哈希码值
- toString 返回对象的说明
...
```
/*clone函数调用
package com.corn.objectsummary;
import com.corn.Person;
public class ObjectTest {
public static void main(String[] args) {
Object o1 = new Object();
// The method clone() from the type Object is not visible
Object clone = o1.clone();
}}
/*clone函数调用
package com.corn.objectsummary;
public class User {
private int uid;
private String name;
private int age;
public int getUid() {
return uid;
}
public void setUid(int uid) {
this.uid = uid;
}
protected String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public boolean equals(Object obj) {
if (obj == null || !(obj instanceof User)) {
return false;
}
if (((User) obj).getUid() == this.getUid()) {
return true;
}
return false;
}
@Override
public int hashCode() {
int result = 17;
result = 31 * result + this.getUid();
return result;
}}
2 java.lang.String：string对象表示一个字符串String s ="java is cool" /字面值赋给String引用变量/
比较两个字符串时候如果想知道两个String对象的值是否相同，要使用String 类的equals方法
字符串字面值：以一个“”开头和结束。如果连接一个对象和一个String，将会调用前者toString方法。并且将该方法结果用于连接操作。
字符串上的switch语句String input =...;
switch(input){
case "one":
System.out.println("you entered 1");
break;
case "two":
System.out.println("you entered 2");
break;
default:
System.out.println("Invalid value.");
break;
}
string类的方法
1)char charAt(int index) ：String s = new String("abcdefghijklmnopqrstuvwxyz");
System.out.println("s.charAt(5): " + s.charAt(5) );
2) int indexOf(String str, int fromIndex) ：从fromIndex开始找第一个匹配字符串位置。String s = new String("write once, run anywhere!");
String ss = new String("run");
System.out.println("s.indexOf('r'): " + s.indexOf('r') );
System.out.println("s.indexOf('r',2): " + s.indexOf('r',2) );
System.out.println("s.indexOf(ss): " + s.indexOf(ss) );3)九种重载方式 static String valueOf(boolean b) static String valueOf(char c) static String valueOf(char[] data) static String valueOf(char[] data, int offset, int count) static String valueOf(double d) static String valueOf(float f) static String valueOf(int i) static String valueOf(long l) static String valueOf(Object obj) 3 java.lang.StringBuffer和java.lang.StringBuilder StringBuilder的类的方法:capacity length append insert public int capacity():返回容量 public int length():返回对象所存储的字符串长度 public int append(String string):将指定的对象添加到所包含字符串结尾 4 基本类型包装器 java.lang.Boolean的使用方法
package com.tutorialspoint;
import java.lang.*;
public class BooleanDemo {
public static void main(String[] args) {
// create 2 boolean primitives bool1, bool2
boolean bool1, bool2;
/**
* using System class's setProprty method, set the values of
* system properties demo1, demo2.
*/
System.setProperty("demo1","true");
System.setProperty("demo2","abcd");
// retrieve value of system properties to s1, s2
String s1 = System.getProperty("demo1");
String s2 = System.getProperty("demo2");
// assign result of getBoolean on demo1, demo2 to bool1, bool2
bool1 = Boolean.getBoolean("demo1");
bool2 = Boolean.getBoolean("demo2");
String str1 = "boolean value of system property demo1 is " + bool1;
String str2 = "System property value of demo1 is " + s1;
String str3 = "boolean value of system property demo2 is " + bool2;
String str4 = "System property value of demo2 is " + s2;
// print bool1, bool2 and s1, s2 values
System.out.println( str1 );
System.out.println( str2 );
System.out.println( str3 );
System.out.println( str4 );}
}
5 java.lang.class:每次JVM创建对象时，会创建一个java.lang.Class的对象来描述该对象的类型package app05;
import java.lang.*;
public class ClassDemo {
public static void main(String[] args) {
String country ="fiji"
Class myClass=country。getClass();
System.out.println( myClass.getName() );
Class klass =null
try{
klass=Class.forName("app05.Test");
}catch (ClassNotFoundException e){
}
if(klass!=NULL){
try{
Test test=(Test)klass.newInstance();
test.print();
}catch (ClassNotFoundException e){
}catch (ClassNotFoundException e){
}}
}
}
6 java.lang.system:System是一个final类。三个字段是：out in err
7 java.until.scanner：使用Scannery来接收用户输入package net.nyist;
import java.util.Scanner;
public class ScannerDemo2 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int intValue = scanner.nextInt();
System.out.println(intValue);
}}
## 第六章 数组
1 数组是相同类型的数据按顺序组成一组复合类型的数据
String[] aArray = new String[a];
2 遍历数组String[]names={"John","Mary","Paul"};
for (Stringname:names) {
System.out.println(name);
}
3 java.until.Arrays类提供了数组静态的方法
asList：List<String> arrayList = Arrays.stream(stringArray).collect(Collectors.toList());
binarySearch：特定键查找数组
copyOf：创建具有镇定长度的新数组
equals：比较两个数组内容
sort：排序指定数组元素
4 修改数组的大小int[] numbers=new int[]{1,2,3,};
int[] temp=new int[4];
int length =number.length;
for(int j=0;j<length;j++)
temp[j]=numbers[j];
}
5 查找一个数组
可以使用Aaysrry中的binarySearch查找import java.util.*;
public class Demo1
{
public static void main(String args[])
{
int iArr[] = {1, 2, 3, 4, 6, 8, 22, 44, 99, 111, 112, 116};
System.out.println("数组的所有元素为：");
for(int i : iArr)
System.out.print(i + " ");
System.out.println();
System.out.print("请输入你要查找的元素：");
Scanner scan = new Scanner(System.in);
int iNum = scan.nextInt();
int index = binarySearch(iArr, iNum, 0, iArr.length-1);
if(index == -1)
System.out.println("没有找到元素" + iNum);
else
System.out.println("找到元素" + iNum + ", 下标为:" + index);
}
public static int binarySearch(int[] arr, int num, int iMin, int iMax)
{
int iMid = (iMin + iMax) / 2;
if (num < arr[iMin] || num > arr[iMax])
return -1;
else if (num == arr[iMid])
return iMid;
else if (num < arr[iMid])
return binarySearch(arr, num, iMin, iMid - 1);
else
return binarySearch(arr, num, iMid + 1, iMax);
}}
6 给面方法传入一个字符串数组package app06;
public class MainMethodTest{
public static void main(String[]args){
for (String arg:args){
System.out.pringln(arg);
}
}
}
##第八章 错误处理
1捕获异常：主要有两种错误，编译错误和运行错误。前者在编译时就被处理，后者是在运行阶段进行处理的。增加了异常处理机制。从Java异常处理中得到的哲学启发，很多事情是你所无法保证的，必须在运行的过程中解决。
例如：
public void methodA(int m){
try{
//以下代码可能会抛出SpecialException
if(--m <= 0)
throw new SpecialException("Out of money");
}
catch(SpecialException e){
//异常处理
}
}
2 捕获多个异常try{
ServerSocket.accept();
}catch( ServerSocketTimeoutException|SecurityException|IllegalBlockingModeException e){
}catch(IOException e){
//处理操纵输入流和输出流出现的异常
}
3 java.lang.Exception
java异常类都派生自java.lang.exception类。printStackTrace方法是对Exception对象的一次栈追踪。可以找到是哪一行代码导致了问题。
一个try语句都带有一个捕获java.lang.exception的catch语句块。
注意：不能将一个处理java.lang.exception的catch语句放在其他catch语句前面。因为JVM按照catch语句的参数块匹配抛出异常。
抛出一个异常：public string(String s)throws NullPointerException{
if(s=null){
throw new NullPointerException{
"You passed a null argument"
}
character firstChar=s.charAt(0);
String theRest=S.SUBSTRING(1);
return firstChar.toString().toUpperCase()+theRest;
}
4 用户定义的异常
当位于最上层的子系统不需要关心来自底层的异常的细节时，常见的做法是捕获原始的异常，把它转换为一个新的不同类型的异常，再抛出新的异常，这种处理异常的办法称为异常转译。
5 异常处理的注意事项
1、异常处理只能用于非正常情况。
2、为异常提供说明文档。通过JavaDoc的@throws标签来描述产生异常的条件。
3、尽可能地避免异常。
4、保持异常的原子性。异常的原子性是指当异常发生时后，各个对象的状态能够恢复到异常发生前的初始状态，而不至于停留在某个不合理的中间状态。保持原子性有以下办法：在对象的临时拷贝上进行操作，当操作成功后，把临时拷贝中的内容复制到原来的对象中。
5、避免过于庞大的try代码块。
6、在catch子句中指定具体的异常类型
7、不要在catch代码块中忽略被捕获的异常。
##第九章 操作数字
1拆箱和装箱：基本类型和对象包装器的类型相互转换
2数字解析：将字符串解析成为一个数字的基本类型；
3数字格式化：使数字更具有可读性java.text.NumberFormat类，NumberFormat nf = new DecimalFormat();
import java.text.*;
class NumberFormatTest {
public static void main(String[] args) {
double x = 10000.0 / 3.0;
NumberFormat formatter =
NumberFormat.getNumberInstance();
String s = formatter.format(x);
System.out.println(s); //输出：3,333.333
}
}
4随机数生成器
public static void main(String args[])
{
Random rnd = new Random(10);
for(int i=0;i<10;i++)
System.out.println(rnd.nextInt());
}
```
5.计算货币
RandomNumberGenerator类随机数生成器 产生0~9之间的一个int类的值
遇到的问题
1.如果要对boolean的属性使用EL表达式，要将其isXX()方法改成，getXXX()
2.Exception in thread "main" java.lang.NoClassDefFoundError: antlr/ANTLRException
少了antlr-2.7.5H3.jar包,从D:\eclipse\eclipse\plugins\com.genuitec.org.hibernate.eclipse_4.1.1\data\lib
3.
修改环境变量
进度条
学习到java第9章