Java-访问修饰符

类的访问修饰符

• 类只能用default(什么也不写)，public 来修饰。对与用default 修饰的类只能在同一包下进行访问。
• 类还可以使用abstract ，表示该类是抽象类，不能实例化该类。
• 类还可以用final 来修饰。

方法和域的访问修饰符

• 方法的访问修饰符有private,default,protected 和 public。
• private 修饰的方法只能在本类中访问。
• default 只能在本包中访问。在同一包中的子类将继承该方法。

基类，

package ly.practice;
public class Refernce {
    private String name;
    private int age;
    String s="Test"; //default修饰符修饰域
    public Refernce(){
        name="Hello World!";
        age=20;
    }
    protected Refernce(String name){
        this.name=name;
        this.age=12;
    }
    public Refernce(String name,int age){
        this.name=name;
        this.age=age;
    }

    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public String getS() {
        return s;
    }
    void display(){ //default修饰符修饰方法
        System.out.println(name+"  "+age);
    }
}

同一包下的类

package ly.practice;
class B extends Refernce{ //Refernce和B在同一个包下
    public B(){}

}

public class Test {
    public static void main(String[] args){
        B b=new B();//建立子类对象
        b.display();//同一包中访问default修饰的方法，该方法是继承来的
        System.out.println(b.s);//同一包中访问default域，该域是继承来的

        Refernce r=new Refernce();//建立父类对象
        b.display();//在同一包中访问父类default修饰的方法
        System.out.println(r.s);//在同一包中访问父类default修饰的域
    }
}

不同包下的类，

package ly.practiceDefault;
import ly.practice.Refernce;//Refernce该类修饰符为public
public class TestDefault extends Refernce {
    public static void main(String[] args){
        TestDefault t=new TestDefault();//建立子类对象
        //System.out.println(t.s);//子类实例不能访问从基类继承的default域
        System.out.println(t.getS());//但是可以通过公有方法记性访问
        //t.display();//子类实例不能访问从基类继承的default方法

        Refernce r=new Refernce();//Refernce是public，可以访问，建立父类实例，但是不能通过该实例访问基类的default域和方法
        //r.display(); //Error。不能访问基类实例的default方法，default只能在同一包下访问
        //System.out.println(r.s); //Error,不能通过基类实例访问基类的default域。
        System.out.println(r.getS());//但是可以通过公有方法访问
    }
}

• protected 对本包和所有子类可见。子类和基类在同一包中，被声明为protected 变量，方法的能被同一包中其它类所访问。子类和基类不在同一个包中，子类实例可以访问从基类继承来方法和域，而不能访问基类实例的protected 方法和域。

基类，

package ly.practice;
public class Refernce {
    private String name;
    private int age;
    protected String s="Test";
    public Refernce(){
        name="Hello World!";
        age=20;
    }
    protected Refernce(String name){
        this.name=name;
        this.age=12;
    }
    public Refernce(String name,int age){
        this.name=name;
        this.age=age;
    }
    protected void display(){ //可以跨包在子类中访问
        System.out.println(name+"  "+age);
    }
}

不在同一包下的子类，

package ly.practiceDefault;
import ly.practice.Refernce;//Refernce该类修饰符为public
public class TestDefault extends Refernce {
    public static void main(String[] args){
        TestDefault t=new TestDefault();//建立子类对象
        System.out.println(t.s);//子类实例访问从基类继承的protected域
        t.display();//子类实例可以访问其从基类继承而来的protected方法
        //Refernce r=new Refernce("Jerry"); //Error,该构造函数有protected修饰，不能直接访问。
        Refernce r=new Refernce();//Refernce是public，可以访问，建立父类实例，但是不能通过该实例访问基类的protected域和方法
        //r.display(); //Error。不能访问基类实例的protected方法，protected只能在同一包和子类中访问
        //System.out.println(r.s); //Error,不能通过基类实例访问基类的protected方法和域。
    }
}

同一包下的子类，

package ly.practice;
class B extends Refernce{ //Refernce和B在同一个包下
    public B(){}

}
public class Test {
    public static void main(String[] args){
        B b=new B();//建立子类对象
        b.display();//同一包中访问protected方法
        System.out.println(b.s);//同一包中访问protected域
    }
}

• public 对所有的类可见。

接口的修饰符

• 接口的修饰符只能是public 和default 。default 修饰的接口只能在同一包下实现。

如有错误，欢迎留言指正！