Java中四种访问权限总结
一、Java中有四种访问权限， 其中三种有访问权限修饰符，分别为private、public、protected，还有一种不带任何修饰符（default）。
private: Java语言中对访问权限限制的最窄的修饰符，一般称之为“私有的”。被其修饰的属性以及方法只能被该类的对象访问，其子类不能访问，更不能允许跨包访问。
default：即不加任何访问修饰符，通常称为“默认访问权限“或者“包访问权限”。该模式下，只允许在同一个包中进行访问。
protected: 介于public 和 private 之间的一种访问修饰符，一般称之为“保护访问权限”。被其修饰的属性以及方法只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。
public： Java语言中访问限制最宽的修饰符，一般称之为“公共的”。被其修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包访问。
这里给出一个确定访问权限的技巧：
确定内容提供者是谁 确定内容的访问者是谁 比较内容提供者和内容访问者在上边表中符合的条件。
封装
定义：封装是面向对象的三大特性之一，就是将类的状态信息隐藏在类内部，不让外部程序直接访问，而是通过类提供的方法来实现对隐藏信息的操作及访问（getter,setter方法）。
实现：：将属性设置为private，再设置public权限的getter和setter方法实现对属性的存取。
意义：隐藏类的实现细节，让使用者只能通过程序规定的方法来访问数据，可以方便的加入存取控制语句，限制不合理操作。
public class XX{
//私有属性
private int i;
private String b;
//getter&setter方法
public int getI() {
return i;
}
public void setI(int i) {
this.i = i;
}
public String getB() {
return b;
}
public void setB(String b) {
this.b = b;
}
//无参和带参的构造方法
public XX() {
super();
// TODO Auto-generated constructor stub
}
public XX(int i, String b) {
super();
this.i = i;
this.b = b;
}
}
this的用法
定义： this关键字是 对一个对象的默认引用。在每个实例方法内部，都有一个this引用变量，指向调用这个方法的对象。
this关键字必须放在非静态方法里面
使用案例：
1.调用成员变量，解决成员变量和局部变量的冲突：
//成员变量i
private int i;
public void setI(int i) {//局部变量 int i
//this.i调用成员变量，解决同名冲突
this.i = i;
}
public void setI(int x) {//局部变量 int x
//不同名时可以省略this
i = x;
}
2.调用成员方法，this可以省略直接调用。
public class XX{
public void print(){
System.out.print("a");
}
public void play(){
System.out.print("b");
this.print();//this可以省略，直接写成print();
}
}
3.调用重载的构造方法，只能在构造方法中使用，且必须是第一句.
public class X {
private String i;
private int a;
public X(String i){
this.i=i;
}
public X(String i,int a){
//this(i)即为调用重载的构造方法public X(String i){...}
this(i);
this.a=a;
}
}
继承
语法：修饰符(不可以使用private和protected) Subclass(子类） extends SuperClass(父类/基类/超类）{ //类定义部分}
定义：继承是面向对象的三大特性之一，是代码实现重用的重要手段之一。只支持单继承，每一个类只能有一个直接父类。通过extends关键字实现，修饰符如果是public则在整个项目可见，如果是默认，则同包可见，不可以使用private和protected修饰类。
从父类继承到的：
1.继承了public 和 protected修饰的属性和方法。
2.父类和子类同包时，可以继承default修饰符（默认修饰符）修饰的属性和方法。
3.无法继承private 修饰的属性和方法
4.无法继承父类的构造方法
//父类
public class Pet {
//私有属性无法被继承
private String name="无名";
private int health=100;
private int love=0;
public Pet() {
this.health=90;
System.out.println("无参构造执行");
}
//有参构造
public Pet(String name) {
this.name = name;
}
//getter方法
public String getName() {
return name;
}
public int getHealth() {
return health;
}
public int getLove() {
return love;
}
@Override
public String toString() {
return "Pet [name=" + name + ", health=" + health + ", love=" + love + "]";
}
}//继承Pet
public class Dog extends Pet{
//子类新增的属性
private String strain;
//有参构造
public Dog(String name,String strain){
//因为父类中name是私有属性(private name),不能用this.name=name;
super(name);//使用super(name)调用了父类的有参构造
this.strain=strain;
}
//getter方法
public String getStrain() {
return strain;
}
}
public class Test {
/* 结果：
* 无参构造执行
Pet [name=无名, health=90, love=0]
Pet [name=a, health=100, love=0]
*
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Pet pet=new Pet();
System.out.println(pet.toString());
Dog dog=new Dog("a", "nb");
System.out.println(dog.toString());
}
}重写
如果从父类继承的方法不能满足子类的使用，则需要在子类中对父类的同名方法进行重写（覆盖），以符合要求。
重写需要满足如下要求：
1.重写的方法和被重写的方法必须要有相同的方法名和相同的参数列表。
2.重写的方法必须和被重写方法的返回值类型相同或者是其子类。
3.重写的方法不能缩小被重写方法的访问权限。
public void show(){
System.out.println("父类方法");
} public void show(){
super.show();
System.out.println("重写父类方法");
}Super关键字
super关键字代表对当前对象的直接父类对象的默认引用，在子类中可以通过super关键字来访问父类的成员。
注意：
1.super必须出现在子类的方法和构造方法中，而不是其他位置
2.可以访问父类的成员，如属性，方法，构造方法。
super.name;//访问父类的name属性
super.print();//访问父类的print方法
super(name)//访问父类对应的构造方法，只能出现在构造方法中。3.注意访问权限，比如不能访问private成员。
继承条件下构造方法调用规则：
1.如果子类没有通过super调用父类有参构造方法，也没有通过this调用自身的其他构造方法，则系统默认调用父类的无参构造
2.如果子类的构造方法中通过super调用了父类的有参构造，则不执行父类的无参构造
3.如果子类的构造方法通过this调用自身的其他构造方法,则在相应其他的构造方法中也应用前两条规则。
4.多级继承关系以上规则会多次应用于更高一级父类，直到Object的无参构造为止。
5.构造方法中如果有this或者super关键字，只能是第一条语句，也因此，super和this不能同时存在于构造方法中。(实例方法中没有这种规定）
6.类方法中（static修饰的方法）不允许存在this和super
public class Person {
String name;
public Person(){
System.out.println("execute Person");
}
public Person(String name){
this.name=name;
System.out.println("execute Person(name)");
}
}public class Student extends Person{
String school;
public Student(){
//super();//有没有该语句效果都一样
System.out.println("execute Student");
}
public Student(String name,String school){
super(name);//调用了父类的有参(name)构造,不执行无参
System.out.println("execute Student(name,school)");
}
}
public class PostGraduate extends Student{
String guide;
public PostGraduate(){
//super();//有没有该语句效果都一样
System.out.println("execute PostGraduate");
}
public PostGraduate(String name,String school,String guide){
super(name,school);//调用了父类的有参(name,school)构造,不执行无参
System.out.println("execute PostGraduate(name,school,guide)");
}
}
测试类：
public class Test {
/* 结果：
execute Person
execute Student
execute PostGraduate
execute Person(name)
execute Student(name,school)
execute PostGraduate(name,school,guide)
*/
public static void main(String[] args) {
//调用public PostGraduate(){}依次向上回溯
PostGraduate pg=new PostGraduate();
System.out.println();
//调用public PostGraduate(String name,String school,String guide){}依次向上回溯
pg=new PostGraduate("a","b","c");
}
}抽象类和抽象方法：
abstract关键字特点：
1.抽象类和抽象方法都可以通过abstract关键字来修饰。
2.抽象类不能实例化。抽象类中的抽象方法可以任意多个也可以没有。但是有抽象方法的类必须声明为抽象类。
3.抽象方法只有方法声明，没有方法实现。子类必须重写方法才能实例化，否则子类还是抽象类。
4.抽象类中可以有构造方法，不受影响。
5.abstract不能和private同时修饰一个方法（子类无法继承到private）
6.abstract不能和static同时修饰一个方法（无法访问一个没有实现的方法）
7.abstract不能和final同时修饰一个方法（final不能重写，而abstract要求子类重写，矛盾了）
//抽象类
public abstract class Pet {
private String name="qq";
private int health=100;
private int love=0;
//有参构造
public Pet(String name) {
this.name = name;
}
//抽象方法
public abstract void print();
//getter&setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
public int getLove() {
return love;
}
public void setLove(int love) {
this.love = love;
}
}public class Dog extends Pet{
private String strain;
public Dog(String name,String strain) {
super(name);
this.strain=strain;
}
//抽象方法的重写
@Override
public void print() {
System.out.println("a");
}
public String getStrain() {
return strain;
}
public void setStrain(String strain) {
this.strain = strain;
}
}
Final修饰符：
用final修饰的类不能再被继承
final class Penguin{}
class SubPenguin extends Penguin{}//报错，不能继承Penguin类用final修饰的方法不能被子类重写
class Penguin{
public final void print(){}
}
class SubPenguin extends Penguin{
public void print(){}//报错，不能重写
}final修饰的变量（成员变量或者局部变量）将变成常量，且只能赋值一次。
public class Penguin{
final String home="nan";
public void setHome(String home){
this.home=home;//报错，home不能二次赋值
}
}final修饰引用变量，变量的值是固定不变的（只能new一次），但变量所指的对象的属性值可以改变（new的对象的属性可以改变）。
public class Dog{
String name;
public Dog(String name) {
super();
this.name = name;
}
}public class Test {
public static void main(String[] args) {
final Dog dog=new Dog("oo");
dog.name="aa";//正确，所指对象内容可以改变
dog=new Dog("vv");//报错，变量不可以再指向其他对象。
}
}