精华内容
下载资源
问答
  • Java修饰符类型(public、protected、private)小结
    2021-02-13 01:18:33

    Java修饰符号类型:

    public:Java语言中访问限制最宽的修饰符,一般称之为“公共的”。被其修饰的类、属性以及方法不仅可以跨类访问,而且允许跨包(package)访问。

    private:Java语言中对访问权限限制的最窄的修饰符,一般称之为“私有的”。被其修饰的类、属性以及方法只能被该类的对象访问,其子类不能访问,更不能允许跨包访问。

    protected:介于public 和 private 之间的一种访问修饰符,一般称之为“保护形”。被其修饰的类、属性以及方法只能被类本身的方法及子类访问,即使子类在不同的包中也可以访问。

    default:即不加任何访问修饰符,通常称为“默认访问模式“。该模式下,只允许在同一个包中进行访问。

    (一)类

    访问修饰符 修饰符 class 类名称 extends 父类名称 implement 接口名称

    (访问修饰符与修饰符的位置可以互换)

    访问修饰符

    名称

    说明

    备注

    public

    可以被所有类访问(使用)

    public类必须定义在类名相同的同名文件中

    package

    可以被同一个包中的类访问(使用)

    默认的访问权限,可以省略此关键字,可以定义在和public类的同一个文件中

    修饰符

    名称

    说明

    备注

    final

    使用此修饰符的类不能被继承

    abstract

    如果要使用abstract类,之前必须首先建一个继承abstract类的新类,新类中实现abstract类的抽象方法。

    类只要有一个abstract方法,类就必须定义为abstract类,但abstract类不一定非要保护abstract方法。

    (二)变量

    1、Java中没有全局变量,只有方法变量、实例变量(类中的非静态变量)、类变量(类中的静态变量)。

    2、方法中的变量不能够有访问修饰符。所以下面访问修饰符表仅针对于在类中定义的变量。

    3、声明实例变量时,如果没有赋初值,将被初始化为null(引用类型)或者0、false(原始类型)。

    4、可以通过实例变量初始化器来初始化较复杂的实例变量,实例变量初始化器是一个用{}包含的语句块,在类的构造器被调用时运行,运行于父类构造器之后,构造器之前。

    5、类变量(静态变量)也可以通过类变量初始化器来进行初始化,类变量初始化器是一个用static{}包含的语句块,只可能被初始化一次。

    访问修饰符

    名称

    说明

    备注

    public

    可以被任何类访问

    protected

    可以被同一包中的所有类访问;可以被所有子类访问,子类可跨包。

    子类没有在同一包中也可以访问

    private

    只能够被当前类的方法访问

    子类不能访问

    缺省

    可以被同一包中的所有类访问

    如果子类不是在同一个包中,则不可访问。

    修饰符

    名称

    说明

    备注

    static

    静态变量(又称为类变量,其他的称为实例变量)

    可以被类的所有实例共享

    final

    常值,值只能分配一次,不能更改

    注意不要使用const,虽然它和C、C++中的const关键字含义一样;可以同static一起使用,避免对类的每个实例维护一个拷贝。

    transient

    告诉编译器,在类对象序列化的时候,此变量不需要持久保存

    主要是因为改变量可以通过其它变量来得到,使用它是为了性能的问题

    volatile

    指出可能有多个线程修改此变量,要求编译器优化以保证对此变量的修改能够被正确的处理

    (三)方法

    访问修饰符 修饰符 返回类型 方法名称(参数列表)throws 违例列表

    1、类的构造器方法不能够有修饰符、返回类型和throws子句。

    2、类的构造器方法被调用时,它首先调用父类的构造器方法,然后运行实例变量和静态变量的初始化器,然后才运行构造器本身。(很重要)

    3、如果构造器方法没有显示的调用一个父类的构造器,那么编译器会自动为它加上一个默认的super(),而如果父类又没有默认的无参数构造器,编译器就会报错。super必须是构造器方法的第一个子句。(很重要)

    4、注意理解private构造器方法的使用技巧。

    访问修饰符

    名称

    说明

    备注

    public

    可以从所有类访问

    protected

    可以被同一包中的所有类访问;可以被所有子类访问。

    子类没有在同一个包中也可以访问

    private

    只能够被当前类的方法访问

    缺省

    可以被同一包中的所有类访问

    如果子类没有在同一个包中,也不能访问

    修饰符

    名称

    说明

    备注

    static

    静态方法(又称为类方法,其它的称为实例方法)

    提供不依赖于类实例的服务;并不需要创建类的实例就可以访问静态方法。

    final

    防止任何子类重载该方法

    注意不要使用const,虽然它和C、C++中的const关键字含义一样;可以同static一起使用,避免对类的每个实例维护一个拷贝。

    abstract

    抽象方法,类中已声明而没有实现的方法。

    不能将static方法、final方法或者类的构造器方法声明为abstract

    native

    用该修饰符定义的方法在类中没有实现,而大多数情况下该方法的实现是用C、C++编写的。

    参见Sun的Java Native接口(JNI),JNI提供了运行时加载一个native方法的实现,并将其于一个Java类关联的功能

    synchronized

    多线程的支持

    当一个此方法被调用时,没有其它线程能够调用该方法,其它的synchronized方法也不能调用该方法,直到该方法返回

    (四)接口

    访问修饰符 interface 接口名称 extends 接口列表

    1、接口不能够定义其声明的方法的任何实现。

    2、接口中的变量总是需要定义为“public static final 接口名称”,但可以不包含这些修饰符,编译器默认就是这样,显示的包含修饰符主要是为了程序清晰。

    访问修饰符

    名称

    说明

    备注

    public

    所有

    无访问修饰符

    同一个包内

    更多相关内容
  • 详解Java修饰符

    2020-08-31 21:14:34
    Java语言提供了很多修饰符,主要分为以下两类:访问修饰符;非访问修饰符修饰符用来定义类、方法或者变量,通常放在语句的最前端。我们通过下面的例子来说明,下面就跟小编一起来看下吧
  • 一文搞懂JAVA 修饰符

    2020-08-19 00:46:38
    主要介绍了JAVA 修饰符的的相关资料,文中代码非常详细,帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • java修饰符

    千次阅读 多人点赞 2019-09-11 01:01:43
    java修饰符 文章目录java修饰符java中的修饰符分类:一,权限修饰符:private, default, protected, publicprivate:default:protected:public:二,状态修饰符:static, finalstatic修饰符语法格式:特点static...

    java修饰符

    java中的修饰符分类:

    • 权限修饰符: private, default, protected, public
    • 状态修饰符: static, final
    • 抽象修饰符: abstract

    一,权限修饰符:private, default, protected, public

    private:

    如果实体使用private修饰符声明,那么实体将只能由定义实体的类中的包含的代码访问。它的访问权限仅限于类的内部,是一种封装的体现。这样,就不能从类的外边直接访问他们,我们提供set和get方法,保证类中数据域的安全。

    default:

    默认修饰符,什么都不加,实际上它限制的范围就是一个包内可以访问。如果不在一个包内,即使继承关系任然是不能访问的。它是针对本包访问而设计的,任何处于本包下的类,接口,异常等,都可以互相访问,即使是父类没有用protected修饰的成员也可以

    protected:

    经常需要允许子类访问定义在父类中的数据和方法,但是不允许非子类访问这些数据和方法,这种情况下就可以使用protected,它允许任何包中的子类访问父类。

    public:

    具有最大的访问权限,可以访问任何一个CLASSPATH下的类,接口、异常等。它往往对于对外的情况,也就是对象或类对外的一种接口形式。

    在这里插入图片描述

    二,状态修饰符:static, final

    static修饰符

    static的主要作用在于创建独立于具体对象的域变量或者方法。

    语法格式:

    修饰变量:static 数据类型 变量名

    修饰方法:【访问权限修饰符】 static 方法返回值 方法名(参数列表)

    特点

    static可以修饰变量,方法被static修饰的变量或者方法是独立于该类的任何对象,也就是说,这些变量和方法不属于任何一个实例对象,而是被类的实例对象所共享。

    在类被加载的时候,就会去加载被static修饰的部分。被static修饰的变量或者方法是优先于对象存在的,也就是说当一个类加载完毕之后,即便没有创建对象,也可以去访问。

    static静态变量

    static修饰的成员变量叫做静态变量,也叫做类变量,说明这个变量是属于这个类的,而不是属于是对象,没有被static修饰的成员变量叫做实例变量,说明这个变量是属于某个具体的对象的。

    静态变量与非静态变量的区别

    • 静态变量可以直接使用类名调用。

    • 静态变量被所有对象共享,在内存中只有一个副本,在类初次加载的时候才会初始化。

    • 静态变量一旦变化,所有的实例的静态变量值都会变化。

    • 非静态变量是对象所拥有的,在创建对象的时候被初始化,存在多个副本,各个对象拥有的副本互不影响

    • 非静态方法可以调用静态变量、静态方法和非静态变量、非静态方法。

    static静态方法

    • 被static修饰的方法也叫做静态方法,因为对于静态方法来说是不属于任何实例对象的,那么就是说在静态方法内部是不能使用this的。
    • 由于这个特性,在静态方法中不能访问类的非静态变量和非静态方法,因为非静态方法/变量都是须依赖具体的对象才能够被调用。
    • 在静态方法中不能访问非静态方法和非静态变量,但是在非静态方法中是可以访问静态方法/静态变量。

    final 修饰符

    final 关键字可以用于修饰类,方法和变量

    1、final关键字通常与static修饰符一起使用来创建类常量

    2、 final 修饰成员变量

    • 必须要赋初始值,而且是只能初始化一次。
    • 被fianl修饰的成员变量赋值,有两种方式:1、直接赋值 2、全部在构造方法中赋初值。
    • 如果修饰的成员变量是基本类型,则表示这个变量的值不能改变。
    • 如果修饰的成员变量是一个引用类型,则是说这个引用的地址的值不能修改,但是这个引用所指向的对象里面的内容还是可以改变的。

    3、final 关键字修饰方法时,则该方法不能被重写

    • 一个类的private方法会隐式的被指定为final方法。
    • 如果父类中有final修饰的方法,那么子类不能去重写。

    4、final 关键字修饰类时,该类不能被继承

    • 被final修饰的类,final类中的成员变量可以根据自己的实际需要设计为fianl。
    • final类中的成员方法都会被隐式的指定为final方法。

    三,抽象修饰符:abstract

    abstract修饰符

    用abstract关键字来修饰该类[抽象类],用abstract来修饰该方法[抽象方法]。

    抽象类:

    • 抽象类是为了把相同的但不确定的东西的提取出来,为了以后的重用。定义成抽象类的目的,就是为了在子类中实现抽象类。
    • 抽象类不能被实例化。因为抽象类中方法未具体化,除此之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样。
    • 由于抽象类不能实例化对象,所以抽象类必须被继承,才能被使用。
    • 抽象类中不一定要包含abstract方法。也就是抽象中可以没有abstract方法。

    抽象方法:

    • 用abstract来修饰该的抽象方法只包含一个方法名,不能有方法主体。
    • 抽象方法没有定义,方法名后面直接跟一个分号,而不是花括号。
    • 一旦类中包含了abstract方法,那类该类必须声明为abstract类。
    展开全文
  • Java修饰符.pdf

    2020-09-13 15:55:34
    整理了一下Java修饰符详解做成的思维导图,整理了一下Java修饰符详解做成的思维导图,整理了一下Java修饰符详解做成的思维导图,整理了一下Java修饰符详解做成的思维导图
  • Java有四种访问权限,其中三种有访问权限修饰符,分别为private,public和protected,还有一种不带任何修饰符,下面通过本文给大家简单介绍下java修饰符访问权限相关知识,感兴趣的朋友一起学习吧
  • java修饰符的使用.pdf

    2021-10-03 23:51:27
    java修饰符的使用.pdf
  • 以下是对Java修饰符abstract,static,final的区别进行了详细的介绍,需要的朋友可以过来参考下
  • 父子类可以是不同包 在不同包下面只有public 与 protected 可以访问,而且protected必须是在继承关系下才能够访问
  • java修饰符总结

    2014-02-27 13:26:31
    总结java修饰符,简单明了,作用很大哦,欢迎大家交流
  • java修饰符介绍

    2012-10-13 09:48:03
    java的各种权限介绍,表格形式,调理很清楚,忘了的时候看看很不错。
  • java练习题chp7 Key Point ●static ●final ●abstrac
  • 也是通过查阅网上资料,初略的整理了一下,(包含了final、static、abstract和访问修饰符public、protect、default、private)写成规范文档希望对有需要的提供些帮助
  • Java修饰符总结[汇编].pdf
  • java修饰符的使用[整理].pdf
  • Java修饰符demo

    2017-01-08 22:50:56
    java修饰符的基础知识介绍,Intellij项目demo 对应博客地址:http://blog.csdn.net/forgot2015/article/details/54236231
  • 该文件主要是测试初学者对java三个修饰符的理解是否完善,能很好的测试出测试者是否对三个java三个修饰符有很好的理解。
  • 主要介绍了Java 基础之修饰符关键词整理的相关资料,需要的朋友可以参考下
  • Java修饰符,抽象类

    千次阅读 2019-05-08 20:01:36
    final修饰符 final主要用法有以下四种: 一、用来修饰数据,包括成员变量和局部变量,该变量只能被赋值一次且它的值无法被改变。对于成员变量来讲,我们必须在声明时、构造方法或者初始化块中对它赋值; 1. public ...

    final修饰符
    final主要用法有以下四种:
    一、用来修饰数据,包括成员变量和局部变量,该变量只能被赋值一次且它的值无法被改变。对于成员变量来讲,我们必须在声明时、构造方法或者初始化块中对它赋值;

    1.	public class FinalMemberVariables {
    2.	    // final 修饰的实例变量
    3.	    // 必须在非静态初始化块、声明该实例变量或构造器中指定初始值,
    4.	
    5.	    //声明该实例变量指定初始值
    6.	    final int INT_A=10;
    7.	    //初始化块指定初始值
    8.	    final int INT_B;
    9.	    {
    10.	
    11.	        INT_B=11;
    12.	    }
    13.	    final int INT_C;
    14.	    //构造器中指定初始值
    15.	    public FinalMemberVariables(){
    16.	        INT_C=12;
    17.	    }
    18.	
    19.	    //final 修饰 类变量
    20.	    //必须在静态初始化块中指定初始值或声明该类变量时指定初始值,
    21.	    final static String STR_A="123";
    22.	    final static String STR_B;
    23.	    static{
    24.	        STR_B="123456";
    25.	    }
    26.	}
    

    二、用来修饰局部变量,表示在变量的生存期中它的值不能被改变、

    1.	/**
    2.	 * final 修饰 局部变量
    3.	 * @author sxj
    4.	 *
    5.	 */
    6.	public class FinalLocalVariable {
    7.	    //final修饰局部变量时,既可以在定义时指定默认值,也可以不指定默认值。
    8.	    public static void main(String[] args) {
    9.	
    10.	        //在定义时指定默认值
    11.	        //不能再后面的代码中为变量赋值
    12.	        final int INT_A=10;
    13.	        //下面的赋值语句非法
    14.	        //INT_A=12;
    15.	
    16.	        //定义时不指定默认值
    17.	        //可以在后面的代码中赋值一次
    18.	        final String STR_A;
    19.	        STR_A="123";
    20.	        //下面的赋值语句非法
    21.	        //STR_A="456";
    22.	    }
    23.	
    24.	
    25.	    public void test(final int num){
    26.	        // 不能对final修饰的形参赋值
    27.	        //num=10;
    28.	    }
    29.	}
    

    三、修饰方法,表示该方法无法被重写;

    1.	/**
    2.	 * final 修饰的方法不能被重写Override
    3.	 * @author sxj
    4.	 *
    5.	 */
    6.	public class FinalMethod {
    7.	    public void print(){
    8.	        System.out.println("FinalMethod---print方法");
    9.	    }
    10.	
    11.	    public final void finalPrint() {
    12.	        System.out.println("FinalMethod--finalPrint方法");
    13.	    }
    14.	}
    15.	
    16.	
    17.	class FinalMethodTow extends FinalMethod{
    18.	    public void print(){
    19.	        System.out.println("FinalMethodTow--print方法");
    20.	    }
    21.	
    22.	    //下面的代码有错误,无法重写final修饰的方法
    23.	//    public void finalPrint() {
    24.	//        System.out.println("FinalMethodTow--finalPrint方法");
    25.	//    }
    26.	}
    

    四、 修饰类,表示该类无法被继承。

    1.	/**
    2.	 * final 修饰的类不能被继承
    3.	 * @author sxj
    4.	 *
    5.	 */
    6.	public final class FinalClass {
    7.	    int age=10;
    8.	}
    9.	
    10.	//classDemo2 无法继承 FinalClass
    11.	//class classDemo2 extends FinalClass{
    12.	//
    13.	//}
    

    Java 抽象类
    在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。
    抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法、初始化块和构造方法和普通类一样。
    由于抽象类不能实例化对象,所以抽象类必须被继承,才能被使用。
    一、抽象方法
    抽象方法只包含一个方法名,而没有方法体,使用abstract修饰。
    格式:

    1. [修饰符] abstract 返回类型 方法名();
      • 修饰符 (public protected private)三选一
      二、示例代码
    1.	public abstract class Animal {
    2.	
    3.	    //成员变量
    4.	    protected int weight =0;
    5.	
    6.	    {
    7.	        System.out.println("初始化块");
    8.	    }
    9.	    //构造器
    10.	    public Animal(){
    11.	        System.out.println("Animal 的构造器");
    12.	    }
    13.	
    14.	    public Animal(int weight) {
    15.	        this.weight=weight;
    16.	        System.out.println("Animal 的构造器");
    17.	    }
    18.	
    19.	    // 定义一个普通方法 休息
    20.	    public void sleep() {
    21.	        System.out.println("休息");
    22.	    }
    23.	
    24.	
    25.	    //抽象方法 没有方法体
    26.	    public abstract void running();
    27.	
    28.	    public abstract String sayWeiget();
    29.	}
    

    三、总结

    1. 抽象类必须使用abstract修饰符来修饰,
      抽象方法也必须使用abstract修饰符来修饰,
      抽象方法不能有方法体。
    2. 抽象类不能被实例化,
      无法使用new关键字来调用抽象类的构造器创建抽象类的实例。
    3. 抽象类可以包含成员变量、
      方法(普通方法和抽象方法都可以)、
      构造器、初始化块、
      内部类(接 口、枚举)5种成分。
    4. 抽象类的构造器不能用于创建实例,主要是用于被其子类调用。
    5. 抽象类中不一定包含抽象方法,但是有抽象方法的类必定是抽象类
    6. abstract static不能同时修饰一个方法
    展开全文
  • Java 修饰符

    千次阅读 2020-01-02 18:45:28
    Java 修饰符 Java语言提供了很多修饰符,主要分为以下两类: 访问修饰符 非访问修饰符 访问控制修饰符 Java中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。 ...

    Java 修饰符

    Java语言提供了很多修饰符,主要分为以下两类:

    • 访问修饰符
    • 非访问修饰符

    访问控制修饰符

    Java中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

    • default (即默认,什么也不写): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。
    • private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)
    • public : 对所有类可见。使用对象:类、接口、变量、方法
    • protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)。

    帮助理解:

    • public:在当前类 ,同一包内,子孙类(同一包),子孙类(不同包),其他包中都是可以访问到的
    • protected ::在当前类 同一包内 ,子孙类(同一包),子孙类(不同包)可以访问到的,其他包是不可以的
    • default当前类 同一包内 ,子孙类(同一包)可以访问到的, 子孙类(不同包)和其他包是不可以的
    • private当前类可以访问到,同一包内,子孙类(同一包),子孙类(不同包)和其他包都是不可以访问到的

    1:默认访问修饰符-不使用任何关键字

    //变量和方法的声明可以不使用任何修饰符。
    	void demo(){
    		int i=10;
    	}
    

    2:私有访问修饰符-private*

    私有访问修饰符是最严格的访问级别,所以被声明为 private 的方法、变量和构造方法只能被所属类访问,并且类和接口不能声明为 private。
    声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。
    
    public class NameDemo {
       private String name;
       public String getName() {
          return this.name;
       }
       public void setName(String name) {
          this.name = name;
       }
    }
    

    代码NameDemo这个类中,name是一个私有变量,其他类不可以直接访问赋值,那么类中提供了两个public修饰的方法,可以使外部类访问到

    3:公有访问修饰符-public
    被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。

    4:受保护的访问修饰符-protected(修饰符中比较需要注意的)

    在这里推荐一片文章,菜鸟驿站,Java protected 关键字详解

    非访问修饰符

    static 修饰符

    1. 静态变量

    static变量也称作静态变量。静态变量和非静态变量的区别是:静态变量被所有的对象所共享,在内存中只有一个副本,它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的,在创建对象的时候被初始化,存在多个副本,各个对象拥有的副本互不影响。

    1. 静态方法

    static方法一般称作静态方法,由于静态方法不依赖于任何对象就可以进行访问,因此对于静态方法来说,是没有this的,因为它不依附于任何对象。并且由于这个特性,在静态方法中不能访问类的非静态成员变量和非静态成员方法,因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。但是在非静态成员方法中是可以访问静态成员方法/变量的。

    final 修饰符

    1. final变量:被 final 修饰的实例变量必须显式指定初始值,被修饰并赋值后不能再重新赋值
    //final 修饰符通常和 static 修饰符一起使用来创建类常量。
    public static final int a=10;
    
    • final 方法:被final修饰的方法是可以被继承,但是不能重写

    abstract 修饰符

    • 抽象类:不能用来实例化对象,声明抽象类的唯一目的是为了将来对该类进行扩充。

    • 特别注意一个类不能同时被 abstract 和 final 修饰

    抽象方法

    • 没有任何实现的方法,该方法的的具体实现由继承类提供。
    • 抽象方法不能被声明成 final 和 static。
    • 任何继承抽象类的子类必须实现父类的所有抽象方法,除非该子类也是抽象类。
    • 如果一个类包含多个抽象方法,那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

    synchronized 修饰符

    • synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。
    展开全文
  • Java修饰符

    千次阅读 2022-03-11 16:37:25
    Java入门之修饰符 一、引入包(前提) 1.1 包的概述和使用 包的本质其实就是文件夹 作用:对项目中的类进行分类管理 1.2 包的定义的格式 格式:package 包名;(多级包用.分开) 范例:package ...
  • 主要介绍了Java的访问修饰符与变量的作用域讲解,是Java入门学习中的基础知识,需要的朋友可以参考下
  • java权限修饰符

    2022-01-09 19:41:02
    修饰符 权限修饰符:private<defult<protected<public 二.private关键字 三.defult关键字 四.protected关键字 1.作用域 可跨包,在不同包的具有继承关系的类可见,子类的对象可用。 同级目录下不同...
  • 本小节详细介绍了 Java 访问修饰符。它们控制 Java 类及其成员(函数和数据)的可见性。它们是公共的、私有的和受保护的。 但是,当没有修饰符存在时,Java 也实现了默认情况。这意味着一个类、它的函数、字段只能...
  • Java 默认修饰符 总结

    2021-02-28 12:44:41
    Java 默认修饰符总结1.类(class)可见性修饰符:public—在所有类中可见,在其他包中可以用import导入。缺省—就是没有修饰符,在同一个包中的类中可见,在其他包中不能用import导入。修饰符:final—终态类,表示该...
  • 本文通过实例向我们展示了java中final修饰符的概念,final修饰的基本变量和引用类型变量的区别。有需要的小伙伴可以参考下
  • Java修饰符总结

    2013-01-02 20:00:35
    主要对Java的主要修饰符进行分析,相关特点与用法。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 311,673
精华内容 124,669
关键字:

java修饰符

java 订阅