「java类修饰符」java类修饰符权限
今天给各位分享java类修饰符的知识，其中也会对java类修饰符权限进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
- 1、java修饰符作用范围
- 2、java中有几种修饰符？
- 3、在java中一个类的修饰符有哪些
- 4、Java内部类的修饰符有哪些?
- 5、在java中能用private修饰类吗?
- 6、java的接口、类、属性、方法各有哪些修饰符
java修饰符作用范围
1、java中的修饰符
1）访问修饰符：
private
被private修饰的属性和方法，不能被其他类访问，子类不能继承也不能访问。只能在所在类内部访问。
缺省
变量或者方法前没有访问修饰符时，可以被所在类访问，可以被同一包内的其他类访问 或者继承。但是不能被其他包访问。
protected
被protected修饰的方法和属性，在同一包内可被访问和继承。不同包内，子类可继承，非子类不能访问。
public
方法和属性前有public修饰，可以被任意包内的类访问。
另外，类要想被其他包导入，必须声明为public。被public修饰的类，类名必须与文件名相同。
2）静态修饰符：
static是一个修饰符，用于修饰成员(成员变量和成员函数)
静态成员随着类的加载而加载。
静态成员优先于对象存在。
静态成员被所有对象所共享
静态成员多了一个中调用方式，可以被类名直接调用。
java中有几种修饰符？
java中的修饰符分为类修饰符，字段修饰符，方法修饰符。根据功能的不同，主要分为以下五种。
1、权限访问修饰符
public,protected,default,private,这四种级别的修饰符都可以用来修饰类、方法和字段。
2、final修饰符
final的意思是不可变，他可以修饰类、字段、方法。修饰类后类不能被扩展（extends），也就是不能被继承。修饰字段后字段的值不能被改变，因此如果有final修饰字段，应该对字段进行手动初始化。修饰方法后该方法不能被改变，也就是重写。
3、abstract修饰符
abstract是抽象的意思，用来修饰类和方法，修饰类后，该类为抽象类，不能被实例化，必需进行扩展。修饰方法后，该方法为抽象方法必须被子类重写（override）。
4、static修饰符
static用来修饰内部类，方法，字段。修饰内部类说明该内部类属于外部类而不属于外部类的某个实例。修饰字段说明该字段属于类而不属于类实例。修饰方法说明该方法属于类而不属于类实例
5、volatile修饰符
易失 ( 共享 ) 域修饰符 volatile 是用来说明这个成员变量可能被几个线程所控制和修改。也就是说在程序运行过程中，这个成员变量有可能被其它的程序影响或改变它的取值。
扩展资料：
修饰符的特点：
static是一个修饰符，用于修饰成员(成员变量和成员函数)
静态成员随着类的加载而加载。静态成员优先于对象存在。静态成员被所有对象所共享静态成员多了一个中调用方式，可以被类名直接调用。
使用的注意事项：
静态方法只能访问静态成员, 非静态方法既可以访问静态又可以访问非静态。静态方法中不可以定义this，super关键字。因为this代表是对象。而静态存在时，有可能没有对象。所以静态方法运行时，this是没有任何对象代表的。
简单说，先进内存的数据不可以访问后进内存的数据，可是后进内存数据可以访问先进内存的数据。主函数是静态的。
在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内部类的修饰符有哪些?
一、内部类可以为四种：
⒈ 静态内部类
⒉ 成员内部类
⒊ 局部内部类
⒋
匿名内部类几种内部类的共性：
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中能用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的接口、类、属性、方法各有哪些修饰符
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类修饰符权限、java类修饰符的信息别忘了在本站进行查找喔。
发布于：2022-11-22，除非注明，否则均为原创文章，转载请注明出处。