JAVA语法点

运算符

op1 instanceof op2 :当op1指示的对象或数组属于op2给出的引用类型，运算结果返回true
比如“Hello” instanceof String 返回true
final作为常量修饰符，final类不能被集成，final方法不能被覆盖

数组

在Java中，数组是一个动态创建且属于Arrays的类对象，因此它又属于引用类型，数组一旦创建长度不可修改，变长数组需要使用ArrayList

int[] myArray;或者 int myArray[];//定义，仅分配引用的存储空间
int[][] myArray;或者int myArray[][];或者int[] myArray[]; //二位数组定义
myArray = new int[10]; //创建，分配元素空间
int[] myArray = {1, 2, 3}; //定义+创建

数组可以通过foreach语句完成遍历：

for(元素类型t 元素变量x : 遍历对象obj){ 
     引用了x的java语句; 
} 

如

int sum =0;
for(int v : value){
	sum += v;
}

Java支持创建不定长行数组

floatArray = new float[5][];
for(int i=0 ; i<5 ; i++){
	loatArray[i] = new float[i+1];
}

类与对象

[修饰符] class 类名{
	类体
}

UML类图
使用“+”表示public访问特性，"#“表示protected访问特性，”-"表示private访问特性
依赖关系的类使用带箭头的虚线相连接，箭头方向为被依赖的类，A类成员方法调用B类成员方法，就说A类依赖B类
聚合关系使用带菱形的实线相连接，菱形一端的类为整体，另一端为部分，指一个类的对象包含另外一个类对象的关系
继承关系使用带三角的实线相连接，三角一端为父类，另外一端为子类，反映“一般与特殊”的关系，任何类都是Object类的直接或者间接子类

初始化块
位于类定义中且用一对花括号括起来的语句组，只要创建了这个类，就会在调用构造方法之前执行这些初始化块。

方法的定义格式

[修饰符] 返回类型 成员方法名(参数列表)[throws 异常类型列表]{
	成员方法体
}

成员方法支持重载，具体调用哪个成员方法与参数列表共同决定，且称此为成员方法的签名

构造方法
不允许定义返回类型,包括void

[修饰符]类名(参数列表)

toString方法
将对象的状态转换为字符串

equals方法
可以实现判断两个对象是否相等的操作

对象定义

[修饰符]类名 对象名[,对象名];

new的作用：
1.为对象分配内存,其中成员方法和静态变量共用一个副本；
2.根据形参调用构造函数，并且返回对象的引用。

Java的自动垃圾回收
Java运行环境中有一个软件实现“垃圾回收器”，当一个对象处于被引用状态，对应的存储空间会被做标记，当引用结束，标记取消后，存储空间将会被周期性扫描的回收器释放，因此Java中不需要像C++一样使用delete。

访问特性控制
1.默认访问权限:只能被本类和同一个包中的其他类、接口和成员方法引用
2.public:被本类和任何其他类及方法引用
3.private:只能被本类直接引用
4.protect:只对本包和其他包的子类开放

内部类
在一个类中定义另外一个类，这样的类被称作内部类
内部类的类名文件为Outer$Inner

1.private内部类可以通过外部类的成员函数创建内部类对象后使用

public class Outer{
	private InClass in;
	private class InClass{ //私有内部类
		public void printCount(){
			System.out.printlin("123");
		}
	}
	public void CreateInObj(){
		in = new InClass();
	}
}

如果内部类的权限是非private，非static，就可以在外部其他程序中被访问到，就可以通过创建外部类对象完成

Outer.Inner in= new Outer().new Inner();

如果内部类是静态的，非私有的，静态成员可以直接类名调用，注意只有内部静态类才可以包含静态成员

class Outer{
	static class Inner{ //内部静态类
		static int num;
	}
}

2.不仅内部类可以访问外部类的private成员，其实外部类也可以访问内部类的private成员
3.局部内部类不能访问所在局部的局部变量(比如一个在类成员方法的内部类不能访问该方法的局部变量，因为本质上编译器将内部类编译成独立的Outer$Inner类文件)，除非该变量为final常量(jdk1.8之后编译器会自动将该局部变量添加final修饰)

匿名类
匿名类的类名文件为“外部类名称+$+匿名类顺序”
匿名类就是利用父类的构造函数和自身类体构造成一个类，格式为

new 父类(){ //“父类”是指子类需要继承或者实现外部的类或者接口
	子类内容
};

匿名类可以访问外部类的成员变量和方法，匿名类的类体不可以声明称static成员变量和static方法。

静态成员
静态成员变量不能在构造方法中初始化，只能在静态成员变量初始化器赋值

static{
	······
};

常见Java类
可变长字符串需要使用StringBuffer
高精度整数BigInteger、高精度浮点BigDecimal
InetAddress类用于IP地址的处理
URL类用于url的解析
URLConnection类用于网络资源处理
InputStream和OutputStream是字节流输入输出处理类
Reader和Writer是字符流输入输出处理
Socket类用于客户端TCP套接字创建
ServerSocket用于服务端TCP的套接字创建
DatagramSocket和DatagramPacket可用于UDP通讯

继承与多态

定义子类的格式：

[修饰符] class 子类名 extends 父类名{
	子类体
}

子类的构造函数
Java规定，必须将调用父类构造函数的super(…)放在子类构造方法的第一条语句位置，否则编译器将自动在这个位置插入一条不带参数的父类构造方法语句

重载与覆盖
子类中定义与父类同名的成员方法，但参数列表不同
当子类定义的成员方法名称和参数列表与父类某个成员方法完全一样时，称为成员方法的覆盖，子类需要使用被覆盖的父类成员，可以用Son.super.xxx()

多态
子类覆盖父类的某个成员方法，然后定义父类对象引用，并由它引用创建的子类对象。当调用成员方法时，根据实际引用的对象类型确定最终调用哪个成员方法。由于只有在执行时才会知道
引用的对象类型，所以究竟执行哪个成员方法在程序执行时才能动态确定，而不是在程序编译时确定，因此这种机制也叫作动态联编。

PersonClass[] info = new PersonClass[3];
info[0] = new PersonClass(1,2,3);
info[1] = new TeacherClass(1,2,3,4);
info[3] = new StudentClass(1,2,3,4,5);
for(PersonClass v : info)
	System.out.println(v); //将打印各种子类的toString方法结果

抽象类
表示概念性的事物，不能被实例化，即不能创建抽象类的对象，但是可以定义抽象类的引用，并用它引用抽象类的某个可实例化子类的对象，实现多态

[修饰符] abstract class 抽象类名{
	[修饰符] abstract 返回类型 抽象方法名(参数列表) //抽象方法只能在不能被实例化的抽象类中出现，不能使用static、private和final修饰符
	······
}

接口
一种特殊的抽象类，只允许包含常量和抽象方法，常量默认为public static final,成员方法默认为public abstract

public interface Comparable{
	int compareTo(Object other);//缺省public abstract
}
public class EmployeeClass implements Comparable{
	public int compareTo(Object other){
	
	}
}

对象复制
Java中提供了一个Cloneable接口用于支持深浅复制，默认的Object.clone()只提供对象的浅复制，实现深复制需要在子类中覆盖Object.clone()

多线程

线程创建方法
1.继承Thread类
2.实现Runnable接口

守护线程
当程序所有非守护线程都终止运行，即使守护线程在运行，应用程序也将终止，可以在start()之前调用线程对象的setDaemon(boolean on)设置。

优先级
Java采用“抢占式”策略调度，有别于FreeRTOS简单的同优先级均分时间片，Java中“高优先级线程”被分配的时间片多于“低优先级线程”，线程时间片用完将让出CPU，
无论是是级别相同还是不同，线程调用都不会绝对按照优先级执行，每次执行结果都不一样，调度算法无规律可循，所以线程之间不能有先后依赖关系。

线程控制
start()启动
sleep()休眠
wait()阻塞等待
notify()唤醒wait()的线程
interrpt()通过抛出InterruptException强制唤醒wait和sleep线程
yeild() 线程主动将剩余时间片转让给其他线程，但并不永久阻塞
join() 线程A调用B线程的join方法可以使A暂停运行，直到线程B终止

线程的互斥
Java中的synchronized限定对象任意时刻只能由一个线程访问
1.同步方法

synchronized <方法声明>{
	<方法体>
}
等价于
<方法声明>{
	synchronized(this){
		<方法体>
	}
}
eg:
class Booking{
	public synchronized void sail(int num){
		·····
	}
}
class Booking{
	public void sail(int num){
		synchronized(this){}
			·····
		}
	}
}

2.对象同步

synchronized<对象名>{
	<代码块>
}
eg:
class BookingTest implements Runnable{
	Booking bt;
	public void run(){
		synchronized(bt){
			bt.sales(num);
		}
	}
}

集合类

常见集合类
1.Collection:所有集合的接口，具有所有集合都具有的通用方法
2.HashSet:能快速定位一个元素的数据集合，放入的对象需要实现hashCode()方法
3.TreeSet:放入的对象需要是可排序的
4.LinkedList:可按照序号检索数据，能向前向后遍历
5.ArrayList:类对象可以动态改变大小，实质为不定长数组(与LinkedList本质区别是，前者为链表，后者为顺序结构)
6.HashMap:描述key与value一对键值的映射集合，key唯一，允许存储空对象
7.TreeMap:描述key值可排序的映射集合
8.WeakHashMap:一种改进的HashMap，集合中某些内容不再使用时，可进行垃圾回收
9.Vector:可存储不定长，类型不一致的顺序结构集合，与ArrayList不同之处在于，Vector支持线程同步，增删速度较慢
10.Stack:一种先进后出的数据结构，Vector的子类

迭代器
迭代器是一个实现了Interator或者ListInterator接口的对象，一般通过集合类的interator()或者listInterator()方法返回对象的迭代器
Last La = new LinkedList();
ListIterator aIter = La.listInterator();

泛型类

具有参数化类型的类，定义格式：

class xxx<k,v...>{
	以k,v作为参数的类体
}
eg:
class Gen<T>{
	private T ob;
	public Gen(T ob){
		this.ob = ob;
	}
	public T getOb(){
		return ob;
	}
}
public class TestGen<k,v>{
	public HashMap<k,v> h = new HashMap<k,v>();
	public void put(k key, v value){
		h.put(key, value);
	}
	public static void main(String args[]){
		Gen<Integer> intOb = new Gen<Integer>(66);
		int i = intOb.getOb();
		Gen<String> stringOb = new Gen<String>("Test");
		String s = stringOb.getOb();
		TestGen<String, String> t1= new TestGen<String, String>();
		t1.put("book", "C Programing");
		TestGen<Integer, Integer> t2 = new TestGen<>(Integer, Integer);
		t2.put(2, 3);
	}
}