java访问权限整理

类实例化成对象之后,可以通过对象加上"."操作符访问和操纵该对象的域和方法,但是这种访问是有限制的,通过public、protected、default(啥都不写)、private来控制。

先看一个实验的例子:(不注释表示可以访问,注释掉表示无法访问)

package packageA;

import packageB.SubB;

public class Base {
    public String publicStr = "publicString";
    protected String protectedStr = "protectedString";
    String defaultStr = "defaultString";
    private String privateStr = "privateString";

    public void print() {
        System.out.println("packageA.Base has access to");
        System.out.println("    " + publicStr);
        System.out.println("    " + protectedStr);
        System.out.println("    " + defaultStr);
        System.out.println("    " + privateStr);

        Base b = new Base(); // -- other Base instance
        System.out.println("    b." + b.publicStr);
        System.out.println("    b." + b.protectedStr);
        System.out.println("    b." + b.defaultStr);
        System.out.println("    b." + b.privateStr);

        SubA subA=new SubA();
        System.out.println("    subA." + subA.publicStr);
        System.out.println("    subA." + subA.protectedStr);
        System.out.println("    subA." + subA.defaultStr);
     //   System.out.println("    subA." + subA.privateStr);

        SubB subB=new SubB();
        System.out.println("    subB." + subB.publicStr);
        System.out.println("    subB." + subB.protectedStr);
     //   System.out.println("    subB." + subB.defaultStr);
     //   System.out.println("    subB." + subB.privateStr);

    }
}
package packageA;

import packageB.SubB;

public class SubA extends Base {

    public void print() {
        System.out.println("packageA.SubA has access to");
        System.out.println("    " + publicStr + " (inherited from Base)");
        System.out.println("    " + protectedStr + " (inherited from Base)");
        System.out.println("    " + defaultStr + " (inherited from Base)");
        // -- not accessible - private elements are even not inherited
        // System.out.println(privateStr);

        Base b = new Base(); // -- other Base instance
        System.out.println("    b." + b.publicStr);
        System.out.println("    b." + b.protectedStr);
        System.out.println("    b." + b.defaultStr);
        // -- not accessible
        // System.out.println(b.privateStr);

        SubA subA=new SubA();
        System.out.println("    subA." + subA.publicStr);
        System.out.println("    subA." + subA.protectedStr);
        System.out.println("    subA." + subA.defaultStr);

     //   System.out.println("    subA." + subA.privateStr);

        SubB subB=new SubB();
        System.out.println("    subB." + subB.publicStr);
        System.out.println("    subB." + subB.protectedStr);
     //   System.out.println("    subB." + subB.defaultStr);
     //   System.out.println("    subB." + subB.privateStr);

    }
}
package packageA;
import packageB.SubB;

public class AnotherA {
    public void print() {
        System.out.println("packageA.AnotherA has access to");
        Base b = new Base();
        System.out.println("    b." + b.publicStr);
        System.out.println("    b." + b.protectedStr);
        System.out.println("    b." + b.defaultStr);
        // System.out.println(b.privateStr);

        SubA subA=new SubA();
        System.out.println("    subA." + subA.publicStr);
        System.out.println("    subA." + subA.protectedStr);
        System.out.println("    subA." + subA.defaultStr);
     //   System.out.println("    subA." + subA.privateStr);

        SubB subB=new SubB();
        System.out.println("    subB." + subB.publicStr);
        System.out.println("    subB." + subB.protectedStr);
     //   System.out.println("    subB." + subB.defaultStr);
     //   System.out.println("    subB." + subB.privateStr);

    }
}
package packageB;
import packageA.Base;
import packageA.SubA;

public class SubB extends Base {
    public void print() {
        System.out.println("packageB.SubB has access to");
        System.out.println("    " + publicStr + " (inherited from Base)");
        // -- protectedStr is inherited element -> accessible
        System.out.println("    " + protectedStr + " (inherited from Base)");
        // -- not accessible
        // System.out.println(defaultStr);
        // System.out.println(privateStr);

        Base b = new Base(); // -- other Base instance
        System.out.println("    b." + b.publicStr);
        // -- protected element, which belongs to other object -> not accessible
        // System.out.println(b.protectedStr);

        // -- not accessible
        // System.out.println(b.defaultStr);
        // System.out.println(b.privateStr);

        SubA subA=new SubA();
        System.out.println("    subA." + subA.publicStr);
     //   System.out.println("    subA." + subA.protectedStr);
     //   System.out.println("    subA." + subA.defaultStr);
     //   System.out.println("    subA." + subA.privateStr);

        SubB subB=new SubB();
        System.out.println("    subB." + subB.publicStr);
        System.out.println("    subB." + subB.protectedStr);
     //   System.out.println("    subB." + subB.defaultStr);
     //   System.out.println("    subB." + subB.privateStr);

    }
}
package packageB;
import packageA.Base;
import packageA.SubA;

public class AnotherB{
    public void print() {
        System.out.println("packageB.AnotherB has access to");
        Base b = new Base();
        System.out.println("    b." + b.publicStr);
        // -- not accessible
        // System.out.println(b.protectedStr);
        // System.out.println(b.defaultStr);
        // System.out.println(b.privateStr);

        SubA subA=new SubA();
        System.out.println("    subA." + subA.publicStr);
     //   System.out.println("    subA." + subA.protectedStr);
     //   System.out.println("    subA." + subA.defaultStr);
     //   System.out.println("    subA." + subA.privateStr);

        SubB subB=new SubB();
        System.out.println("    subB." + subB.publicStr);
     //   System.out.println("    subB." + subB.protectedStr);
     //   System.out.println("    subB." + subB.defaultStr);
     //   System.out.println("    subB." + subB.privateStr);

    }
}

总结:

1).不考虑继承的情况下:

一个类在 ”某处“实例化并访问域和方法,或者直接访问类域和类方法:

a). 在类定义出:四种类型都可访问。(见Base中的b对象)

b). 与类定义在同一包中:default、protected、public可访问。(见AnotherA中b对象)

c). 与类定义在不同包中:仅可访问public类型。(见AnotherB中b对象)

2).有继承关系

一个子类在 ”某处“实例化并访问父类继承的域和方法(子类新定义的域和方法参加上面不考虑继承的情况),或者直接访问父类类域和类方法:

a).定义在包内的子类(如上例的SubA)

A).在子类定义处、同包内:default、protected、public可访问。

B).在包外:只可访问public属性

b).定义在包外的子类(如上例的SubB)

A).在子类定义处、父类同包内:protected及public可访问。

B).在子类包内(非子类定义处):只可访问public属性

java访问权限整理

时间: 2024-10-06 08:50:13

java访问权限整理的相关文章

Java访问权限控制

访问权限控制   java提供了访问权限修饰词,以供类库开发人员向客户端程序员指明哪些是可用的,哪些是不可用的.访问权限控制的等级,从最大权限到最小权限依次是:public.protected.包访问权限(没有关键字).private. 包:库单元 包内有一组类,它们在单一名字空间之下被组织在了一起.如果你向导入某个标准库中的类的话,可以使用import关键字.我们之所以要导入,就是要提供一个管理名字空间的机制.所有类成员的名称都是彼此分离的.所以具有相同方法的不同类在程序运行时不会出现错误的.

Java 访问权限控制:你真的了解 protected 关键字吗?

摘要: 在一个类的内部,其成员(包括成员变量和成员方法)能否被其他类所访问,取决于该成员的修饰词:而一个类能否被其他类所访问,取决于该类的修饰词.Java的类成员访问权限修饰词有四类:private,无(默认情况下,包访问权限),protected 和 public,而其中只有包访问权限和public才能修饰一个类(内部类除外).特别地,很多的介绍Java的书籍对protected介绍的比较笼统,常常会对大家造成误解.因此,本文重点揭示了 protected 关键字的内涵和用法,并介绍了一些其他

java访问权限的问题

java访问权限的问题 java 访问权限 修饰符 背景: 关于java中的四种访问修饰符,public ,default ,protected ,private的作用范围本以为很熟悉了,但碰到了这样一段代码: package pac1; public class Parent { protected int i; protected class Inner{ } } package pac2; import pac1.Parent; public class Child extends Par

Java访问权限控制小结

进行访问权限控制的两个原因 第一,可以控制类成员的可见性,使客户程序员只看到应该看到的内容 第二,可以使类的创建者随意改变类内部的工作方式,而不必担心会对客户端程序产生重大影响 四种访问权限 pulic 默认(包权限) protected private 用于域和方法 public表示所有人对本成员都可以访问 默认访问权限表示同一包下的类可以对本成员进行访问,其他包中的则不可以(!默认包) protected用于类的继承中,protected提供包访问权限,同时,子类也对protected成员具

[THINKING IN JAVA]访问权限控制

6 访问权限控制 6.1 包:库单元 package.import.import *.import static: 修改classpath环境变量可以将自己写的类库添加至环境变量并在任何java程序中import: 6.2  JAVA访问权限修饰符 访问权限:public>protected>包访问权限(没有限定词)>private: public:任何类在任何地方均可访问: 默认包:没有声明package并且处于同一目录下,则他们隶属于默认包,处于同一个package下: protec

论Java访问权限控制的重要性

人在什么面前最容易失去抵抗力? 美色,算是一个,比如说西施的贡献薄就是忍辱负重.以身报国.助越灭吴:金钱,算是另外一个,我们古人常说"钱乃身外之物,生不带来死不带去",但我们又都知道"有钱能使鬼推磨". 除去美色和金钱,我认为还有一个,就是读者的认可--"二哥,你的文章真的很棒,我特别喜欢.希望能多多更新Java基础知识,真的是受益良多,就好像是在读王小波的散文,但又学了编程!"--你说,收到读者这样暖暖的评语,还需要美色和金钱?"两者

【java编程思想--学习笔记(二)】访问控制-Java访问权限修饰词

如果不提供任何访问修饰词,则意味着它是"包访问权限". 2.1 包访问权限 包访问权限赋予包内的类相互访问彼此成员的权限. 应该说, 包访问权限为将类群聚在一起的行为提供了意义和理由,即建立包的目的不仅仅是为了分类和区分,更是为了是同一个包内的类可以拥有彼此的代码. 取得对某一成员访问权的途径: 1)该成员的访问修饰词为public. 2)通过不加访问权限修饰词并将目标类放在同一包内的方式. 3)继承.子类可以访问父类的public和protected修饰词的成员,但只有在父子类处于同

java 访问权限控制

java提供四种访问权限: public > protected > 包访问权限(无关键词) > private 包:库单元 对于包访问权限,一个包内的都可以访问. 在eclipse中创建类时如果不创建包,类将会被创建在默认包(default package)中,我一直习惯这样,然而这是一个很不好的做法(= =!)不相关的类应该置于不同的包.因为如果一个包中有两个名字相同的类会产生冲突的. 把不同的类放入不同的包,如果想使用其他包的类,将需要在名字前加上包名.例如ArrayList类在j

Java 访问权限修饰符以及protected修饰符的理解

2017-11-04 22:28:39 访问权限修饰符的权限 访问修饰符protected的权限理解 在Core Java中有这样一段话"在Object类中,clone方法被声明为protected,因此无法直接调用anObject.clone().子类只能直接调用受保护的clone方法克隆它自己.为此,必须重新定义clone方法,并将它声明为public,这样才能让所有的方法克隆对象".但是不是所有的子类都可以访问受保护的方法吗?不是每个子类都是Object的之类吗?下面就用例子来说