java类的修饰符

⑴ java默认方法的修饰符是什么

默认什么都不加，就是default（不用把default写出来）。
意思就是只能由跟这个类在同一个包中的类来访问，比private限制更少，但比protected限制更多。'
Java访问修饰符包括private，default，protected和public。含义分别表示私有的，默认的，受保护的和公有的访问修饰符。这些访问修饰符既可以修饰类中的属性，又可以修饰类中的方法，而public和default还可以修饰类。在同一个java文件里，公有类有且仅有一个，并且该文件命名为类名.java。
Java访问修饰符就是确定类中属性或方法的访问权限，换句话说，就是这些属性和方法所起的作用范围。
private，私有的访问权限，也是最严格的访问权限，仅只能在设置了该权限的类中访问，利用这个访问权限，表现出封装思想。
default，默认的访问权限，也是可以省略的访问权限，它不仅能在设置了该权限的类中访问，也可以在同一包中的类或子类中访问。
protected，受保护的访问权限，它除了具有default的访问权限外，还可以在不同包中所继承的子类访问。
public，公有的访问权限，也是最宽松的访问权限，不仅可以是同一个类或子类，还是同一个包中的类或子类，又还是不同包中的类或子类，都可以访问。
要想更深入地理解这些访问权限，一方面需要明白各自的作用域，另一方面更是要弄清楚各自所体现出来的编程思想，比方说，prvite表现的封装思想，public表现的面向接口编程的思想等。
在面向对象设计和编程的过程中，归根结底就是类的设计。而要设计出不仅满足当前需求同时也能符合未来需求的类，就很有必要对类中属性和行为设置合适的访问
权限。那些应该为私有的，那些又应该为公有的，还有那些又应该为受保护的等，都应该给予合理的规划和布局，一来保证程序的功能要求，二来要体现程序的扩展
性能，三来要呈现程序友好性质。总之，程序应该更好地服务用户。而访问权限在这样宏伟目标里扮演着重要角色。

⑵ 在java中一个类的修饰符有哪些

一：访问修饰符：
1.省略访问修饰符
具有默认的访问特性，即具有包访问特性，只能被同一个包中的类使用。
2.public访问修饰符
用于说明类和类的成员的访问权限。这种类叫公有类。在一个文件中只能有一个public类型的类。
例如：Rect和UseImport两个类，分别在两个不同的包中。顺便回顾一下不同类要用import导入。（哎，一直就没记住）
//Rect.java
pacakage my;
public class Rect
{
private int a,b;
public void init(int len,int width)
{
a=len;
b=width;
}
public int area()
{
return a*b;
}
}
//UseImport.java
import.my.*;//导入my 包的所有类
public class UseImport
{
public static void main(string[] args)
{
Rect x=new Rect();
x.init(2,3);
System.out.println("矩形面积为："+x.area());
}
}
3.private
用private修饰的类成员成为私有成员，只能在声明该成员的类中使用，不能在类外使用。一般通过本类中公有方法进行访问。
4.protected
protected修饰的类成员为保护成员，可以被三种类使用，分别是该类本身，该类的所有子类，该类同包的其他类，该类的子类。
5.private protected
私有保护成员。可被两种类使用。分别是：该类本身和该类的所有子类。
二：特征修饰符
1.abstract：抽象
修饰类为抽象类，修饰方法为抽象方法。只要类中有抽象方法，就必须定义为抽象类。抽象方法只能声明，不能实现。但是可以在其子类中对抽象方法进行实现。抽象类中也可以包含非抽象方法。
2.final：最终
修饰的类为终止类，不能有子类。修饰变量为终止变量，只可赋值一次。修饰方法为终止方法，不能在子类中更改。如Socket、ServerSocket等都是final类，防止黑客派生子类进行破坏。同时，final与abstract是相互矛盾的。
3.static：静态
静态成员无需通过对象调用，可以直接通过类名直接调用。
public class RectArea//输出6 和 12
{
public static void main(String[] args)
{
System.out.println(area(2,3));
System.out.println(area(3,4));
}
static void area(int a,int b)

⑶ java接口的修饰符有哪些

1、 接口的修饰符只有：public 2、 类的修饰符分为：可访问控制符和非访问控制符两种。 可访问控制符是：公共类修饰符 public 非访问控制符有：抽象类修饰符 abstract ；最终类修饰符 final 1、公共类修饰符public： Java 语言中类 的可访问控制符只有一个： public 即公共的。每个 Java 程序的主类都必须是 public 类作为公共工具供其它类和程序使用的应定义为 public 类。 2 、抽象类修饰符abstract：凡是用 abstract 修饰符修饰的类，被称为抽象类。所谓抽象类是指这种类没有具体对象的一种概念类。这样的类就是 Java 语言的 abstract 类。 3、最终类修饰符final：当一个类不可能有子类时可用修饰符 final 把它说明为最终类。被定义为 final 的类通常是一些有固定作用、用来完成某种标准功能的类。 4、类缺省访问控制符：如果一个类没有访问控制符，说明它具有缺省的访问控制符特性。此时，这个类只能被同一个包中的类访问或引用。这一访问特性又称为包访问性。 3、属性的控制修饰符也分为：可访问控制符和非访问控制符两类。 可访问控制符有 4 种：公共访问控制符： public ；私有访问控制符： private ；保护访问控制符： protected ；私有保护访问控制符： private protected 非访问控制符有 4 种：静态域修饰符： static ；最终域修饰符： final ；易失 ( 共享 ) 域修饰符： volatile ；暂时性域修饰符： transient 1、公共访问控制符 public ：用 public 修饰的域称为公共域。如果公共域属于一个公共类，则可以被所有其它类所引用。由于 public 修饰符会降低运行的安全性和数据的封装性，所以一般应减少 public 域的使用。 2、私有访问控制符 private ： 用 private 修饰的成员变量 ( 域 ) 只能被该类自身所访问，而不能被任何其它类 ( 包括子类 ) 所引用。 3、保护访问控制符 protected ：用 protected 修饰的成员变量可以被三种类所引用：①该类自身；②与它在同一个包中的其它类；③在其它包中的该类的子类。使用修饰符 protected 的主要作用是允许其它包中它的子类来访问父类的特定属性。 4、私有保护访问控制符 private protected ：用修饰符 private protected 修饰的成员变量可以被该类本身或该类的子类两种类访问和引用。 5、静态域修饰符 static ：用 static 修饰的成员变量仅属于类的变量，而不属于任何一个具体的对象，静态成员变量的值是保存在类的内存区域的公共存储单元，而不是保存在某一个对象的内存区间。任何一个类的对象访问它时取到的都是相同的数据；任何一个类的对象修改它时 , 也都是对同一个内存单元进行操作。 6、最终域修饰符 final ：最终域修饰符 final 是用来定义符号常量的。一个类的域 ( 成员变量 ) 如果被修饰符 final 说明，则它的取值在程序的整个执行过程中都是不变的。 7、易失 ( 共享 ) 域修饰符 volatile ：易失 ( 共享 ) 域修饰符 volatile 是用来说明这个成员变量可能被几个线程所控制和修改。也就是说在程序运行过程中，这个成员变量有可能被其它的程序影响或改变它的取值。因此，在使用中要注意这种成员变量取值的变化。通常 volatile 用来修饰接受外部输入的域。 8、暂时性域修饰符 transient ：暂时性域修饰符 transient 用来定义一个暂时性变量。其特点是：用修饰符 transient 限定的暂时性变量，将指定 Java 虚拟机认定该暂时性变量不属于永久状态，以实现不同对象的存档功能。否则，类中所有变量都是对象的永久状态的一部分，存储对象时必须同时保存这些变量。 4、方法的控制修饰符也分为：可访问控制符和非访问控制符两类。 可访问控制符有 4 种：公共访问控制符： public ；私有访问控制符： private ；保护访问控制符： protected ；私有保护访问控制符： private protected 非访问控制符有 5 种：抽象方法控制符： abstract ；静态方法控制符： static ；最终方法控制符： final ；本地方法控制符： native ；同步方法控制符： synchronized 1、抽象方法控制符 abstract ：用修饰符 abstract 修饰的方法称为抽象方法。抽象方法是一种仅有方法头，没有方法体和操作实现的一种方法。 2、静态方法控制符 static ：用修饰符 static 修饰的方法称为静态方法。静态方法是属于整个类的类方法；而不使用 static 修饰、限定的方法是属于某个具体类对象的方法。 由于 static 方法是属于整个类的，所以它不能操纵和处理属于某个对象的成员变量，而只能处理属于整个类的成员变量，即 static 方法只能处理 static 的域。 3、最终方法控制符 final ：用修饰符 final 修饰的方法称为最终方法。最终方法是功能和内部语句不能更改的方法，即最终方法不能重载。这样，就固定了这个方法所具有的功能和操作，防止当前类的子类对父类关键方法的错误定义，保证了程序的安全性和正确性。所有被 private 修饰符限定为私有的方法，以及所有包含在 final 类 ( 最终类 ) 中的方法，都被认为是最终方法。 4、本地方法控制符 native ：用修饰符 native 修饰的方法称为本地方法。为了提高程序的运行速度，需要用其它的高级语言书写程序的方法体，那么该方法可定义为本地方法用修饰符 native 来修饰； 5、同步方法控制符 synchronized ：该修饰符主要用于多线程共存的程序中的协调和同步。

⑷ java中有几种修饰符

java中的修饰符分为类修饰符，字段修饰符，方法修饰符。根据功能的不同，主要分为以下五种。

1、权限访问修饰符

public,protected,default,private,这四种级别的修饰符都可以用来修饰类、方法和字段。

(4)java类的修饰符扩展阅读：

修饰符的特点：

static是一个修饰符，用于修饰成员(成员变量和成员函数)

静态成员随着类的加载而加载。静态成员优先于对象存在。静态成员被所有对象所共享静态成员多了一个中调用方式，可以被类名直接调用。

使用的注意事项：

静态方法只能访问静态成员, 非静态方法既可以访问静态又可以访问非静态。静态方法中不可以定义this，super关键字。因为this代表是对象。而静态存在时，有可能没有对象。所以静态方法运行时，this是没有任何对象代表的。

简单说，先进内存的数据不可以访问后进内存的数据，可是后进内存数据可以访问先进内存的数据。主函数是静态的。

⑸ java的接口，类，属性，方法各有哪些修饰符

1、 接口的修饰符只有：public
2、 类的修饰符分为：可访问控制符和非访问控制符两种。
可访问控制符是：公共类修饰符 public
非访问控制符有：抽象类修饰符 abstract ；最终类修饰符 final
3、属性的控制修饰符也分为：可访问控制符和非访问控制符两类。
可访问控制符有 4 种：公共访问控制符： public ；私有访问控制符： private ；保护访问控制符： protected ；私有保护访问控制符： private protected
非访问控制符有 4 种：静态域修饰符： static ；最终域修饰符： final ；易失 ( 共享 ) 域修饰符： volatile ；暂时性域修饰符： transient
4、方法的控制修饰符也分为：可访问控制符和非访问控制符两类。
可访问控制符有 4 种：公共访问控制符： public ；私有访问控制符： private ；保护访问控制符： protected ；私有保护访问控制符： private protected
非访问控制符有 5 种：抽象方法控制符： abstract ；静态方法控制符： static ；最终方法控制符： final ；本地方法控制符： native ；同步方法控制符： synchronized

⑹ Java中目前学习涉及到的四种权限修饰符都有什么并说明各自的权限范围

（1）public : 公共权限

修饰对象： 修饰类、方法、属性

继承： 被public所修饰的成员能被该类的所有子类继承下来。

作用域： 可以被任意类访问

public能用来修饰类，在一个java源文件中只能有一个类被声明为public，而且一旦有一个类为public，那这个java源文件的文件名就必须要和这个被public所修饰的类的类名相同，否则编译不能通过。说到这里，穿插多一点知识。一个类作为外部类的时候只能被public或者默认访问修饰符所修饰，但是一个类如果作为内部类的时候，则可以被四种访问修饰符所修饰，因为一个类作为内部类的时候，就作为外部类的一个成员属性了，因此可以有四种访问修饰符修饰，这是内部类和外部类的一个区别。

public用来修饰类中成员(变量和方法)，被public所修饰的成员可以在任何类中都能被访问到。通过操作该类的对象能随意访问public成员。

public在类的继承上的体现，被public所修饰的成员能被所有的子类继承下来。

（2）protected：受保护的权限

修饰对象：修饰内部类，接口，属性，方法

继承： 被protected所修饰的成员能被该类的所有子类继承下来。

作用域： 可以被同包类访问，如果不是同包，必须是该类的子类才能访问

（3）default : 同包权限(默认，缺省的)

修饰对象：修饰类，属性，方法。

继承：被default所修饰的成员只能被该类所在同一个package中的子类所继承下来。(也就是说只有在同一个package中的子类才能访问到父类中default修饰的成员)

作用域： 只能被同包的类访问

（4） private : 私有权限

修饰对象 ： 内部类，属性，方法

作用域： 只能在本类中使用

注意：

（1）protected不能修饰类。

（2）priavte可以修饰类，但是该类必须是一个内部类。

在定义类时，推荐访问控制级别从严处理：

（1） 如果不允许外部直接通过 new 创建对象，构造方法必须是 private。

（2）工具类不允许有 public 或 default 构造方法。

（3）类非 static 成员变量并且与子类共享，必须是 protected。

（4）类非static成员变量并且仅在本类使用，必须是private。

（5）类 static 成员变量如果仅在本类使用，必须是 private。

（6）若是 static 成员变量，必须考虑是否为 final。

（7）类成员方法只供类内部调用，必须是 private。

（8）类成员方法只对继承类公开，那么限制为 protected。

⑺ java的接口、类、属性、方法各有哪些修饰符

1、
接口的修饰符只有:public
2、
类的修饰符分为:可访问控制符和非访问控制符两种。
可访问控制符是:公共类修饰符
public
非访问控制符有:抽象类修饰符
abstract
;最终类修饰符
final
1、公共类修饰符public:
Java
语言中类
的可访问控制符只有一个:
public
即公共的。每个
Java
程序的主类都必须是
public
类作为公共工具供其它类和程序使用的应定义为
public
类。
2
、抽象类修饰符abstract:凡是用
abstract
修饰符修饰的类，被称为抽象类。所谓抽象类是指这种类没有具体对象的一种概念类。这样的类就是
Java
语言的
abstract
类。
3、最终类修饰符final:当一个类不可能有子类时可用修饰符
final
把它说明为最终类。被定义为
final
的类通常是一些有固定作用、用来完成某种标准功能的类。
4、类缺省访问控制符:如果一个类没有访问控制符，说明它具有缺省的访问控制符特性。此时，这个类只能被同一个包中的类访问或引用。这一访问特性又称为包访问性。
3、属性的控制修饰符也分为:可访问控制符和非访问控制符两类。
可访问控制符有
4
种:公共访问控制符:
public
;私有访问控制符:
private
;保护访问控制符:
protected
;私有保护访问控制符:
private
protected
非访问控制符有
4
种:静态域修饰符:
static
;最终域修饰符:
final
;易失
(
共享
)
域修饰符:
volatile
;暂时性域修饰符:
transient
1、公共访问控制符
public
:用
public
修饰的域称为公共域。如果公共域属于一个公共类，则可以被所有其它类所引用。由于
public
修饰符会降低运行的安全性和数据的封装性，所以一般应减少
public
域的使用。
2、私有访问控制符
private
:
用
private
修饰的成员变量
(
域
)
只能被该类自身所访问，而不能被任何其它类
(
包括子类
)
所引用。
3、保护访问控制符
protected
:用
protected
修饰的成员变量可以被三种类所引用:①该类自身;②与它在同一个包中的其它类;③在其它包中的该类的子类。使用修饰符
protected
的主要作用是允许其它包中它的子类来访问父类的特定属性。
4、私有保护访问控制符
private
protected
:用修饰符
private
protected
修饰的成员变量可以被该类本身或该类的子类两种类访问和引用。
5、静态域修饰符
static
:用
static
修饰的成员变量仅属于类的变量，而不属于任何一个具体的对象，静态成员变量的值是保存在类的内存区域的公共存储单元，而不是保存在某一个对象的内存区间。任何一个类的对象访问它时取到的都是相同的数据;任何一个类的对象修改它时
,
也都是对同一个内存单元进行操作。
6、最终域修饰符
final
:最终域修饰符
final
是用来定义符号常量的。一个类的域
(
成员变量
)
如果被修饰符
final
说明，则它的取值在程序的整个执行过程中都是不变的。
7、易失
(
共享
)
域修饰符
volatile
:易失
(
共享
)
域修饰符
volatile
是用来说明这个成员变量可能被几个线程所控制和修改。也就是说在程序运行过程中，这个成员变量有可能被其它的程序影响或改变它的取值。因此，在使用中要注意这种成员变量取值的变化。通常
volatile
用来修饰接受外部输入的域。
8、暂时性域修饰符
transient
:暂时性域修饰符
transient
用来定义一个暂时性变量。其特点是:用修饰符
transient
限定的暂时性变量，将指定
Java
虚拟机认定该暂时性变量不属于永久状态，以实现不同对象的存档功能。否则，类中所有变量都是对象的永久状态的一部分，存储对象时必须同时保存这些变量。
4、方法的控制修饰符也分为:可访问控制符和非访问控制符两类。
可访问控制符有
4
种:公共访问控制符:
public
;私有访问控制符:
private
;保护访问控制符:
protected
;私有保护访问控制符:
private
protected
非访问控制符有
5
种:抽象方法控制符:
abstract
;静态方法控制符:
static
;最终方法控制符:
final
;本地方法控制符:
native
;同步方法控制符:
synchronized
1、抽象方法控制符
abstract
:用修饰符
abstract
修饰的方法称为抽象方法。抽象方法是一种仅有方法头，没有方法体和操作实现的一种方法。
2、静态方法控制符
static
:用修饰符
static
修饰的方法称为静态方法。静态方法是属于整个类的类方法;而不使用
static
修饰、限定的方法是属于某个具体类对象的方法。
由于
static
方法是属于整个类的，所以它不能操纵和处理属于某个对象的成员变量，而只能处理属于整个类的成员变量，即
static
方法只能处理
static
的域。
3、最终方法控制符
final
:用修饰符
final
修饰的方法称为最终方法。最终方法是功能和内部语句不能更改的方法，即最终方法不能重载。这样，就固定了这个方法所具有的功能和操作，防止当前类的子类对父类关键方法的错误定义，保证了程序的安全性和正确性。所有被
private
修饰符限定为私有的方法，以及所有包含在
final
类
(
最终类
)
中的方法，都被认为是最终方法。
4、本地方法控制符
native
:用修饰符
native
修饰的方法称为本地方法。为了提高程序的运行速度，需要用其它的高级语言书写程序的方法体，那么该方法可定义为本地方法用修饰符
native
来修饰;
5、同步方法控制符
synchronized
:该修饰符主要用于多线程共存的程序中的协调和同步。

⑻ 在java中能用private修饰类吗

一般的类是不能用private修饰，类的可见性最少是包可见的，也就是默认的，不加任何修饰。
但是有一种特殊的情况，内部类是可以用private修饰的！不让类以外的其他类访问！这个问题在《java核心技术》里有讲！

Java的外部类为什么不能使用private、protected进行修饰？

对于顶级类(外部类)来说，只有两种修饰符：public和默认(default)。因为外部类的上一单元是包，所以外部类只有两个作用域：同包，任何位置。

因此，只需要两种控制权限：包控制权限和公开访问权限，也就对应两种控制修饰符：public和默认(default)。

如果类使用了private修饰符，说明是个内部类。内部类的上一级是外部类，那么对应的有四种访问控制修饰符：本类(private)，同包(default)，父子类(protected)，任何位置(public)。

当一个内部类使用了private修饰后，只能在该类的外部类内部使用。可以想一下，一个java项目是不可能在一个class里面完成的。

mvc模式中，是把类分为三层，一层层调用类。如果定义为私有的和受保护的就无法调用。换句话说，对于一个java文件，要么就是自己单独运行，要么就是被其他程序作为库调用。

如果一个java文件的类被private修饰，那么是不是其他的程序或是类是无法使用它的，那么他作为一个单独的文件就没啥用了。

如果它作为单个文件运行，类加载怎么找到它呢，因为它对外不可见。同时，也失去了类的存在意义。因此，类只有public和默认修饰符。

⑼ Java内部类的修饰符有哪些

一、内部类可以为四种：

⒈ 静态内部类

⒉ 成员内部类

⒊ 局部内部类

⒋
匿名内部类几种内部类的共性：

A、内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类命和$符号。

B、内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。

1、静态嵌套类：从技术上讲，静态嵌套类不属于内部类。因为内部类与外部类共享一种特殊关系，更确切地说是对实例的共享关系。而静态嵌套类则没有上述关系。它只是位置在另一个类的内部，因此也被称为顶级嵌套类。静态的含义是该内部类可以像其他静态成员一样，没有外部类对象时，也能够访问它。静态嵌套类不能访问外部类的成员和方法。 class Outer{ static class Inner{} } class Test { public static void main(String[] args){ Outer.Inner n = new Outer.Inner(); } }

2、成员内部类：形式如下
class Outer { class Inner{} }
编译上述代码会产生两个文件：Outer.class和Outer$Inner.class。成员内部类内不允许有任何静态声明！下面代码不能通过编译。
class Inner{ static int a = 10;
}能够访问成员内部类的唯一途径就是通过外部类的对象！

A、从外部类的非静态方法中实例化内部类对象。 class Outer { private
int i = 10; public void makeInner(){ Inner in = new Inner();
in.seeOuter(); } class Inner{ public void seeOuter(){
System.out.print(i); } }
}表面上，我们并没有创建外部类的对象就实例化了内部类对象，和上面的话矛盾。事实上，如果不创建外部类对象也就不可能调用makeInner()方法，所以到头来还是要创建外部类对象的。可能试图把makeInner()方法修饰为静态方法，即static
public void
makeInner()。这样不创建外部类就可以实例化外部类了！但是在一个静态方法里能访问非静态成员和方法吗？显然不能。它没有this引用。没能跳出那条规则！但是如果在这个静态方法中实例化一个外部类对象，再用这个对象实例化外部类完全可以！也就是下一条的内容。

B、从外部类的静态方法中实例化内部类对象。
class Outer { private int i = 10; class Inner{ public void seeOuter(){
System.out.print(i);
} } public static void main(String[] args) { Outer out = new Outer();
Outer.Inner in = out.new Inner(); //Outer.Inner in = new Outer().new
Inner(); in.seeOuter(); }
}被注释掉的那行是它上面两行的合并形式，一条简洁的语句。对比一下：在外部类的非静态方法中实例化内部类对象是普通的new方式：Inner in =
new Inner();在外部类的静态方法中实例化内部类对象，必须先创建外部类对象：Outer.Inner
in = new Outer().new
Inner();

C、内部类的this引用。普通的类可以用this引用当前的对象，内部类也是如此。但是假若内部类想引用外部类当前的对象呢？用“外部类名”.this；的形式,如下例的Outer.this。
class Outer { class Inner{ public void seeOuter(){
System.out.println(this); System.out.println(Outer.this); } }
}

D、成员内部类的修饰符。对于普通的类，可用的修饰符有final、abstract、strictfp、public和默认的包访问。但是成员内部类更像一个成员变量和方法。可用的修饰符有：final、abstract、public、private、protected、strictfp和static。一旦用static修饰内部类，它就变成静态内部类了。

3、方法内部类：顾名思义，把类放在方法内。
class Outer { public void doSomething(){ class Inner{ public void
seeOuter(){ } } }
}

A、方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。

B、方法内部类对象不能使用该内部类所在方法的非final局部变量。因为方法的局部变量位于栈上，只存在于该方法的生命期内。当一个方法结束，其栈结构被删除，局部变量成为历史。但是该方法结束之后，在方法内创建的内部类对象可能仍然存在于堆中！例如，如果对它的引用被传递到其他某些代码，并存储在一个成员变量内。正因为不能保证局部变量的存活期和方法内部类对象的一样长，所以内部类对象不能使用它们。下面是完整的例子：
class Outer { public void doSomething(){ final int a =10; class Inner{
public void seeOuter(){ System.out.println(a); } } Inner in = new
Inner(); in.seeOuter(); } public static void main(String[] args) { Outer
out = new Outer(); out.doSomething(); }
}

C、方法内部类的修饰符。与成员内部类不同，方法内部类更像一个局部变量。可以用于修饰方法内部类的只有final和abstract。

D、静态方法内的方法内部类。静态方法是没有this引用的，因此在静态方法内的内部类遭受同样的待遇，即：只能访问外部类的静态成员。

4、匿名内部类：顾名思义，没有名字的内部类。表面上看起来似乎有名字，实际那不是名字。

A、继承式的匿名内部类。
class Car { public void drive(){ System.out.println("Driving a car!"); }
} class Test{ public static void main(String[] args) { Car car = new
Car(){ public void drive(){ System.out.println("Driving another car!"); }
}; car.drive(); } }结果输出了：Driving another
car!
Car引用变量不是引用Car对象，而是Car匿名子类的对象。建立匿名内部类的关键点是重写父类的一个或多个方法。再强调一下，是重写父类的方法，而不是创建新的方法。因为用父类的引用不可能调用父类本身没有的方法！创建新的方法是多余的。简言之，参考多态。B、接口式的匿名内部类。
interface Vehicle { public void drive(); } class Test{ public static
void main(String[] args) { Vehicle v = new Vehicle(){
public void drive(){ System.out.println("Driving a car!"); } };
v.drive(); }
}上面的代码很怪，好像是在实例化一个接口。事实并非如此，接口式的匿名内部类是实现了一个接口的匿名类。而且只能实现一个接口。

C、参数式的匿名内部类。class
Bar{ void doStuff(Foo f){}}interface Foo{ void foo();}class Test{
static void go(){ Bar b = new Bar();
b.doStuff(new Foo(){ public void foo(){ System.out.println("foofy"); }
});
}}

二、权限修饰符：public、protected、default、private。

修饰符：abstract、static、final。

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

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

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

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

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

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

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

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

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

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

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

⑽ 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 (精确浮点)。（可修饰类、接口、方法）

(10)java类的修饰符扩展阅读：

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

类修饰符：

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

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

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

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

成员变量修饰符：

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

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

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

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

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

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

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

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

方法修饰符：

public（公共控制符）

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

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

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

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

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

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