数据类型及其运算

标识符命名：字符、货币符号、_ Java使用Unicode数据集

byte<short、char<int、float<long、double

基本数据类型

字符类型

16位unicode码表示

类型转换：自动类型转换、强制类型转换

算数运算注意

在Java中,”%”（求模运算符）的操作数可为浮点数,如52.3%10=2.3；
Java对”+”运算进行了扩展,可作字符串连接运算符,如”ab”+”efd”得”abefd”；
做”+”运算时,如果一个操作数是字符串,其它操作数自动转换成字符串.如: String s; s=”s:”+4*5; //结果是s=”s:20”；注意+的左结合性（运算先后顺序）。e.g.1+2+”=3”→”3=3”；”12=”+1+2→”12=12”。
byte，short，char等类型进行混合运算时，会先自动转换为int类型再运算。
~取反、^异或、»>无符号右移、»符号位填充右移、长度不同的对短的符号扩充

数组

数组的定义：int a[] 或 int[] a未分配空间，空引用
使用new为数组分配空间int a[]=new int[5]{0,1,2,3,4}，每个数组对象有属性length
自动赋初值，char为\0

二维数组分配空间：int two[][]=new int[2][3]、int two[][];two=new int[2][];two[0]=new int[2];two[1]=new int[2]

数组初始化：

String[]ss=new String[3];
ss[0]=new String();
ss[1]=new String();
ss[3]=new String();
  
String[]ss=new String[]{new String(),new String(),new String()};

程序控制语句

面向对象技术基础

面向对象的基本概念

封装：属性和方法封装成独立单元、对外部信息隐蔽
继承：继承并增加状态和行为
多态：静态重载和动态重写

类的定义

[修饰符] class 类名 [extends 超类名] [implements接口名列表] {
……
}
[public][abstract|final] class 类名 [extends 超类名] 
[implements 接口名列表]{
……
}

成员变量的修饰符有以下几种：缺省访问修饰符default、public、protected、private、final、static、transient和volatile。
[public protected private ] [static] [final abstract] [native] [synchronized]

returnType methodName ([paramList]) [throws exceptionList] //方法声明 {……} //方法体

类、对象的使用

创建对象三步骤

类定义
对象分配内存空间
初始化并执行构造方法

类的初始化三步骤

为对象分配内存空间
初始化对象的实例变量的值，初始值缺省或赋值
调用对象的构造方法

包package

同名的类可能发生冲突，包提供了一种命名机制和可见性限制机制
package在源文件首句，指明指定文件中定义的类所在的包
包层次的根目录由环境变量classpath确定
classpath查询路径优先级：
- 缺省值，当前路径
- 用户指定的环境变量
- 命令行参数-classpath指定

成员变量及方法的访问权限

protected提供了一种高于package private（default）但低于public的权限，同一个包下类似于public，但是不同包只有继承的子类才可以访问属性或调用方法

// ./demo1/test.java
package demo1;
public class test{
    void method1(){};
    protected void method2(){};
    public void method3(){};
}

// ./demo2/test.java
package demo2;
import demo2.test;
class ttest extend demo2.test(){
    public void method4(){super.method2();}
}
public class test(){
    public static void main(String[]args){
        demo2.test d2t=new demo2.test();
        // d2t.method1();
        // d2t.method2();
        d2t.method3();x`
        ttest tt=new ttest();
        tt.method4();
    }
}

final、this和其他

final成员变量：常量、方法：不能被子类覆盖、类：不能被继承

class ttest{
	final int var=1;
	// final int var2;
	public final void method(){};
}
final class tttest{}
// public class test extends tttest{
public class test extends ttest{
	// public void method(){};
	public void method1(){method();}
	public static void main(String[]args){
		test t=new test();
		t.method1();
		// t.var=2;
	}
}

this：指向当前对象
super：对父类的引用
null：不代表任何实例

java.lang.Object

class ttest{}
final class tttest implements Cloneable{
	public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class test extends ttest{
	public static void main(String[]args) throws Exception{
		test t=new test();
		test tt=new test();
		test ttt=t;
		Class c=t.getClass();
		System.out.println(c.getName());//class9.test
		System.out.println(c.hashCode());//925858445
		System.out.println(t.hashCode());//798154996
		System.out.println(t.equals(tt));//false
		System.out.println(t.equals(ttt));//true
		System.out.println(t.toString());//class9.test@2f92e0f4
		System.out.println(t instanceof test);//true
		tttest tttt=new tttest();
		tttest ttttt=(tttest)tttt.clone();
		System.out.println(tttt.equals(ttttt));//false
	}
}

面向对象高级程序设计

继承

创建子类：从已有的类创建新的类
- 子类继承父类的状态和行为，修改父类的状态或重写父类的行为，添加新的状态和行为
- 子类可以继承父类访问权限为public、protected、default的成员变量和方法
- 隐式调用super()父类的构造方法，使用extends关键字
- 子类父类在同一个包中，子类继承父类的非private成员变量和方法
  
  子类父类不在同一个包中，子类继承父类protected、public的成员变量和方法，也就是非private和非default
成员变量的隐藏和方法重写
- 子类成员变量和父类同名，子类成员变量隐藏了父类的成员变量
- 子类方法和父类方法定义相同，子类方法重写父类方法
super：引用对象的父类
- 访问父类被隐藏的成员变量super.variable
- 调用父类中被重写的方法super.Method([param])
- 调用父类的构造方法super([paramlist])
对象的向上转型对象：用子类创建对象，用父类引用该对象，称为向上转型
- 上转型对象不能操作子类新增的成员变量和方法
- 子类重写了父类的方法后，上转型对象调用的是重写的方法
- 可以将上转型对象强制转换到子类对象，子类对象又具备所有的属性和功能。

多态

多态：使用相同的名字定义不同的方法，包括重载和重写
- 方法重载：静态多态性，编译时多态，形参不同
- 方法重写：动态多态性，运行时多态，全部相同
重写了父类的方法，运行时系统调用子类的方法；子类继承了父类的方法（未重写），运行时调用父类的方法
重写的原则：不能是原来的子集
- 重写后得到方法不能比被重写的方法有更严格的访问权限
- 重写后的方法不能比被重写的方法产生更多的异常

抽象方法和抽象类

抽象方法：使用abstract来修饰一个方法抽象类：使用abstract来修饰一个类
抽象类必须被继承且不能实例化，抽象方法必须被重写且没有方法体，但可以有非抽象方法且不用重写

接口

接口声明：关键字interface
- Java不支持多继承，一个类只能由一个父类
- 一个接口可以有多个父接口，子接口继承父接口所有的常量和方法，使用extends
```
[public] interface interfaceName [extends  listOfSuperInterface]{
……
}
    
```
  public指明任何类都可以使用该接口，缺省情况下，只有同一个包中的类才可以访问该接口
- 接口体：常量定义和方法定义
  - 常量均具有static、final、public属性（隐式说明）
  - 接口方法均有public和abstract属性（保证能被类使用）
- 类通过关键字implements实现多个接口
  - 如果一个类使用了某个接口，该类必须实现接口的所有方法
  - 接口方法默认public，所以类实现时，一定要用public来修饰
接口优点
- 特殊抽象类，只包含常量和方法的定义，没有变量和方法的实现；方法定义和常量值的集合
- 接口把方法的定义和类的层次区分开来；同时及口中可以实现多重继承，同一个类实现多个接口

内部类和匿名类

内部类的定义
- 嵌套类：一个类被嵌套定义在另一个类中，除了静态嵌套类，嵌套类是内部类
- 类或接口中声明一个类
- 类或接口中声明一个接口
- 类和接口声明可嵌套任意深度
内部类特性
- 用在定义它的类或语句块内，外部引用必须给出它的完整名称
- 可以使用外部类的静态成员变量和实例成员变量，所在方法内的局部变量
- 可以定义为abstract
- 可以被声明为private、protected
- 被声明为static，成为顶层类，不能使用实例成员变量和局部变量
- 有static成员的内部类，必须声明为static内部类
- 内部类作为外部类的成员，如同成员变量和成员方法，外部类通过内部类对象引用其成员
- 静态内部类和非静态内部类的区别
  - 能否拥有静态成员：非静态内部类不能有静态成员
  - 访问外部类的成员：静态内部类只能访问外部类的静态成员
  - 静态内部类和非静态内部类在创建对象时有区别
匿名类
- 不能有名称的类，无法引用，创建时用new语句声明
- 非静态内部类，不能有构造函数
- 提供更好的封装

字符串处理

初始化后不能改变的字符串类String、字符串内容可以动态改变的类StringBuffer、字符串词法分析类StringTokenizer

在C/C++中，字符串以字符数组的形式处理，以’\0’作为字符串结束符，容易发生错误

在Java中，字符串作为对象处理，对象中封装方法进行字符串处理

String类

字符串构造

String s; s=new String("GBK","s"); s="s";
char cDemo0[]={66,67,68};  String strDemo0=new String(cDemo0);
byte cDemo1[]={66,67,68};  String strDemo1=new String(cDemo1);
// String(StringBuffer)

String类的常用方法

//字符串长度计算
String s="xxx"; int n=s.length();
  
//字符串比较：
//equals、equalsIgnoreCase忽略大小写、
//startsWith前缀是否有指定字符串s、endsWith后缀、
//regionMatches从字符串中截取字串和参数比较、
//compareTo按照字典顺序和参数比较大小、compareToIgnoreCase
String a=new String("xxx"); String b=new String("XXX"); 
a.equals(b); a.equalsIgnoreCase(b);
String c=new String("aaabbb"); c.startsWith("aa");
c.regionMatches(2,"ab",2);
String d=new String("baabbb"); d.compareTo("aaabbb");

//字符串检索
//搜索指定字符串的位置
String str="i love java";  int nPos=str.indexOf('v');//4
nPos=str.indexOf('a',9); //11，从9开始后第一次出现a
nPos=str.indexOf("love",0); //2

//字符串截取
String str="i love java";
String subStr=str.substring(5); //e java
String subStr2=str.substring(5,6); //e

//字符串替换
String s="i mist theep";
String temp=s.replace('t','s'); // i miss sheep
String s="  i am a student  "; 
String temp=s.trim();  // "i am a student"

StringBuffer类

StringBuffer类的构造

StringBuffer s=new StringBuffer("hello");
s.setCharAt(1,'o'); // hollo
public StringBuffer();
public StringBuffer(int);//初始容量的字符缓冲区
public StringBuffer(String);

StringBuffer类的常用方法

//添加操作
StringBuffer sbSource=new StringBuffer("1+2=");
int nTree=3;
sbSource.append(nTree);//1+2=3
//StringBuffer和String的转换
println(sbSource.toString());

//插入操作
StringBuffer sbSource=new StringBuffer("1+=2");
int nOne=1;
sbSource.insert(2,nOne);//1+1=2

//取字符
StringBuffer sbfSource=new StringBuffer(10);
sbfSource.append("My");
//charAt(int index)
char c=sbfSource.charAt(0); // 'M'
  
StringBuffer sbfSource=new StringBuffer("you are the best!");
char[] str;
//getChars(int srcBegin,int srcEnd,char[]dst,int dstBegin)
sbfSource.getChars(0,2,str,0) // "yo"

//删除字符
StringBuffer sbfSource=new StringBuffer("you are the best");
sbfSource.delete(0,3);// " are the best"

//重设字符串长度
public void ensureCapacity(int minimumCapacity);
public void SetLength(int new Length);

//内容替换
StringBuffer sbfSource=new StringBuffer("you are the best");
String str="i'm";
sbfSource.replace(0,7,str);//"i'm the best"

//取子串
StringBuffer sbfSource=new StringBuffer("you are the best");
String str=sbfSource.substring(0,2);//yo

//字符反转
String str=sbfSource.reverse();//tseb eht era uoy

//获取长度
capacity,length

StringTokenizer类

构造方法：对字符串解析时，字符串中必须有分隔符号，默认为空格、\t、\n、\r

StringTokenizer fenxi=new StringTokenizer("we are students");
StringTokenizer fenxi=new StringTokenizer("we,are;students",",;");

常用方法

//统计分隔符数量
StringTokenizer st=new StringTokenizer("i love java");
int nTokens=st.countTokens();//3
  
//匹配和寻找分隔符
//利用StringTokenizer类进行简单词法分析
//TestToken.java
import java.util.*;
public class TestToken
{
   public static void main(String args[])
   {
      //构造StringTokenizer对象
	StringTokenizer st = new StringTokenizer
        ("this is a Java programming");
  	//在字符串中匹配默认的分隔符
        while(st.hasMoreTokens())
        {
            //打印当前分隔符和下一分隔符之间的内容
		     System.out.println(st.nextToken());
      }
   }
}
// this  is  a  Java  Programming

数据类型转换

String提供了静态方法valueOf()，将不同的简单数据转化为字符串

其他数据转化为String，提供了toString()方法

String转为其他数据，对应的数据类型提供了valueOf()方法

int nInt = 10;    //转换为整型
Integer obj1 = new Integer(nInt);  //转换为浮点数类型
String strString1 = obj1.toString();
strString1=String.valueOf(nint);
Integer obj11=Integer.valueOf(strString1); //转化为基本数据类型
int nInt1=stringString1.intValue();
int nInt2=Int.parseInt(strString1);

//【例6-7】将简单数据转换成字符串
public class CovertString
{
  public static void main(String args[])
  {
      int nInt = 10;
      float fFloat = 3.14f;
      double dDouble = 3.1415926;       //转换为整型
      Integer obj1 = new Integer(nInt);  //转换为浮点数类型
      Float obj2= new Float(fFloat);        //转换为双精度类型
      Double obj3 = new Double(dDouble);    //分别调用toString方法转换为字符串
      String strString1 = obj1.toString(); // strString1=String.valueOf(nint);
      System.out.println(strString1);
      String strString2 = obj2.toString();
      System.out.println(strString2);
      String strString3 = obj3.toString();
      System.out.println(strString3);
  }
}

//【例6-8】 将字符串转换为相应的简单数据类型。
public class CovertSimple{
  public static void main(String args[]){
      char[] cArray;
      int nInt;
      float fFloat;
      double dDouble;
      String strString = new String("I love Java");
      String strInteger = new String("314");
      String strFloat = new String("3.14");
      String strDouble = new String("3.1416");
      cArray = strString.toCharArray();
      System.out.println(cArray);
      nInt = Integer.parseInt(strInteger);
      System.out.println(nInt);
      fFloat = Float.parseFloat(strFloat);
      System.out.println(fFloat);
      dDouble = Double.parseDouble(strDouble);
      System.out.println(dDouble);
  } } 

Java标准类库

包装器类

Number类：

集合框架

处理对象集合的工具类，类集合，通过接口实现
- 高效、易拓展
- 提供了迭代器接口iterator
- 定义了映射接口和类

Collection：

增加元素、删除元素、判断元素的存在
返回迭代器，集合set转化成数组List
集合大小


boolean add(Object obj)	将obj加入到中。如果obj被加入到类集合中了，则返回true；如果未能加入集合，则返回false
boolean addAll(Collection c)	将c中的所有元素都加入到类集合中，如果操作成功，则返回true；否则返回false
void clear( )	从类集合中删除所有元素
boolean contains(Object obj)	如果obj是类集合的一个元素，则返回true，否则，返回false
boolean containsAll(Collection c)	如果类集合包含了c中的所有元素，则返回true；否则，返回false
int hashCode( )	返回调用集合类的散列值
boolean isEmpty( )	如果调用集合类是空的，则返回true；否则返回false
Iterator iterator( )	返回调用集合类的迭代程序
Boolean remove(Object obj)	从调用集合类中删除obj的一个实例。如果这个元素被删除了，则返回true；否则返回false
Boolean removeAll(Collection c)	从调用集合类中删除c的所有元素。如果集合类被改变了（也就是说元素被删除了），则返回true；否则返回false
Boolean retainAll(Collection c)	删除调用集合类中除了包含在c中的元素之外的全部元素。如果集合类被改变了（也就是说元素被删除了），则返回true，否则返回false
int size( )	返回调用集合类中元素的个数
Object[ ] toArray( )	返回一个数组，该数组包含了所有存储在调用集合类中的元素。
Object[ ] toArray(Object array[ ])	返回一个数组，该数组仅仅包含了那些类型与数组元素类型匹配的集合类元素。

List：有序、可重复


void add(int index, Object obj)
boolean addAll(int index, Collection c)
Object get(int index)
int indexOf(Object obj)
int lastIndexOf(Object obj)
ListIterator listIterator( )
ListIterator listIterator(int index)
Object remove(int index)
Object set(int index, Object obj)
List subList(int start, int end)

Set：无序、不可重复

方法	描述
Comparator comparator( )	返回调用被排序集合的比较器，如果对该集合使用自然顺序，则返回null
Object first( )	返回调用被排序集合的第一个元素
SortedSet headSet(Object end)	返回一个包含那些小于end的元素的SortedSet，那些元素包含在调用被排序集合中。返回被排序集合中的元素也被调用被排序集合所引用
Object last( )	返回调用被排序集合的最后一个元素
SortedSet subSet(Object start, Object end)	返回一个SortedSet，它包括了从start到end–1的元素。返回类集中的元素也被调用对象所引用
SortedSet tailSet(Object start)	返回一个SortedSet，它包含了那些包含在分类集合中的大于等于start的元素。返回集合中的元素也被调用对象所引用

hashset，散列表存储，对于大集合，索引操作运行时间：常数，不保证有序
treeset，树结构存储元素，对于大集合，快速检索，对象按升序存储

iterator迭代接口

// 基本集合的泛型初始化、增加元素、遍历操作、排序
// 迭代器的初始化和使用
// 数组对象的声明和初始化
public class test{
	public static void main(String[]args)throws Exception{
		ArrayList<String>arrayList=new ArrayList<>();
		arrayList.add("hello");
		arrayList.add("world");
		for(String s:arrayList){
			System.out.println(s);
		}

		LinkedList<Integer>linkedList=new LinkedList<>();
		linkedList.add(1);
		linkedList.add(2);
        Collections.sort(linkedList);
		for(Integer i:linkedList){
			System.out.println(i.toString());
		}

		HashSet<String>hashSet=new HashSet<>();
		hashSet.add("world");
		hashSet.add("hello");
		for(String s:hashSet){
			System.out.println(s);
		}

		TreeSet<String>treeSet=new TreeSet<>();
		treeSet.add("w");
		treeSet.add("h");
		for(String s:treeSet){
			System.out.println(s);
		}
		Iterator<String>iterator=treeSet.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
		ArrayList aList=new ArrayList<>();
		aList.add(new String("hello"));
		aList.add(new String[]{"hello","world"});
		Iterator iterator2=aList.iterator();
		while(iterator2.hasNext()){
			System.out.println(iterator2.next().getClass().getName());
		}

		HashMap<String,Integer>hashMap=new HashMap<>();
		hashMap.put("hello", 1);
		hashMap.put("world", 2);
		for(Map.Entry<String,Integer>entry:hashMap.entrySet()){
			System.out.println(entry.getKey()+entry.getValue());
		}
		Integer i=hashMap.get("hello");
		Boolean b1=hashMap.containsKey("hello");
		Boolean b2=hashMap.containsValue(1);
		// treemap同理
	}
}

异常

什么是异常

异常exception：硬件设备问题、软件设计缺陷导致的程序错误
在Java中，产生异常就是产生一个异常对象
java.io.IOException、java.lang.ArrayIndexOutOfBoundsException、java.lang.ArithmeticException指明了异常类型和异常所在的包
- 对于部分异常，编译不通过；对于另一些异常，运行时系统处理

异常处理机制

异常类的类层次

Java异常处理机制
- 捕获catch异常：积极的异常处理机制。Java生成异常对象后，沿着方法的调用栈逐层回溯，寻找处理异常对象的方法，找到后，将该异常对象交给这个方法处理。
- 声明抛弃throws异常：如果一个方法可能会出现异常，但没有处理该异常的能力，可以在方法声明时，声明抛弃throws异常

异常处理

捕获异常try-catch-finally，可以嵌套
- try：选定捕获异常的范围
- catch：处理try代码块中的异常事件，形参说明异常类型（Throwable子类）
  - 异常捕获顺序和catch顺序有关，从特殊到一般
- finally：统一出口，可选，不论是否有异常，都要执行finally

抛弃异常

public int read()throws IOException,IndexOutOfBoundsException{}

抛出异常就是产生异常对象的过程

IOException e=new IOException();
throw e;

抛出的异常必须是Throwable及其子类实例

public class Exception6{
	public static void main(String[]args){
		try{
			throw new Exception("My Exception");
		}catch(Exception e){
		   System.err.println("Caught Exception");
		   System.err.println("getMessage():" + e.getMessage());
		   System.err.println("getLocalizedMessage():"+ e.getLocalizedMessage());
		   System.err.println("toString():" + e);
		   System.err.println("printStackTrace():");
		   e.printStackTrace();
		}
	}
}
//程序运行结果如下:
//d:\user\chap08>java Exception6
//Caught Exception
//getMessage():My Exception
//getLocalizedMessage():My Exception
//toString():java.lang.Exception: My Exception
//printStackTrace():
//java.lang.Exception: My Exception
//				at Exception6.main(Exception6.java:5)

创建用户异常类

Java提供的系统异常类型无法满足程序设计需求

class UserException extends Exception{
	UserException(String msg){super(msg);}
}
public class Exception8 {
  public static void f() throws UserException {
    System.out.println("Throwing UserException from f()");
    throw new UserException();
  }
  public static void g() throws UserException {
    System.out.println("Throwing UserException from g()");
    throw new UserException("Originated in g()");
  }
  public static void main(String[] args) {
    try { f();
    } catch (UserException e) {
      e.printStackTrace();
    }
    try {  g();
    } catch (UserException e) {
      e.printStackTrace();
    }
}
}
//程序的运行结果如下：
//Throwing UserException from f()
//Throwing UserException from g()
//UserException
//				at Exception8.f(Exception8.java:13)
//				at Exception8.main(Exception8.java:21)
//UserException: Originated in g()
//				at Exception8.g(Exception8.java:17)
//				at Exception8.main(Exception8.java:26)

Java Base