精华内容
下载资源
问答
  • 尽管促使Java 诞生的源动力是可移植性和安全性,但在Java语言终成型的过程中,其他一些因素也起了重要的作用。接下来,小编就一一来介绍一下。· 简单(Simple)· 安全(Secure)· 可移植(Portable)· 面向对象(Object...

    Java有哪些常用语?不介绍Java 常用语,对Java 的总体介绍就是不完整的。尽管促使Java 诞生的源动力是可移植性和安全性,但在Java

    语言终成型的过程中,其他一些因素也起了重要的作用。接下来,小编就一一来介绍一下。

    · 简单(Simple)

    · 安全(Secure)

    · 可移植(Portable)

    · 面向对象(Object-oriented)

    · 健壮(Robust)

    · 多线程(Multithreaded)

    · 体系结构中立(Architecture-neutral)

    · 解释执行(Interpreted)

    · 高性能(High performance)

    · 分布式(Distributed)

    · 动态(Dynamic)

    在这些特性中,安全和可移植已经在有很多文章介绍过,本文主要针对其他特性的含义讲解。

    e025c65bfa52f3c26b0da16637116e31.png

    一、简单

    Java 设计目的是让专业程序员觉得既易学又好用。设你有编程经历,你将不觉得Java 难掌握。如果你已经理解面向对象编程的基本概念,学习Java

    将更容易。如果你是一个经验丰富的C++ 程序员,那就 好了,学习Java 简直不费吹灰之力。

    因为Java 承C/C++ 语法和许多C++ 面向对象的特性,大多数程序员在学习Java

    时都不会觉得太难。另外,C++中许多容易混淆的概念,或者被Java 弃之不用了,或者以一种更清楚、更易理解的方式实现。

    除了和C/C++ 类似以外,Java 的另外一个属性也使它更容易学习:设计人员努力使Java 中不出现显得让人吃惊的特性。在Java

    中,很少明确地告诉你如何才能完成一项特定的任务。

    二、 面向对象

    尽管受到其前辈的影响,但Java 没被设计成兼容其他语言源代码的程序。这允许Java 开发组自由地从零开始。这样做的一个结果是,Java

    语言可以更直接、更易用、更实际的接近对象。

    通过对近几十年面向对象软件优点的借鉴,Java

    设法在纯进化论者的“任何事物都是一个对象”和实用主义者的“不讨论对象不对象”的论点之间找到了平衡。Java

    的对象模型既简单又容易扩展,对于简单数据类型,例如整数,它保持了高性能,但不是对象。

    三、健壮

    万维网上多平台的环境使得它对程序有特别的要求,因为程序必须在许多系统上可靠地执行。这样,在设计Java

    时,创建健壮的程序被放到了高度优先考虑的地位。

    为了获得可靠性,Java 在一些关键的地方限制你,强迫你在程序开发过程中及早发现错误。同时,Java

    使你不必担心引起编程错误的许多常见的问题。因为Java

    是一种严格的类型语言,它不但在编译时检查代码,而且在运行时也检查代码。事实上,在运行时经常碰到的难以重现的、难以跟踪的许多错误在Java

    中几乎是不可能产生的。

    要知道,使程序在不同的运行环境中以可预见的方式运行是Java 的关键特性。

    为更好理解Java

    是如何具有健壮性的,让我们考虑使程序失败的两个主要原因:内存管理错误和误操作引起的异常情况(也就是运行时错误)。在传统的编程环境下,内存管理是一项困难、乏味的任务。

    例如,在C/C++

    中,程序员必须手工地分配并且释放所有的动态内存。这有时会导致问题,因为程序员可能忘记释放原来分配的内存,或者释放了其他部分程序正在使用的内存。Java

    通过替你管理内存分配和释放,可以从根本上消除这些问题(事实上,释放内存是完全自动的,因为Java 为闲置的对象提供内存垃圾自动收集)。

    在传统的环境下,异常情况可能经常由“被零除”或“文件未找到”这样的情况引起,而我们又必须用既繁多又难以理解的一大堆指令来对它们进行管理。Java

    通过提供面向对象的异常处理机制来解决这个问题。一个写得很好的Java 程序,所有的运行时错误都可以并且应该被你的程序自己进行管理。

    四、多线程

    设计Java 的目标之一是为了满足人们对创建交互式网上程序的需要。为此,Java 支持多线程编程,因而你用 Java

    编写的应用程序可以同时执行多个任务。

    Java 运行时系统在多线程同步方面具有成熟的解决方案,这使你能够创建出运行平稳的交互式系统。Java

    的多线程机制非常好用,因而你只需关注程序细节的实现,不用担心后台的多任务系统。

    五、结构中立

    Java

    设计者考虑的一个主要问题是程序代码的持久性和可移植性。程序员面临的一个主要问题是,不能保 今天编写的程序明天能否在同一台机器上顺利运行。

    操作系统升级、处理器升级以及核心系统资源的变化,都可能导致程序无法继续运行。Java 设计者对这个问题做过多种尝试,Java 虚拟机(JVM

    )就是试图解决这个问题的。他们的目标是“只要写一次程序,在任何地方、任何时间该程序永远都能运行”。在很大程度上,Java 实现了这个目标。

    六、解释性和高性能

    前面已提到,通过把程序编译为Java 字节码这样一个中间过程,Java 可以产生跨平台运行的程序。字节码可以在提供Java 虚拟机(JVM

    )的任何一种系统上被解释执行。

    早先的许多尝试解决跨平台的方案对性能要求都很高。其他解释执行的语言系统,如BASIC,Tcl,PERL 都有无法克服的性能缺陷。然而,Java

    却可以在非常低档的CPU 上顺利运行。

    前面已解释过,Java 确实是一种解释性语言,Java 的字节码经过仔细设计,因而很容易便能使用JIT

    编译技术将字节码直接转换成高性能的本机代码。Java 运行时系统在提供这个特性的同时仍具有平台独立性,因而“高效且跨平台”对Java 来说不再矛盾。

    七、分布式

    Java 为Internet 的分布式环境而设计,因为它处理TCP/IP 协议。事实上,通过URL

    地址存取资源与直接存取一个文件的差别是不太大的。

    Java 原来的版本(Oak) 包括了内置的地址空格消息传递(intra-address-space)

    特性。这允许位于两台不同的计算机上的对象可以远程地执行过程。Java 近发布了叫做远程方法调用(Remote Method Invocation ,RMI

    )的软件包,这个特性使客户机/服务器编程达到了无与伦比的抽象级。

    八、动态

    Java

    程序带有多种的运行时类型信息,用于在运行时校验和解决对象访问问题。这使得在一种安全、有效的方式下动态地连接代码成为可能,对小应用程序环境的健壮性也十分重要,因为在运行时系统中,字节码内的小段程序可以动态地被更新。

    文中图片素材来源网络,如有侵权请联系删除

    展开全文
  • 前面已解释过,Java 确实是一种解释性语言Java 的字节码经过仔细设计,因而很容易便能使用JIT 编译技术将字节码直接转换成高性能的本机代码。Java 运行时系统在提供这个特性的同时仍具有平台独立性,因而“高效且...

    · 简单(Simple)

    · 安全(Secure)

    · 可移植(Portable)

    · 面向对象(Object-oriented)

    · 健壮(Robust)

    · 多线程(Multithreaded)

    · 体系结构中立(Architecture-neutral)

    · 解释执行(Interpreted)

    · 高性能(High performance)

    · 分布式(Distributed)

    · 动态(Dynamic)

    在这些特性中,安全和可移植已经在有很多文章介绍过,本文主要针对其他特性的含义讲解。

    一、简单

    Java 设计目的是让专业程序员觉得既易学又好用。假设你有编程经历,你将不觉得Java 难掌握。如果你已经理解面向对象编程的基本概念,学习Java 将更容易。如果你是一个经验丰富的C++ 程序员,那就最好了,学习Java 简直不费吹灰之力。

    因为Java 承C/C++ 语法和许多C++ 面向对象的特性,大多数程序员在学习Java 时都不会觉得太难。另外,C++中许多容易混淆的概念,或者被Java 弃之不用了,或者以一种更清楚、更易理解的方式实现。

    除了和C/C++ 类似以外,Java 的另外一个属性也使它更容易学习:设计人员努力使Java 中不出现显得让人吃惊的特性。在Java 中,很少明确地告诉你如何才能完成一项特定的任务。

    二、 面向对象

    尽管受到其前辈的影响,但Java 没被设计成兼容其他语言源代码的程序。这允许Java 开发组自由地从零开始。这样做的一个结果是,Java 语言可以更直接、更易用、更实际的接近对象。

    通过对近几十年面向对象软件优点的借鉴,Java 设法在纯进化论者的“任何事物都是一个对象”和实用主义者的“不讨论对象不对象”的论点之间找到了平衡。Java 的对象模型既简单又容易扩展,对于简单数据类型,例如整数,它保持了高性能,但不是对象。

    c6cfd000e493051d281f5b8981559708.png

    三、健壮

    万维网上多平台的环境使得它对程序有特别的要求,因为程序必须在许多系统上可靠地执行。这样,在设计Java 时,创建健壮的程序被放到了高度优先考虑的地位。

    为了获得可靠性,Java 在一些关键的地方限制你,强迫你在程序开发过程中及早发现错误。同时,Java 使你不必担心引起编程错误的许多最常见的问题。因为Java 是一种严格的类型语言,它不但在编译时检查代码,而且在运行时也检查代码。事实上,在运行时经常碰到的难以重现的、难以跟踪的许多错误在Java 中几乎是不可能产生的。

    要知道,使程序在不同的运行环境中以可预见的方式运行是Java 的关键特性。

    为更好理解Java 是如何具有健壮性的,让我们考虑使程序失败的两个主要原因:内存管理错误和误操作引起的异常情况(也就是运行时错误)。在传统的编程环境下,内存管理是一项困难、乏味的任务。

    例如,在C/C++ 中,程序员必须手工地分配并且释放所有的动态内存。这有时会导致问题,因为程序员可能忘记释放原来分配的内存,或者释放了其他部分程序正在使用的内存。Java 通过替你管理内存分配和释放,可以从根本上消除这些问题(事实上,释放内存是完全自动的,因为Java 为闲置的对象提供内存垃圾自动收集)。

    在传统的环境下,异常情况可能经常由“被零除”或“文件未找到”这样的情况引起,而我们又必须用既繁多又难以理解的一大堆指令来对它们进行管理。Java 通过提供面向对象的异常处理机制来解决这个问题。一个写得很好的Java 程序,所有的运行时错误都可以并且应该被你的程序自己进行管理。

    四、多线程

    设计Java 的目标之一是为了满足人们对创建交互式网上程序的需要。为此,Java 支持多线程编程,因而你用 Java 编写的应用程序可以同时执行多个任务。

    Java 运行时系统在多线程同步方面具有成熟的解决方案,这使你能够创建出运行平稳的交互式系统。Java 的多线程机制非常好用,因而你只需关注程序细节的实现,不用担心后台的多任务系统。

    五、结构中立

    Java 设计者考虑的一个主要问题是程序代码的持久性和可移植性。程序员面临的一个主要问题是,不能保证今天编写的程序明天能否在同一台机器上顺利运行。

    操作系统升级、处理器升级以及核心系统资源的变化,都可能导致程序无法继续运行。Java 设计者对这个问题做过多种尝试,Java 虚拟机(JVM )就是试图解决这个问题的。他们的目标是“只要写一次程序,在任何地方、任何时间该程序永远都能运行”。在很大程度上,Java 实现了这个目标。

    六、解释性和高性能

    前面已提到,通过把程序编译为Java 字节码这样一个中间过程,Java 可以产生跨平台运行的程序。字节码可以在提供Java 虚拟机(JVM )的任何一种系统上被解释执行。

    早先的许多尝试解决跨平台的方案对性能要求都很高。其他解释执行的语言系统,如BASIC,Tcl,PERL 都有无法克服的性能缺陷。然而,Java 却可以在非常低档的CPU 上顺利运行。

    前面已解释过,Java 确实是一种解释性语言,Java 的字节码经过仔细设计,因而很容易便能使用JIT 编译技术将字节码直接转换成高性能的本机代码。Java 运行时系统在提供这个特性的同时仍具有平台独立性,因而“高效且跨平台”对Java 来说不再矛盾。

    七、分布式

    Java 为Internet 的分布式环境而设计,因为它处理TCP/IP 协议。事实上,通过URL 地址存取资源与直接存取一个文件的差别是不太大的。

    Java 原来的版本(Oak) 包括了内置的地址空格消息传递(intra-address-space) 特性。这允许位于两台不同的计算机上的对象可以远程地执行过程。Java 最近发布了叫做远程方法调用(Remote Method Invocation ,RMI )的软件包,这个特性使客户机/服务器编程达到了无与伦比的抽象级。

    八、动态

    Java 程序带有多种的运行时类型信息,用于在运行时校验和解决对象访问问题。这使得在一种安全、有效的方式下动态地连接代码成为可能,对小应用程序环境的健壮性也十分重要,因为在运行时系统中,字节码内的小段程序可以动态地被更新。

    绿茶小编猜你还喜欢:

    展开全文
  • java是一门高级程序语言,使用java语言可以实现人机沟通,干程序员这行实在是离不开英语,那你知道java常用方法涉及到的单词有哪些吗?下面是厦门美联小编收集整理的一些java常用方法涉及到的单词,大家一起来看看吧!...

    java是一门高级程序语言,使用java语言可以实现人机沟通,干程序员这行实在是离不开英语,那你知道java常用方法涉及到的单词有哪些吗?下面是厦门美联小编收集整理的一些java常用方法涉及到的单词,大家一起来看看吧!

    java常用方法涉及到的单词1:

    一、常用的java数据类型:

    int 整型 用于存储整数:如 学员人数、一天的天数、小时数、编号等

    double 双精度浮点型 用于存储带有小数的数字:如商品的价格、工资等

    char 字符型 用于存储单个字符:如性别“男”/"女"、成绩“优”/“良”等

    String 字符串型 用于存储一串字符:如姓名、产品型号、价格信息等

    二、语法:数据类型 变量名

    double score; //声明双精度浮点型变量 score存储分数

    String name ; //声明字符串型变量 name 存储学生姓名

    char sex ; //声明字符型变量sex存储性别】

    三、调用变量:(使用存储的变量,我们称之为“调用变量”)

    System.out.println(score); //从控制台输出score存储的信息

    System.out.println(name); //从控制台输出name存储的信息

    System.out.println(sex); //从控制台输出sex存储的信息

    cd9dee0e3206866a46f1e85ec54e5e47.png

    java常用方法涉及到的单词2:

    一、java常用方法涉及到的单词 Authentication(认证),验证用户的身份与可使用的网络服务;授权(Authorization):依据认证结果开放网络服务给用户;计帐(Accounting):记 录用户对各种网络服务的用量,并提供给计费系统,简称java常用方法涉及到的单词系统。

    二、CALLBACK首先是基于多线程的,没有线程的调用就不要谈回调.子类调用父类的构造方法叫回调用,那TMD的任何构造对象都叫回调了,因为任何对象至少继承了Object,构造时至少要调用Object的构造方法。

    三、DTD Document type Definition(文档类型定义),它为一个 XML文档或者文档集合建立一套规则。它本身不是独立的技术规范,而是属于规范的一部分,XML文档中的文档类型声明既可以是标记约束,也可以是带有标记约束的外部文档。这两种约束的总和就是DTD。它规定了XML文档的构建方式。

    java常用方法涉及到的单词3:

    一、EJB Enterprise JavaBeans,Java中用于开发企业级应用的技术标 准,他定义了一个用于开发和发布可重用的服务器端组件的模型,包括 Session beans,Entity beans以及Message-driven beans三种 。

    二、Interface Definition Language(接口定义语言), CORBA的一个关键特性,是一个语言中立的接口定义语言,每个支持CORBA的语言 都会有一个自己的IDL映射。

    三、Inversion of Control(控制反转),由容器控制程序 之间的关系,而非传统实现中,由程序代码直接操控,控制权由应用代码中转到 了外部容器,控制权的转移,是所谓反转。(以上摘自夏昕的Spring开发指南)

    java常用方法涉及到的单词4:

    abstract (关键字) 抽象 ['æbstrækt]

    access vt.访问,存取 ['ækses]'(n.入口,使用权)

    algorithm n.算法 ['ælgәriðm]

    Annotation [java] 代码注释 [ænәu'teiʃәn]

    anonymous adj.匿名的[ә'nɒnimәs]'(反义:directly adv.直接地,立即[di'rektli, dai'rektli])

    apply v.应用,适用 [ә'plai]

    application n.应用,应用程序 [,æpli'keiʃәn]' (application crash 程序崩溃)

    arbitrary a.任意的 ['ɑ:bitrәri]

    argument n.参数;争论,论据 ['ɑ:gjumәnt]'(缩写 args)

    assert (关键字) 断言 [ә'sә:t] ' (java 1.4 之后成为关键字)

    associate n.关联(同伴,伙伴) [ә'sәuʃieit]

    attribute n.属性(品质,特征) [ә'tribju:t]

    boolean (关键字) 逻辑的, 布尔型

    call n.v.调用; 呼叫; [kɒ:l]

    circumstance n.事件(环境,状况) ['sә:kәmstәns]

    crash n.崩溃,破碎 [kræʃ]

    cohesion 内聚,黏聚,结合 [kәu'hi:ʒәn]

    (a class is designed with a single, well-focoused purpose. 应该不止这点)

    command n. 命令,指令 [kә'mɑ:nd](指挥, 控制) (command-line 命令行)

    Comments [java] 文本注释 ['kɒments]

    compile [java] v.编译 [kәm'pail]' Compilation n.编辑[,kɒmpi'leiʃәn]

    const (保留字)

    implements (关键字) 实现 ['implimәnt]

    import (关键字) 引入(进口,输入)

    Info n.信息 (information [,infә'meiʃәn] )

    Inheritance [java] 继承 [in'heritәns] (遗传,遗产)

    initialize 预置 初始化 [i'niʃәlaiz]

    instanceof (关键字) 运算符,用于引用变量,以检查这个对象是否是某种类型。返回 boolean 值。

    interface (关键字) 接口 ['intәfeis]

    invoke vt.调用 [in'vәuk]' ( invocation [,invәu'keiʃәn])

    Iterator [java] 迭代器, 迭代程序

    legal 合法的 ['li:gәl]

    log n.日志,记录 [lɒg]

    native (关键字) ?? ['neitiv]

    nested [java] 嵌套的 ['nestid] '如:内部类(nested classes)

    Object [java] 对象 ['ɒbdʒekt]

    Overload [java] 方法的重载(不同参数列表的同名方法) [,әuvә'lәud]

    Override [java] 方法的覆盖(覆盖父类的方法) [,әuvә'raid]

    polymiorphism[java] 多态 (polymorphism 多形性[,pɒli'mɒ:fizm])

    allowing a single object to be seen as having many types.

    principle n.原则,原理,主义 ['prinsipl]

    priority n. 优先级 [prai'ɒriti]

    process n. 程序, 进程 ['prɒses]

    展开全文
  • java语言常用语法

    2008-11-22 19:12:53
    非常好的java代码,将帮助你迅速掌握java语言
  • 第8章 常用类 日期处理相关的类 java.util.Date 用于表示日期和时间 示例获取当前时间 SimpleDateTest.java 示例按照特定格式输出 SimpleDate2Test.java已过时 FormatDateTest.java java.util.Date 示例将字符串转换...
  • Java常用高级语言特性整理

    千次阅读 2019-02-22 16:52:17
    JAVA 中有一个特殊的类,它是 JAVA 体系中所有类的父类(直接父类或者间接父类),此类中的方法可以使所有的类均能继承。以下介绍的三种属于 Object 类的方法:  1)操作符“==”和方法 equals():  1. ==:比较...

    1、修饰符 static


      1)静态类变量(修饰成员变量)
        1.Static int data 语句说明 data 为类变量,为一个类的共享变量,是所有对象共享的,它不属于任何对象,是属于整个类的(静       态方法也是一样)。
        2.Static 定义的是一块为整个类共有的一块存储区域。
        3.其变量可以通过类名去访问:类名.变量名(与通过对象引用访问变量是等价的)。
      2)静态方法(修饰方法)
        1.Public static void printData(){}:表明此类方法为类方法(静态方法),访问是在编译期完成,执行效率比较高。
        2.静态方法不需要有对象,可以使用类名调用(不需要实例也可以调用静态方法)。
        3.静态方法中不能访问类的非静态成员,包括成员变量和方法;只能访问本类中的静态变量和其它静态方法。因为此时是通过类      调用的,没有对象的概念。方法中 this.data 和super.data 是不可用的。
        原因:从根本上说,静态变量不管类是否实例化都会存在,而实例变量只有类实例化了才存在。直接调用静态方法时并不确定实例变量是否存在。
        4. 一般情况下,主方法是静态方法,所以 JVM 可以直接调用它,主方法为静态方法是因为它是整个软件系统的入口,而进入入      口时系统中没有任何对象,只能使用类调用。
        5.静态方法不能被覆盖,如果子类中有和父类重名的静态方法,虽然编译通过,但它并不能实现多态,所以不能称作覆盖。例          如:

    class Super{
        static public void show(){System.out.println("in Super");}
    }
    class Sub extends Super{
        static public void show(){System.out.println("in Sub");}
    }
    public class Test {
        public static void main(String[] arg) {
            Super s = new Sub();
            s.show();
        }
    }

       执行结果是: in Super。

      3)静态代码块(修饰没有名字的代码块)
        1.只被执行一次
        2.初始化块在类被加载后首先被运行,不管类是否实例化,而且只执行这一次
        3.作用:一般用来初始化一些复杂类型的静态变量。
      4)静态内部类(注意:只能修饰成员内部类)
        class Out{
          public static class Inner{}
        }
      5)Static 通常用于 Singleton 模式开发
        Singleton 模式(单例模式):是一种设计模式,高于语法,可以保证一个类在整个系统中仅有一个对象
          1.问题域:
            系统中你需要获得某个类的唯一实例,所有客户端对它的访问都将通过一个公共的访问点获得。
          2.解决方案:创建一个类并使其
             a.定义一个私有的构造器;
             b.定义一个私有、静态的实例变量指向自己(类型是自己的类型);
             c.定义一个公有、静态的访问方法 getInstance()用于返回该类的唯一实例(注:懒汉式需同步)。
          3.分类:
             a.饿汉式:在类装载的时候就进行实例化
             b.懒汉式:在公有、静态的访问方法(同步:用 synchronized 修饰)中进行实例化,用的多一些
     

    // 饿汉式实现
    public class ConnectionFactory{
        private static Connection conn;
        static{
            conn = new Connection();
        }
        public static Connection getInstance(){
        return conn;
        }
    }
    // 没有解决同步的懒汉式:
    public class ConnectionFactory{
        private static Connection conn;
        private Connection(){
            if(conn==null)
                conn = new Connction();
        }
        public Connection getInstance(){
            return conn;
        }
    }
    
    // 解决同步的懒汉式:
    public class ConnectionFactory{
    private static Connection conn;
        private Connection(){
        }
       //同步函数
        public static synchronized ConnectionFactory getInstance() {
            if (conn == null)
                conn = new ConnectionFactory();
            return conn;
        }
        //同步加锁
        public static ConnectionFactory getInStanceBlock(){
            if(conn == null)
                synchronized (ConnectionFactory.class) {
                    if(conn == null)
                        conn = new ConnectionFactory();
                }        
            return conn;        
        }
    }

    2、修饰符 final


      1)final 型变量(修饰变量时):
        1. 当利用 final 修饰一个变量(属性)的时候,此时该变量变为常量。
            注意:a. JAVA 命名规范中常量全部字母要求大写:Final int AGE=10
                       b. 常量的地址不可改变,但在地址中保存的值(即对象的属性)是可以改变的
        2. 在 JAVA 中利用 public static final 的组合方式对常量进行标识(固定格式)。
        3. Final 变量是在整个类被创建时候被赋值,之后就不能改变了
            注意:a. 对于 final 变量,如果在声明和构造的时候均不进行赋值,将显示编译出错
                       b. 对于利用构造器对 final 变量进行赋值的时候,此时在构造之前系统设置的默认值被覆盖。
        4. 常量赋值(这里的常量指的是实例常量,即成员变量):
            ① 在初始化的时候通过显式声明赋值:Final int x=3;
            ② 在构造的时候赋值。
      2)final 型方法(修饰方法时):
        1. final 方法不能被覆盖(不能被改写),只能被继承
        2. 为了保证方法的一致性(即不被改变),可将方法用 final 定义
        注意:a. 如果在父类中有 final 定义的方法,那么在子类中继承同一个方法。
                   b. 如果一个方法前有修饰词 private 或 static,则系统会自动在前面加上 final, private 和 static 方法默认均为 final 法。
                   c. final 并不涉及继承,继承取决于类的修饰符是否为private、default、protected 还是 public。也就是说,是否继承取                 决于这个类对于子类的可见性。
        3. Final 和 abstract 永远不会同时出现
      3)final 类(修饰类时):
        1.final 类不能被继承,即 final 类没有子类。
        2.可以用 final 保证用户调用时动作的一致性,可以防止子类覆盖情况的发生。
        3.final 修饰类时表明同时类中的方法都是 final 型,但其变量不是。


    3、修饰符 Abstract


      1)抽象方法(修饰方法时):子类继承抽象类时必须实现其中的抽象方法
        1.当 abstract 用于修饰方法时,此时该方法为抽象方法,此时方法不需要实现,实现留给子类覆盖,子类覆盖该方法之后方法      才能够生效
        2.抽象方法没有方法体,要求子类必须提供这个方法的实现。注意比较:private void print(){};此语句表示方法的空实现。
        Abstract void print(); 此语句表示方法的抽象,无实现。
      2)抽象类(修饰类时):
        1. 如果将一个类声明为 abstract,表明此类不能创建对象(不能实例化),只能声明变量
        2. Abstract 类的设计是将子类的共性最大限度的抽取出来,以提高程序的统一性。
        3. 带有抽象方法的类一定是抽象类,但抽象类可以没有抽象方法
        4. Abstract 类可以作为编译时类型,但不能作为运行时类型。


    4、接口


      1) 接口是抽象类的另外一种形式(没有实例变量的抽象类);
      2) 在一个接口中所有方法都是抽象方法;
      3) 接口中所有变量都必须被定义为 final static;
      4) 接口可以继承多个接口(可多重继承);
      5) 接口只有两种语法成分:静态常量和公有的抽象方法。
      注:接口中的方法自动被置为 public, 因此在接口中声明方法并不需要提供 public 关键字。但在实现接口时,必须把方法声明      为public。

    public interface IA{
    public abstract void method();
    void method2();
    }
    public interface IB{
    void method3();
    }
    public interface IC extends IA,IB{
    void method4();
    }
    public class C implements IC{} // implements 表示对接口 IC 中方法的实现,共有 4 个

    5、Object 类

    JAVA 中有一个特殊的类,它是 JAVA 体系中所有类的父类(直接父类或者间接父类),此类中的方法可以使所有的类均能继承。以下介绍的三种属于 Object 类的方法:
      1)操作符“==”和方法 equals():
        1.==:比较的是引用,表示其引用值是否相等,即是否指向同一对象
        注:“==”在任何时候都是比较地址,这种比较永远不会被覆盖
        2.equals: 比较的是对象,其默认比较规则就是"==";
        注意:基本类型没有 equals(),只有复杂类型才有
        3.附加知识:字符串类为 JAVA 中的特殊类(String 类在 Java 中为 final 类型),一个字符串的值不可重复。因此在 JVM(虚        拟机)中有一个字符串池,专门用来存储字符串。如果遇到 String a="hello"时(注意没有 new,不是创建新串),系统在        字符串池中寻找是否有"hello",此时若字符串池中没有"hello",那么系统将此字符串存到字符串池中,然后将"hello"在字符      串池中的地址返回给 a。如果系统再遇到 String b="hello",此时系统在字符串池中可以找到"hello"字符串,并将其地址返回      给 b,则此时 a 与 b 相同。
        4.举例:
           a. String a = new String("hello");
               String b = new String("hello");
               System.out.println(a==b);
           则 a==b 的返回为结果为 false。 //因为==判断的是引用是否相等,并不是判断对象。
           b. String a = "hello";
               String b = "hello";
               System.out.println(a==b);
           系统的返回值为 true。
           c. 故如果要比较两个字符串是否相同(而不是比较它们的地址是否相同),可以对 a 调用 equals:
           System.out.println(a.equals(b));
           系统的返回值为 true。注意 equals()用来比较两个对象中字符串的顺序,即 a.equals(b)比较的是 a 与 b 的值。
        5.注意下面程序:
           student a=new student(“LUCY”,20);
           student b=new student(“LUCY”,20);
           System.out.println(a==b);
           System.out.println(a.equals(b));
           此时返回的结果为 false。因为 Student 继承的是 Object 的 equals()方法,此时toString()等于“==” ,为了实现对象的比较需           要覆盖 equals()方法(加上这个定义,则返回 ture或 false)。
       6.实现标准 equals()方法的流程
           public boolean equals(Object o){
           if (this==o) return true; //此时两者相同
           if (o==null) return false;
           if (! o instanceof Student) return false; //不同类
           Student s = (Student)o; //强制转换
           if (s.name.equals(this.name)&&s.age==this.age) return true;
           else return false;
           }
      2)finalize 方法:当一个对象被垃圾收集器回收的时候调用的方法
      3)toString():是利用字符串来表示对象的方法,简化输出。
        1.当我们直接打印定义的对象的时候,隐含的是打印 toString()的返回值(返回一个字符串)。
        2.可以通过子类作为一个 toString()来覆盖父类的 toString()以取得我们想得到的表现形式,即当我们想利用一个自定义的方式      描述对象的时候,我们应该覆盖 toString()。


    6、内部类(Inner class)


      1)概念:内部类是指在一个类的内部再定义一个类。它可以访问外围类的私有成员,其语法特别繁琐,在实际开发中避免使      用。
      注意:所有使用内部类的地方都可以不用内部类,但使用内部类可以使程序更加的简洁,便于划分层次结构和命名规范。
      2)特点:1. 缩小类的访问范围,比包还小
           2. 用内部类定义在外部类中不可访问的属性,这样就在外部类中实现了比外部类的 private 还要小的访问权限。
           注意:内部类是一个编译时的概念,一旦编译成功,就会成为完全不同的两个类。对于一个名为 outer 的外部类和一个在其         内部定义的名为 inner 的内部类,编译完成后就会出现outer.class 和 outer$inner.class 两个不同的类。
      3)内部类可为静态,也可用 PROTECTED 和 PRIVATE 修饰(而外部类不可以,顶级类只能使用 PUBLIC 和 DEFAULT 修饰)。
           注意:JAVA 文件中没有任何一个 public class 可以类名和文件名不同,但内部类可以。
      4)内部类的分类:与成员变量同一级别(成员内部类和局部内部类);与方法中的局部变量同一级别(静态内部类和匿名内部    类(经常用到,必须掌握))。
      5)成员内部类:
        1.概念:作为外部类的一个成员存在,与外部类的属性、方法并列。是最复杂,用的最少的内部类。
        2.特点:必须依附于外围类的实例而存在,能访问外围类的一切成员,成员内部类不能有静态属性
        3.在内部类中访问实例变量:this.属性在内部类访问外部类中与它命名冲突的成员:Outer.this.member在外部类的外部访问内      部类,使用 out.inner
        4.构建成员内部类实例:
           a.在外围类以外的地方:(new outer()).new Inner();
           b.在外围类内部:this.new Inner();
       6)静态内部类:
           1.静态内部类定义在类中,任何方法外,用 static 定义。是最简单的内部类,与外围类的名字不能相同。
           2.静态内部类只能访问外部类的静态成员。
           3.不需要构建外围类实例就可直接构建静态内部类的实例:这是静态内部类和成员内部类的区别,静态内部类的对象可以直         接生成,而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类。静态内部类不可用 private 来           进行定义。
           Outer.Inner in = new Outer.Inner();
           4.注意: a.当类与接口(或者是接口与接口)发生方法命名冲突的时候,此时必须使用内部类来实现。
                          b.用接口不能完全地实现多继承,用接口配合内部类才能实现真正的多继承。
              例子:对于两个类,拥有相同的方法,另有一个 robot 类:class Robot extends Person implement Machine{}。此时 run()            不可直接实现。
     

    interface Machine{
        void run();
    }
    class Person{
        void run(){
            System.out.println("run");
        }
    }
    class Robot extends Person{
        private class MachineHeart implements Machine{
            public void run(){
                System.out.println("heart run");
            }
        }
        public void run(){
            System.out.println("Robot run");
        }
        Machine getMachine(){
            return new MachineHeart();
        }
    }
    class Test{
        public static void main(String[] args){
        Robot robot = new Robot();
        Machine m = robot.getMachine();
        m.run();
        robot.run();
        }
    }

      6)局部内部类:
        1.概念:在方法中定义的内部类称为局部内部类。
        2.与局部变量类似,在局部内部类前不能使用修饰符 public,protected,private 和 static,其范围为定义它的代码块。
        3.局部内部类可以访问外部类的一切成员,还可以访问这个方法中由 final 修饰的局部变量(即常量)。
        4.可见范围缩小到一个方法的内部:在类外不可直接访问局部内部类(保证局部内部类对外是不可见的)。
        注意:在方法中才能调用其局部内部类。
      7)匿名内部类:
        1.概念:匿名内部类是一种特殊的局部内部类,它是通过匿名类实现接口。
        注意:匿名内部类没有名字,没有关键词 class,没有 extends 和 implements,也没有构造器。
        2.一个匿名内部类一定是在 new 的后面,隐含着继承一个父类或者实现一个接口(或实现一个类),没有类名,根据多态,        我们使用其父类名。
        3.利用父类或接口的名字代替 new 后面的名字来创建对象。
        4.利用父类或接口声明变量:接口名 对象名 = new 接口名(){...};
        注意:new 是一个完整的语句,注意一定要在花括号后加分号;
        如果一个对象编译时的类型是接口,那么其运行的类型为实现这个接口的类。
        5.因其为局部内部类,那么局部内部类的所有限制都对其生效。
        注意:匿名内部类是唯一一种没有构造器的类。因匿名内部类无构造器,所以其使用范围非常的有限。
        6.匿名内部类在编译的时候由系统自动起名 Out$1.class。


    7、包装器类:Wrapper Class功能:将基本类型数据包装成对象


         int i = 5; 或 String s = "5";
         Integer integer = new Integer(i 或 s); //装箱(box):包装成对象
         int j = integer.intValue(); //拆箱(unbox):提取数据
         对于 String 型数据来说以上两步相当于:int j = Integer.parseInt(s);


    8、集合 Collection


      1)概念:集合是指一个可以容纳多个对象(不是引用)的对象,这个集合对象主要用来管理和维护一系列相似的对象
      2)集合三要素:若干个接口,接口的实现类和算法(一系列方法和实现类交合在一起)
      3)集合接口类层次:位于 package java.util.*;
            

        注意:1.Set: 集合类中不允许有重复对象;
                   2.SortedSet: 和 Set 接口相同,但元素按升序排列;
                   3.List: 元素加载和移出时按照顺序,可以保存重复对象。
                   4.Map: 存储了唯一关键字辨识和对应的值(key-value 对)。
                   5.SortedMap: 和 Map 类相同,但对象按他们的关键字升序排列。

      4)集合类层次 :
      

      5)Collection 接口的方法:
        add(Object o)
        addAll(Collection c)
        contains(Object o)
        containsAll(Collection c)
        remove(Object o)
        removeAll(Collection c)
        clear()
        equals(Object o)
        isEmpty()
        iterator()
        size()
        toArray()
        toArray(Object[] o)
      6)Iterator(迭代器):读集合的一个工具
      public interface Iterator{
        boolean hasNext();
        Object next();
        void remove();
      }
      7)五个最常用的集合类之间的区别和联系:
        1.ArrayList: 元素单个,效率高,多用于查询
        底层是 Object 数组,所以 ArrayList 具有数组的查询速度快的优点以及增删速度慢的缺点
        2.LinkedList:元素单个,多用于插入和删除
          a.经常在增删操作较多而查询操作很少的情况下使用:队列和堆栈。
          队列:先进先出的数据结构;
          栈:后进先出的数据结构。
          b.在 LinkedList 的底层是一种双向循环链表。在此链表上每一个数据节点都由三部分组成:前指针(指向前面的节点的位            置),数据,后指针(指向后面的节点的位置)。最后一个节点的后指针指向第一个节点的前指针,形成一个循环
          c.双向循环链表的查询效率低但是增删效率高
          d.注意:使用栈的时候一定不能提供方法让不是最后一个元素的元素获得出栈的机会
          ArrayList 和 LinkedList 在用法上没有区别,但是在功能上还是有区别的。
        3.Vector: 元素单个,线程安全,多用于查询
          a.与 ArrayList 相似,区别是 Vector 是重量级的组件,使用时消耗的资源比较多
          b.结论:在考虑并发的情况下用 Vector(保证线程的安全);在不考虑并发的情况下用 ArrayList(不能保证线程的安                全)
        4.HashMap: 元素成对,元素可为空
        5.HashTable: 元素成对,线程安全,元素不可为空
        6.   Map 遍历的形式
     

    // 1) 
    Set ks = map.keySet();
    Iterator it = ks.iterator();
    while(it.hasNext()){
        Object key = it.next();
        Object value = map.get(key);
    }
    // 2) 
    Collection values = map.values();
    Iterator it = values.iterator();
    while(it.hasNext()){
        Object value = it.next();
    }
    // 3) 
    Set<Map.Entry> entrySet = map.entrySet();
    for(Map.Entry entry:entrySet){
        Object value = entry.getValue();
    }

      8)知识点:
        1.java.util.stack(stack 即为堆栈)的父类为 Vector。可是 stack 的父类是最不应该为Vector 的。因为 Vector 的底层是数组,      且 Vector 有 get 方法(意味着它可能访问到并不属于最后一个位置元素的其他元素,很不安全)。对于堆栈和队列只能用            push 类和 get 类。故Stack 类以后不要轻易使用。
        2.实现栈一定要用 LinkedList,collection 由 queue 来实现队列。
        3.Set-HashSet 实现类:
          a.遍历一个 Set 的方法只有一个:迭代器(interator)
          b.HashSet 中元素是无序的(这个无序指的是数据的添加顺序和后来的排列顺序不同),而且元素不可重复。
          c.HashSet 底层用的也是数组
          d.在 Object 中除了有 finalize(),toString(),equals(),还有 hashCode()。当向数组中利用 add(Object o)添加对象的时候,          系统先找对象的 hashCode:
            int hc = o.hashCode(); //返回的 hashCode 为整数值。
            Int I = hc%n; //n 为数组的长度,取得余数后,利用余数向数组中
          相应的位置添加数据,以 n 为 6 为例,如果 I=0 则放在数组 a[0]位置,如果 I=1,则放在数组a[1]位置。如果 equals()返回的          值为 true,则说明数据重复。如果 equals()返回的值为 false,则再找其他的位置进行比较。这样的机制就导致两个相同的对        象有可能重复地添加到数组中,因为他们的 hashCode 不同。
          如果我们能够使两个相同的对象具有相同 hashcode,才能在 equals()方法中返回真。因此在实际中,我们定义 Student 对          象时要覆盖它的 hashcode。因为 String 类是自动覆盖的,所以当比较 String 类的对象的时候,就不会出现有两个相同的            string 对象的情况。现在在大部分的 JDK 中,都已经要求覆盖了 hashCode。
          结论:如将自定义类用 hashSet 来添加对象,一定要覆盖 hashcode()和equals()这两个方法,覆盖的原则是保证当两个对象        相同时 hashcode 返回相同的整数,而且equals()返回的值为 True。如果偷懒,没有设定 equals(),就会造成返回hashCode        虽然结果相同,但在程序执行的过程中会多次地调用 equals(),从而影响程序执行的效率。
          我们要保证相同对象的返回的 hashCode 一定相同,也要保证不相同的,对象的 hashCode 尽可能不同(因为数组的边界            性,hashCode 还是可能相同的)。
          例子:
          public int hashCode(){
            return name.hashcode()+age;
          }
          这个例子保证了相同姓名和年龄的记录返回的 hashCode 是相同的。
          e.使用 hashSet 的优点:
             hashSet 的底层是数组,其查询效率非常高。而且在增加和删除的时候由于运用的 hashCode 的比较确定添加元素的位             置,所以不存在元素的偏移,所以效率也非常高。因为 hashSet 查询和删除和增加元素的效率都非常高。但是 hashSet             增删的高效率是通过花费大量的空间换来的:因为空间越大,取余数相同的情况就越小。HashSet 这种算法会建立许多无           用的空间
          f.使用 hashSet 类时要注意,如果发生冲突,就会出现遍历整个数组的情况,这样就使得效率非常的低
       4.比较:
         Collections 类(工具类 ---> 全是 static 方法):
         Public static int binarySearch(List list,Object key)
         Public static void Sort(List list,Comparator com)
         Comparator 接口:
         Int compare(Object a,Object b)
         Boolean equals(Object o)
         注意:集合的最大缺点是无法进行类型判定,这样就可能出现因为类型不同而出现类型错误。解决的方法是添加类型的判断。
         例子:

    import java.util.*;
    public class Test {
        public static void main(String[] arg) {
            ArrayList al = new ArrayList();
            Person p1 = new Person("kevin");
            Person p2 = new Person("robin");
            Person p3 = new Person("terry");
            al.add(p1);
            al.add(p2);
            al.add(p3);
            Collections.sort(al,p1);
            for(Iterator it = al.iterator();it.hasNext();){
                Person p = (Person)it.next();
                System.out.println(p.name);
            } 
        }
    }
    class Person implements java.util.Comparator{
        public String name;
        public Person(String name){
            this.name = name;
        }
        public int compare(Object a,Object b){
            if(a instanceof Person && b instanceof Person){ //类型的判断
                Person pa = (Person)a;
                Person pb = (Person)b;
                return pa.name.compareTo(pb.name);
            }
            return 0;
        }
        public boolean equals(Object a){return true;}
    }

      9)总结:谈谈 Java 中的集合框架?
        1.ArrayList,Vector,LinkedList 的存储性能和特性?
        2.Collection(集合的最上层接口)与 Collections(工具类)的区别?
        3.怎样使 ArrayList 成为线程安全的?
        根据集合存放数据的特点,分为两类:
            1)只存单值: List , Set
           ArrayList:以数组的方式管理数据,线程不安全的,适合于做大量的查询操作
           思考:怎么变成线程安全的(java.util.Collections)?
           -----> synchronizedList(List<T> list)方法
           LinkedList:线程安全的,以双向链表的方式管理数据,适合于做大量的增加、删除操作;
           Vector:不适合查询,线程安全的,适合处理多线程集合;

           2)存 Key-Value 键值对: Map
                 HashMap(线程不安全的)
                 Hashtable(线程安全的)
                 TreeMap(根据 HashCode 进行排序)


    9、反射(JAVA 中最抽象并且是最难理解的概念,也叫镜像)


      1)作用:
        1.动态构建类的实例:确定一个对象的类;
        2.获得类的内部信息:获得一个类的修改符、变量、方法、构器函数、和父类的相关信息;
           找出哪些常量和方法是从一个接口声明的;
           创建一个在运行时才知道名称的类;
           调用对象的方法;
        3.改变类的一些特性。
      2)获取镜像仅有的三种方式:
        1.知道类的对象
          object o = xxxx;
          Class clazz = o.getClass();

        2.知道类名获取镜像
           java.uil.ArrayList
          Class clazz = ArrayList.class;

        3.知道存放类名的字符串
           String s = "xxxxx"; //不知类名
           Class clazz = Class.forName(s);
      3)通过反射修改类的特性:
        1. 修改一个对象的实例变量值
          Field.set(instance,value);
        2. 调用一个对象上的方法
          Method.invoke(instance,new Object[]{value1,value2});
        3. 调用一个类中的构造器
          Constructor.newInstance{new Object[]{value1,value2});
      4)程序范例:

    import java.util.*;
    public class DynamicObject{
        public static void main(String[] args) throws Exception {
            if(args.length<1){
            System.out.println("Usage: java "+
            DynamicObject.class.getName()+" XXXX");
            System.exit(0);
        }
        String className = args[0];
        Class clazz = Class.forName(className);
        Collection conn = (Collection)clazz.newInstance();
        conn.add(new Integer(32));
        conn.add(new Integer(6454));
        conn.add(new Integer(-4242));
        Iterator iter = conn.iterator();
        while(iter.hasNext()){
            System.out.println(iter.next());
            }
        }
    }

     

    展开全文
  • JAVA语言常用英语汇总

    2012-09-14 15:42:32
    自己整理的一些关于java英语常用的资料
  • java语言常用的包和类

    2021-03-01 00:30:30
    八、java语言中的常用包 由于java语言的package是用来存放类与接口的地方,所以也把package译为“类库”,即java类库是以包的形式实现的,java语言已经把功能相近的类分门别类的存放在不同的类库中(除类之外还包含...
  • java语言常用

    2014-10-21 20:54:36
    java.lang   java.util   java.io
  • 这是可以导入到有道词典的文件 共550个常用的编程单词 导入之后,随时能够在手机上进行查看和记忆 分享给大家,希望对你们有所帮助 加油吧~打工人!
  • java常用

    2018-09-12 08:22:09
    一、Java 常用java.lang–语言包:Java语言的基础类,包括Object类、Thread类、String、Math、System、Runtime、Class、Exception、Process等,是Java的核心类库 java.util–实用工具包:Scanner、Date、...
  • 1.java.lang包 java.lang包 是Java中最常用的包,程序不需要注入,就可以使用该包中的类,利用包中的类可以设计最e799bee5baa6e997aee7ad94e78988e69d8331333365633838基本的Java程序。2.java.awt包 java.awt包中的...
  • 实验五java语言中的常用类.doc 仲恺农业工程学院实验报告纸计算科学与工程(院、系)网络工程专业班组JAVA语言程序设计课学号姓名实验日期2010/11/19教师评定实验五JAVA语言中的常用类一、实验目的1、掌握JAVA语言中的...
  • Java语言编程-常用

    2010-08-21 13:35:17
    Java 语言编程- 常用
  • Java语言部分基础知识 Java语言的特点: 开源:开发源代码 查看Java源代码如何实现! 跨平台: 跨操作系统 软件结构划分 C/S结构:Client-Server :客户端和服务器端的交互 特点:客户端想要使用服务器端的高...
  • JAVA语言常用

    2008-05-05 16:40:00
    Java语言中的一些常用的词汇Abstract class 抽象类:抽象类是不允许实例化的类,因此一般它需要被进行扩展继承。 Abstract method 抽象方法:抽象方法即不包含任何功能代码的方法。 Access modifier 访问控制修饰符:...
  • JAVA语言常用英语

    千次阅读 2013-06-25 20:15:17
    这是因为计算机软件技术更新的速度越来越快,而这些技术大多来源于英语国家,我们在引进这些技术时往往受到语言障碍的制约,严重影响到对新技术的理解和消化。首先编程本身就依赖于英语,虽然现在技术的发展,可以...
  • 常用java包_JAVA 常用

    2021-03-05 20:19:12
    引入这些包的关键词就是 import下面说说JAVA常用包有下面的几个1.java.lang这个是默认引入的,也是一个最基础的包。其中lang不是中文的“狼,浪,朗”,而是language的简写。java.lang提供利用 Java 编程语言进行...
  • java语言常用性能优化技巧介绍  优化通常包含两方面的内容  1 减小代码的体积,  2 提高代码的运行效率。   java程序常用的方法有以下几种:   1.不用new关键词创建类的实例。用new关键词创建类的...
  • Java常用名词

    热门讨论 2015-09-08 11:10:12
    Java常用名词     经过初步的对软考、J2SE的了解,Java集合了几乎计算机语言所有的优点,避开了的之前C、C#语言等的不足,在 现实的工作中现在Android系统也就是用的Java语言,Java 的确是一个十分优美的语言,其...
  • java.lang: 这个包下包含了Java语言的核心类,如String、Math、Sytem和Thread类等,使用这个包无需使用import语句导入,系统会自动导入这个包中的所有类。java.util: 这个包下包含java的大量工具类/接口和集合框架类...
  • 该包提供了Java语言进行程序设计的基础类,它是默认导入的包。该包里面的Runnable接口和Object、Math、String、StringBuffer、System、Thread以及Throwable类需要重点掌握,因为它们应用很广。第二个包:java.util包...
  • java常用代码

    2013-05-20 22:59:24
    java 常用代码集合,适合刚开始接触java语言的童鞋们呢。
  • 什么是运算符:Java 语言常用的运算符可分为如下几种:Ø算术运算符Ø赋值运算符Ø比较运算符Ø逻辑运算符Ø条件运算符Java中的算术运算符:算术运算符主要用于进行基本的算术运算,如加法、减法、乘法、除法等。...
  • Java编程语言中为方便学习者学习,编制了许多类,这些类已经经过测试,都是我们编程的基础。如果不利用这些已存在的类,我们的编程工作将变得异常复杂并且效率低下。所以我们应尽可能多的掌握Java基本类库的内容。...
  • Java语言常用的包

    2019-03-05 09:54:44
    Java采用包结构来组织和管理类和接口文件,以下是开发中常用的几大包; 1.java.lang包 该包提供了Java的基础类,它是默认导入的。该包里面的Runnable接口和Object, Math, String, StringBuffer, System, Thread...
  • 正在学习编程语言的你,是否认识Java的基本常用语言?,对Java开发的总体来讲就是不完整的。Java 设计开发人员总结经验出关键因素,为Java入门的专门用语如下8个语言:     简单(Simple) 安全(Secure...
  • Java常用

    2019-09-30 20:11:17
    Java常用包 1.java.lang 包含一些Java语言的核心类,如String、Math、Interger、System和Thread,提供常用功能。要使用这个包中的类,可以不用 import 语句来显式引用。在默认情况下,编译器会将这个包自动引入任何 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,641
精华内容 6,656
关键字:

java常用语言

java 订阅