Android驱动-Java入门学习（java安装）

在ubuntu 14.04上java开发环境。

下载 jdk-7u75-linux-x64.tar.gz

使用tar xvf jdk-7u75-linux-x64.tar.gz 解压

在/usr/lib/ 下创建jvm目录，将解压过的java文件夹移动进来

在 /etc/profile中添加

#set java environment  

export JAVA_HOME=/usr/lib/jvm/你的jdk目录名字
export JRE_HOME=${JAVA_HOME}/jre
export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/lib
export PATH=${JAVA_HOME}/bin:$PATH

运行下列两行语句即可

 sudo update-alternatives --install /usr/bin/java java  /usr/lib/jdk1.7.0_06/bin/java 300
 sudo update-alternatives --install /usr/bin/javac javac  /usr/lib/jdk1.7.0_06/bin/javac 300

第二种

sudo apt-get install openjdk-7-jdk

Java基本的数据类型：bootlean、byte、char、short、int、long、float、double

第一个例子：

/*
*  filename hello.java
*/
public class hello {
    public static void main( String args[] )
    {
        System.out.println("Hello world");
    }
}

注：class的类名要和文件名一致。

javac hello.java    //编译  会自动生成hello.class 文件

java hello       // 执行

在申请一块内存后，如果想释放，直接给指针赋空即可。java的垃圾回收机制会自动释放内存。

char str[] = new char[100];

str = null;　　//释放内存

如果想在类的定义的时候自动执行一段代码，不一定要写在构造函数中，也可以写在构造块中。

java中，在类中直接添加一个大括号，里面添加相应的代码，即为构造块。构造块比构造函数先执行。

还有一种就是静态代码块。

静态代码块与构造块不同的是静态代码块只执行一次。并且要在大括号前加static。

在继承（extends）中，默认调用父类无参的构造函数（super()）。

如果需要调用有参数的，需要使用 super( 参数1，参数2，..... )

继承的限制：

　　1. 父类的私有成员，子类无法直接访问。

　　2.子类去除父类的成员。

　　3.子类不能修改父类的权限。

抽象类：

　　在父类中可以声明抽象方法而不定义。但是子类如果继承父类，则必须实现抽象方法。

　　抽象类不能有实例化对象，只能用来继承。

　　在声明抽象方法时，需要用abstract来修饰

接口(implements)：

　　一个子类只能继承一个父类，但是一个子类可以可以多个接口。

数据类型转换:

　　整数默认是int,小数默认是double.

1. Java基础

第一个Java程序

代码

Hello.java

public class Hello {

public static void main (String args[]) {

System.out.println("Hello, world!");

}

}

编译

javac Hello.java

运行

java Hello

数据类型

基本数据类型

引用数据类型

使用new来分配，不需要自己释放，把变量设为null即可

int p[]=new int [10];

p = null;

数组

int a[]=null;

a = new int[10];

int b[]=new int[10];

int c[]={1,2,3,4,5};

类

接口

null

数据类型转换

自动转换

数据不丢失的前提下可以自动转换

int a=30;

long b = a; // 自动转换，因为long的表示范围比int大

float c = 3.1

int d = (int)c; // 必须使用强制转换

注意：整数默认是int，有小数时默认是double

强制转换

例子

byte b= 1;

short s= 3;

编译器会判断该值有无超过该变量的表示范围，如果超过就报错。

short s = 1;

s = s + 1; // 出错，因为对于byte，short的运算，为了保证精度，会自动转换为int类型

s = (short)(s + 1);

short s2 = 1;

s = s + s2; // 出错，理由同上

运算符、表达式、语句

跟C语言完全一样

if, if...else, if...else if...else, switch

while, do...while, for; break, continue

方法

格式

public static 返回值类型 方法名称 (类型 参数1, 类型 参数2, ...) ｛

程序语句;

[return 表达式];

｝

示例：

public static int add(int x, int y) {

int sum;

sum = x + y;

return sum;

}

重载

方法名相同

参数类型或个数不同

返回值可以相同也可以不同

参数

基本数据作为参数

方法内部对参数的修改不影响调用者

引用数据作为参数

方法内部修改了堆，结果会保留下来

2. 面向对象程序设计

类的引入

C语言中的结构体(struct)

struct Person {

char name[100];

int age;

int money;

char *(*getName)(struct Person per);

int (*getMoney)(struct Person per);

};

char *getName(struct Person per)

{

return per.name;

}

int getMoney(struct Person per)

{

return per.money;

}

struct Person per;

struct Person *p = malloc(sizeof(struct Person));

per.getName = getName;

per.getMoney = getMoney;

p->getName = getName;

p->getMoney = getMoney;

int i = per.age;

char *str = per.getName();

类型定义

创建结构体

使用

Java中的类(class)

class 类名称 {

数据类型 属性;

...

public 返回值类型 方法名称 (参数1, 参数2, ...) {

程序语句;

[return 表达式;]

}

}

class Person {

String name;

int age;

int money;

public String getName( );

public int getMoney( );

}

Person per = null;

per = new Person( );

int i = per.age;

int m = per.getMoney( );

class定义

创建对象

访问属性和方法

构造方法

class Person {

String name;

int age;

int money;

public String getName( );

public int getMoney( );

// 构造方法

访问权限 类名称 (类型1 参数1, 类型2 参数2, ...) {

程序语句;

..... // 构造方法没有返回值

}

}

如果没实现构造方法，编译器自动加上一个无参数的空构造方法

this关键字

表示当前对象, 当前类

static关键字

类属性

类方法

代码块

普通代码块

方法的{}就是普通代码块

构造代码块

class Person {

{

// 构造块

// 每实例化一个对象前，都执行；先于构造方法执行

}

}

静态代码块

class Person {

static {

// 静态块

// 实例化第一个对象前，执行；只执行一次

}

}

封装性

权限

private

本类可访问

default

本包可访问

protected

本包、其他包的子类可访问

public

所有

使用方法来访问属性

setter

getter

继承性

引入

格式

class 父类{ }

class 子类 extends 父类 { }

构造方法

如果一个类没有实现构造方法，java编译器会给它定义一个空的构造方法

实例化子类对象时，先调用父类的构造方法，再调用子类的构造方法

super关键字

子类的构造方法里会默认调用super()

可以在子类构造方法中首行自己调用super()，可加参数

super表示父类，可以用super.xxxx调用父类方法

子类继承父类的属性和方法，也可以覆写

final关键字

final类不能有子类

final方法不能被覆写

final变量变成常量，不能被修改

继承的限制

看不到父亲的私房钱：私有属性不能被子类访问

看不到父亲的绝招：私有方法不能被子类访问

不能把祖传的招式私吞了：子类覆写的方法不能缩小权限

抽象类

abstract class 类名 {

属性;

普通方法 { }

// 抽象方法

访问权限 abstract 返回值类型 方法名 (参数) ; /* 只需要声明，不需要实现 */

}

作用：规定子类必须实现的方法，起“模板”作用

不能实例化对象

子类必须覆写全部抽象方法

接口

// 接口由全局常量、公共的抽象方法组成

interface 接口名称 {

全局常量;

抽象方法;

}

interface A {

public static final i = 10;

public abstract int getNumber( );

}

interface B {

public static final String name = "www.100ask.net";

public abstract int getName( );

}

class C implements A,B {

//覆写A中方法

public int getNumber () { return i; }

//覆写B中方法

public int getName () { return name; }

}

作用：跟抽象类相似，起“模板”作用；子类可以继承多个接口，突破“单继承”的限制

子类必须覆写全部抽象方法

多态性

方法的重载与覆写

重载overload: 定义多个同名方法，其参数类型、个数不同

覆写override：子类里实现跟父类同样的方法

对象的多态性

向上转换

父类 父类对象 = 子类实例;

Son son = new Son(); Father f = son;

f.fun(...)只能调用被子类覆写的方法，不能调用只在子类中定义的方法

向下转换

子类 子类对象 = (子类)父类实例;

Father f = new Son(); Son son = (Son)f;

在进行对象的向下转换前，必须首先发生对象的向上转换

instanceof: 用来判断一个对象是不是某个类的实例

异常

异常

JAVA异常类

分为Error, Exception两类

Error

JAVA虚拟机本身的问题，跟程序无关，程序不需要处理

Exception

程序本身可以处理的异常

还可以分为

不可查的异常(unchecked exceptions)

RuntimeException及其子类

可查的异常(checked exceptions)

其他异常

还可以分为

运行时异常

RuntimeException及其子类

非运行时异常(编译异常)

其他异常

处理原则

对于可查异常必须捕捉、或者声明抛出; 允许忽略不可查的RuntimeException和Error

“运行时异常”都是“不可查异常”

程序中可以捕获处理它，也可以不处理

其他异常在程序中必须处理，否则连编译都过不了

处理方法

try...catch...finally

try {

// 程序语句，可能发生异常

} catch (异常类型1 e) {

// 处理语句

} catch (异常类型2 e) {

// 处理语句

} catch (异常类型3 e) {

......

}

[ finally {

//一定会运行到的代码

} ]

try或catch块中有return或throw语句， 会先执行finally块，再返回来执行return或throw语句

或者再次向上throws

throws

写在方法的声明位置，表示如果发生异常，扔给调用者处理

public 返回值 方法名(参数列表……) throws 异常类 { }

public int div (int m, int n) throws Exception {

......

}

对于“不可查异常”, 系统也会抛出它，写不写throws效果一样

对于“可查异常”，必须处理；处理方法见上

throw

人为抛出一个异常

throw 异常类的实例化对象;

throw new Exception("My Error");

throw“不可查异常”时，可以不处理它

throw“可查异常”时，必须处理； 处理方法见上

assert

assert boolean表达式 ;

assert boolean表达式 : 详细信息 ;

表达式为true时，无错误；

表达式为false时，打印“详细信息”

assert x == 0;

assert x == 0 : "X is not zero";

包及访问权限

包

package

包实际上是一个文件夹(可以含有多级子目录)

格式：package 包名称.子包名称; 例子：package a.b.c.d;

编译命令：javac -d <dir> <file.java> (表示在<dir>目录下生成包)

执行方法：java 包名称.子包名称.类名称

作用：解决类的同名冲突问题

import

使用不同包的类时需要import

格式： import 包名称.子包名称.类名称; // 手工导入某个类 import 包名称.子包名称.* ; // 由JVM自动加载所需要的类

jar

生成：jar -cvf <file.jar> <dir>

查看：jar -tvf <file.jar>

解压：tar -xvf <file.jar>

CLASSPATH

指定编译时查找源码的目录

指定运行时查找的“.class文件的目录”或“jar文件”

设置方法： export CLASSPATH=<dir1>:<dir2>:....:<file1.jar>:<file2.jar>:...

权限

类

public class可以被外包访问

class只能在本包中访问

类成员

private

本类可访问

default

本包可访问

protected

本包、其他包的子类可访问

public

所有

内部类

一般内部类

在内的内部定义一个类

class Outer {

class Inner {

}

}

Inner被称为内部类。

好处：内部类可以直接访问外部类的私有属性

示例：

Outer o = new Outer( );

Outer.Inner i = o.new Inner( );

静态内部类

class Outer {

static class Inner {

}

}

用static声明的内部类就变成了外部类；

它可以访问外部类的static属性

使用示例：

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

匿名内部类

interface A {

public void printInfo( );

}

class B implements A {

public void printInfo( ) {

System.out.println("Hello, world!");

}

}

public class Anony {

public static void testFunc(A a) {

a.printInfo( );

}

public static void main(String args[]) {

testFunc(new B());

testFunc(new A( ) {

public void printInfo() {

System.out.println("Hello, world!");

}

});

}

}

3. JNI

JAVA调用C

Java访问C库的方法

1. 加载C库

System.loadLibrary

2. 建立Java函数名到C库函数名的映射关系

隐式建立

类a.b.c.d.JNIDemo要调用hello函数

C语言中要实现Java_a_b_c_d_JNIDemo_hello

可以用工具生成头文件

javac -d . JNIDemo.java

javah -jni a.b.c.d.JNIDemo

显示建立

JNI_OnLoad

加载C库时就会调用这个函数

RegisterNatives

定义一个映射数组JNINativeMethod[]

typedef struct {

char *name; /* Java里调用的函数名 */

char *signature; /* JNI字段描述符, 用来表示Java里调用的函数的参数和返回值类型 */

void *fnPtr; /* C语言实现的本地函数 */

} JNINativeMethod;

static const JNINativeMethod methods[] = {

{"hello", "(Ljava/lang/String;)Ljava/lang/String", (void *)native_hello},

};

每个数组项含3个成员

Java里调用的函数名

JNI字段描述符

用"["表示数组，比如"int []"表示为"[I"

对于类，要用全称"L包.子包.类名;"(前面有"L"，后面有";")， 比如"Ljava/lang/String;"

除String类外，其他的类都用Object表示，即"Ljava/lang/Object;"

C语言实现的本地函数

注册这个数组

(*env)->RegisterNatives(JNIEnv *env, jclass clazz, const JNINativeMethod *methods, jint nMethods)

注意：C函数比Java里的声明多2个参数: (JNIEnv *env, jclass cls)

env提供一些辅助函数，后面有例子

cls是对Java类或实例的引用

如果是static方法，则cls是对Java类的引用

否则，cls是对类的实例化对象的引用

3. 在Java程序里调用函数

简单例子

Java和C库传递数据

传递基本类型数据

直接使用、直接返回

传递字符串 (jni.pdf P39)

以下函数从Java中获得一个字符串，

再返回一个字符串给Java：

JNIEXPORT jstring JNICALL

Java_Prompt_getLine(JNIEnv *env, jobject obj, jstring prompt)

{

char buf[128];

const jbyte *str;

str = (*env)->GetStringUTFChars(env, prompt, NULL);

if (str == NULL) {

return NULL; /* OutOfMemoryError already thrown */

}

printf("%s", str);

(*env)->ReleaseStringUTFChars(env, prompt, str);

/* We assume here that the user does not type more than

* 127 characters */

scanf("%s", buf);

return (*env)->NewStringUTF(env, buf);

}

传递数组 (jni.pdf P48

以下函数从Java中获得一个int数组，

再求和返回一个整数给Java：

JNIEXPORT jint JNICALL

Java_IntArray_sumArray(JNIEnv *env, jobject obj, jintArray arr)

{

jint *carr;

jint i, sum = 0;

carr = (*env)->GetIntArrayElements(env, arr, NULL);

if (carr == NULL) {

return 0; /* exception occurred */

}

for (i=0; i< (*env)->GetArrayLength(env, arr); i++) {

sum += carr[i];

}

(*env)->ReleaseIntArrayElements(env, arr, carr, 0);

return sum;

}

C调用JAVA (jni.pdf P97)

步骤

1. 创建虚拟机

JavaVM* jvm;

JNIEnv* env;

jint create_vm(JavaVM** jvm, JNIEnv** env)

{

JavaVMInitArgs args;

JavaVMOption options[1];

args.version = JNI_VERSION_1_6;

args.nOptions = 1;

options[0].optionString = "-Djava.class.path=.";

args.options = options;

args.ignoreUnrecognized = JNI_FALSE;

return JNI_CreateJavaVM(jvm, (void **)env, &args);

}

2. 获得class

jclass cls = (*env)->FindClass(env, "Hello");

3. 实例化对象

对于静态方法，不需要实例化对象

也是通过调用JAVA方法实现

jmethodID mid = (*env)->GetMethodID(env, cls, "<init>", "()V"); // 获得构造方法

jobject obj = (*env)->NewObject(env, cls, mid); // 实例化对象

4. 调用JAVA方法

1. 获得方法ID

jmethodID smid = (*env)->GetStaticMethodID(env, cls, "sayhello_to", "(Ljava/lang/String;)I");

jmethodID mid = (*env)->GetMethodID(env, cls, "saygoodbye_to", "(Ljava/lang/String;)I");

2. 构造参数

jstring jstr = (*env)->NewStringUTF(env, "weidongshan@qq.com");

3. 调用方法

(*env)->CallStaticVoidMethod(env, jobj, smid, jstr);

ret = (*env)->CallIntMethod(env, jobj, mid, jstr);

5. 其他

设置属性

jfieldID fid = (*env)->GetFieldID(env, cls, "name", "Ljava/lang/String;");

jstring jstr = (*env)->NewStringUTF(env, "Bill");

(*env)->SetObjectField(env, jobj, fid, jstr);

1. 获得属性ID

2. 设置属性

3. 读取属性