面向对象程序设计:封装,继承,多态,方法重写和重载的区别

 一. **封装**:
 封装有四种访问权限,public,protected,default,private,这四种权限的区别如下:
 1.public. 所有人都能使用
 2.protected. 只能是相同包中的类可以使用,不同包中的子类可以访问父类的protected属性.
 3.default. 相同包中的类可以使用
 4.private.类内部可以使用
 封装的意义:可以降低代码的复杂度,类的实现者的实现细节可以隐藏起来(private),这样类的使用者就不必关注过多的内容.
 二**.继承**:
 继承主要要用到这几个关键字:
 1.extends关键字: 使用extends关键字,子类就拥有了父类的所有属性和方法(拥有不代表就能访问).
 2.super关键字: 父类对象的引用,例如:super.name 就是调用父类的name 属性;super(name)表示调用父类的构造方法,传入那么参数,
 继承需要注意的问题: 
 只允许单一继承,任何一个类,只有一个直接继承的父类.
 继承层次太多的时候,代码也会显得非常混乱,最好控制继承的层次<=3;
 final会显示禁止某个类被继承,表示最后一个类,不可被继承或者修改.
 三.**多态**:
 多态一个引用可能表现出多种形态,一个父类引用可以对应到不同的子类对象,不同子类对象具体的行为都会存在差异.
 语法上的体现:
 1.向上转型: Animal cat=new Cat();创建子类对象指向父类引用作为方法参数,作为返回值     
 2.动态绑定:调用方法的时候要关注当前引用的实际类型
 3.方法重写:子类和父类中具有相同名字,相同参数的方法,调用这个方法的时候,最终执行父类版本还是子类版本,取决于引用对应的实际对象类型.
 方法重写是Java语法上的约定,动态绑定描述的是jvm底层执行规则,方法重写这样的语法机制,是基于动态绑定来实现的.
 **方法重写和方法重载的区别**
 方法重载(overload)
 描述两个普通方法之间,名字相同,参数不同,和继承没有直接关系,和返回值无关;
 方法重写(override)
 必须是父类方法和子类方法之间,名字相同,参数也相同,和返回值无关,一般情况下在重写方法的时候尽量不要修改返回值的类型.
 **多态的好处**:
 1.类的使用者对于类的使用成本进一步降低(不需要知道类型)
 2.多态也能够降低代码的圈复杂度(代码中if语句,while for语句等的数量)
 3.代码的扩展能力增强

下面写一个例子方便更好的理解封装 继承和多态:
父类:

public class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat(String food) {
        System.out.println("Animal.eat");
        System.out.println(this.name + " 正在吃 " + food);
    }
}

 创建子类bird继承这个父类:重写父类的eat方法,用super调用父类的eat方法,传入参数"谷子"

public class Bird extends Animal {

    public Bird(String name) {
        // 调用父类的构造方法
        super(name);
    }

    @Override
    public void eat(String food) {
        System.out.println("Bird.eat");
        System.out.println(super.name + " 正在吃 " + food);
    }

    public void fly() {
        System.out.println(this.name + " 使用翅膀正在飞");
        // 调用 eat, this 对应的是 Bird 类型
        super.eat("谷子");
    }
}

测试一下:

public class Test {
    public static void main(String[] args) {
        Animal animao =new Animal(name:"小动物");
        animal.eat(food:"爆米花");
        Animal bird=new Bird(name:"圆圆");//向上转型
        bird.eat(food:"谷子");//动态绑定,eat方法执行效果如何,要在运行时看bird是什么类型的

    }
}

运行结果:

说明动态绑定后,执行的还是子类的eat;

多态的应用:
先创建子类

public class Shape {
    public void draw() {
        // 绘制
        // 对于 Shape 来说暂时啥都不画
    }
}

子类重写父类方法:

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("○");
    }
}

public class Rect extends Shape {
    @Override
    public void draw() {
        System.out.println("□");
    }
}

public class Flower extends Shape {
    @Override
    public void draw() {
        System.out.println("♣");
    }
}

public class Test {
    public static void main(String[] args) {
        Shape shape=new circle();//向上转型
        shape.draw();
        shape=new Rect();
        shape.draw();
        shape=new Flower();
        shape.draw();

    }

结果: