在Java,什么# 39;公共,默认的,受保护的,之间的差异和私人?


有明确的规则时,使用这些类和接口时,处理好继承?
已邀请:

zhuyaqi2006

赞同来自:


这个Java教程可能对你有帮助。

|类包装类改性剂| | |世界
------------ + + + + ------- --------- ---------- -------
公共| Y Y Y Y | | |
------------ + + + + ------- --------- ---------- -------
| |保护Y Y Y N | |
------------ + + + + ------- --------- ---------- -------
没有修饰符| Y Y N | | | N××也被称为包私人××
------------ + + + + ------- --------- ---------- -------
私人| Y N N N

| | | Y:访问
N:无法访问

baliguan163

赞同来自:


简单的规则。首先声明一切私人。然后朝着公共的需求出现时,设计令。

曝光时成员问你自己如果你选择或选择曝光表示抽象。第一个是你要避免将出台更依赖于实际的表现而不是它的可观察的行为。

作为一般规则,我尽量避免重写方法实现的子类,这是容易把逻辑。如果你打算要重写抽象方法声明的保护。同时使用@Override注释

超越时,保持从打破当你重构

city2046

赞同来自:


的差异可以在已经提供的链接发现,但使用哪一个通常归结为“最少知识原则”。只允许最小能见度
是必要的。

lishipeng

赞同来自:


戴维的回答提供了每个访问修饰符的含义。至于什么时候使用,我建议在公共所有的类和每一类是外部使用的方法(它的API),和其他一切私人。你会随着时间的发展感觉,当做出一些类包私人当宣布某些方法保护使用
子类。

liuhanhan512

赞同来自:


这一页写得很好的保护&默认访问修饰符的…#

# #保护:保护访问修饰符是一个有点棘手,你可以说是默认的访问修饰符的一个超集。受保护的成员是相同的作为默认的成员就在同一个包的访问有关。不同的是,受保护的成员也可以访问类的子类成员的声明是在包中父类是目前。但这些受保护的成员是“包外访问只能通过继承”。即你可以访问受保护的类成员,在其他一些包直接作为如果成员在子类的子类本身的存在。但是,受保护的成员将不使用父类中的参考外包装的子类可以访问。

的…

xuweilinjijis

赞同来自:


它实际上不是一个简单的网格显示更复杂一点。网格告诉你是否访问是允许的,但究竟是一个访问?同时,访问级别的嵌套类和继承以复杂的方式相互作用。“默认”访问

(由关键字没有指定)又称包私有。例外:在一个界面,没有修饰符意味着公共的访问;除了公共修饰符是禁止的。枚举常量始终是公共的。总结是一个成员

访问该访问说明符允许吗?

成员是私有的:只有当成员定义在同一个类调用代码。
-件包私有:如果调用代码在会员立即封闭包装。
成员保护:相同的包,或者是父类的成员包含调用代码的类中定义的成员。
公共:是的。

什么访问说明符用于

局部变量和形式参数不能访问说明符。因为他们天生就无法外根据作用域规则,他们实际上是私人的。在顶部的范围类的公共和私人

,包允许。本设计选择,大概是因为保护和私人都是多余的在包级别(没有继承包)。

所有访问说明符是可能的类成员(构造函数,方法和静态成员函数,嵌套类)。相关:Java类访问

顺序访问修饰符可以严格有序的

公共>保护>包私有>私人

意味着公众提供最访问,私人至少。在一个私有成员的任何参考可能也适用于封装私有成员;任何对包私有成员是有效的在一个受保护的成员,等等。(在同一个包给访问受保护的成员的其他类是错误的。)

笔记

一类的方法可以访问其他的同一类对象的私有成员。更确切地说,一个C类的方法可以访问C对任何类C,Java不支持通过实例限制访问对象的私有成员,只有类。(与Scala,它支持使用私人[这]。)
-你需要访问一个构造函数构造一个对象。因此,如果所有的构造函数是私有的,类只能在类代码(通常生活构建静态工厂方法或静态变量的初始化)。同样包装的私有或受保护的构造函数。

只有私有构造函数也意味着类不能被继承外,因为Java需要一个类的构造函数隐式或显式地调用父类的构造函数。(可以,但是,包含嵌套类的子类的内部类

它。)你也要考虑嵌套作用域,如内部类。的复杂性的一个例子是,内部类的成员,它们可以访问修饰符。所以你可以有一个私有内部类的公共成员;成员可以访问?(见下文。)总的原则是看范围,认为递归看你是否可以访问每一个层面。

然而,这是相当复杂的,和细节,参考Java语言规范。(是的,过去也有。被编译器错误)一尝这些互动

,考虑一下这个例子。这是可能的“泄漏”的私有内部类;这通常是一个警告:
class Test {
public static void main(final String ... args) {
    System.out.println(Example.leakPrivateClass()); // OK
    Example.leakPrivateClass().secretMethod(); // error
}
}

class Example {
private static class NestedClass {
    public void secretMethod() {
        System.out.println("Hello");
    }
}
public static NestedClass leakPrivateClass() {
    return new NestedClass();
}
}


编译器的输出:
Test.java:4: secretMethod() in Example.NestedClass is defined in an inaccessible class or interface
    Example.leakPrivateClass().secretMethod(); // error
                              ^
1 error

doushiguokea

赞同来自:


在很短的

公共可从到处。
保护可以通过一个软件包的类和居住在任何包类
。默认可以通过一个软件包的类。
私人访问在同一个班只有

andyhebear

赞同来自:


作为一个经验法则:

私有:类作用域。
违约(或包私有):包范围
保护范围:包+儿童(如包装,但我们可以从不同的包装件小类)。保护剂总是保持“亲子”关系。
公共:到处。

作为一个结果,如果我们将访问权为三权:

-(D)直接(调用在同一个类的方法)
-(R)的参考(调用方法使用参考对类,或通过“点”的语法)
-(我)(通过继承)灵长

然后我们有了这个简单的表格:

cfyme

赞同来自:

| highest precedence <---------> lowest precedence
*———————————————+————————————————+———————————+———————————————+———————
\ xCanBeSeenBy | this           | any class | this subclass | any
\             | class          | in same   | in another    | class
\—————————\  | nonsubbed      | package   | package       |    
Modifier of x \ |                |           |               |       
————————————————*————————————————+———————————+———————————————+———————
public          |       ?        |    ?      |    ?          |   ?   
————————————————+————————————————+———————————+———————————————+———————
protected       |       ?        |    ?      |    ?          |   ?   
————————————————+————————————————+———————————+———————————————+———————
package-private |                |           |               |
(no modifier)   |       ?        |    ?      |    ?          |   ?   
————————————————+————————————————+———————————+———————————————+———————
private         |       ?        |    ?      |    ?          |    ?   

wei509085

赞同来自:


最被人误解的访问修饰符在Java是受保护的。我们知道,它类似于默认的修饰有一个例外,子类可以看到它。但如何?这里有一个例子希望澄清混乱:

-假设我们有3节课;祖父,父亲和儿子:

package grandfatherpackage;

public class Grandfather
{

}

-------------------------------------------

package fatherpackage;

public class Father extends Grandfather
{

}

-------------------------------------------

package sonpackage;

public class Son extends Father
{

}

-让我们添加一个受保护的方法foo()祖父

package grandfatherpackage;

public class Grandfather
{
protected void foo(){}
}

-方法foo()可以称为3个方面:

内类位于同一包的定义是foo(),grandfatherpackage:

package grandfatherpackage;

public class SomeClass
{
public void someMethod() throws Exception
{
    Father f = new Father();
    f.foo();

    Son s = new Son();
    s.foo();
}
}

内的一个子类,对当前实例:

package fatherpackage;

public class Father extends Grandfather
{
public void fatherMethod()
{
    this.foo();
}
}

-------------------------------------------

package sonpackage;

public class Son extends Father
{
public void sonMethod()
{
    this.foo();
}
}

在参考其类型是同一类:
package fatherpackage;

public class Father extends Grandfather
{
public void fatherMethod()
{
    Father f = new Father();
    f.foo();
}
}

-------------------------------------------

package sonpackage;

public class Son extends Father
{
public void sonMethod()
{
    Son s = new Son();
    s.foo();
}
}


-关于第三的情况,它不会编译如果引用是父类的类型:
package fatherpackage;

public class Father extends Grandfather
{
public void fatherMethod()
{
    Grandfather f = new Grandfather();
    g.foo(); // compilation error

    Grandfather g = new Father();
    g.foo(); // compilation error
}
}

-------------------------------------------

package sonpackage;

public class Son extends Father
{
public void sonMethod()
{
    Grandfather g = new Grandfather();
    g.foo(); // compilation error

    Grandfather s = new Son();
    s.foo(); // compilation error

    Father f = new Father();
    f.foo(); // compilation error

    Father ff = new Son();
    ff.foo(); // compilation error
}
}

yjisxx

赞同来自:


私人

-方法,变量和构造函数

方法,声明私有变量和构造函数只能在类声明本身。

-类和接口

私人访问修饰符是最严格的访问级别。类和接口不能是私有的。注意变量声明

私人可以访问外部类如果公众getter方法中存在的类。
变量,方法和构造函数声明父类的保护只能通过子类其他包或任何类别的受保护成员的类包内访问。

保护

-类和接口

保护访问修饰符不能应用于类和接口的方法。可以声明

,域保护,但方法和域在一个接口不能声明保护。



保护访问给子类的一个机会使用辅助方法或变量,在防止非相关的类,尝试使用它。公共

一类,方法,构造函数声明为公共接口等,可以从任何其他类访问。

因此领域,方法,块内声明一个公共类可以从任何Java类属于宇宙访问。

不同包

然而如果我们试图访问公共类在不同的包,那么公共课还需要进口。

因为类的继承,一个类所有的公共方法和变量从父类继承。没有关键词:

默认默认访问修饰符意味着我们不显式声明一个类,访问修饰符字段,方法,等在同一个包

变量或方法声明没有任何访问控制修饰符是任何其他类的同一个包。接口中的域隐式public static final的方法在一个界面默认公开。我们不能重写

注意静态fields.if你试图推翻它不显示任何错误
但它不工作,我们除了。相关答案

-重写静态方法在Java

参考链接

HTTP:/ /文档。甲骨文。COM / JavaSE /教程/ Java / javaoo /控制。HTML
http://www.tutorialspoint.com/ ... s.htm

woyaozixue51

赞同来自:


私人:类的默认访问限制(只有

没有修饰符):类名和包

保护访问限制:类和子类的访问限制,包裹(内外包)公共访问类

,包(所有),总之处处
子……

suixsy

赞同来自:


公共和私人保护默认访问修饰符。

就意味着封装,或隐藏和显示类的内容。课

可以公开或默认
类成员可以是公开的,受保护的,默认的或私人的。

外部不能访问类的私有
默认只包访问
。保护包以及任何类扩展它。
公共开放给所有成员变量。通常

,定义私有成员,但方法是公共的。

dzz10

赞同来自:


访问修饰符有几个级别的访问限制。

公共:它基本上是简单,你可以从任何类访问,在同一包或不。

访问如果你在同一个包你可以直接访问如果你在其他包,那么你可以创建类的对象。默认:

是从任何包装在同一包装类访问。

访问您可以创建类的对象。但你不能访问这个变量在外包装。保护:

可以访问相同的包变量以及任何其他包类。所以基本上是
默认+继承行为。

访问受保护字段定义在基类可以创建子类对象。这私人:

可以在同一类中的非静态方法访问。

你可以直接访问因为这个参考(在构造函数)但访问静态方法,您需要创建该类的对象

要回复问题请先登录注册