第一课 Java基础
1. ubuntu上环境搭建 (建议使用我们提供的VMWare映象文件)
如果要自己安装ubuntu, 请参考<韦东山Android系统视频使用手册.pdf>
ubuntu 12.04.5 这是一个长期支持的版本
硬盘空间至少预留80G
a. root分区 : 20G, 从其中划出6G用作swap
b. work分区 : 60G
c. 内存 : 4G
安装Java开发环境
sudo apt-get update
sudo apt-get install openjdk-7-jdk
sudo apt-get install openjdk-7-jre
2. 第1个JAVA程序 (和C对比)
编译的方法：javac Hello.java
运行的方法：java hello
3. JAVA数据类型
基本数据类型：boolean, byte, char(2字节), short, int, long, float, double
引用数据类型：数组、类对象、接口（引用数据类型指的是变量所指向的数据在堆中，比如：int p2[] = {1,2,4}，数据1,2,4在堆中，p2在栈上，其值是堆的地址），引用和C语言中的指针比较类似
引用数据类型使用new来分配，不需要自己释放，把变量设为null即可
栈内存、堆内存
数据类型转换(自动转换（发生的前提是数据转换后不会丢失）, 强制转换)
short s=1；s=s+1会出错，因为对于byte，short的运算，为了保证精度，会自动转换为int，其不能直接赋给short类型，改为s=（short）（s+1）
sourceinsight编写的文件是以ascii码编译的，java编译器是以UTF-8来解析字符的，所以如果文件中存在汉字，会存在无法解析的情况，所以需要使用UE把该文件转换成UTF-8格式
4. 语句：跟C完全一样
5. 方法(函数)
6. 方法重载、参数传递
重载指的是函数名相同，参数类型或者参数个数不同，返回值类型的不同不是重载
int p[] = new int[1];p[0]=123;fun2(p);这个时候p[0]的值会改变（public static void fun2（int[] p）{p[0]=100}）
第二课 面向对象程序设计
1. 类的引入
C语言是面向过程的
出一道题：写一个程序，输出张三、李四两个人的姓名
定义一个类（class A），实例化这个变量（A a），a就是个对象
构造函数格式：public 类名称（类型 参数......）//其没有返回值，可以有多个构造方法
{
语句；
}
static修饰的类方法属于类，通过“类名.方法”来调用
在类中通过一个大括号”{}”括起来的就是构造块，通过构造块扩起来的代码在任何构造函数被调用之前会被调用执行
大括号“{}”之前加上一个static修饰就是静态代码块，实例化第一个对象之前执行，并且只执行一次，在执行构造块和构造方法，再之后实例化都不会再次执行静态代码块。
类中的main函数通过static修饰是为了让虚拟机不用实例化对象就能执行main函数
2. 封装性
private修饰的变量和方法只能被类的内部方法所访问，不能被外部所访问
private本类可访问；default本包可访问；protected本包、其他包的之类可访问；public所有都可访问
3. 继承性
实例化子类对象时，先调用父类的构造方法，再调用子类的构造方法（如果子类构造函数中没有super等语句，在子类的构造函数中第一行默认会添加一句super();表示调用父类的默认无参构造函数）；
如果父类有个构造方法是“类名（参数1）”，则在子类构造方法中第一句加上“super（参数1）”，在实例化一个对象时会先调用父类的构造方法“类名（参数1）”
final类不能有子类；final方法不能被覆写；final变量变成常量，不能被修改
继承的限制：1、父类的private修饰属性和方法不能被之类继承，对应私有属性，如果有公开的方法获得私有属性，子类可以调用该方法
2、子类覆写的方法不能缩小权限，比如父类的public方法a，子类也只能覆写为public；
在class前加上abstract修饰的类是抽象类，其类内部除了有属性、普通方法外还有抽象方法（）在方法的访问权限和返回值之间加上abstract修饰的方法），抽象方法仅需要声明，不需要实现；
抽象类不能实例化对象，子类必须覆写全部抽象方法；
接口：interface 接口名称{全局常量；抽象方法}
接口和抽象类相似，其模板作用，子类可以继承多个接口，子类必须覆写全部抽象方法
（子类只能extends继承一个父类）
class A extends D implements B，C{}//B和C是接口，D是普通类火灾抽象类
4. 多态性
Son son = new Son();Father f = son;//如果fun()在父类Father和子类Son中都定义，f.fun()只能调用被子类覆写的方法；而如果fun仅在son中定义，则不能调用f.fun(),不能调用只在子类中定义的方法；而如果fun仅在father中定义，则f.fun就是调用自己的fun函数（这就是向上转换，把子类的对象赋给父类）
Father f = new Son();Son son = (Son)f;//在进行对象的向下转换前，必须首先发生对象的向上转换（比如声明父类对象的时候使用new 子类）（向下转换，把父类的对象赋值给子类，需要强制转换）
向上转换使用场景：在main中定义了一个函数，函数的参数是父类，这时候在调用这个函数的时候可以传子类；
eg：public static void main(String args[]){ //Son和Daughter是Father的子类
Father f = new Father();
Son s = new Son();
Daughter d = new Daughter();
print(f);
print(s);
print(d);
}
public static void print(Father f){
f.printfInfo();
}
instanceof用来判断对象是不是某个类的实例 eg：if(f instanceof Father)
向下转换的使用场景:
eg：public static void main(String args[]){ //Son和Daughter是Father的子类
Father f = new Father();
Son s = new Son();
Daughter d = new Daughter();
printAction(f);
printAction(s);
printAction(d);
}
public static void printAction(Father f){
if(f instanceof Son){
Son son = (Son)f;
son.playGame();
}
else if(f instanceof Daughter){
Daughter d= (Daughter)f;
d.dance();
}
else if(f instanceof Father){ //父类的instanceof必须放在最后面，子类对象 instanceof Father的时候也是真的
f.drink();
}
}
5. 异常
自己处理：
try
｛执行语句｝
catch（异常）
｛
捕获异常后执行的语句
｝
finally｛
不管有无异常都会执行的语句，finally可有可无
｝
让别人处理：
1、在调用语句的函数“｛”前面加上throws 异常，其表示扔给函数的调用者A处理；
2、把调用者A放到try语句块中，并加上catch来处理；
3、也可以在调用者A所属的函数出加上throws来上仍
4、对于有些异常需要自己处理一部分，也需要调用者处理一部分的情况时，这时候需要在自己处理的catch语句块中的最后一行加上throw
eg：catch （ArithmeticException e）｛
System.out.println("div:"+e);
throw e;
｝
通过catch （异常A）｛
｝catch（异常B）｛
｝catch （异常C）｛
｝通过catch捕获多个异常时，子异常必须在前面，否则父异常会把所有异常捕获
如果try或catch块中有return或throw语句，会先执行finally块，在返回执行return或者throw语句，如果在fianlly中直接return返回了就不会在执行了，所有不要在finally中加return语句。
对于可查（代码不需要运行就知道运行到此处肯定会抛出异常）异常必须处理（自己处理或者抛出去）
对于不可查异常可以不处理，系统也会自动抛出去
参考文章:
深入理解java异常处理机制
http://blog.csdn.net/hguisu/article/details/6155636
6. 包和权限
javac A.java // 将在当前目录下生成A.class
能否把这些class文件存放于其他目录呢？
在A.class 中添加一句“Package a”，这样在执行javac -d . A.java;//这样就会在当前目录下生存a包，即目录a
jar -cvf my.jar a // 把包a创建为压缩文件my.jar
export CLASSPATH=.:my.jar //“：”是分开的意思，“.”表示当前目录，这里表示从当前目录或者my.jar中找包
public class可以被外包访问；class只能在本包中访问；
7. 内部类
在一个类A的里面重新定义一个新类B，这个类B就是内部类
一般内部类：（一般内部类可以反问外部类的私有属性）
class Outer｛
private int a =10；
class Inner｛
public void printInfo(){
System.out.println("a = "+a);
}
｝
｝
public class InnerDemo{
public static void main(String args[]){
Outer o = new Outer();
Outer.Inner i = o.new Inner();
i.printlnfo();
}
}
静态内部类：（静态内部类的好处是可以直接访问外部类的私有静态属性）
class Outer｛
private static int a =10；
static class Inner｛
public void printInfo(){
System.out.println("a = "+a);
}
｝
｝
public class InnerDemo{
public static void main(String args[]){
Outer.Inner i = new Outer.Inner();//不声明外部类的情况下，直接声明内部类时，必须把内部类声明为static，且这时候的内部类只能访问外部类的static属性
i.printlnfo();
}
}
匿名内部类：(声明的类仅使用一次，因此不需要去继承接口，在实例化这个类)
interface A{
public void printflnfo();
}
public class Anony{
public static void main(String args[]){
testFunc(new A(){
public void printlnfo(){
System.out.println("hello");
}
});
}
public static void testFunc(A a){
a.printlnfo();
}
}
第三课 JNI (Java Native Interface)
1. JAVA调用C
Linux是用C语言写的，可以写一个APP简单调用open,read,write来访问驱动程序;
Android是用Java写的，Java怎么访问C函数？
jni.pdf P117
Android JNI知识简介
http://blog.csdn.net/linweig/article/details/5417319
Android JNI（实现自己的JNI_OnLoad函数）
http://jjf19850615.blog.163.com/blog/static/356881472013342153912/
查看"JNI field descriptors" (JNI字段描述符)
javap -s -p Var.class
JNINativeMethod的参数解析
http://carywei.iteye.com/blog/1075647
http://cs.fit.edu/~ryan/java/language/jni.html
http://blog.csdn.net/conowen/article/details/7524744
2. C调用JAVA
jni.pdf P97
http://blog.csdn.net/lhzjj/article/details/26470999
4步骤:
a. 创建虚拟机
b. 获得class
c. 实例化对象 : 获得构造方法(方法名为"<init>"), 构造参数, 调用方法
d. 调用方法 : 又分为获得方法, 构造参数, 调用方法
读取/设置类中的属性:
a. 获得属性ID
b. 读取/设置
第四课 JAVA高级应用
1. 泛型(Generics)
在定义类的时候使用通配符来表示一个类型，在实例化的时候传入真正的类型
eg：
class Person<T> {
private T age;
public void setAge(T age) {
this.age = age;
}
public T getAge() {
return this.age;
}
}
public class Generics {
public static void main(String args[]) {
Person<String> p = new Person<String>();
p.setAge("3 years old");
System.out.println(p.getAge());
Person<Integer> p2 = new Person<Integer>();
p2.setAge(3);
System.out.println(p2.getAge());
}
}
eg：函数参数的泛型使用通配符“？”
public class Generics {
public static void main(String args[]) {
Person<String> p = new Person<String>();
p.setAge("3 years old");
//System.out.println(p.getAge());
printInfo(p);
Person<Integer> p2 = new Person<Integer>();
p2.setAge(3);
//System.out.println(p2.getAge());
printInfo(p2);
Person<?> p3;
p3 = p;
//p3.setAge("4 years");//这里会出错
p3.getAge();//这里可以正常执行
}
public static void printInfo(Person<?> p) {
System.out.println(p.getAge());
}
eg：方法泛型举例
printInfo2(p);
printInfo2(p2);
printInfo2(p3);
public static <T> void printInfo2(Person<T> p) {
System.out.println(p.getAge());
}
eg：子类也声明为泛型举例
class Person<T> {
private T age;
public void setAge(T age) {
this.age = age;
}
public T getAge() {
return this.age;
}
}
class Student<T> extends Person<T> {
}
class Student2 extends Person<String> {
}
public class Generics {
public static void main(String args[]) {
Person<String> p = new Person<String>();
p.setAge("3 years old");
//System.out.println(p.getAge());
printInfo(p);
Person<Integer> p2 = new Person<Integer>();
p2.setAge(3);
/System.out.println(p2.getAge());
printInfo(p2);
Person<?> p3;
p3 = p;
//p3.setAge("4 years");
p3.getAge();
printInfo2(p);
printInfo2(p2);
printInfo2(p3);
Student<Integer> s = new Student<Integer>();
s.setAge(10);
printInfo(s);
Student2 s2 = new Student2();
s2.setAge("11 years");
printInfo(s2);
}
public static void printInfo(Person<?> p) {
System.out.println(p.getAge());
}
public static <T> void printInfo2(Person<T> p) {
System.out.println(p.getAge());
}
}
eg：接口泛型举例
interface Person<T> {
public void setAge(T age);
public T getAge();
}
class Student<T> implements Person<T> {
T age;
public void setAge(T age)
{
this.age = age;
}
public T getAge() {
return this.age;
}
}
class Student2 implements Person<String> {
String age;
public void setAge(String age)
{
this.age = age;
}
public String getAge() {
return this.age;
}
}
public class Generics {
public static void main(String args[]) {
Student<Integer> s = new Student<Integer>();
s.setAge(10);
printInfo(s);
Student2 s2 = new Student2();
s2.setAge("11 years");
printInfo(s2);
}
public static void printInfo(Person<?> p) {
System.out.println(p.getAge());
}
public static <T> void printInfo2(Person<T> p) {
System.out.println(p.getAge());
}
}
eg：受限泛型参数举例
泛型的上限 <T extends Number> T只能是Number类或其子类
泛型的下限<T super String> T只能是String类或其父类
上限举例：
interface Person<T> {
public void setAge(T age);
public T getAge();
}
/* Integer, Float */
class Student<T extends Number> implements Person<T> {
T age;
public void setAge(T age)
{
this.age = age;
}
public T getAge() {
return this.age;
}
}
class Student2 implements Person<String> {
String age;
public void setAge(String age)
{
this.age = age;
}
public String getAge() {
return this.age;
}
}
public class Generics {
public static void main(String args[]) {
Student<Integer> s = new Student<Integer>();
s.setAge(10);
printInfo(s);
Student2 s2 = new Student2();
s2.setAge("11 years");
printInfo(s2);
}
public static void printInfo(Person<?> p) {
System.out.println(p.getAge());
}
public static <T> void printInfo2(Person<T> p) {
System.out.println(p.getAge());
}
}
下限举例：
在声明类的地方加上<T super string>后会报错，只能在使用的时候比如在方法的参数中声明
interface Person<T> {
public void setAge(T age);
public T getAge();
}
class Student<T> implements Person<T> {
T age;
public void setAge(T age)
{
this.age = age;
}
public T getAge() {
return this.age;
}
}
class Student2 implements Person<String> {
String age;
public void setAge(String age)
{
this.age = age;
}
public String getAge() {
return this.age;
}
}
public class Generics {
public static void main(String args[]) {
Student<String> s = new Student<String>();
s.setAge("10");
printInfo(s);
Student2 s2 = new Student2();
s2.setAge("11 years");
printInfo(s2);
}
public static void printInfo(Person<? super String> p) {
System.out.println(p.getAge());
}
public static <T> void printInfo2(Person<T> p) {
System.out.println(p.getAge());
}
}
2. 反射(Reflect)
反射操作中，一切的操作都使用Object完成，类、数组的应用都可以使用Object进行接收
对于每个类，在编译后都会生成.class文件，JVM会把这些类加载进内存，并创建classobject，其有包名称、类名称、构造方法、方法、属性，可以使用三种方法来获得一个类的classobject
A、Class<？> c = Class.forName("包.类")
B、Class<？> c = new 类名().getClass();
C、Class<？> c = 类名.class
eg：根据实例化对象获得完整的包类名称
package a.b.c.d;
class Person {
private String name;
void setName(String name) { this.name = name; }
String getName() { return this.name; }
};
public class Reflect {
public static void main(String args[]) {
Person p = new Person();
Class<?> c1 = null;
try {
c1 = Class.forName("a.b.c.d.Person");
} catch (ClassNotFoundException e) {
System.out.println(e);
}
Class<?> c2 = p.getClass();
Class<?> c3 = Person.class;
System.out.println(c1.getName());
System.out.println(c2.getName());
System.out.println(c3.getName());
int arr[] = {1,2,3};
int arr2[][] = {{1,2,3,4},{1}};
Class<?> c4 = arr.getClass();
Class<?> c5 = arr2.getClass();
Class<?> c6 = int.class;
System.out.println(c4.getName());
System.out.println(c5.getName());
System.out.println(c6.getName());
System.out.println((c4 == c5));
System.out.println((c4 == c6));
}
}
执行结果：
a.b.c.d.Person
a.b.c.d.Person
a.b.c.d.Person
[I //JNI描述符
[[I
int
false
false
eg:获得类的名字有什么用呢？获得类后，可以直接实例化他，并访问其属性和方法
A：通过反射实例化对象，不用import导入包类
Person.java文件
package a.b.c.d;
public class Person {
private String name;
void setName(String name) { this.name = name; }
String getName() { return this.name; }
public Person() {
System.out.println("Constructor of Person");
}
public Person(String name) {
this.name = name;
System.out.println("Constructor2 of Person, name is "+this.name);
}
};
Reflect.java文件，通过反射获得内存中的classobject，在实例化后直接访问对象的属性和方法
//import a.b.c.d.Person;使用反射，不需要导入包
import java.lang.reflect.Constructor;
public class Reflect {
public static void main(String args[]) throws Exception {
Class<?> c = null;
try {
c = Class.forName("a.b.c.d.Person");
} catch (ClassNotFoundException e) {
System.out.println(e);
}
Object p = null;//因为没有import person，所有只能使用Object，其是所有类的父类
try {
p = c.newInstance();//调用类的无参构造方法来创建获取类的实例化对象，其向上转换
} catch (InstantiationException e) {
System.out.println(e);
}
Constructor<?> con = c.getConstructor(String.class);//通过参数类型来获得构造函数，其参数也是class类型
Object p2 = con.newInstance("weidongshan");
}
}
B、通过反射范围对象的方法
//import a.b.c.d.Person;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class Reflect {
public static void main(String args[]) throws Exception {
Class<?> c = null;
try {
c = Class.forName("a.b.c.d.Person");
//c = Class.forName(args[0]);这个时候可以通过命令上次包类名称：java Reflect a.b.c.d.Person
} catch (ClassNotFoundException e) {
System.out.println(e);
}
Object p = null;
try {
p = c.newInstance();
} catch (InstantiationException e) {
System.out.println(e);
}
Constructor<?> con = c.getConstructor(String.class);
Object p2 = con.newInstance("weidongshan");
Method set = c.getMethod("setName", String.class);//获得方法
set.invoke(p2, "123");//如果方法是静态方法，invoke的第一个参数可以是null
set.invoke(p, "abc");
Method get = c.getMethod("getName");
System.out.println(get.invoke(p));
System.out.println(get.invoke(p2));
}
}
eg：通过反射设置或者获得属性
import java.lang.reflect.Field;
.........
Field name = c.getDeclaredField("name");//获得本类中名为name的属性，所有的包括private属性
//Field name = c.getField("name")获得公共public属性，此方法先搜索本类，在搜它实现的接口，最后在父类中搜索
name.setAccessible(true);//设为可被外部访问,没有这一句，private属性将不可被访问
name.set(p, "www");
name.set(p2, "100ask");
System.out.println(name.get(p));
System.out.println(name.get(p2));