下列说法正确的是（）_

嶷如秋山·令出不返

形参在方法内部类只能用final修饰，其他都不行

值传递：方法调用时，实际参数把它的值传递给对应的形式参数，方法执行中形式参数值的改变不影响实际参数的值。

引用传递：也称为传地址。方法调用时，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，方法执行中形式参数值的改变将会影响实际参数的值。

发表于 2017-08-26 21:51:46 回复(2)

李李李

分类

Java语言提供了很多修饰符，大概分为两类：

1. 访问权限修饰符

2. 非访问权限修饰符

访问权限修饰符

public：共有访问。对所有的类都可见。
protected：保护型访问。对同一个包可见，对不同的包的子类可见。
default：默认访问权限。只对同一个包可见，注意对不同的包的子类不可见。
private：私有访问。只对同一个类可见，其余都不见。

非访问权限修饰符

static 修饰符，用来创建类方法和类变量。
final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
abstract 修饰符，用来创建抽象类和抽象方法。
synchronized 用于多线程的同步。
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
transient：序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。

类

外部类修饰符

public（访问控制符），将一个类声明为公共类，它可以被任何对象访问，一个程序的主类必须是公共类。
default（访问控制符），类只对包内可见，包外不可见。
abstract（非访问控制符），将一个类声明为抽象类，抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充，抽象类可以包含抽象方法和非抽象方法。。
final（非访问控制符），将一个类生命为最终（即非继承类），表示它不能被其他类继承。

注意：

1.protected 和 private 不能修饰外部类，是因为外部类放在包中，只有两种可能，包可见和包不可见。

2. final 和 abstract不能同时修饰外部类，因为该类要么能被继承要么不能被继承，二者只能选其一。

3.不能用static修饰类，因为类加载后才会加载静态成员变量。所以不能用static修饰类和接口，因为类还没加载，无法使用static关键字。

内部类修饰符

内部类与成员变量地位一直，所以可以public,protected、default和private，同时还可以用static修饰，表示嵌套内部类，不用实例化外部类，即可调用。

方法修饰符

public（公共控制符），包外包内都可以调用该方法。
protected（保护访问控制符）指定该方法可以被它的类和子类进行访问。具体细节可参考：http://blog.csdn.net/dawn_after_dark/article/details/74453915
default(默认权限），指定该方法只对同包可见，对不同包（含不同包的子类）不可见。
private（私有控制符）指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类），非常严格的控制。
final ,指定方法已完备，不能再进行继承扩充。
static，指定不需要实例化就可以激活的一个方法，即在内存中只有一份，通过类名即可调用。
synchronize，同步修饰符，在多个线程中，该修饰符用于在运行前，对它所属的方法加锁，以防止其他线程的访问，运行结束后解锁。
native，本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。
abstract ,抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。抽象方法不能被声明成 final 和 static。任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。抽象方法的声明以分号结尾，例如：public abstract sample();。

成员变量修饰符

public（公共访问控制符），指定该变量为公共的，它可以被任何对象的方法访问。
protected（保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。
default(默认权限），指定该变量只对同包可见，对不同包（含不同包的子类）不可见。
private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。
final，最终修饰符，指定此变量的值不能变。
static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。
transient（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。不持久化。
volatile（易失修饰符）指定该变量可以同时被几个线程控制和修改，保证两个不同的线程总是看到某个成员变量的同一个值。

final 和 static 经常一起使用来创建常量。

局部变量修饰符

only final is permitted。

为什么不能赋予权限修饰符？

因为局部变量的生命周期为一个方法的调用期间，所以没必要为其设置权限访问字段，既然你都能访问到这个方法，所以就没必要再为其方法内变量赋予访问权限，因为该变量在方法调用期间已经被加载进了虚拟机栈，换句话说就是肯定能被当前线程访问到，所以设置没意义。

为什么不能用static修饰

我们都知道静态变量在方法之前先加载的，所以如果在方法内设置静态变量，可想而知，方法都没加载，你能加载成功方法内的静态变量？

接口

接口修饰符

接口修饰符只能用public、default和abstract。

不能用final、static修饰。

接口默认修饰为abstract。

接口中方法修饰符

only public & abstract are permitted 。

意思只能用 public abstract修饰，当然如果你什么都不写，默认就是public abstract。

注意：在Java1.8之后，接口允许定义static 静态方法了！所以也可以用static来修饰！

发表于 2017-10-23 13:20:22 回复(53)

zhisheng_blog

排除法，最后选的D

发表于 2017-05-18 23:30:58 回复(0)

_1651

形式参数可被视为local variable(局部变量)

发表于 2021-06-09 08:11:11 回复(0)

我要变大神

给大家解释一下什么是形参和实参，从网上找了一个例子

1.形式参数：就是调用的方法中需要输入的参数。

public static void add(int x,int y){
int c;
c=x+y;
System.out.println©;
}

这个为自己构建一个方法,其中参数x和y就是形式参数，切记这里的变量c，它是变量，不是参数，这个容易混淆。

2.实际参数：方法调用时属于的参数。

public static void main(String[] args){
int a=5;
int b=6;
add(a,b);
}

在这里，a和b就是实际参数。
————————————————
版权声明：本文为CSDN博主「Lee_cg」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Lee_cg/article/details/100057488

发表于 2021-04-18 00:03:32 回复(0)

蝶语星辰梦

形式参数只能被final修饰，用其他修饰符编译器会报错

方法被调用时真正传入的参数是形参的副本

编辑于 2020-08-11 08:01:55 回复(0)

Luv_violet

B选项不奇怪吗？形参不可以是对象。

形参怎么可以是对象？B说法没错吧

如果B是：形参不可以是引用类型，那这题的答案我觉得就没问题

发表于 2020-05-04 11:43:15 回复(0)

Rogerofit

分类 Java语言提供了很多修饰符，大概分为两类： 1. 访问权限修饰符 2. 非访问权限修饰符访问权限修饰符 public：共有访问。对所有的类都可见。 protected：保护型访问。对同一个包可见，对不同的包的子类可见。 default：默认访问权限。只对同一个包可见，注意对不同的包的子类不可见。 private：私有访问。只对同一个类可见，其余都不见。非访问权限修饰符 static 修饰符，用来创建类方法和类变量。 final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。 abstract 修饰符，用来创建抽象类和抽象方法。 synchronized 用于多线程的同步。 volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。 transient：序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。类外部类修饰符 public（访问控制符），将一个类声明为公共类，它可以被任何对象访问，一个程序的主类必须是公共类。 default（访问控制符），类只对包内可见，包外不可见。 abstract（非访问控制符），将一个类声明为抽象类，抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充，抽象类可以包含抽象方法和非抽象方法。。 final（非访问控制符），将一个类生命为最终（即非继承类），表示它不能被其他类继承。注意： 1.protected 和 private 不能修饰外部类，是因为外部类放在包中，只有两种可能，包可见和包不可见。 2. final 和 abstract不能同时修饰外部类，因为该类要么能被继承要么不能被继承，二者只能选其一。 3.不能用static修饰类，因为类加载后才会加载静态成员变量。所以不能用static修饰类和接口，因为类还没加载，无法使用static关键字。内部类修饰符内部类与成员变量地位一直，所以可以public,protected、default和private，同时还可以用static修饰，表示嵌套内部类，不用实例化外部类，即可调用。方法修饰符 public（公共控制符），包外包内都可以调用该方法。 protected（保护访问控制符）指定该方法可以被它的类和子类进行访问。具体细节可参考：http://blog.csdn.net/dawn_after_dark/article/details/74453915 default(默认权限），指定该方法只对同包可见，对不同包（含不同包的子类）不可见。 private（私有控制符）指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类），非常严格的控制。 final ,指定方法已完备，不能再进行继承扩充。 static，指定不需要实例化就可以激活的一个方法，即在内存中只有一份，通过类名即可调用。 synchronize，同步修饰符，在多个线程中，该修饰符用于在运行前，对它所属的方法加锁，以防止其他线程的访问，运行结束后解锁。 native，本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。 abstract ,抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。抽象方法不能被声明成 final 和 static。任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。抽象方法的声明以分号结尾，例如：public abstract sample();。成员变量修饰符 public（公共访问控制符），指定该变量为公共的，它可以被任何对象的方法访问。 protected（保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。 default(默认权限），指定该变量只对同包可见，对不同包（含不同包的子类）不可见。 private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。 final，最终修饰符，指定此变量的值不能变。 static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。 transient（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。不持久化。 volatile（易失修饰符）指定该变量可以同时被几个线程控制和修改，保证两个不同的线程总是看到某个成员变量的同一个值。 final 和 static 经常一起使用来创建常量。局部变量修饰符 only final is permitted。为什么不能赋予权限修饰符？因为局部变量的生命周期为一个方法的调用期间，所以没必要为其设置权限访问字段，既然你都能访问到这个方法，所以就没必要再为其方法内变量赋予访问权限，因为该变量在方法调用期间已经被加载进了虚拟机栈，换句话说就是肯定能被当前线程访问到，所以设置没意义。为什么不能用static修饰我们都知道静态变量在方法之前先加载的，所以如果在方法内设置静态变量，可想而知，方法都没加载，你能加载成功方法内的静态变量？接口接口修饰符接口修饰符只能用public、default和abstract。不能用final、static修饰。接口默认修饰为abstract。接口中方法修饰符 only public & abstract are permitted 。意思只能用 public abstract修饰，当然如果你什么都不写，默认就是public abstract。注意：在Java1.8之后，接口允许定义static 静态方法了！所以也可以用static来修饰！

发表于 2019-03-17 15:37:20 回复(1)

加班的卡夫卡

答案：D

在Java中修饰符总共有一下几种：

1.访问控制修饰符
分别有：public private protected,缺省

2.其它修饰符

分别有：abstract,final,static,native,synchronized,transient,volatile等

对于形式参数只能用final修饰符，其它任何修饰符都会引起编译器错误。但是用这个修饰符也有一定的限制，就是在方法中不能对参数做任何修改。

不过一般情况下，一个方法的形参不用final修饰。只有在特殊情况下，那就是：方法内部类。

一个方法内的内部类如果使用了这个方法的参数或者局部变量的话，这个参数或局部变量应该是final。

通过以上分析，你应该知道答案了吧。

因为字段修饰符包括很多（上面写的），但是方法修饰符只能用final这一个修饰符。

所以说这句话不对。

参数可以是值也可以是对象，且实参才是真正被传递的参数，形参就像局部变量

发表于 2016-12-06 09:54:18 回复(3)