java接口的修饰符（java中接口和抽象类以及它们的属性方法都分别可以用什么访问修饰符）

本文目录

• java中接口和抽象类以及它们的属性方法都分别可以用什么访问修饰符
• java中的interface的修饰符可以是为什么不可以是protected
• 在使用interface声明一个接口时，只可以使用（ ）修饰符修饰该接口
• java 重写接口中的方法，为什么必须在前加public呢
• 请问java中接口的修饰符是必须是public的吗
• java接口interface的数据类型有哪些修饰符
• 接口中所有数据域的修饰符
• java中修饰符有哪些

java中接口和抽象类以及它们的属性方法都分别可以用什么访问修饰符

【Java接口修饰符是public abstract】

接口就是提供一种统一的”协议”，而接口中的属性也属于“协议”中的成员。它们是公共的，静态的，最终的常量。相当于全局常量。抽象类是不“完全”的类，相当于是接口和具体类的一个中间层。即满足接口的抽象，也满足具体的实现。

接口中不可以定义变量即定义的变量前都要加上final修饰，使之成为常量(没有final修饰的是变量，加上final修饰就会变成常量)。所以接口的属性默认是public static final 常量，且必须赋初值。

【抽象类】

abstract抽象

1、修饰类时为抽象类，即为概念类，不能实例化；

2、修饰的方法为抽象方法，该方法没有方法体，必须由子类实现，若没有实现会报错；

3、子类若为抽象类，则其中的抽象方法可不实现；

注：抽象类可以没有抽象方法，但抽象方法所在的类必须为抽象类

【抽象类和接口的相同点和区别】

1、抽象类是创建一个体现某些基本行为的类，并声明各种方法但不实现该类，这点与接口类似；但区别是抽象类中可以有抽象方法和非抽象方法，接口中的方法都为抽象方法；

2、抽象类中不能有抽象构造方法和抽象静态方法；

3、接口中的变量只能定义static  final的成员变量；

4、抽象类和接口中的抽象方法必须全部实现；

5、子类只能继承一个抽象类，接口的实现可实现多个接口；

java中的interface的修饰符可以是为什么不可以是protected

java中的interface的修饰符不能是protected，这违反了设计的原则，接口本身就应该对外界开放的：
接口中的方法默认的都是public的，这是接口的一种规范
public的才能被实现
接口中定义的字段也只会是static final的
网上有人打了个比方：
接口是用来定义一种（对象之间的）交互规范的，当然必须是public的。打个比方。你说我要修一个房子，就订一个规则，在房子左边必须有一个小门，用来送垃圾出去。收垃圾的人就知道了该从这个门进来收垃圾。可是你不告诉大家这个门是用来送垃圾的，收垃圾的人就不会知道。

在使用interface声明一个接口时，只可以使用（ ）修饰符修饰该接口

在使用interface声明一个接口时，只可以使用（public）修饰符修饰该接口。

接口的声明，修饰符的使用和类的声明是一致的，（当前，前提类是外部类，不是所谓的内部类），都只能使用public或者什么都不写。

默认权限（这里的默认权限不是default，可以理解为friendly，但是java没有这个关键字，但权限上可以理解为default），无论是private还是protected都是不可以的。 

关于修饰符大小的说明：public》protected》默认》private。

扩展资料

不写修饰符就默认是public了，接口的声明不写修饰符就是default权限，只能同包的类可以访问，其他包是不行的，不信试试看。其次虽然protected权限要比默认权限高，但是对于类或者接口的声明却不能使用，可以简单这么理解。

一个外部类或者接口，它的上一层结构是包，因此他们只有两个作用域：同包，任意位置。除此之外的权限没有任何意义，而基于此，public和默认权限就是足够的了，不需要使用protected这种多余的权限造成更为复杂的类关系，因此java限制了类或接口的声明，就仅限于public和默认。

百度百科——interface

java 重写接口中的方法，为什么必须在前加public呢

java中接口方法不管是否加了修饰符都是public。因此在实现的时候修饰范围不能缩小，只能是public。
比如：
public interface A{//定义一个接口
void show();//没有修饰符，默认修饰符是public
public void show1();//显示定义修饰符是public
}
public class A1 implements A{
public void show(){//不能缩小使用范围，原来定义的是public，现在只能是public
}
public void show1(){//不能缩小使用范围，原来定义的是public，现在只能是public
}
}

请问java中接口的修饰符是必须是public的吗

接口中只能有常量和抽象方法，必须是public的，即使你没有写全，系统也会默认补上：
public static final
public abstract
接口和实现类是可以写在一起的，接口本身的修饰符可以是default和public。

java接口interface的数据类型有哪些修饰符

接口中的变量必须都是公有的，静态的常量，即可以用 public static final 这些关键字修饰。
在接口中你可以不用这些关键字修饰，只要是在接口中声明变量，默认就是（即你加不加关键字修饰，系统都认为是公有的静态的常量）。

1. public

2. static

3. final
   

接口中所有数据域的修饰符

具体修饰符如下。
java接口的修饰符：abstract（inteeface本身就是抽象的，加不加abstract都一样）。public:使接口的实现类可以使用这个常量。static：接口不涉及和任何具体实例相关的细节,因此接口没有构造方法,不能被实例化,没有实例变量，只有静态（static）变量。static修饰就表示它属于类的，随的类的加载而存在的，当JVM把字节码加载进JVM的时候，static修饰的成员已经在内存中存在了。如果是非static的话，就表示属于对象的，只有建立对象时才有它，而接口是不能建立对象的，所以接口的常量必须定义为static。
final：接口中不可以定义变量即定义的变量前都要加上final修饰，使之成为常量(没有final修饰的是变量，加上final修饰就会变成常量)。所以接口的属性默认是publicstaticfinal常量，且必须赋初值。（final修饰就是保证接口定义的常量不能被实现类去修改，如果没有final的话，由子类随意去修改的话，接口建立这个常量就没有意义了。）

java中修饰符有哪些

java的修饰符有：权限修饰符：public、protected、default、private

修饰符：abstract、static、final

public 使用对象：最广，类、接口、变量、方法

protected使用对象：变量、方法 注意：不能修饰类（外部类）

default 使用对象：类、接口、变量、方法。（即缺省，什么也不写）

private 使用对象：变量、方法 注意：不能修饰类（外部类）

abstract使用对象：类、接口、方法

static 使用对象：类、变量、方法、初始化函数（注意：修饰类时只能修饰 内部类 ）

final 使用对象：类、变量、方法

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

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

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

synchronized：修饰方法，多线程的支持

类分外部类和内部类，他们的访问控制是相同的吗

外部类是相对于内部类而言的，内部类是定义在类里面的类。

外部类的修饰符有：

default（缺省，不写）：类定义时前面未加任何修饰符，表示同一个包中可见。

public：修饰类时表示该类能被项目中所有类可见

abstract：表示是抽象类

final：表示类不可以被继承

scrictpf:(java关键字) 当对一个类或接口使用 strictfp 关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。严格约束意味着所有表达式的结果都必须是 IEEE 754 算法对操作数预期的结果，以单精度和双精度格式表示

内部类又分：成员内部类、局部内部类、静态内部类、匿名内部类

成员内部类：作为外部类的一个成员存在，与外部类的属性、方法并列

局部内部类：定义在外部类的方法体里面的类

静态内部类：使用static修饰的内部类

匿名内部类：就是没有名字的内部类

成员内部类修饰符有：

public：

protected：

private：private不能修饰外部类，

abstract：

final：

static：可以当做普通类使用，而不用先实例化一个外部类。（用他修饰后，就成了静态内部类了）

strictfp：（java关键字） 即 strict float point (精确浮点)。（可修饰类、接口、方法）

扩展资料：

java中的类修饰符、成员变量修饰符、方法修饰符。

类修饰符：

public（访问控制符），将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类。

abstract，将一个类声明为抽象类，没有实现的方法，需要子类提供方法实现。

final，将一个类生命为最终（即非继承类），表示他不能被其他类继承。

friendly，默认的修饰符，只有在相同包中的对象才能使用这样的类。

成员变量修饰符：

public（公共访问控制符），指定该变量为公共的，他可以被任何对象的方法访问。

private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。

protected（保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。

friendly ，在同一个包中的类可以访问，其他包中的类不能访问。

final，最终修饰符，指定此变量的值不能变。

static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。

transient（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。

volatile（易失修饰符）指定该变量可以同时被几个线程控制和修改。

方法修饰符：

public（公共控制符）

private（私有控制符）指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类）

protected（保护访问控制符）指定该方法可以被它的类和子类进行访问。

final，指定该方法不能被重载。

static，指定不需要实例化就可以激活的一个方法。

synchronize，同步修饰符，在多个线程中，该修饰符用于在运行前，对他所属的方法加锁，以防止其他线程的访问，运行结束后解锁。

native，本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。