Java面向对象（中）

Java访问控制修饰符

---

封装：

封装就是利用抽象数据类型（类）将数据（类的属性）和基于数据的操作（方法）绑定在一起，数据被保存在抽象数据类型内部（类的内部），系统只有通过被授权的方法才能够访问数据。（访问权限由访问控制修饰符限定）

封装是利用访问控制符来实现的！

---

访问控制权限

1. public（共有的）
2. protected（被保护的）
3. 默认（无任何访问控制修饰符）
4. private（私有的）
   public权限最大，private权限最小

在程序中，以上四类访问控制权限修饰符可用于：

1. 修饰类
2. 修饰类的域变量（属性成员）
3. 修饰类的成员方法

当修饰符修饰类时：

当类前的修饰符为public时，这个类可以被所有类访问（通过import）；
当类无任何修饰符（即默认）是，只能被同一个包中的类所访问；
注意：类前的修饰符只能为以上两种。

当修饰符修饰类中方法或属性时：

前提：类前修饰符为public
方法或属性修饰符为：

• public
  则该属性或方法可被所有类访问。

• protected
  若被修饰的属性或方法用于其他类的定义，则访问权限为包中的类和所有子类；
  若被修饰的属性或方法用于对象引用，则只能被包中的类访问；

• 默认
  只能被包中的类访问；

• private
  只能被本类内部的方法所访问；

前提：类前修饰符为默认
方法或属性修饰符为：

• public
  只能被包中的类访问；
• protected
  只能被包中的类访问；
• 默认
  只能被包中的类访问；
• private
  只能被本类内部方法访问；

---

组合

class FighterPlane{
    String name;
    int missileNum;
    public FighterPlane(String _name,int _missileNum){
        name=_name;
        missileNum=_missileNum;
    }
    public void fire(){
        if(missileNum>0){
            System.out.println("now fire a missile!");
            missileNum--;
        }
        else {
            System.out.println("No missile left!");
        }
    }
}
class A{
    FighterPlane fp;
    public A(FighterPlane fpp){
        this.fp=fpp;//A对象中有了FighterPlane对象的引用
    }
    public void invoke(){
        System.out.println(fp.name); //A对象发送消息给FighterPlane的对象
    }
}
public class Run{
    public static void main(String[] args){
        FighterPlane ftp=new FighterPlane("su35",10);
        A a=new A(ftp);//产生A对象，并将ftp作为对象引用传入
        a.invoke();//发送消息，产生调用关系
    }
}

输出：su35
说明：A类对象属性fp引用FighterPlane对象，就将A对象和FighterPlane对象组合起来——A对象和FighterPlane对象在内存中虽然是两个对象，但是由于A中拥有FighterPlane对象的引用，就可以把A对象看成是由FighterPlane对象组合而成的。

---

继承

Java的继承是通过extends关键字来实现的，即通过extends关键字使两个类发生继承关系。（Java中只能是单继承，即一个类只允许有一个父类）；
在父类能被访问的前提下，（子类继承父类时，首先要满足父类可被访问），修饰符为public和protected的父类属性成员及方法能被子类所访问；
修饰符为provide的属性成员或方法不能被直接访问，可通过可访问的方法间接访问。
如：

class Plane{
    private String name;//当修饰符为public子类可直接访问
    public void setName(String _name){
        name=_name;
    }
    public String getName(){
        return name;
    }
}
class FighterPlane extends Plane{
    private int missileNum;
    public void setMissileNum(int _missileNum){
        missileNum=_missileNum;
    }
    public void fire(){
        if(missileNum>0){
            System.out.println("now fire a missile!");
            missileNum--;
        }
        else {
            System.out.println("No missile left!");
        }
    }
}
public class RunPlane{
    public static void main(String[] args){
        FighterPlane fp=new FighterPlane();
        fp.setMissileNum(6);
        //fp.name;父类修饰符为public时可直接访问
        fp.setName("苏苏苏");//通过父类共有方法setName间接访问父类私有属性
        System.out.println(fp.getName());
        fp.fire();
    }
}
//输出：
//苏苏苏
//now fire a missile!

---

重载

定义：在类中定义了多个同名而不同内容参数的成员方法时，称这些方法是重载。
例：

class Parent{
    public int getScore(){//无参数
        return 3;
    }
    public int getScore(int i){//有一个参数
        return i;
    }
    public String getScore(String a){
    	return a;
    }
    //同名同参数但不同类型返回值的方法不是重载,编译不能通过
    /*public long getScore(int i){
    	return i;
    }*/
}

代码编写中，重载的多个方法之间往往存在一定的调用关系，即一个方法写有实现功能，其他方法采用委托方式进行调用——体现了程序共享的设计思想；
如：

public boolean addAll(Collection c){
    return addAll(size,c);
    //size是当前集合所拥有的对象引用数量，此方法调用下面的方法
}
//类似数组下标，每个对象引用在集合结构当中都拥有index
public boolean addAll(int index,Collection c){
        ...//真正的实现代码
}

---

覆盖

定义：子类对父类参数相同，返回类型相同的同名方法重新进行定义，这种多态被称为覆盖；
例：

class Parent{
    public int getScore(){
        return 3;
    }
    public String getCountryName(){
        return "China";
    }
}
class Son extends Parent{
    //覆写父类方法
    public int getScore(){
        return 4;
    }
    //与父类名称相同，但参数不同，为重载
    public int getScore(int i){
        return i;
    }
}
public class RunSon{
    public static void main(String[] args){
        Son s=new Son();
        System.out.println(s.getScore());
        System.out.println(s.getCountryName());
    }
}
//输出
//4
//China

注意：

1. 子类方法覆盖父类方法，子类的访问修饰符权限应等于或大于父类；
2. 同名的static方法和非static方法不能相互覆盖；
3. final修饰符方法不能覆盖；
4. JDK当中，很多父类的方法被子类重新覆盖，赋予了不同的含义。例如Object中的方法boolean equals（Object obj），是比较两个对象引用是否相同，而一些子类如Integer或String，将它们覆盖，此时虽然传入的是对象，但是比较的是对象所代表的值；
5. 抽象类中如果存在抽象方法，则具体子类必须对抽象方法进行覆盖；