类的访问修饰符
- 类只能用
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
修饰的接口只能在同一包下实现。
如有错误,欢迎留言指正!