在Java中,在创建类和接口以及处理继承时,是否有明确的规则来确定何时使用每个访问修饰符,即默认的(包私有)、公共的、受保护的和私有的?


当前回答

Java中的访问修饰符。

Java访问修饰符用于在Java中提供访问控制。

1.默认值:

只能访问同一包中的类。

例如

// Saved in file A.java
package pack;

class A{
  void msg(){System.out.println("Hello");}
}

// Saved in file B.java
package mypack;
import pack.*;

class B{
  public static void main(String args[]){
   A obj = new A(); // Compile Time Error
   obj.msg(); // Compile Time Error
  }
}

这种访问比公共访问受到更多的限制和保护,但比私人访问受到更少的限制。

2.公众

可以从任何地方访问。(全球访问)

例如

// Saved in file A.java

package pack;
public class A{
  public void msg(){System.out.println("Hello");}
}

// Saved in file B.java

package mypack;
import pack.*;

class B{
  public static void main(String args[]){
    A obj = new A();
    obj.msg();
  }
}

输出:您好

3.私人

只能在同一类中访问。

如果您试图访问另一个类中一个类的私有成员,将引发编译错误。例如

class A{
  private int data = 40;
  private void msg(){System.out.println("Hello java");}
}

public class Simple{
  public static void main(String args[]){
    A obj = new A();
    System.out.println(obj.data); // Compile Time Error
    obj.msg(); // Compile Time Error
  }
}

4.受保护

只能访问同一包中的类和子类

例如

// Saved in file A.java
package pack;
public class A{
  protected void msg(){System.out.println("Hello");}
}

// Saved in file B.java
package mypack;
import pack.*;

class B extends A{
  public static void main(String args[]){
    B obj = new B();
    obj.msg();
  }
}

输出:您好

其他回答

Java中最容易被误解的访问修饰符是受保护的。我们知道它类似于默认修饰符,只有一个例外,子类可以看到它?这里有一个例子,希望能澄清这一困惑:

假设我们有2个类;父亲和儿子,每个人都有自己的包装:包父包;公共课父亲{}-------------------------------------------package-sonpackage;公共课儿子延伸父亲{}让我们向Father添加一个受保护的方法foo()。包父包;公共课父亲{受保护的void foo(){}}方法foo()可以在4种上下文中调用:在位于定义foo()的同一包中的类内(父包):包父包;公共类SomeClass{公共无效方法(父f,子s){f.foo();s.foo();}}在子类内部,在当前实例上通过this或super:package-sonpackage;公共课儿子延伸父亲{public void sonMethod(){this.foo();super.foo();}}在类型为同一类的引用上:包父包;公共课父亲{公共无效父方法(父f){f.foo();//即使foo()是私有的,也有效}}-------------------------------------------package-sonpackage;公共课儿子延伸父亲{公共无效sonMethod(Sons){s.foo();}}在一个类型为父类的引用上,该引用位于定义foo()的包内(父包)[这可以包含在上下文1中]:包父包;公共课儿子延伸父亲{公共无效sonMethod(父f){f.foo();}}以下情况无效。在类型为父类且位于定义foo()的包(父包)外部的引用上:package-sonpackage;公共课儿子延伸父亲{公共无效sonMethod(父f){f.foo();//编译错误}}子类包中的非子类(子类从其父类继承受保护的成员,并使其成为非子类的私有成员):package-sonpackage;公共类SomeClass{public void someMethod(儿子)引发异常{s.foo();//编译错误}}

私有的

方法、变量和构造函数

声明为私有的方法、变量和构造函数只能在声明的类本身内访问。

类和接口

专用访问修饰符是限制性最强的访问级别。类和接口不能是私有的。

Note

如果类中存在公共getter方法,则可以在类外部访问声明为私有的变量。在超类中声明为受保护的变量、方法和构造函数只能由其他包中的子类或受保护成员类的包中的任何类访问。

受保护的

类和接口

受保护的访问修饰符不能应用于类和接口。

方法、字段可以声明为受保护,但接口中的方法和字段不能声明为受。

Note

受保护的访问使子类有机会使用helper方法或变量,同时防止非相关类尝试使用它。

平民的

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

因此,可以从属于Java Universe的任何类访问在公共类中声明的字段、方法和块。

不同的软件包

但是,如果我们试图访问的公共类位于不同的包中,那么仍然需要导入公共类。

由于类继承,类的所有公共方法和变量都由其子类继承。

默认-无关键字:

默认访问修饰符意味着我们不为类、字段、方法等显式声明访问修饰符。

在相同的软件包中

没有任何访问控制修饰符的变量或方法可用于同一包中的任何其他类。接口中的字段是隐式的公共静态final,接口中的方法默认是公共的。

Note

我们无法覆盖静态字段。如果尝试覆盖,则不会显示任何错误但除了我们之外,它不起作用。

相关答案

重写java中的静态方法

参考链接

http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.htmlhttp://www.tutorialspoint.com/java/java_access_modifiers.htm

Java中的访问修饰符。

Java访问修饰符用于在Java中提供访问控制。

1.默认值:

只能访问同一包中的类。

例如

// Saved in file A.java
package pack;

class A{
  void msg(){System.out.println("Hello");}
}

// Saved in file B.java
package mypack;
import pack.*;

class B{
  public static void main(String args[]){
   A obj = new A(); // Compile Time Error
   obj.msg(); // Compile Time Error
  }
}

这种访问比公共访问受到更多的限制和保护,但比私人访问受到更少的限制。

2.公众

可以从任何地方访问。(全球访问)

例如

// Saved in file A.java

package pack;
public class A{
  public void msg(){System.out.println("Hello");}
}

// Saved in file B.java

package mypack;
import pack.*;

class B{
  public static void main(String args[]){
    A obj = new A();
    obj.msg();
  }
}

输出:您好

3.私人

只能在同一类中访问。

如果您试图访问另一个类中一个类的私有成员,将引发编译错误。例如

class A{
  private int data = 40;
  private void msg(){System.out.println("Hello java");}
}

public class Simple{
  public static void main(String args[]){
    A obj = new A();
    System.out.println(obj.data); // Compile Time Error
    obj.msg(); // Compile Time Error
  }
}

4.受保护

只能访问同一包中的类和子类

例如

// Saved in file A.java
package pack;
public class A{
  protected void msg(){System.out.println("Hello");}
}

// Saved in file B.java
package mypack;
import pack.*;

class B extends A{
  public static void main(String args[]){
    B obj = new B();
    obj.msg();
  }
}

输出:您好

我的两分钱:)

私人:

class->顶级类不能是私有的。内部类可以是私有的,可以从同一类访问。

实例变量->只能在类中访问。无法在类外部访问。

包专用:

class->顶级类可以是包专用的。它只能从同一个包访问。不是来自子包装,不是来自外包装。

实例变量->可从同一包访问。不是来自子包装,不是来自外包装。

受保护的:

class->无法保护顶级类。

实例变量->只能在同一包或子包中访问。扩展类时只能在包外部访问。

公众:

类->可从包/子包/另一个包访问

实例变量->可从包/子包/另一个包访问

下面是详细的答案

https://github.com/junto06/java-4-beginners/blob/master/basics/access-modifier.md

Public Protected Default和private是访问修饰符。

它们用于封装,或隐藏和显示类的内容。

类可以是公共的或默认的类成员可以是公共的、受保护的、默认的或私有的。

课堂外无法访问私人课程默认值只能在包中访问。在包以及扩展它的任何类中受到保护。公众对所有人开放。

通常,成员变量被定义为私有的,但成员方法是公共的。