java核心技术 第11版 本地方法

最新推荐文章于 2023-10-22 12:32:05 发布
最新推荐文章于 2023-10-22 12:32:05 发布
阅读量295 收藏
点赞数 2
分类专栏： java 文章标签： java linux 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Nexas/article/details/125195245
版权

本地方法

从Java程序调用C函数

/**
 * @version 1.11 2007-10-26
 * @author Cay Horstmann
 */

 class HelloNative{
    
    public static native void greeting();
    public static void main(String...args)
     {
         greeting();
     }
 }

对于编译生成的class文件， 为了实现本地代码，命名规则如下：

  1. 使用完整的Java方法名例如HelloNative.greeting, 如果该类属于某个包，则还要加上包名，例如com.horstmann.HelloNative.greeting
  2. 用下划线替换所有的句号并加上Java_前缀，例如Java_HelloNative_greeting
  3. 如果含有非ASCII字母或数字， 用_0xxxx来替代， xxxx是该字符的Unicode值的4个十六进制数序列

tips：若重载了本地方法则应该在名称后面追加两个下划线再加上已编码的参数类型

使用

javac -h . HelloNative.java

随后实现函数

/*
    @version 1.10 1997-07-01
    @author Cay Horstmann
*/
#include"HelloNative.h"
#include<stdio.h>

JNIEXPORT void JNICALL Java_HelloNative_greeting(JNIEnv*env, jclass thiz)
{
    printf("Hello Native World!\n");
}

Linux下gcc编译:

 gcc -fPIC -I /usr/lib/jvm/java-17-openjdk-amd64/include -I /usr/lib/jvm/java-17-openjdk-amd64/include/linux -shared
 -o libHelloNative.so HelloNative.c

这里java安装目录视实际安装位置而定

追加初始化操作

/**
 * @version 1.11 2007-10-26
 * @author Cay Horstmann
 */

 class HelloNative{
    
    public static native void greeting();
    public static void main(String...args)
     {
         greeting();
     }
     static{
         System.loadLibrary("HelloNative");
     }
 }

数值参数与返回值

/**
 * @version 1.10 1997-07-01
 * @author Cay Horstmann
 */
class Printf1{
    public static native int print(int width, int precision, double x);
    static
    {
        System.loadLibrary("Printf1");
    }
}

/**
 * @file Printf1.c
 * @author Cay Horstmann
 * @brief 
 * @version 1.10 1997-07-01
 * @date 2022-06-07
 * 
 * @copyright Copyright (c) 2022
 * 
 */
#include"Printf1.h"
#include<stdio.h>
JNIEXPORT jint JNICALL Java_Printf1_print(JNIEnv* env, jclass cl, jint width, jint precision, jdouble x)
{
    char fmt[30];
    jint ret;
    sprintf(fmt, "%%%d.%df", width, precision);
    ret = printf(fmt, x);
    fflush(stdout);
    return ret;
}

public class Printf1Test {
    public static void main(String ...args)
    {
        int count = Printf1.print(8, 4, 3.14);
        count += Printf1.print(8, 4, count);
        System.out.println();
        for(int i = 0; i < count; i++)
        {
            System.out.print("-");
        }
        System.out.println();
    }
    
}

字符串参数

Java使用UTF-16编码点的序列作为字符串， 而C使用以null结尾的字节序列， JNI有两组操作字符串的函数， 一组把Java字符串转换成“modified UTF-8”字节序列， 另一个转换为jchar数组

JNIEXPORT jstring JNICALL Java_HelloNative_getGreeting(JNIEnv * env, jclass cl)
{
    jstring jstr;
    char greeting[] = "Hello, Native World\n";
    jstr = (*env)-> NewStringUTF(env, greeting);
    return str;
}

env是一个指向函数指针表的指针, 必须在每个JNI调用前加上(*env)->， 以便解析对函数指针的引用。

/**
 * @version 1.10 1997-07-01
 * @author Cay Horstmann
 */
public class Printf2 {
    public static native String sprintf(String format, double x);
    static{
        System.loadLibrary("Printf2");
    }
}


/**
 * @file Printf2.c
 * @author Cay Horstmann
 * @brief 
 * @version 1.10
 * @date 1997-07-01
 * 
 * @copyright Copyright (c) 2022
 * 
 */

#include"Printf2.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<float.h>

/**
 * @param format a string containing a printf format specifier
 * (such as "%8.2f"), Substrings "%%" are skipped.
 * @return a pointer to the format specifier (skipping the '%')
 * or NULL if there was not a unique format specifier.
 * 
 */
char * find_format(const char format[])
{
    char *p;
    char *q;
    p = strchr(format, '%');
    while(p != NULL && *(p + 1) == '%') /*ship %%*/
        p = strchr(p + 2, '%');
    if(p == NULL) return NULL;
    /* now check that % is unique*/
    p++;
    q = strchr(p, '%');
    while(q != NULL && *(q + 1) == '%') /*skip %% */
        q = strchr(q + 2, '%');
    if(q != NULL) return NULL;  /* % not unique */
    q = p + strspn(p, " -0+#"); /* skip past flags */
    q += strspn(q, "0123456789");   /*ship past field width */
    if(*q =='.'){
        q++;
        q += strspn(q, "0123456789");
    }
    /* skip past field width */
    if(strchr("eEfFgG", *q) == NULL) return NULL;
    /* skip past precision */
    return p;   
}

JNIEXPORT jstring JNICALL Java_Printf2_sprintf(JNIEnv * env, jclass cl, jstring format, jdouble x){
    const char * cformat;
    char * fmt;
    jstring ret;

    cformat =(*env)->GetStringUTFChars(env, format, NULL);
    fmt = find_format(cformat);
    if(fmt == NULL)
    ret = format;
    else{
        char * cret;
        int width = atoi(fmt);
        if(width == 0) width = DBL_DIG + 10;
        cret = (char *)malloc(strlen(cformat) + width);
        sprintf(cret, cformat, x);
        ret = (*env)->NewStringUTF(env, cret);
        free(cret);
    }
    (*env)->ReleaseStringUTFChars(env, format, cformat);
    return ret;
}


/**
 * @version 1.10 1997-07-01
 * @author Cay Horstmann
 */
public class Printf2Test {
    public static void main(String...args)
    {
        double price = 44.95;
        double tax = 7.75;
        double amountDue = price * (1 + tax / 100);
        String s = Printf2.sprintf("Amount due = %8.2f", amountDue);
        System.out.println(s);
    }
}

访问域

访问实例域

对于Java方法

public void raiseSalary(double byPercent)
{
    salary *= 1 + byPercent / 100;
}

重写成本地方法后为

JNIEXPORT void JNICALL Java_Employee_raiseSalary(JNIEnv *, jobject, jdouble);

第二个参数变为jobject， 他和this引用等价。

静态方法得到类的引用，非静态得到this参数对象的引用。

获得各种类型的通用语法为

x = (*env)->GetXxxxField(env, this_obj, fieldId);
(*env)->SetXxxxxField(env, this_obj, fieldId, x);

fieldID标识结构中的一个域， 为了获得fieldID首先要获得一个表示类的值

jclass class_Employee = (*env)->GetObjectClass(env, this_obj);

FindClass函数可以以字符串形式来指定类名

jclass class_String = (*env)->FindClass(env, "java/lang/String");

之后使用GetFieldID来获得fieldID

jfield id_salary = (*env)->GetFieldID(env, class_Employee, "salary", "D");

/**
 * @version 1.10 1999-11-13
 * @author Cay Horstmann
 */
public class Employee {
    private String name;
    private double salary;

    public native void raiseSalary(double byPercent);

    public Employee(String n, double s)
    {
        name = n;
        salary = s;
    }
    public void print(){
        System.out.println(name + " " + salary);
    }
    static{
        System.loadLibrary("Employee");
    }
}


/**
 * @file Employee.c
 * @author Cay Horstmann
 * @brief 
 * @version 1.10
 * @date 2022-06-08
 * 
 * @copyright Copyright (c) 2022
 * 
 */
#include"Employee.h"
#include<stdio.h>

JNIEXPORT void JNICALL Java_Employee_raiseSalary(
    JNIEnv * env, jobject this_obj, jdouble byPercent){
        /* get class */
        jclass class_Employee = (*env)->GetObjectClass(env, this_obj);

        /* get the field ID */
        jfieldID id_salary = (*env)->GetFieldID(env, class_Employee, "salary", "D");

        /* get the field value */
        jdouble salary = (*env)->GetDoubleField(env, this_obj, id_salary);
        
        salary *= 1 + byPercent/ 100.0;
        /* set the field value */
        (*env)->SetDoubleField(env, this_obj, id_salary, salary);
    }

/**
 * @version 1.11 2018-05-01
 * @author Cay Horstmann
 */
public class EmployeeTest {
    public static void main(String[] args) {
        var staff = new Employee[3];
        staff[0] = new Employee("Harry Hacker", 35000);
        staff[1] = new Employee("Carl Cracker", 75000);
        staff[2] = new Employee("Tony Tester", 38000);

        for(Employee e: staff)
            e.raiseSalary(5);
        for(Employee e: staff)
            e.print();
    }
}

访问静态域

访问静态域使用GetStaticFieldID和GetStaticXxxField/SetStaticXxxField函数

jclass class_System = (*env)->FindClass(env, "java/lang/System");

/* get the field ID */
jfieldID id_out = (*env)->GetStaticFieldID(env, class_System, "out", "Ljava/io/PrintStream;");

/* get the field value */
jobject obj_out = (*env)->GetStaticObjectField(env, class_System, id_out);

编码签名

B: byte

C: char

D: double

F: float

I: int

J:long

Lclassname; : 类的类型

S: short

V: void

Z: boolean

描述数组类型使用[

字符串数组: [Ljava/lang/String;

float[][] : [[F

一个接收两个整型返回一个整型的方法编码: (II)I

如构造器： Employee(java.lang.String, double, java.util.Date)

签名为: (Ljava/lang/String;DLjava/util/Date;)V

可以使用带有选项-s的javap命令来从类文件中产生方法签名

javap -s -private Employee

调用Java方法

使用如下方法可以调用Java方法

(*env)->CallXxxxMethod(env, implicit parameter, methodID, explicit parameters)

import java.io.*;
/*
 * @version 1.10 1997-07-01
 * @author Cay Horstmann
 */
public class Printf3 {
    public static native void fprint(PrintWriter out, String format, double x);

    static{
        System.loadLibrary("Printf3");
    }
}


/**
 * @file Printf3.c
 * @author Cay Horstmann
 * @brief 
 * @version 1.10
 * @date 2022-06-08
 * 
 * @copyright Copyright (c) 2022
 * 
 */
#include"Printf3.h"
#include<string.h>
#include<stdlib.h>
#include<float.h>
/**
 * @param format a string containing a printf format specifier
 * (such as "%8.2f"). Substrings "%%" are skipped.
 * @return a pointer to the format specifier (skipping the '%')
 * or NULL if there was not a unique format specifier
 * 
 */
char * find_format(const char format[])
{
    char * p;
    char *q;

    p = strchr(format, '%');
    while(p != NULL && *(p + 1) == '%') /* skip %% */
        p = strchr(p + 2, '%');
    if(p == NULL) return NULL;
    /* now check that % is unique */
    p++;
    q = strchr(p, '%');
    while(q != NULL && *(q + 1) == '%') /* skip %% */
        q = strchr(q + 2, '%');
    if(q != NULL)return NULL;   /* % not unique */
    q = p + strspn(p, " -0+#"); /* skip past flags */
    q += strspn(q, "0123456789");   /*skip past field width */
    if(*q == '.') {q++; q +=strspn(q, "0123456789");}
    /*skip past precision */
    if(strchr("eEfFgG", *q) == NULL) return NULL;
    /* not a floating-point format */
    return p; 
}
JNIEXPORT void JNICALL Java_Printf3_fprint(JNIEnv * env, jclass cl, jobject out, jstring format, jdouble x)
{
    const char * cformat;
    char * fmt;
    jstring str;
    jclass class_PrintWriter;
    jmethodID id_print;

    cformat = (*env)->GetStringUTFChars(env, format, NULL);
    fmt = find_format(cformat);
    if(fmt == NULL)
        str = format;
    else{
        char * cstr;
        int width = atoi(fmt);
        if(width == 0) width = DBL_DIG + 10;
        cstr = (char *) malloc(strlen(cformat) + width);
        sprintf(cstr, cformat, x);
        str = (*env)->NewStringUTF(env, cstr);
        free(cstr);
    }
    (*env)->ReleaseStringUTFChars(env, format, cformat);

    /* now call ps.print(str) */

    /* get the class */
    class_PrintWriter = (*env)->GetObjectClass(env, out);

    /* get the methodID */
    id_print = (*env)->GetMethodID(env, class_PrintWriter, "print", "(Ljava/lang/String;)V");

    /* call the method */
    (*env)->CallVoidMethod(env, out, id_print, str);
}

import java.io.*;
/**
 * @version 1.11 2018-05-01
 * @author Cay Horstmann
 */
public class Printf3Test {
    public static void main(String[] args) {
        double price = 44.95;
        double tax = 7.75;
        double amountDue = price * (1 + tax / 100);
        var out = new PrintWriter(System.out);
        Printf3.fprint(out, "Amount due = %8.2f\n", amountDue);
        out.flush();
    }
}

静态方法

用GetStaticMethodID和CallStaticXxxxMethod函数。

当调用方法时提供类对象而不是参数对象。

jclass class_System = (*env)->FindClass(env, "java/lang/System");
jmethodID id_getProperty = (*env)->GetStaticMethodID(env, class_System, "getProperty",
  "(Ljava/lang/String;)Ljava/lang/String;");
jobject obj_ret = (*env)->CallStaticObjectMethod(env, class_System,id_getProperty, (*env)->NewStringUTF(env, "java.class.path"));

jstring str_ret = (jstring) obj_ret;

构造器

本地方法通过调用构造器创建Java对象， 调用NewObject来调用构造器

jobject obj_new = (*env)->NewObject(env, class, methodID, construction parameters);

const char[] fileName = "...";
jstring str_fileName = (*env)->NewStringUTF(env, fileName);
jclass class_FileOutputStream = (*env)->FindClass(env, "java/io/FileOutputStream");
jmethodID id_FileOutputStream = (*env)->GetMethodID(env, class_FileOutputStream, "<init>", "(Ljava/lang/String;)V");
jobject obj_stream = (*env)->NewObject(env, class_FileOutputStream, id_FileOutputStream, str_fileName);

CallNonvirtualXxxxMethod函数将调用指定的类中指定的版本的方法。

访问数组元素

GetArrayLength返回数组的长度


jarray array = ...;
jsize length = (*env)->GetArrayLength(env, array);

jdoubleArray array_a = ....;
double scaleFactor = ....;
double * a = (*env)->GetDoubleArrayElements(env, array_a, NULL);
for(int i = 0; i < (*env)->GetArrayLength(env, array_a); i++)
    a[i] = a[i] * scaleFactor;
(*env)->ReleaseDoubleArrayElements(env, array_a, a, 0);

如果要访问一个大数组的多个元素， 可以用GetXxxxArrayRegion和SetXXXArrayRegion方法

NewXXXArray在本地方法中创建新的Java数组

jclass class_Employee = (*env)->FindClass(env, "Employee");
jobjectArray array_e = (*env)->NewObjectArray(env, 100, class_Employee, NULL);

错误处理

import java.io.*;
/*
 * @version 1.10 1997-07-01
 * @author Cay Horstmann
 */
public class Printf4 {
    public static native void fprint(PrintWriter ps, String format, double x);

    static{
        System.loadLibrary("Printf4");
    }
}


/**
 * @file Printf3.c
 * @author Cay Horstmann
 * @brief 
 * @version 1.10
 * @date 2022-06-08
 * 
 * @copyright Copyright (c) 2022
 * 
 */
#include"Printf4.h"
#include<string.h>
#include<stdlib.h>
#include<float.h>
/**
 * @param format a string containing a printf format specifier
 * (such as "%8.2f"). Substrings "%%" are skipped.
 * @return a pointer to the format specifier (skipping the '%')
 * or NULL if there was not a unique format specifier
 * 
 */
char * find_format(const char format[])
{
    char * p;
    char *q;

    p = strchr(format, '%');
    while(p != NULL && *(p + 1) == '%') /* skip %% */
        p = strchr(p + 2, '%');
    if(p == NULL) return NULL;
    /* now check that % is unique */
    p++;
    q = strchr(p, '%');
    while(q != NULL && *(q + 1) == '%') /* skip %% */
        q = strchr(q + 2, '%');
    if(q != NULL)return NULL;   /* % not unique */
    q = p + strspn(p, " -0+#"); /* skip past flags */
    q += strspn(q, "0123456789");   /*skip past field width */
    if(*q == '.') {q++; q +=strspn(q, "0123456789");}
    /*skip past precision */
    if(strchr("eEfFgG", *q) == NULL) return NULL;
    /* not a floating-point format */
    return p; 
}
JNIEXPORT void JNICALL Java_Printf4_fprint(JNIEnv * env, jclass cl, jobject out, jstring format, jdouble x)
{
    const char * cformat;
    char * fmt;
    jstring str;
    jclass class_PrintWriter;
    jmethodID id_print;
    char * cstr;
    int width;
    int i;

    if(format == NULL)
    {
        (*env)->ThrowNew(
            env,
            (*env)->FindClass(env, "java/lang/NullPointerException"),
            "Printf4.fprint: format is null"
        );
    }

    cformat = (*env)->GetStringUTFChars(env, format, NULL);
    fmt = find_format(cformat);
    if(fmt == NULL)
    {
        (*env)->ThrowNew(env,
        (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
        "Printf4.fprint: format is invalid");
        return;
    }
        width = atoi(fmt);
        if(width == 0) width = DBL_DIG + 10;
        cstr = (char *) malloc(strlen(cformat) + width);
        if(cstr == NULL)
        {
            (*env)->ThrowNew(env,
            (*env)->FindClass(env, "java/lang/OutOfMemoryError"),
            "Printf4.fprint: malloc failed!");
            return;
        }
        sprintf(cstr, cformat, x);
        (*env)->ReleaseStringUTFChars(env, format, cformat);

        /* now call ps.print(str) */

    /* get the class */
    class_PrintWriter = (*env)->GetObjectClass(env, out);

    /* get the methodID */
    id_print = (*env)->GetMethodID(env, class_PrintWriter, "print", "(C)V");

    /* call the method */
    for(i = 0; cstr[i] != 0 && !(*env)->ExceptionOccurred(env); i++)
        (*env)->CallVoidMethod(env, out, id_print, cstr[i]);
    free(cstr);
}

import java.io.*;
/**
 * @version 1.11 2018-05-01
 * @author Cay Horstmann
 */
public class Printf4Test {
    public static void main(String[] args) {
        double price = 44.95;
        double tax = 7.75;
        double amountDue = price * (1 + tax/ 100);
        var out = new PrintWriter(System.out);
        /* This call will throw an exception--note the %% */
        Printf4.fprint(out, "Amount due = %%8.2f\n", amountDue);
        out.flush();
    }
}

使用调用API

调用API所需的基本代码

JavaVMOption option[1];
JavaVMInitArgs vm_args;
JavaVM * jvm;
JNIEnv * env;

options[0].optionString = "-Djava.class.path=.";
memset(&vm_args, 0, sizeof(vm_args));
vm_args.version = JNI_VERSION_1_2;
vm_args.nOption = 1;
vm_args.options = options;

JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args);

以下是测试程序， 因为是在linux下，windows的兼容性我就懒的写了（lj微软）

/**
 * @file InvocationTest.c
 * @author Cay Horstmann
 * @brief 
 * @version 0.1
 * @date 2022-06-08
 * 
 * @copyright Copyright (c) 2022
 * 
 */
#include<string.h>
#include<jni.h>
#include<stdlib.h>

#ifdef _WINDOWS
#include<windows.h>
static HINSTANCE loadJVMLibrary(void);
typedef jint(JNICALL * CreateJavaVM_t)(JavaVM**, void **, JavaVMInitArgs *);

#endif

int main()
{
    JavaVMOption options[2];
    JavaVMInitArgs vm_args;
    JavaVM * jvm;
    JNIEnv * env;
    long status;

    jclass class_Welcome;
    jclass class_String;
    jobjectArray args;
    jmethodID id_main;

    #ifdef _WINDOWS
    HINSTANCE hjvmlib;
    CreateJavaVM_t createJavaVM;
    #endif
    options[0].optionString = "-Djava.class.path=.";

    memset(&vm_args, 0, sizeof(vm_args));
    vm_args.version = JNI_VERSION_1_6;
    vm_args.nOptions = 1;
    vm_args.options = options;

    #ifdef _WINDOWS
    hjvmlib = loadJVMLibrary();
    createJavaVM = (CreateJavaVM_t) GetProcAddress(hjvmlib, "JNI_CreateJavaVM");
    status = (*createJavaVM)(&jvm, (void **)&env, &vm_args);
    #else
    status = JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args);
    #endif

    if(status == JNI_ERR)
    {
        fprintf(stderr, "Error creating VM\n");
        return 1;
    }
    class_Welcome = (*env)->FindClass(env, "Welcome");
    id_main = (*env)->GetStaticMethodID(env, class_Welcome, "main", "([Ljava/lang/String;])V");

    class_String = (*env)->FindClass(env, "java/lang/String");
    args = (*env)->NewObjectArray(env, 0, class_String, NULL);
    (*env)->CallStaticVoidMethod(env, class_Welcome, id_main, args);

    (*jvm)->DestroyJavaVM(jvm);
}


/**
 * This program displays a greeting for the reader.
 * @version 1.30 2014-02-27
 * @author Cay Horstmann
 */
public class Welcome
{
   public static void main(String[] args)
   {
      String greeting = "Welcome to Core Java!";
      System.out.println(greeting);
      for (int i = 0; i < greeting.length(); i++)
         System.out.print("=");
      System.out.println();
   }
}
silent碎月
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java核心技术 第11版 英文版 卷2
12-24
java核心技术 第11版 英文版 卷2
Java核心技术第11章(1)
yiranant的专栏
10-16 881
第11章  异常,断言,日志和调试     程序必须做到以下几点:     1.向用户通告错误     2.保存所有的工作结果     3.允许用户以妥善的形式退出程序     对于异常情况,例如,可能造成程序崩溃的错误输出,Java使用一种称为异常处理(exception handing)的错误捕获机制处理.本章的第1部分将介绍Java的异常.     在测试期间,需要进行大量的测试
java核心技术 第11版 流
Nexas的博客
10-17 869
从迭代到流的操作 var contents = new String(Files.readAllBytes(Path.get("alice.txt")), StandardCharsets.UTF_8); List<String> words = List.of(contents.split("\\PL+")); int count = 0; for (String w: words){ if(w.length() > 12) count++; } 使用流时相同的操作如下所示 l
java核心技术第11版 继承
Nexas的博客
05-16 275
类、超类和子类 例如员工只有标准工资， 而经理有工资加奖金， Manager和Employee之间存在明显的“is-a”关系 定义子类 使用关键字extends表示继承 public class Manager extends Employee { add methods and fields } 构造的新类诞生与一个已存在的域（超类（superclass）， 基类（base class）或父类（parents class））， 新类称为子类（subclass）， 派生类（derived class）或
Java核心技术11：异常、日志、断言和调试
bbllbbcpt的专栏
04-19 379
11.1    处理异常11.1.1    异常分类        Java中，异常对象都是派生于Throwable类的一个实例。进而分为Error和Exception。Error描述了Java运行时系统的内部错误和资源耗尽错误，很少出现。主要关注Exception，分为RuntimeException和其他异常。由程序错误导致的异常属于RuntimeException，程序本身没有问题，由于像i...
Java核心技术（上+中+下）.zip
08-31
本课程以领衔打造，以全、新、细为特点，让学员在短的时间收获与企业接轨的前沿技术。 学完本期课程能初步掌握计算机基础知识，认识软件开发，了解到Java语言的特点。 能对基础语法有了初步的掌握，认识了基础逻辑...
Java 核心技术 卷Ⅰ 基础知识 第11版 英文版
08-15
Java 核心技术 卷Ⅰ 基础知识 第11版 英文版 Core Java Volume I–Fundamentals Eleventh Edition Cay S. Horstmann
java核心技术 卷1 第十版
10-20
java核心技术 卷1 第十版pdf 不是扫描版 带目录的 全书可以复制粘贴 很好的资源 打牢基础 面试开发 初学入门 必备
java 核心技术卷一 第十版
01-17
java经典书籍，不用多介绍。java核心技术卷一第十版中文版（网盘链接），真实有效，如果链接失效请私信我。
Java核心技术笔记-第11章
acwa的博客
02-28 528
异常，断言，日志和调试1.异常 (1)Exception和Error（内部错误）继承自Throwable，而Exception又派生出IOException和RuntimeException（开发者编写的程序出现的错误都属于这类）。其中派生于Error和RuntimeException属于未检查异常，派生于IOException属于已检查异常。只有已检查异常才需要在方法定义的后面添加throws
java核心技术第十版源代码
12-03
java核心技术第十版源代码,英文版的书籍已经有第十一版，但中文翻译本最新的是第十版，书里讲的非常全面，适合初学者，这是书中的源代码。
Core Java.JAVA核心技术（中文版）
05-16
Core Java.JAVA核心技术（中文版） Core Java.JAVA核心技术（中文版）
Java核心技术（第11版）卷1 勘误1
hong_shao的专栏
12-29 1920
在书的第50页： boolean blank() 应改为 boolean isBlank()
java核心技术 第11版 泛型程序设计
Nexas的博客
07-10 302
java核心技术 第11版 泛型程序设计定义简单泛型类泛型方法类型变量的限定泛型代码和虚拟机类型擦除转换泛型表达式转换泛型方法调用历史遗留代码限制与局限性泛型类型的继承规则通配符类型通配符概念通配符的超类型限定无限定通配符通配符捕获反射和泛型泛型Class类API使用Class< T > 参数进行类型匹配虚拟机中的泛型类型信息类型字面量API 泛型的引入， java允许设计者详细的描述变量和方法的类型要如何变化 定义简单泛型类 public class pair<T> { p
java核心技术 第11版 集合
Nexas的博客
07-10 1905
java 核心技术第11版 集合java集合框架集合接口与实现分离Collection接口迭代器泛型实用方法API集合框架中的接口链表API数组列表散列集API树集API队列与双端队列API优先队列API映射基本映射操作API更新映射条目映射视图弱散列映射链接散列集和映射枚举集与映射表示散列映射视图与包装器小集合子范围不可修改的视图同步视图检查型视图算法泛型算法排序和混排二分查找简单算法批操作集合和数组间的转换遗留的集合Hashtable类枚举属性映射栈位集 java集合框架 集合接口与实现分离 java
Java核心技术卷1（第11版）阅读笔记——第3章
weixin_43824410的博客
07-29 727
第三章 Java的基本程序设计结构（上）3.1 一个简单的java应用程序3.1.1 注意点3.2 注释3.3 数据类型3.3.1 整型3.3.2 浮点类型3.3.3 char类型3.3.4 Unicode 和 char 类型3.3.5 boolean 类型3.4 变量与常量3.4.1 声明变量3.4.2 变量初始化3.4.3 常量3.4.4 枚举类型3.5 运算符3.5.1 算术运算符3.5.2 数学函数与常量3.5.3 数值类型之间的转换3.5.4 强制类型转换3.5.5 结合幅值和运算符3.5.6
Java核心技术· 卷一（11版）笔记（第1-3章）
weixin_43647460的博客
10-22 444
Java是一种跨平台的编程语言，广泛应用于企业级应用、嵌入式系统、移动应用等领域。Java程序可以在不同的操作系统和硬件平台上运行，具有高效性、安全性、稳定性等特点。Java程序的编写需要使用Java开发工具，如Eclipse、NetBeans、IntelliJ IDEA等。编写完成后，Java程序需要通过编译器将其转换为字节码，然后再通过Java虚拟机（JVM）解释执行。Java程序的基本组成部分包括类、对象、方法、变量、运算符等，Java程序也支持面向对象编程的特性，如封装、继承和多态。
Java核心技术11 | Java IO
Kim_
03-25 4039
典型定义 Java IO方式有很多种，基于不同的 IO 抽象模型和交互方式，可以进行简单区分。 首先，传统的 java.io 包，它基于流模型实现，提供了我们最熟知的一些 IO 功能，比如 File 抽象、输入输出流等。交互方式是同步、阻塞的方式，也就是说，在读取输入流或者写入输出流时，在读、写动作完成之前，线程会一直阻塞在那里，它们之间的调用是可靠的线性顺序。 java.io 包的好处是代...
java核心技术可复制版本
最新发布
11-15
Java核心技术是指Java编程语言的基础知识和技术，包括Java语言的语法、面向对象编程、集合框架、多线程编程、网络编程、数据库操作等。这些技术是Java开发的基础，几乎所有的Java应用程序都需要用到这些核心技术。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值