Java编程 Javase12

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量330 收藏
点赞数 1
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kkh01421/article/details/115707041
版权

一、异常

（一）异常的概念和体系

1、异常的概念

  • 异常： 指的是程序在执行过程中，出现的非正常情况，最终会导致JVM非正常停止。

在Java等面向对象的编程语言中，异常本身是一个类，产生异常是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

  • 注意：异常指的并不是语法错误，若编译错误，则不会产生字节码文件，根本不能运行。

2、异常的体系

  • 异常的根类是java.lang.Throwable，其下有两个子类：java.lang.Error与java.lang.Exception，平常所说的异常指的是java.lang.Exception。
  • Error：不能处理只能避免   Exceptio：使用不当导致，可以避免。

（二）异常的分类

  • java.lang.Throwable类是Java语言中所有错误或异常的超类。

1、Exception

  • 编译器异常，进行编译Java程序出现的问题。异常处理掉后，程序可以继续执行。
  • RuntimeException：运行期异常，Java程序运行过程中出现的问题。
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class e1 {
    public static void main(String[] args) /*throws ParseException*/ {
        //异常处理两种方式：thorw 和 try catch
        //Exception：编译器异常，编译Java程序出现的问题
        SimpleDateFormat sdf = new SimpleDateFormat("yyy-MM-dd");//格式化日期
        Date date = null;
        try {
            date = sdf.parse("1999-09-09");
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println(date);
        //RuntimeException：运行期异常，Java程序运行过程出现的问题
        int[] arr = {1, 2, 3};
        try {
            //可能出现异常的代码
            System.out.println(arr[3]);/*Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
        at Demo12.e1.main(e1.java:21)*/
        } catch (Exception e) {
            //异常处理的逻辑
            System.out.println(e);
        }
    }
}

Thu Sep 09 00:00:00 CST 1999
java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3

2、Error：错误

  • 必须修改源代码，程序才可以继续执行。
/*错误：创建超过JVM分配内存大小的数组
       Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
        at Demo12.e1.main(e1.java:30)
          只能通过修改代码避免错误
        int [] arr1 = new int[100000*100000];*/
        int [] ar = new int[1024];
        System.out.println("后续代码！");

（三）异常的产生过程解析

二、异常的处理

  • Java处理异常的五个关键字：try、catch、finall、throw、throws。

（一）throw关键字

1、作用

  • 可以使用throw关键字在指定的方法中抛出指定的异常

2、使用格式

throw new xxxException（异常产生的原因）

3、注意

  • throw关键字必须写在方法的内部
  • throw关键字后边new的对象必须是Exception或者Exception的子类对象
  • throw关键字抛出指定的异常对象，我们就必须处理这个异常对象
  1. throw关键字后边创建的是RuntimeException或者是其子类对象我们可以不处理默认交给JVM处理（打印异常对象然后中断程序）
  2. throw关键字后边创建的是编译异常，我们就必须处理这个异常，要么throws，要么try...catch

4、实例

  • 在实际操作中，我们首先必须对方法传递过来的参数进行合法性校验。如果参数不合法，那么我们就必须使用抛出异常的方法告知方法的调用者传递的参数有问题。
public class e2 {
    public static void main(String[] args) {
            /*int [] arr1 = null;
            int e1=getarr(arr1,0);
            System.out.println(e1);
        Exception in thread "main" java.lang.NullPointerException: 传递的数组为空！*/
            int [] arr2 =new int[3];
            int e2=getarr(arr2,5);
            System.out.println(e2);
        //Exception in thread "main" java.lang.NullPointerException: 传递的数组为空！
    }
    public static int getarr(int [] arr, int index){
         /*对传递的数组参数进行合法性检验，若传递的数组为NULL，则抛出空指针异常
            若传递的数组索引越界则抛出数组索引越界异常。
             */
        if(arr==null){
            throw new NullPointerException("传递的数组为空！");
        }
        if(index<0||index>arr.length-1){
            throw new ArrayIndexOutOfBoundsException("数组索引越界");
        }
            int ele = arr[index];
            return ele;
           
    }
}

（二）Objects非空判断

  • Objects类中的静态方法
public static <T> requireNonNull( T obj ):查看指定的引用对象是否为null
import java.util.Objects;

public class e3 {
    public static void main(String[] args) {
        method(null);//Exception in thread "main" java.lang.NullPointerException: 传递对象为null！
    }
    public static void method(Object obj){
        Objects.requireNonNull(obj,"传递对象为null！");
    }
}

（三）声明异常throws

  • 异常处理的第一种方式，交给别人处理

1、作用

  • 当方法内部抛出异常对象的时候，那么我们就必须处理这个异常对象
  • 可以使用throws关键字处理异常对象，会把异常对象声明抛出给方法的调用者处理，最终交给JVM处理——>中断处理

2、使用格式：在方法声明时使用

修饰符 返回值类型 方法名（参数列表）throws AAAException,BBBException...{
    throw new AAAException("产生原因");
    throw new BBBException("产生原因");
    ...
}

3、注意

  • throws关键字必须写在方法声明处
  • throws关键字后边生命的异常必须是Exception或者是Exception子类
  • 方法内部如果抛出了多个异常对象，那么throws后边必须也声明多个异常，如果抛出的异常对象有子父类关系，那么直接声明父类异常即可（所有异常均是Exception子类，声明只声明Exception即可）。
  • 调用一个声明抛出异常的方法，我们就必须处理声明的异常。要么继续使用throws声明抛出交给方法的调用者处理最终交给JVM。要么try...catch自己处理异常。
import java.io.FileNotFoundException;
import java.io.IOException;

public class e3{
    public static void main(String[] args)throws Exception {
        readfile("C\\a.txt");
    }
    /*定义一个文件，对文件的路径和格式进行判断*/
//    public static void readfile(String filename)throws FileNotFoundException,IOException
    public static void readfile (String filename)throws Exception{
        //文件路径异常处理
        if(!filename.equals("C\\a.txt")){
            throw new FileNotFoundException("文件路径异常！");
        }//Exception in thread "main" java.io.FileNotFoundException: 文件路径异常！

        //文件格式异常处理
        if(!filename.endsWith(".txt")){
            throw new IOException("文件格式异常！");
        }//Exception in thread "main" java.io.IOException: 文件格式异常！
        System.out.println("文件读取正常。");//文件读取正常。
    }
}
注意：FileNotFoundException extends IOException extends Exception

（四）捕获异常 try...catch

  • 异常处理的第二种方式，自己处理异常

1、格式

try{
    可能产生异常的代码
}catch(定义一个异常的变量，用来接收try中抛出的异常对象){
    异常的处理逻辑，接收异常对象之后，怎么处理异常
    一般在实际中，会把异常的信息记录到日志中
}
...
catch(异常类名 变量名){

}

2、注意

  • try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象
  • 如果try中产生异常，那么就会执行catch中的异常处理逻辑，执行完catch中的处理逻辑，继续执行try...catch之后的代码。如果try中没有产生异常，那么就不会执行catch中异常的处理逻辑，执行完try中的代码，继续执行try...catch之后的代码。

import java.io.IOException;

public class e3{
    public static void main(String[] args) {
        try {
            readfile("c:\\a.tx");
        } catch (IOException e) {
            e.printStackTrace();
        }//java.io.IOException: 文件格式异常！
        System.out.println("后续代码！");//后续代码正常执行
    }
    public static void readfile(String filename)throws IOException{
        if(!filename.endsWith(".txt")){
            throw new IOException("文件格式异常！");
        }
        System.out.println("文件读取正常");
    }
}

（五）Throwable类中处理异常的三个方法

String getMessage() 返回此 throwable 的简短描述
String toString() 返回此 throwable 的详细消息字符串
void printStackTrace() JVM打印异常对象，打印的异常信息最为全面
 try {
            readfile("c:\\a.tx");
        } catch (IOException e) {
//            System.out.println(e.getMessage());//文件格式异常！
//            System.out.println(e.toString());//java.io.IOException: 文件格式异常！
//            System.out.println(e);//java.io.IOException: 文件格式异常！
               e.printStackTrace();
//            java.io.IOException: 文件格式异常！
//            at Demo12.e3.readfile(e3.java:20)
//            at Demo12.e3.main(e3.java:8)
        }

（六）finally代码块

1、格式

try{
    可能产生异常的代码
}catch(定义一个异常的变量，用来接收try中抛出的异常对象){
    异常的处理逻辑，接收异常对象之后，怎么处理异常
    一般在实际中，会把异常的信息记录到日志中
}
...
catch(异常类名 变量名){

}finally{
    无论是否出现异常都会执行
}

2、注意

  • finally不能单独使用，必须和try一起使用
  • finally一般用于资源释放（资源回收），无论程序是否出现异常，最后都要资源释放
try {
            readfile("c:\\a.tx");
        } catch (IOException e) {

               e.printStackTrace();
        }finally {
            System.out.println("资源释放！");
        }//资源释放！正常运行
        
    }

（七）异常的注意事项

  • 多异常的捕获处理

  1. 多个异常分别处理
  2. 多个异常一次捕获，多次处理
  3. 多个异常一次捕获一次处理
//多个异常分别处理
public class e3{
    public static void main(String[] args) {
        try{
            int[] arr =new int[3];
            System.out.println(arr[3]);
        }catch(ArrayIndexOutOfBoundsException e)
        {
            e.printStackTrace();
            
        }
        try {
            List<Integer> list = List.of(1,2,3);
            System.out.println(list.get(3));
        }catch (IndexOutOfBoundsException e){
            e.printStackTrace();
        }
    System.out.println("后续代码！");

    }
}
/*java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
	at Demo12.e3.main(e3.java:11)
java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
	at java.base/java.util.ImmutableCollections$ListN.get(ImmutableCollections.java:547)
	at Demo12.e3.main(e3.java:19)
后续代码！*/

import java.util.List;

/*一次捕获多次处理
注意：异常变量若存在父子类关系则子类变量必须写在上面，否则会报错
原因：try中抛出的异常对象会从上到下依次赋值给catch中定义的变量（多态）
 */
public class e4{
    public static void main(String[] args) {
        try{
            int[] arr =new int[3];
            System.out.println(arr[3]);
            List<Integer> list = List.of(1,2,3);
            System.out.println(list.get(3));
        }catch(ArrayIndexOutOfBoundsException e)
        {
            e.printStackTrace();
        }
       catch (IndexOutOfBoundsException e){
            e.printStackTrace();
        }System.out.println("后续代码！");
    }
//    java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
//    at Demo12.e3.main(e3.java:13)
//    后续代码
}
//一次捕获一次处理
public class e5 {
    public static void main(String[] args) {
        try {
            int[] arr = new int[3];
            System.out.println(arr[3]);
            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(3));
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("后续代码！");
    }
}
//java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
//        at Demo12.e3.main(e3.java:12)
//        后续代码！

注意：运行时异常被抛出可以不处理，默认给虚拟机处理，终止程序，什么时候不抛出运行异常了在来继续执行程序。

  • finally有return语句，永远返回finally中结果，避免出现该情况。

public class e6 {
    public static void main(String[] args) {
        int a = getnumber(10);
        System.out.println(a);
    }//输出为100
        public static int getnumber(int a){
            try{
                a = 10;
                return a;
            }catch (Exception e){
                System.out.println(e);
            }finally {
                a=100;
                return a;
            }
    }
}

  • 子父类异常

  1. 如果父类抛出了多个异常，子类重写父类方法时，抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
  2. 父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常，此时子类产生该异常，只能捕获处理，不能声明抛出。
  3. 注意：父类异常什么样，子类异常就是什么样。
//父类不抛出异常子类产生该异常，只能捕获处理，不能声明抛出
public class Fu{
    public void show01()  {}
}

class zi extends Fu{ 
        public void show01()  {
            try{
                throw new Exception("异常");
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

三、自定义异常

（一）概述

  • Java提供的异常类，不够我们使用，需要自己定义一些异常类。

1、格式

public class XXXException extends Exception | RuntimeException{

    添加一个空参数的构造方法
    添加一个带异常信息的构造方法
}

2、注意

  • 自定义异常类一般都是以Exception结尾，说明该类是一个异常类
  • 自定义异常类必须继承Exception或者RuntimeException
  1. 继承Exception：自定义的异常类就是一个编译器异常，如果方法内部抛出了编译器异常，就必须处理这个异常，要么throws，要么try...catch
  2. 继承RuntimeException：自定义的异常类就是一个运行期异常，交给虚拟机处理（中断处理）。

（二）自定义异常类的练习

  • 要求：模拟注册操作，如果用户名已经存在，则抛出异常并提示：该用户名已被注册

  • 分析：

  1. 使用数组保存已经注册过的用户名（数据库）
  2. 使用Scanner获取用户输入的注册的用户名（前端，页面）
  3. 定义一个方法，对用户输入注册的用户名进行判断，遍历存储已经注册过用户名的数组获取每一个用户名，使用获取到的用户名和用户输入的用户名进行比较。
  • true：用户名已经存在，抛出RegisterException异常，告知用户“用户名已被注册”
  • false：继续遍历比较。如果循环结束还未找到重复的用户名，提示用户“恭喜您，注册成功！”

  • 代码实现

//自定义异常类
public class RegisterException extends Exception {
    public RegisterException() {
        super();
    }
    public RegisterException(String message){
        super(message);
    }
}

import java.util.Scanner;

public class Register {
    //存储用户数据
    static String[] usernames={"张三","李四","王麻子"};

    public static void main(String[] args) {
        //让用户输入用户名
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要注册的用户名");
        String username=sc.next();
        check(username);
    }
    /*利用方法判断用户名是否与原有用户数据重合
    如果没有则注册成功，如果有重复则抛出异常。
     */
    private static void check(String username) {
        for (String s : usernames) {
            if(s.equals(username)){
                try {
                    throw new RegisterException("该用户名已被注册！");
                } catch (RegisterException e) {
                    e.printStackTrace();
                    return;//停止方法运行
                }
            }
        } System.out.println("恭喜您，注册成功！");
    }
}

请输入要注册的用户名
张三
该用户名已被注册！


请输入要注册的用户名
赵四
恭喜您，注册成功！

 

快乐麦肯
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
《JavaSE系列教程》
緑水長流*z
08-10 7万+
本专栏内容是为零基础正在学习Java的学习者量身定制的学习路线及方案，本教程字数超20w+，插图超过400+，知识体系极其全面，案例极其丰富。本配备有专门的学习群及学习视频，读者可加学习群与正在学习该阶段的人一同学习，有任何不懂的也可以观看于此教程配套的学习视频。
java,javase,javaee区别
F13253524870的博客
05-18 1133
Java：是一门编程语言 javase和javaee是java开发平台的三个版本，是一种开发技术。 javase:Java Standard Edition，Java标准版，就是一般Java程序的开发就可以(如桌面程序)，可以看作是JavaEE的子集。 Javaee:是指Java Enterprise Edition，Java企业版，多用于企业级开发，包括web开发等等。也叫J2EE。 下图是它们之间的关系 ...
JavaSE目录
热门推荐
本人主攻Java，希望自己能成为出色的程序员。
02-04 34万+
跳转到总目录 01、版本一：视频教程笔记 这个版本是我跟着视频教程做的笔记 教程来源：java基础到高级_零基础自学Java–尚硅谷–宋红康 教程视频地址：https://www.bilibili.com/video/BV1ny4y1Y7CW 名称 笔记地址 一：Java语言概述 二：变量、标识符、保留字、变量 三：运算符 四：程序流程控制 五：数组 六：面向对象（上） 七：面向对象（下） 八：面向对象（中） 九：异常 十：多线程
java中javaSE与javaEE的区别（适合新人）
程序猿进化梯
10-28 2309
javaEE个人理解的就是在javaSE的基础上，添砖加瓦后出现的一种规范，说是框架也行。官方解释：Java EE，Java 平台企业版（Java Platform Enterprise Edition） 之前称为Java 2Platform, Enterprise Edition (J2EE) 2018年3月更名为 JakartaEE(这个名称应该还没有得到群众认可)。是 Sun 公司为企业级应用推出的标准平台，用来开发B/S架构软件。JavaEE 是 Java 应用最广泛的部分。
JAVA基础语言——JAVASE
jsqzy的博客
09-28 595
Java是由Sun Microsystems公司于1995年5月推出的Java程序设计语言（以下简称Java语言）和Java平台的总称。用Java实现的HotJava浏览器（支持Java applet）显示了Java的魅力：跨平台、动态的Web、Internet计算。从此，Java被广泛接受并推动了Web的迅速发展，常用的浏览器现在均支持Java applet。另一方面，Java技术也不断更新。 其中Java有JAVAME、JAVASE、JavaEE组成。JAVASE目前也算是里面最基础的了。 Jav.
Java，JavaSE和JavaEE的区别
qq_37850901的博客
10-08 1205
Java是一门编程语言。Java分为三大版本，SE即标准版，包含了Java核心类库，主要用来开发桌面应用；EE即企业版，包含SE，又有扩展部分（Servlet，JDBC等），主要用来开发分布式网络程序；ME即微型版，包含了SE中部分类库，又有自己扩展部分，主要用来做移动类、嵌入式开发。 Java SE（Java Platform，Standard Edition）。Java SE 以前称为 J2S...
初识JavaSE与Java环境搭配
qq_39684049的博客
02-08 313
Java的由来 Sun Microsystems 于1995年推出的Java面向对象的程序设计语言 1996年发布JDK1.0 1999年发布J2EE，J2SE，J2ME 2005年更名为Java SE，Java EE，Java ME 2009年被Oralce收购 2011年由Oracle大部Java7.0 2014年由Oracle发布Java8.0 2017年由Oracle发布J...
java和javaEE、Javase有什么区别？
IT1124的博客
02-16 4005
Java分三个版本：Java SE(标准版)、Java EE(企业版)、Java ME(微型版) 其中SE就是大家学的Java基础，EE是公司最常用的用于网站开发(PC端)，ME用于移动端开发，现在熟悉的安卓系统就是用JAVAME开发的。 Java既可以被编译，也可以被解释。通过编译器，可以把Java 程序翻译成一种中间代码 - 称为字节码 - 可以被Java解释器解释的独立于平台的代码。通过解释器，每条Java字节指令被分析，然后在计算机上运行。只需编译一次，程序运行时解释执行。 Java不同于一般的编译
Java、JavaEE、JavaSE、JavaME、JavaWEB之间有什么区别？
xiaoxijinger的博客
08-20 3万+
很多对java不是很了解的同学在看到课程大纲的时候发现里面出现了JavaSE、JavaEE、JavaME、JavaWEB这些词，搞得一头雾水，一个java为啥还有这么多分支？今天小千就来给大家介绍一下这些都是用来干什么的。 Java Java是一门编程语言。Java分为三大版本，SE即标准版，包含了Java核心类库，主要用来开发桌面应用；EE即企业版，包含SE，又有扩展部分（Servlet，JDBC等），主要用来开发分布式网络程序；ME即微型版，包含了SE中部分类库，又有自己扩展部分，主要用来做移动类、嵌
javase和java区别_javase和java有什么区别
weixin_29107289的博客
02-19 2988
Java EE、Java SE和Java ME的区别Java SEJava SE(Java Platform,Standard Edition)。JavaSE以前称为J2SE.它允许开发和部署在桌面、服务器、嵌入式环境和实施环境中使用的Java应用程序。JavaSE 包括支持Java　Ｗeb服务开发的类，并为Java Platform,Enterprise Edition(Java EE)提供基础...
Java领域基础部分JavaSE笔记
04-30
Java领域基础部分aS笔记涵盖了Java编程语言的核心概念，包括但不限于： Java数据类型和变量 控制流程语句（if-else, switch, for, while等） 数组和集合 面向对象编程（OOP）基础（类，对象，继承，封装，多态） ...
JavaSE.rar_Java编程_Java_
08-11
java学习代码以及课件教程，淘宝上的。。价值20多元
javase java2ee 笔记
07-04
Java是一门编程语言，是用来编写软件的。QQ、迅雷、淘宝、京东等等这些常用软件都可以用Java来编写。 其实，Java最擅长的是编写如下类型的软件： 1、互联网：电商、P2P 2、企业级应用：ERP、CRM、BOS、OA JavaSE是...
JavaSE之面对程序语言
07-21
这个文件里的内容适合Java初学者，这是一些关乎JavaSE面向程序的相关知识以及一些Java的基础使用规则、类的定义规则、方法的定义方式等等。这也是小编在刚开学学习JavaSE时记录的一些笔记，里面的内容非常适合JavaSE...
19年全套java教程javase零基础到高级视频idea小白自学编程jdk8
06-16
19年全套java教程javase零基础到高级视频idea小白自学编程jdk8
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 864
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1190
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 480
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
java多线程创建方式
weixin_57763462的博客
05-28 1035
这种方式是通过创建一个实现了Runnable接口的类，并实现run()方法来创建线程。然后将这个类的对象作为参数传递给Thread类的构造器，并调用Thread对象的start()方法来启动线程。这种方式是通过创建一个实现了Callable接口的类，实现call()方法，并使用FutureTask或者ExecutorService来创建线程。这种方式的优点在于，由于Java不支持多重继承，如果你的类需要继承其他类，那么实现Runnable接口将是唯一的选择。// 在这里定义线程的执行逻辑。
javame javase javaee
09-08
javame，javase和javaee是Java编程语言的三个不同平台。 javame是Java Micro Edition的缩写，它是专门为嵌入式设备和移动设备开发的平台。javame有自己的类库和API，可以支持小型设备上的应用程序开发。它通常被...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值