面向对象——封装、继承、多态

封装

把数据私有化（private），使得需要存入（set）或获得（get）数据需要通过方法进行。

public class Person{
    //对属性的封装
    //一个人的姓名、年龄均属于其私有属性
    //这种情况下，无法直接存入或获取属性
    private String name;
    private int age;
  
    //对其进行方法的封装
    //通过调用方法来控制属性的存入和获取
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }  
}

继承

如果类A继承类B，那么类B就是类A的父类，类A就是类B的子类。

注意：

 

1、继承用extends和implements来表示
　　a、extends针对普通父类使用
　　b、implements针对接口使用
2、一个子类只能继承一个父类，但可以继承多个接口
3、子类不能继承父类带final、private修饰的方法和属性

以下我们从三个方面来说明继承：

1、普通父类的继承（private、protected、public、final、static）

public class Father {
    /*
     * 父类：
     *         1、private的小金库
     *         2、protected修饰的工作
     *         3、public修饰的卧室
     */
    private int money;
    protected String work;
    public String bedroom;
    
    /*
     * 获取小金库及存入小金库的方法
     */
    public void setMoney(int money){
        this.money = money;
    }
    public int getMoney(){
        return money;
    }
    //建立一个无法继承的final方法
    final String sport(){
        return "下班去运动";
    }
    static String ring(){
        return "戒指安静地带在无名指上";
    }

    public String getBedroom() {
        return bedroom;
    }

    public void setBedroom(String bedroom) {
        this.bedroom = bedroom;
    }
}

public class Son extends Father{
    //子类继承父类
    /*
     * 子类继承了父类的存入小金库的方法和进入卧室的方法，
     * 比较两个方法，我们可以看到，setMoney里面有super（超类），
     * 而setBedroom里面直接可以用this，
     * 这说明了子类没有继承父类中的money属性
     * 而继承了父类中的bedroom属性
     * 则子类没法继承父类的private方法
     */
    public void setMoney(int money){
        super.setMoney(money);
    }
    public void setBedroom(){
        this.bedroom = bedroom;
    }
    //下面这个方法会报错，因为父类定义了final
//    public String sport(){
//        
//    }
    
    //下面这个方法也会报错，因为用static修饰了ring，不能再被继承
//    public String ring(){
//        
//    }
}

2、抽象类的继承

public abstract class Dog {
    public String name;
    /*
     * 建立一个Dog抽象类
     * 1、定义一个run方法
     * 2、判断是否eat
     * 3、定义一个sleep方法
     */
    //以下两个类都是abstract修饰，所以子类一定要继承
    //抽象类不可定义private方法
    protected abstract void run();
    public abstract boolean eat();
    /*
     * sleep方法没有abstract修饰，
     * 所以需要有方法体，
     * 同时子类不一定要继承
     */
    
    public void sleep() {
    }    
}

public class Pupper extends Dog {
    /*
     * Pupper类继承Dog类的方法
     * Dog类定义的抽象方法都需重写（public、protected）
     * 没有定义抽象类的不一定要重写
     */
    public void run() {
        System.out.println("Pupper can't run very fast!");
    }
    public boolean eat() {
        return true;
    }
}

3、接口的继承

public interface Base {
    //接口Base定义了增删改查的方法
    public void add();
    public void delete();
    public void update();
    public void query();
}

public interface Dictionary extends Base {
    //继承Base类中的基础方法
    public void choice();
}

public class DictionaryD implements Dictionary {
    /*
     * DictionaryD继承接口Dictionary,
     * 此时需要继承所有的Dictionary接口中的方法
     */
    public void add() {
    }
    public void delete() {
    }
    public void update() {
    }
    public void query() {
    }
    public void choice() {
    }
}

 多态

多态就是同一个行为具有多个不同的表现形式或形态的能力
多态存在的三个必要条件：
1、继承
2、重写
3、父类引用指向子类对象

实现多态的3种手段：
1、虚方法
2、抽象类
3、接口

abstract class Human {
    //定义人类有吃的抽象方法
    abstract void eat();
}

public class Man extends Human{
    //男人继承人类的方法
    public void eat() {
        System.out.println("男人就该大口喝酒大口吃肉，但别被老婆发现");
    }
}

public class Woman extends Human{
    //女人同样继承人类的吃方法，但是和男人的吃方法不同
    public void eat() {
        System.out.println("女人就该在众人面前保持矜持的吃法，但没人看就吃多");
    }
}

public class HumanDemo {
    public static void main(String []arg){
        //向上转型
        Human m = new Man();
        Human w = new Woman();
        m.eat();
        w.eat();
        //向下转型
        Man M = (Man)m;
        M.eat();
    }
}