[Thinking in Java]修饰符public,protected,默认,private

在使用Java时,常常会遇到四种修饰符,即public,protected,默认(没有修饰符),private,这里写下它们的区别public :包内包外任意访问

protected :包内访问,包外仅子类访问

默认 :包内任意访问

private :仅类内访问

用代码解释

 1 package p1;
 2 import static java.lang.System.*;
 3
 4 public class A {
 5     public int m1 = 1;
 6     protected int m2 = 2;
 7     int m3 = 3;
 8     private int m4 = 4;
 9
10     public void f1() {
11         out.println("f1");
12     }
13     protected void f2() {
14         out.println("f2");
15     }
16     void f3() {
17         out.println("f3");
18     }
19     private void f4() {
20         out.println("f4");
21     }
22
23     void demo() {
24         out.println(m1);
25         out.println(m2);
26         out.println(m3);
27         out.println(m4);
28
29         f1();f2();f3();f4();
30
31         B b = new B();
32     }
33
34     public static void main(String[] args) {
35         new A().demo();
36     }
37 }
38
39 class B {
40     public B() {
41         out.println("class B");
42     }
43 }

p1.A

 1 package p1;
 2 import static java.lang.System.*;
 3
 4 public class C {
 5     void demo() {
 6         A a = new A();
 7         out.println(a.m1);
 8         out.println(a.m2);
 9         out.println(a.m3);
10         //out.println(a.m4);
11
12         a.f1();a.f2();a.f3();
13         //a.f4();
14
15         //默认类可以在同一个包内使用
16         B b = new B();
17     }
18
19     public static void main(String[] args) {
20         new C().demo();
21     }
22 }

p1.C

package p2;
import p1.*;
import static java.lang.System.*;

public class D {
    void demo() {
        A a = new A();
        out.println(a.m1);
        //以下都无法访问
        //out.println(a.m2);
        //out.println(a.m3);
        //out.println(a.m4);

        a.f1();
        //以下都无法调用
        //a.f2();
        //a.f3();
        //a.f4();

        //默认类不能在其它包内使用
        //B b = new B();
    }

    public static void main(String[] args) {
        new D().demo();
        E.main(args);
    }
}

class E extends A{//A的子类
    void demo() {
        out.println(m1);
        out.println(super.m1);
        out.println(new A().m1);

        out.println(m2);
        out.println(super.m2);
        //out.println(new A().m2);//失败
        //out.println(a.m3);
        //out.println(a.m4);

        f1();
        f2();
        super.f2();
        //new A().f2();//失败
        //a.f3();
        //a.f4();

        //默认类不能在其它包内使用
        //B b = new B();
    }

    public static void main(String[] args) {
        new E().demo();
    }
}

p1.D

时间: 2024-11-07 12:38:37

[Thinking in Java]修饰符public,protected,默认,private的相关文章

Java的权限修饰符(public,protected,default,private)

访问权限修饰符权限从高到低排列是public  ,protected  ,default, private. 一.根据"是否是同包"."是否是子类"分为4中情况+本类 5种情况 二.把 同包中的子类 和 同包中的非子类 合并为 同包 访问修饰符 本类 同包 不同包,子类 不同包,非子类 public √ √ √ √ protected √ √ √   default(friendly) √ √     private √      

java的修饰符 public --> protected -->default --> private

例子代码:代码中报红处为不可使用 鲁迅的儿子和鲁迅生活在一个时代(同一个包),当他想发表一篇关于鲁迅的文章时,他可以使用如下代码所示的资源 韩寒和鲁迅的孙子和鲁迅没有生活在一个时代(同一个包),当他想发表一篇关于鲁迅的文章时,他们可以使用如下代码所示的资源 原文地址:https://www.cnblogs.com/tianhaichao/p/11982165.html

java修饰符public final static abstract transient

JAVA 修饰符public final static abstract transient 关键字: public final static abstract ... 1.public protected default private 组 位置                        private      默认      protected        public 同一个类                    是            是         是         

Java修饰符public,private,protected及默认的区别

Java中访问修饰符public.private.protecte.default的意义讲解:public(接口访问权限): Java语言中访问限制最宽的修饰符,一般称之为“公共的”.被其修饰的类.属性以及方法不仅可以跨类访问,而且允许跨包(package)访问.private(你无法访问): Java语言中对访问权限限制的最窄的修饰符,一般称之为“私有的”.被其修饰的类.属性以及方法只能被该类的对象访问,其子类不能访问,更不能允许跨包访问.protected(继承访问权限): 介于public

Java修饰符public private protected 默认

Java中访问修饰符public.private.protecte.default的意义讲解: public(接口访问权限): Java语言中访问限制最宽的修饰符,一般称之为“公共的”.被其修饰的类.属性以及方法不仅可以跨类访问,而且允许跨包(package)访问.private(你无法访问): Java语言中对访问权限限制的最窄的修饰符,一般称之为“私有的”.被其修饰的类.属性以及方法只能被该类的对象访问,其子类不能访问,更不能允许跨包访问.protected(继承访问权限): 介于publi

Java修饰符public private protected和default(friendly)之间的区别

对于public修饰符,它具有最大的访问权限,可以访问任何一个在CLASSPATH下的类.接口.异常等.它往往用于对外的情况,也就是对象或类对外的一种接口的形式. 对于protected修饰符,它主要的作用就是用来保护子类的.它的含义在于子类可以用它修饰的成员,其他的不可以,它相当于传递给子类的一种继承的东西. 对于default来说,有点的时候也成为friendly(友员),它是针对本包访问而设计的,任何处于本包下的类.接口.异常等,都可以相互访问,即使是父类没有用protected修饰的成员

php类点滴---访问修饰符public protected private

public可以被继承,可以外部访问(也就是实例化对象可以直接访问) protected受保护的,可以被子类继承,无法外部访问 private继承,外部访问都别想 <?phpclass coach{ public $master = "老张"; protected $lover = "丁大锅"; private $lovegame = "SM"; public function slogan() { echo "吼吼~哈哈~&qu

Java修饰符类型(public、protected、private)小结

Java修饰符号类型: public:Java语言中访问限制最宽的修饰符,一般称之为“公共的”.被其修饰的类.属性以及方法不仅可以跨类访问,而且允许跨包(package)访问. private:Java语言中对访问权限限制的最窄的修饰符,一般称之为“私有的”.被其修饰的类.属性以及方法只能被该类的对象访问,其子类不能访问,更不能允许跨包访问. protected:介于public 和 private 之间的一种访问修饰符,一般称之为“保护形”.被其修饰的类.属性以及方法只能被类本身的方法及子类访

JAVA修饰符类型(public,protected,private,friendly)

JAVA修饰符类型(public,protected,private,friendly) public的类.类属变量及方法,包内及包外的不论什么类均能够訪问:protected的类.类属变量及方法,包内的不论什么类,及包外的那些继承了此类的子类才干訪问:private的类.类属变量及方法,包内包外的不论什么类均不能訪问:假设一个类.类属变量及方法不以这三种修饰符来修饰,它就是friendly类型的,那么包内的不论什么类都能够訪问它,而包外的不论什么类都不能訪问它(包含包外继承了此类的子类),因此