XmlPullParserFactory
--private static XmlPullParserFactory newInstance(){}
--private XmlPullParser newPullParser(){}
XmlPullParser
--private void setInput(StringReader stringreader){}
--private int getEventType(){}
--private String getName(){}
--private String nextText(){}
--private int next(){}
StringReader
--public StringReader StringReader(String xmlData){}
DefaultHandler
--public void startDocument() throws SAXException{}
--public void startElement(String uri, String localName, String gName, Attributes attributes)throws --SAXException{}
--public void characters(char[] ch, int start, int length) throws SAXException{}
--public void endElement(String uri, String localName, String qName) throws SAXException{}
--public void endDocument() throws SAXException{}
SAXParserFactory
--private SAXParserFactory newInstance(){}
--private SAXParser newSAXParser(){}
SAXParser
--private XMLReader getXMLReader(){}
XMLReader
--private void setContentHandler(DefaultHandler handler){}
--private void parse(InputSource inputSource){}
InputSource
--public InputSource InputSource(StringReader stringReader){}

JSONArray
--public JSONArray JSONArray(String jsonData){}
--private JSONObject getJSONObject(int i){}
--private int length(){}
JSONObject
--private String getString(String key){}
Gson
--public Gson Gson(){}
--private <?> fromJson(String jsonData, Class <?>.class){}
--private List<?> fromJson(String jsonData, Class TypeToken<List<?>>(){}.getType){}

LocationManager
--private Location getLastKnownLocation(String provider){}
--private List<String> getProviders(Boolean i){}
--private void requestLocationUpdates(String provider, long s, int m, LocationListener locationListener ){}
--private void removeUpdates(LocationListener locationListener){}
List
--private boolean contains(String string){}
LocationListener
--public void onStatusChanged(String provider, int status, Bundle extras){}
--public void onProviderEnabled(String provider){}
--public void onProviderDisabled(String provider){}
--public void onLocationChanged(Location location){}
Location
--private String getLatitude(){}
--private String getLongitude(){}

JSONObject
--public JSONObject JSONObject(String string){}
--private JSONArray getJSONArray(String key){}
Context
--private Context getApplicationContext(){}
百度地图SDK
SDKInitializer
--private static void initialize(Context context){}
MapView
--private void onDestroy(){}
--private void onPause(){}
--private void onResume(){}
--private BaiduMap getMap(){}
MapStatusUpdateFactory
--private static MapStatusUpdate zoomTo(float limit){}
--private static MapStatusUpdate newLatLng(LatLng latLng){}
BaiduMap
--private void animateMapStatus(MapStatusUpdate update){}
--private void setMyLocationData(MyLocationData data){}
--private void setMyLocationEnable(Boolean boolean){}
LatLng
--public LatLng LatLng(String latitude, String longitude){}
MyLocationData.Builder
--public MyLocatoinData.Builder MyLocationData,Builder(){}
--private void latitude(String latitude){}
--private void longitude(String longitude){}
--private MyLocationData build(){}

SensorManager
--private Sensor getDefaultSensor(int type){}
--private void registerListener(SensorEventListener listener, Sensor sensor, int frequency){}
--private void unregisterlistener(SensorEventListener listener){}
--private void getRotationMatrix(float R[9], null, float accelerometerValues[], float magneticValues[] ){}
--private void getOrientation(float R[9], float values[3]){}
SensorEventListener
--public void onAccuracyChanged(Sensor sensor, int accuracy){}
--public void onSensorChanged(SensorEvent event){}
RotateAnimation
--public RotateAnimation RotateAnimation(float last, float now, int relative, float x, int relative, float y){}

Applicatoin
--public void onCreate(){}
--public static Context getContext(){}
Intent
--private putExtra(String key, Serializable values){}
--private getSerializableExtra(String key){}
Parcelable
--public int describeContents(){}
--public void writeToParcel(Parcel parsel, int flags){}
Parcelable.Creator<?>
--public <?> createFromParcel(Parcel parcel){}
--public <?>[] newArray(int size){}
Parcel
--private void writeXxx( Xxx m){}
--private Xxx readXxx(){}

Intent
--private Xxx (Xxx)getParcelableExtra(String key){}
AndroidTestCase
--protected void setUp() throws Exception{}
--protected void tearDown() throws Exception{}
--protected void assertEquals(value1, value2){}

SE
jdk(开发环境)->jre（运行环境）==》.java->.class->JVM==》编译型->解释型==》javac(-d 输出位置 输入位置)
->java(类名)
java -classpath
public类名=文件名
垃圾回收机制==》对象引用
面向结构->功能化->函数 面向对象->对象化->类对象
面向对象(java 支持继承)==》基于对象(js 不支持继承)
UML（用例==》类==》组件）==》部署==》（顺序or活动）
文档注释 javadoc
prperty:
-d -windowtitle -doctitle -header
添加类：*.java
添加包：*, package.html
常用标记：@param @return @exception
生僻关键字
instanceof(属于) native（转语言） strictfp（精确浮点） synchronized（锁） transient(不输出) volatile(最新值)
空引用（空对象）null：单向转化为其他对象引用（指针）类型/类
整型：默认int ，字符串小于127可自动转化byte,小于2^15可自动转化short，大于2^31必须强转long
字符型：可与整型相互自动转化
浮点数：默认double
float--1,8,23;double--1,11,52;特殊--正无穷，负无穷，非数NaN
boolean型:可单向转化为String(格式true/false+"")
自动转化规则符合：赋值、运算中，低位类型向高位类型自动转换，反之强转
直接量
>>符号位填充，>>>0填充
==数值型：值等则true，引用型：同对象则true，包装类、String类：遵循缓存机制--直接赋值true,new则false
&，|：不短路与，或
优先级：数字>关系>逻辑>赋值
return：结束方法（结束循环）
数组类动态初始化的元素初值
整型：0，浮点：0.0，字符：‘/u0000’，boolean：false，指针：null
属性：length
销毁：数组对象指针=null
增强for
for(元素类型：元素实例形参，数组名){}
多维数组：
栈->堆->堆……->堆

java.util
public final class Arrays extends Object
--static int binarySearch(byte[] a, byte key){}
--staitic int binarySearch(byte[] a, int fromIndex, int toIndex, byte key){}
--static byte[] copyof(byte[] original, int newLength){}
--static byte[] copyOfRange(byte[] original, int from, int to){}
--static boolean equals(byte[] a, byte[] a2){}
--static void fill(byte[] a, byte val){}
--static void fill(byte[] a, int fromIndex, int toIndex, byte val){}
--static void sort(byte[] a){}
--static void sort(byte[] a, int fromIndex, int toIndex){}
--static String toString(byte[] a){}

Math
--static int round(double num){}
String
--static String valueOf(int num){}
--int length(){}
--int charAt(int i){}

类修饰符:public final
static 类共用
1、类成员可互相调用
2、static修饰的类成员不能直接调用无static修饰的类成员，如需调用，创建一个新的类实例
对象的创建符合
对象引用->元素（对象引用）->基础类型
对象引用->元素(基础类型)
this总是指向调用该方法的对象，一般可省略
作用：避免重复创建类对象

创建类对象时会给类、对象分配内存堆，即初始化。
成员变量随初始化在内存堆被分配内存。
局部变量保存在方法的栈内存中，不会自动初始化，不分配内存。
函数
函数依赖于类或对象，不存在可以直接调用的独立函数。
函数的参数传递方式只有1种：传值。符合：
a.函数1内存栈中数据==》复制==》函数2内存栈中数据
b.函数1内存栈中指针==》复制==》函数2内存栈中指针（指针指向对象内存堆）
参数可变：将可变参数（同一类型，参数个数依据实际需求输入）作为数组传入 格式 type... 数组名。每个方法限1个。
支持递归
支持重载
需要在对象间传递的变量创建成员变量，需要在方法中传递的变量创建方法局部变量，方法内部运算的中间变量创建代码块局部变量。

访问权限：
默认值：default，包访问权限
private 类访问权限
protected 子类访问权限
public 完全可见
一般访问顺序：
public类/方法->default类->protected方法->private方法/成员变量
package
1一个源文件只能定义1个包
使用javac.exe编译时-d指令会按照源文件指定包路径创建.class文件，否则创建再默认目录下
import
类的导包操作可在调用时省略类的完整名
变量导包（static）操作可以调用相应路径下的静态变量

多构造器
如下方式实现构造器参数互调
构造器1{}
构造器2{
this(初始化变量1，初始化变量2，...)}
方法重写遵循：两同两小一大。可以在子类中super.调用父类中被重写的方法。
super指向所在被调用方法的对象的父类对象。
变量的查询顺序是：局部变量->成员变量->父类变量->……->Object类变量
构造器的调用顺序同上
多态性是指：在声明对象时用子类运行，用父类编译。编译后对象只拥有父类拥有的方法和属性，其中方法与子类一致，属性与父类一致。
强转可以使该对象转为子类对象。
instanceof可用来判断是否能够强转成功（判断一个类的继承中，对象是否是类的子类或类本身，如果是父类，返回false）
继承原则：1、父类尽量使用private修饰防止子类调用、重写 2、父类构造器不调用被子类重写的方法
3、父类可用final修饰类禁止继承，用private修饰构造器禁止调用父类构造器（用禁态方法创建实例）
组合原则：当一个类需要调用其他类的公共方法和属性组成其功能时推荐使用。
初始化块：
创建对象时的执行顺序是：静态初始化块（类初始化块）->对象的初始化块->对象的构造器
用法：用于初始化赋值。

包装类
包装：用构造器执行包装
用基础类型包装
public Boolean Boolean(boolean b){}
用字符串包装
public Boolean Boolean(String b){}
解包：用xxxValue执行解包
public boolean booleanValue(){}
Boolean
--public boolean parseBoolean(String true){}
String
--public String valueOf(boolean ture){}
||--String a = int b + " ";