精华内容
下载资源
问答
  • 2019 年计算机二级考试 Java 入门教程 Java 的基 本构成 1 Java 的定义形式 一个完整的 Java 通常由下面六个部分组成 包定义语句 import 语句 定义{成员变量 构造方法 成员方法 } 其中只有定义 {} 是不...
  • Java类组成

    千次阅读 2019-04-15 00:21:11
    组成类是什么?由什么成分组成?定义语法格式可分为成员变量局部变量可分为:方法构造器==注意:== 静态变量以及非静态变量的区别请说出作用域public,private,protected,以及不写时的区别 是什么?...

    类是什么?

    类是具有相同特性和行为的对象集合。
    

    eg:
    人类是一个类

    其中,分为 四大人种:亚洲人种(黄种人)、高加索人种(白种人)、非洲人种(黑种人)、大洋洲人种(棕种人)
    共同特性~~emmmm (坏笑) 当然都是人啦

    至于行为的话,可以是说话,眨眼睛等等。

    类由什么成分组成?

    Java类由五大部分组成:

    • 成员变量/Field域
    • 方法(method)
    • 构造器
    • 代码块
    • 内部类

    定义语法格式

    类:

    [修饰符] class 类名 {….类体	…..}
    eg:public class yun(){} 	
    注意:类的修饰符可以是public、final 或省略这两个。类名只要是合法的标识符即可。
    一个类里可以包含三种最常见的成员:构造器、属性、方法、代码块、内部类。
    

    类可分为

    • 外部类

    • 内部类

      • 静态内部类
      • 非静态内部类
      • 局部内部类

      (1)至于内部类的话,只要A类是在B类里面定义的,那么A便是B的内部类。
      (2)区分的是不是静态类的话,看有没有用staic修饰即可。
      (3)局部内部类:
      如果把一个内部类放在方法里定义,这就是局部内部类,仅仅在这个方法里有效。
      局部内部类不能在外部类以外的地方使用,那么局部内部类也不能使用访部控制符和static修饰

    成员变量

    [修饰符] 属性类型 属性名 [=属性值];
    eg: 	String nam=”yun”;   或  String  name ; 此处默认值为null   后面再给name赋值  name = “落笔”;
    

    此处应有局部变量。那么见名知意,就明白它们的命名规则都一样。不过大家的范围大小不同。

    成员变量指的是在类范围里定义的变量;局部变量指的是在一个方法内定义的变量。
    

    局部变量可分为:

    • 形参
    • 方法局部变量
    • 代码块局部变量.

    ~~emmm此处见名知意吧(坏笑)

    方法

    [修饰符] 方法返回值类型 方法名(形参列表) {….方法体….}
    eg: public static void main(String[] args ){}
    

    方法中的修饰符可以是public ,protected,private,static,final,abstract,其中访问控制符(public ,protected,private)只能出现一个,abstract ,final 只能出现其一.
    返回值类型可以是基本类型和引用类型,如果无返回值,要用void 来声明
    形参列表,可以由零到多个组成,参数之间用逗号(“,”)隔开.
    static 是一个特殊的关键字,译为”静态”,所有有static 修饰的叫类属性,类方法,类成员.

    构造器

    [修饰符] 构造器名(形参列表) {……}
    修饰符可以是public protected private 构造器名字必须和类名相同,形参和方法的形参一样
    

    构造器通常用来new对象。

    注意: 静态变量以及非静态变量的区别

    1. 静态变量可以直接使用类名去调用,当然也可以通过对象去调用。
    2. 非静态变量只能通过对应引用进行调用。
    3. 静态变量不能访问非静态变量。如果,非要去访问的话,那么,只能 用对象去引用非静态成员。
    4. 静态变量在内存空间中只有一份,也永远只有一份。
    5. 非静态变量只要new出一个对象引用就会在内存中分配一份空间给它。
    6. 存放地点不一样,静态变量存放在栈空间。非静态变量存放在堆空间里

    请说出作用域public,private,protected,以及不写时的区别

    这四个作用域的可见范围如下表所示。

    作用域当前类同一包子类全局
    public公开
    protected子类
    default×默认
    private××私有

    类–>包–>子类–>全局 大–>小
    说明:如果在修饰的元素上面没有写任何访问修饰符,则表示default。
    只要记住访问权限由小到大依次是private → default → protected → public,然后再记住Java存在的4个访问范围,就很容易画出上面的表格了。

    展开全文
  • Java类和对象 详解(一)

    万次阅读 多人点赞 2016-10-06 20:48:02
    几乎现在的所有应用都以面向对象为主了,最早的面向对象的概念实际上是由IBM提出的,在70年代的Smaltalk语言之中进行了应用,后来根据面向对象的设计思路,才形成C++,而由C++产生了Java这门面向对象的编程语言。...

    一、面向对象简述

    面向对象是一种现在最为流行的程序设计方法,几乎现在的所有应用都以面向对象为主了,最早的面向对象的概念实际上是由IBM提出的,在70年代的Smaltalk语言之中进行了应用,后来根据面向对象的设计思路,才形成C++,而由C++产生了Java这门面向对象的编程语言。

    但是在面向对象设计之前,广泛采用的是面向过程,面向过程只是针对于自己来解决问题。面向过程的操作是以程序的基本功能实现为主,实现之后就完成了,也不考虑修改的可能性,面向对象,更多的是要进行子模块化的设计,每一个模块都需要单独存在,并且可以被重复利用,所以,面向对象的开发更像是一个具备标准的开发模式。

    在面向对象定义之中,也规定了一些基本的特征:
    (1)封装:保护内部的操作不被破坏;
    (2)继承:在原本的基础之上继续进行扩充;
    (3)多态:在一个指定的范围之内进行概念的转换。

    对于面向对象的开发来讲也分为三个过程:OOA(面向对象分析)、OOD(面向对象设计)、OOP(面向对象编程)。

    二、类与对象的基本概念

    类与对象时整个面向对象中最基础的组成单元。

    :是抽象的概念集合,表示的是一个共性的产物,类之中定义的是属性和行为(方法);
    对象:对象是一种个性的表示,表示一个独立的个体,每个对象拥有自己独立的属性,依靠属性来区分不同对象。

    可以一句话来总结出类和对象的区别:类是对象的模板,对象是类的实例。类只有通过对象才可以使用,而在开发之中应该先产生类,之后再产生对象。类不能直接使用,对象是可以直接使用的。

    三、类与对象的定义和使用

    在Java中定义类,使用关键字class完成。语法如下:

    class 类名称 {
             属性 (变量) ;
             行为 (方法) ;
    }

    范例:定义一个Person类

    class Person {     // 类名称首字母大写
        String name ;
        int age ;
        public void tell() {        // 没有static
              System.out.println("姓名:" + name + ",年龄:" + age) ;
             }
    }

    类定义完成之后,肯定无法直接使用。如果要使用,必须依靠对象,那么由于类属于引用数据类型,所以对象的产生格式(两种格式)如下:

    (1)格式一:声明并实例化对象

    类名称 对象名称 = new 类名称 () ;

    (2)格式二:先声明对象,然后实例化对象:

    类名称 对象名称 = null ;
    对象名称 = new 类名称 () ;

    引用数据类型与基本数据类型最大的不同在于:引用数据类型需要内存的分配和使用。所以,关键字new的主要功能就是分配内存空间,也就是说,只要使用引用数据类型,就要使用关键字new来分配内存空间。

    当一个实例化对象产生之后,可以按照如下的方式进行类的操作:
    对象.属性:表示调用类之中的属性;
    对象.方法():表示调用类之中的方法。

    范例:使用对象操作类

    package com.wz.classandobj;
    
    class Person { 
        String name ;
        int age ;
        public void get() {
            System.out.println("姓名:" + name + ",年龄:" + age);
        }
    }
    
    public class TestDemo {
            public static void main(String args[]) {
                Person per = new Person() ;// 声明并实例化对象
                per.name = "张三" ;//操作属性内容
                per.age = 30 ;//操作属性内容
                per.get() ;//调用类中的get()方法
            }
    }

    运行结果:

    姓名:张三,年龄:30

    以上完成了一个类和对象的操作关系,下面换另外一个操作来观察一下:

    package com.wz.classandobj;
    
    class Person { 
        String name ;
        int age ;
        public void get() {
            System.out.println("姓名:" + name + ",年龄:" + age);
        }
    }
    
    public class TestDemo {
            public static void main(String args[]) {
                Person per = null;//声明对象
                per = new Person() ;//实例化对象
                per.name = "张三" ;//操作属性内容
                per.age = 30 ;//操作属性内容
                per.get() ;//调用类中的get()方法
            }
    }

    运行结果:

    姓名:张三,年龄:30

    那么,问题来了,以上两种不同的实例化方式有什么区别呢?
    我们从内存的角度分析。首先,给出两种内存空间的概念:
    (1)堆内存:保存对象的属性内容。堆内存需要用new关键字来分配空间;
    (2)栈内存:保存的是堆内存的地址(在这里为了分析方便,可以简单理解为栈内存保存的是对象的名字)。

    1

    任何情况下,只要看见关键字new,都表示要分配新的堆内存空间,一旦堆内存空间分配了,里面就会有类中定义的属性,并且属性内容都是其对应数据类型的默认值。

    于是,上面两种对象实例化对象方式内存表示如下:
    这里写图片描述

    两种方式的区别在于①②,第一种声明并实例化的方式实际就是①②组合在一起,而第二种先声明然后实例化是把①和②分步骤来。

    另外,如果使用了没有实例化的对象,结果如何?
    如下:

    package com.wz.classandobj;
    
    class Person { 
        String name ;
        int age ;
        public void get() {
            System.out.println("姓名:" + name + ",年龄:" + age);
        }
    }
    
    public class TestDemo {
            public static void main(String args[]) {
                Person per = null;//声明对象
                //per = new Person() ;//实例化对象
                per.name = "张三" ;//操作属性内容
                per.age = 30 ;//操作属性内容
                per.get() ;//调用类中的get()方法
            }
    }

    运行结果:

    Exception in thread "main" java.lang.NullPointerException
        at com.wz.classandobj.TestDemo.main(TestDemo.java:15)

    此时,程序只声明了Person对象,但并没有实例化Person对象(只有了栈内存,并没有对应的堆内存空间),则程序在编译的时候不会出现任何的错误,但是在执行的时候出现了上面的错误信息。这个错误信息表示的是“NullPointerException(空指向异常)”,这种异常只要是应用数据类型都有可能出现。

    四、对象引用传递初步分析

    引用传递的精髓:同一块堆内存空间,可以同时被多个栈内存所指向,不同的栈可以修改同一块堆内存的内容。

    下面通过若干个程序,以及程序的内存分配图,来进行代码的讲解。

    我们来看一个范例:

    class Person {     
             String name ;
             int age ;
             public void tell() {        
                       System.out.println("姓名:" + name + ",年龄:" + age) ;
             }
    }
    public class TestDemo {
             public static void main(String args[]) {
                       Person per1 = new Person() ;         // 声明并实例化对象
                       per1.name = "张三" ;
                       per1.age = 20 ;
                       Person per2 = per1 ;  // 引用传递
                       per2.name = "李四" ;
                       per1.tell() ;
             }
    }

    对应的内存分配图如下:

    11

    再来看另外一个:

    class Person {
             String name ;
             int age ;
             public void tell() {
                       System.out.println("姓名:" + name + ",年龄:" + age) ;
             }
    }
    public class TestDemo {
             public static void main(String args[]) {
                       Person per1 = new Person() ;         // 声明并实例化对象
                       Person per2 = new Person() ;
                       per1.name = "张三" ;
                       per1.age = 20 ;
                       per2.name = "李四" ;
                       per2.age = 30 ;
                       per2 = per1 ;// 引用传递
                       per2.name = "王五" ;
                       per1.tell() ;
             }
    }

    对应的内存分配图如下:
    12

    垃圾:指的是在程序开发之中没有任何对象所指向的一块堆内存空间,这块空间就成为垃圾,所有的垃圾将等待GC(垃圾收集器)不定期的进行回收与空间的释放。

    未完待续。。。

    展开全文
  • Java是一种面向对象语言,java中的把方法与数据连接在一起,并构成了自包含式的处理单元。但在Java中不能定义基本类型(primitive type),为了能将基本类型视为对象来处理,并能连接相关的方法,Java为每个基本类型...
  • Java基本语法:java中方法与构造方法。 首先我们要先弄明白什么是是Java中最基本的组成单元,Java将描述一事物的属性(状态)功能(行为)封装在一起,属性用成员变量来刻画;功能通过方法来体现。...

    Java基本语法:java类中方法与构造方法。

    首先我们要先弄明白什么是类:

    类是Java中最基本的组成单元,Java将描述一类事物的属性(状态)和功能(行为)封装在一起,属性用成员变量来刻画;功能通过方法来体现。简单来说,类是一个模板,它描述一类对象的行为和状态。那么有了这这个描述我们对类的的人是就已经可以了。下面我们来看一下类的模板:

    public class Human{
      String name;
      int age;
      String skinColor;
      void barking(){
      }
    
      void hungry(){
      }
    
      void sleeping(){
      }
    }

    这里我们写了一个生动的例子,我们定义了一个Human的类,而这个类它里面有一些个方法,和属性。比如他有个name(属性),age(属性),skinColor(属性),hungry(方法)等。

    方法与构造方法:

    方法就是类他能干什么,比如人就会,吃,睡,玩。
    我们来看一下这个是例子:

    public class Puppy{
        public Puppy(){
        }
             //这是第一个构造方法。
        public Puppy(String name){
            // 这个构造方法仅有一个参数:name
        }
    }
    

    首先我们来看一下方法的结构:

    方法的访问权限 返回值 方法名(参数){

    }
    1.访问权限:public、protected、友好的和private,其中友好的默认为不加任何东西。
    2.返回值:如果我们定义了void,证明我们所写的方法没有返回值。那么如果我们想让方法返回一个值(也就是返回值),3.那么这里就应该写你想返回回来的数据类型。
    4.方法名:根据命名规则书写即可。

    构造方法:

    在这里必须要强调一下构造方法。上面给出的例子就是构造方法的。每个类都有构造方法。如果没有显式地为类定义构造方法,Java编译器将会为该类提供一个默认构造方法。在创建一个对象的时候,至少要调用一个构造方法。构造方法的名称必须与类同名,一个类可以有多个构造方法。
    特点:必须有,方法名与类名相同,没有返回值,不写时程序在编译时会自动生成一个返回值。
    我们在看一段程序:

    package com.zzxt.chx;
    
    public class Human {
        String name;
        public Human(String name) {
            this.name=name;
        }
        public Human(){
    
        }
        void walk(){
            System.out.println(name+"散步");
        }
    }
    

    这里我们着重看一下构造方法中的this,这个this所指的就是Human.name。

    static:

    1.可以修饰属性
    2.可以修饰方法
    3.可以单独使用

    有static搜秀是的变量为静态变量,由ststic修饰的方法为静态方法,他们可以直接使用:类名.静态变量/类名.静态方法。
    也就是想访问static所修饰的变量不需要经过实例化。
    更为重要的一点,就是静态变量是类所特有的,如果实例化后被某一个对象所赋值,那么之后的对象在想访问后,他的值会变成之前被赋值的值。
    我们看下面一段代码:

    package com.zzxt.chx;
    
     class Main{
        public static void main(String[] args) {
            jingtaibianliang d=new jingtaibianliang();
            jingtaibianliang d2=new jingtaibianliang();
            System.out.println(d.num1="静态变量赋值");
            System.out.println(d.num2="非静态变量赋值");
            System.out.println(d2.num1);
            System.out.println(d2.num2);
    
        }
    }
    class jingtaibianliang {
        static String num1="静态变量初始值";
        String num2="非静态变量初始值";
    }

    这里写图片描述

    展开全文
  • java基本类型包装器【转】

    千次阅读 2015-09-29 18:10:25
    简要讲述java基本类型包装类型,为装箱拆箱的学习做准备

    转自:http://blog.csdn.net/hugh1st/article/details/3478247  作者:hugh1st

    java是一种面向对象语言,java中的类把方法与数据连接在一起,并构成了自包含式的处理单元.但在java中不能定义基本类型(primitive type),为了能将基本类型视为对象来处理,并能连接相关的方法,java为每个基本类型都提供了包装类,这样,我们便可以把这些基本类型转化为对象来处理了.这些包装类有:Boolean,Byte,Short,Character,Integer,Long,Float,Double,Void共9个(注意:Date不是,无其基本类型).

    一、 包装类(Wrapper Class)共同的方法

    值得说明的是,java是可以直接处理基本类型的,但是在有些情况下我们需要将其作为对象来处理,这时就需要将其转化为包装类了.所有的包装类(Wrapper Class)都有共同的方法,他们是:

    (1)带有基本值参数并创建包装类对象的构造函数.如可以利用Integer包装类创建对象,Integer obj=new Integer(145);

    (2)带有字符串参数并创建包装类对象的构造函数.如new Integer("-45.36");

    (3)可生成对象基本值的typeValue方法,如obj.intValue();

    (4)将字符串转换为基本值的 parseType方法,如Integer.parseInt(args[0]);

    (5)生成哈稀表代码的hashCode方法,如obj.hasCode();

    (6)对同一个类的两个对象进行比较的equals()方法,如obj1.eauqls(obj2);

    (7)生成字符串表示法的toString()方法,如obj.toString().

    转换关系:

    基本类型------>包装器类
    Integer obj=new Integer(145);

    包装器类------>基本类型
    int num=obj.intValue();

    字符串------>包装器类
    Integer obj=new Integer("-45.36");

    包装器类------>字符串包装器类

    String str=obj.toString();

    字符串------>基本类型
    int num=Integer.parseInt("-45.36");

    基本类型------>字符串包装器类

    String str=String.valueOf(5);


            在一定的场合,运用java包装类来解决问题,能大大提高编程效率.

    二、JDK1.5的新特性:自动装包/拆包(Autoboxing/unboxing)

      自动装包/拆包大大方便了基本类型数据和它们包装类地使用。

      自动装包:基本类型自动转为包装类.(int >> Integer)

      自动拆包:包装类自动转为基本类型.(Integer >> int)

      在JDK1.5之前,我们总是对集合不能存放基本类型而耿耿于怀,现在自动转换机制
    解决了我们的问题。

    int a = 3;
    Collection c = new ArrayList();
    c.add(a);//自动转换成Integer.

    Integer b = new Integer(2);
    c.add(b + 2);

      这里Integer先自动转换为int进行加法运算,然后int再次转换为Integer.

    三、包装类(Wrapper Class)常用其他方法

    String类:



    展开全文
  • java基本类型包装器

    千次阅读 2008-12-08 18:48:00
    java是一种面向对象语言,java中的把方法与数据连接在一起,并构成了自包含式的处理单元.但在java中不能定义基本类型(primitive type),为了能将基本类型视为对象来处理,并能连接相关的方法,java为每个基本类型都提供...
  • Java抽象 详解

    万次阅读 多人点赞 2016-10-05 00:06:35
    一、抽象基本概念普通是一个完善的功能,可以直接产生实例化对象,并且在普通中可以包含有构造方法、普通方法、static方法、常量变量等内容。而抽象是指在普通的结构里面增加抽象方法的组成部分。...
  • Java教程专栏:https://blog.csdn.net/qq_41806966/category_9929686.html 这篇讲String,会让大家了解一下什么是字符串,以及常用操作,了解对象以及...String 是Java中的一个( class ) 是一种引用类型,比如我们使用
  • java 基本数据类型包装

    千次阅读 2007-04-18 08:51:00
    java是一种面向对象语言,java中的把方法与数据连接在一起,并构成了自包含式的处理单元.但在java中不能定义基本类型(primitive type),为了能将基本类型视为对象来处理,并能连接相关的方法,java为每个基本类型都提供...
  • 掌握Java语言的基本组成、基本数据类型、变量 定义、数组、流程控制语句 掌握的定义、对象的创建、方法的构造与重载 理解的继承、超类子类、抽象
  • Java对象与Java类

    千次阅读 多人点赞 2021-07-28 22:23:35
    对象与引用基本类型引用类型的区别:值传递与引用传递8.static关键字概念static属性static方法代码块9.的加载执行10.包包的概念:包的作用:包(package)的命名规范:访问权限修饰符11.面向对象语言的三大特征1....
  • Java中的基本操作单元 - 类和对象

    千次阅读 多人点赞 2020-02-26 18:51:25
    说到类和对象,这都是两个比较抽象的词,如果用在程序中,那就更不知道是什么意思了。其实大家可以先不联系程序,我们在对一大堆东西分类的时候自然是有一个标准的,符合某些特征的分到一,符合另外一些特征的分到...
  • java组成部分

    2020-12-03 21:03:42
    成员变量可以使用Java语言中任何一种数据类型(包括基本类型引用类型)。 在定义成员变量时可以对其初始化,如果不对其初始化,Java使用默认的值对其初始化。 成员变量在创建对象的时候会从中复制一份到对象中。...
  • Java中Kafka的基本使用

    千次阅读 2020-05-14 15:40:09
    由Apache软件基金会开发的一个开源流处理平台,由Scala和Java编写。Kafka是一种高吞吐量的分布式发布订阅消息系统,它可以处理消费者在网站中的所有动作流数据。 这里测试的环境是基于之前写的springcloud项目,博客...
  • 1、java程序基本构成 (1)public class 是 java中的关键字,表示定义的是一个,在java中所有的操作都是由类组成的。 (2)在java中声明一个的方式有两种,即public class名称 class名称。 (3)使用...
  • java 基本类型常量讲解

    千次阅读 2016-11-17 15:39:32
    基本类型或者叫做内置类型,是Java中不同于的特殊类型。java采用与C/C++相同的方法,不用new来创建基本类型的变量,而是创建一个并非是引用的变量,这个变量直接存储“值”,并置于栈中,因此效率更高。1. Java的...
  • Java 有一个由两部分组成的类型系统,包括基本类型(如 int、double boolean)引用类型(如 String List)。每个基本类型都有一个对应的引用类型,称为包装类型。与 int、double boolean 对应的包装是 ...
  • Java链表的基本使用

    万次阅读 多人点赞 2018-11-06 18:29:25
    但是数组本身有一个缺点—— 数组的长度固定,不可改变,在长度固定的情况下首选的肯定是数组,但是在现实的开发之中往往要保存的内容长度是不确定的,那么此时就可以利用链表这样的结构来代替数组的使用。...
  • Java基本语法

    千次阅读 多人点赞 2019-08-20 16:01:41
    Java对各种变量,方法和类等要素命名时使用的字符序列称为标识符 规则 1.标识符由字母,下划线,美元符或数字组成 2.标识符应由字母,下划线,美元符开头 3.Java标识符大小写敏感,长度没有限制 注:Java标识符要见...
  • 一个Java应用,不论简单还是复杂,都是由若干个Java类组成的。因此,对于初学者,先了解Java类组成是必要的。 Java类组成主要有3部分:数据成员、构造方法、方法成员。 首先看下边的代码,是一个简单
  • 使用Notepad开发java基本步骤

    千次阅读 2018-03-21 16:05:59
    1.hello world开发环境:在Notepad++跟着菜鸟教程...把文件名保存为:HelloWorld.java;打开cmd命令窗口,进入目标文件所在的位置,假设是C:\在命令行窗口键入 javac HelloWorld.java ...
  • Java常用集合框架的基本接口

    千次阅读 2016-10-09 16:38:59
    Java中有一套设计优良的接口和类组成Java集合框架,使程序员操作成批的数据或对象元素极为方便。所有的Java集合都在java.util包中。 (1)、List接口及其实现类 List接口继承于Collection接口。 List接口...
  • JAVA基本语法结构

    2013-09-14 21:57:59
    Java程序的基本组成元素 Java基本数据类型、变量与常量 运算符与表达式 算法的基本控制结构 数组 向量
  • Java中的方法和类详解

    万次阅读 2019-10-18 18:31:50
    方法和类详解控制类成员函数的访问向方法传递对象返回对象方法重载重载构造函数递归static关键字static代码块嵌套类和内部类varargs(可变长度实参) 控制类成员函数的访问 Java中的访问控制符有三个: public:...
  • 基本组成

    千次阅读 2018-09-15 10:50:08
    基本组成Java中了是所有Java应用程序的构建快,应用程序的所有内容都应该放在中。 一个Java源程序是由一个或多个组成的,但只有一个public修饰的定义,此时保存源程序的文件名与该名相同,扩展...
  • Java八种基本数据类型(图文详解)

    万次阅读 多人点赞 2020-07-02 22:54:55
    Java八种基本数据类型Java八种数据类型Java八种数据类型的分类(图)基本数据类型分为三大①数值型②字符型③布尔型数值型整数类型(byte,short,int,long)浮点型(float,double)字符型(char)布尔类型(boolean)...
  • Java中Date类和Calendar

    千次阅读 2013-12-17 14:25:37
    前言 写后台程序的时候,经常需要存储当前服务器的时间戳,使用时间戳也很方便,客户端服务器端都可以根据...Java语言中的Calendar,Date,DateFormat组成Java标准的一个基本但是非常重要的部分。日期是商业逻辑

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 487,504
精华内容 195,001
关键字:

java类的基本组成和使用

java 订阅