Java第五章——面向对象（二）

重点：
封装（java访问控制权限）
继承（定义、子类访问控制权限）
类的组合的实现（与继承的区别）
多态（重载与覆写）

1.访问控制修饰符

Java的访问控制修饰符有哪些？各有什么访问权限？

访问权限控制符：

public（公共访问权限）
protected（包访问权限，继承访问权限）
无访问控制修饰（包访问权限）
private（类内部访问权限）

这些修饰符可以用于
（1）修饰类

	[类修饰符] class 类名（ ）

（2）修饰类的域变量（属性成员）
（3）修饰类的成员

2.继承

继承通过extends关键字实现

子类对于从父类继承的哪些属性与方法是可见的？请分别写程序进行验证。

子类继承了父类的所有属性和方法， 但只有public、protected的属性和方法在子类是可见的。

子类在继承父类的时候，首先应该满足父类可被访问，例如当子类和父类不在同一个包当中时，父类修饰符必为public；在父类能被访问的前提下，凡是修饰符为public或是protected的父类属性成员或是方法能被子类所访问；private的属性成员或是方法则不能被访问。

实例
1.子类访问父类的protected属性和方法

class Plane{
    protected String name;
    public void setName(String _name){
        name=_name;
    }
    public String getName(){
        return name;
    }
}
class FighterPlane extends Plane{
    private int missileNum;
    public void setNum(int _missileNum){
        missileNum=_missileNum;
    }
    public void fire(){
        missileNum-=1;
    }
}
public class Run{
    public static void main(String[] args){
        FighterPlane p=new FighterPlane();
        //子类可以直接访问父类的protected属性和方法
        p.name="su35";
        p.setName("f35");
        System.out.println(p.getName());
        p.fire();
    }
}

输出

f35

2.子类访问父类的private属性和方法

class Plane{
    private String name;
    public void setName(String _name){
        name=_name;
    }
    public String getName(){
        return name;
    }
}
class FighterPlane extends Plane{
    private int missileNum;
    public void setNum(int _missileNum){
        missileNum=_missileNum;
    }
    public void fire(){
        missileNum-=1;
    }
}
public class Run{
    public static void main(String[] args){
        FighterPlane p=new FighterPlane();
        //p.name="su35";name在Plane中是private 访问控制
        //子类不能直接访问父类的private属性和方法，可以调用父类的公共方法来间接访问私有属性
        p.setName("f35");
        System.out.println(p.getName());
        p.fire();
    }
}

输出

f35

3.组合

什么是组合？有什么作用？请举例说明

组合是选用已有类的对象作为，表达的是有一个的包含关系，是类的复用方式，优先于继承。

public class Point{//端点类
   private int x,y;
   public Point(int x,int y){
       this.x=x;
       this.y=y;
   }
   public int getX(){
       return x;
   }
   public int getY(){
       return y;
   }
}
class Line{//线段类
    private Point p1,p2;//两端点
    Line(Point a,Point b){
        p1=new Point(a.getX(),a.getY());
        p2=new Point(b.getX(),b.getY());
    }
}

多态——是指一个程序中同名的不同方法共存的情况
Java中提供两种多态机制：重载（overloading）与覆写（overriding）

4.重载

什么是重载？有什么作用？请构造各种重载示例
重载：方法名称相同，参数类型或个数不同
在编译器视角来看，方法签名=方法名称+参数类型+参数个数

public class StuManage {
    public int getScore(){
        return 3;
    }
    public int getScore(int i){
        return i;
    }
    /*public long getScore(int i){
        return i;
    }
    private int getScore(int i){
        return i;
    }
    public static int getScore(int i){
        return i;
    }
    public final int getScore(int i){
        return i;
    }*/
    //同名同参数但不同类型返回值的方法不是重载，编译不能通过
    public int getScore(Integer i){
        return i;
    }
    //可变参数，i实质上是数组int[]    
    public int getScore(int...i){
        return 3;
    }
}

p.getScore(5);调用public int getScore(int i)
p.getScore(1,3,5);调用public int getScore(int ... i)

5.覆盖（覆写）

什么是覆写？有什么作用？覆写父类方法的条件有哪些？请举例说明。

子类对父类的同名方法（方法名称相同，参数相同，返回类型相同）重新进行定义，即在子类中定义与父类中已定义的同名而内容不同的方法。

覆写需满足的条件：
子类的访问修饰符权限应等于或大于父类，不能变小
子类的返回类型能够向上转型成为父类的返回类型
异常也要能向上转型为父类的异常
方法名、参数类型及个数必须严格一致

注意：
覆写只能针对非静态，非final、非构造方法

class Parent {
    Number getScore(int a) {
      return new Integer(7);
   }
}
class Son extends Parent {
    @Override//所有的覆写方法需注明
    Number getScore(int b){
      return new Integer(8);
    }
 }
 public class RunSon{
    public static void main(String args[]){
      Son  s = new Son();
      System.out.println(s.getScore());
   }
}

在JDK中，很多父类的方法被子类重新覆盖，赋予了不同的含义，如Object类中的boolean equals(Object obj)方法

public boolean equals(Object obj){
    return this==obj;
}

public class Equals{
    public static void main(String[] args){
        String s1="apple";
        String s2="apple";
        System.out.println(s1==s2);//true
        System.out.println(s1.equals(s2));//equals比较的是内容，true
        String s3=new String();
        String s4=new String();
        System.out.println(s3==s4);//false
        System.out.println(s3.equals(s4));//初始化的两个对象都为 null，所以是相等，返回 true
    }
}

输出：

true
true
false
true

从上面例子可以看出来“==”比较的是两个引用的对象是否相等，而equals()方法比较的是两个对象的实际内容
内存分配空间为：