java面向对象编程_包_继承_多态_重载和重写_抽象类_接口

访问修饰限定符

java中的字段和方法的四种访问权限

public可以在不同包中的类访问！

protected不同包中继承关系访问！

默认包访问权限，只能在同一包中的类中访问！

privated只能在同一个类中访问

多态

在编程语言和类型论中，多态（英语：polymorphism）指为不同数据类型的实体提供统一的接口。多态类型（英语：polymorphic type）可以将自身所支持的操作套用到其它类型的值上。多态（百度词条）

向上转型

子类对象赋值给了父类引用

该对象只能访问父类的字段和方法！

直接赋值

子类对象赋值给了父类引用

class Animal{
    protected String name;
    protected int  age;
    public void eat(){
        System.out.println("animal eat()!");
    }
}
class Dog extends Animal{
    protected int height;
    public void running(){
        System.out.println("dog running()!");
    }
}
public class Test_1 {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal = new Dog();  //1.子类对象赋值给了父类引用
        Animal animal1 = new Dog(); //2.和 1 等价
        animal.eat(); //调用父类中的方法
        //error animal只能访问父类中的字段和方法！
        animal.height=1;
        animal.running();
    }
}

方法传参

//方法传参
class Animal{
    protected String name;
    protected int  age;
    public void eat(){
        System.out.println("animal eat()!");
    }
}
class Dog extends Animal{
    protected int height;
    public void running(){
        System.out.println("dog running()!");
    }
}
public class Test_2 {
    public static void func(Animal animal){
        animal.eat();
    }
    public static void main(String[] args) {
        Dog dog = new Dog();
        func(dog);
        func(new Dog()); //子类对象赋值给了父类引用！
    }
}

方法返回

//方法返回
class Animal{
    protected String name;
    protected int  age;
    public void eat(){
        System.out.println("animal eat()!");
    }
}
class Dog extends Animal{
    protected int height;
    public void running(){
        System.out.println("dog running()!");
    }
}
public class Test_2 {
    public static Animal func(){
       return new Dog();  //子类对对象返回给了父类引用！
    }
    public static void main(String[] args) {
       Animal animal = func();
       animal.eat();
    }
}

动态绑定

动态绑定就是，当子类重写了父类的方法时，向上转型后，对象调用与重写的方法，访问的是子类对象中的重写方法！

//运行时绑定
class Animal{
    protected String name;
    protected int  age;
    public void eat(){
        System.out.println("animal eat()!");
    }
}
class Dog extends Animal{
    protected int height;
    @Override
    public void eat() {
        System.out.println("dog eat()!");
    }
    public void running(){
        System.out.println("dog running()!");
    }
}
public class Test_2 {
    public static void main(String[] args) {
       Animal animal = new Dog();
       animal.eat(); //运行时绑定！
    }
}

为啥要叫运行时绑定呢？

难道说编译的时候没有绑定？

确实如此，当我们查看java的反汇编代码时就会发现，编译期间anmial调用的是自己的eat方法，但是运行时却绑定了子类的eat()!

java反汇编代码步骤：

找到，我们需要反汇编代码类的字节码文件

在命令符的窗口下，输入javap -c 类名代码回车即可！

理解多态

我们想一想多态可以帮助我们做些什么！

bug郭的理解

运行时绑定使用场景

我们可以重写父类的方法，实现多态。调用重写的方法，一个父类可以有多个子类，不同的子类重写了不同的方法，实现了真正意义上的多态！

eg:打印图形

//类的实现者
class Shape {
    public void draw() {
        // 啥都不用干
    }
}
class Cycle extends Shape {
    @Override
    public void draw() {
        System.out.println("○");
    }
}
class Rect extends Shape {
    @Override
    public void draw() {
        System.out.println("□");
    }
}
class Flower extends Shape {
    @Override
    public void draw() {
        System.out.println("♣");
    }
}
//类的调用者
public class Test_1{
    public static void main(String[] args) {
        Shape shape1 = new Flower();
        Shape shape2 = new Cycle();
        Shape shape3 = new Rect();
        drawShape(shape1);
        drawShape(shape2);
        drawShape(shape3);
    }
    // 打印单个图形
    public static void drawShape(Shape shape) {
        shape.draw();
    }
}

使用多态的好处是什么?

类调用者对类的使用成本进一步降低。

封装是让类的调用者不需要知道类的实现细节。

多态能让类的调用者连这个类的类型是什么都不必知道, 只需要知道这个对象具有某个方法即可。

因此, 多态可以理解成是封装的更进一步, 让类调用者对类的使用成本进一步降低。

能够降低代码的 “圈复杂度”, 避免使用大量的 if - else。

“圈复杂度” :就是代码中的分支和循环；

可扩展能力更强。

如果要新增一种新的形状，使用多态的方式代码改动成本也比较低。

向下转型

我们知道向上转型是子类对象赋值给了父类引用！

那向下转型莫不就是：父类对象赋值给了子类引用~

并不常见~了解一下即可！

//向下转型
class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food) {
        System.out.println("我是一只小动物");
        System.out.println(this.name + "正在吃" + food);
    }
}
class Bird extends Animal {
    public Bird(String name) {
        super(name);
    }
    public void eat(String food) {
        System.out.println("我是一只小鸟");
        System.out.println(this.name + "正在吃" + food);
    }
    public void fly() {
        System.out.println(this.name + "正在飞");
    }
}
public class Test_2 {
    public static void main(String[] args) {
        Animal animal = new Bird("鸽鸽"); //先借助向上转型
        animal.eat("脐橙");
        //animal.fly;  //error
        Bird bird;
        bird = (Bird)animal; //向下转型需要强转
        bird.fly();
    }
}

可以看到向下转型步骤比较繁琐，通常要借助向上转型！

而且我们需要确定是否为父子类关系！避免异常！

利用instanceof 关键字可以判定一个引用是否是某个类的实例。

若真返回true，若假返回false!

构造方法中调用一个重写的方法（一个坑！）

Plain Text

自动换行

xxxxxxxxxx

//坑

class B {

    public B() {

        // do nothing

        func();

    public void func() {

        System.out.println("B.func()");

class D extends B {

    private int num = 1;

    @Override

    public void func() {

        System.out.println("D.func() " + num);

public class Test_3{

    public static void main(String[] args) {

        D d = new D();

bug郭看了半天愣是没整明白为啥这个代码运行结果是这样！！！

我的理解：创建子类对象d会调用自己的构造方法，子类要先帮助父类构造，而父类中调用了子类重写的方法，动态绑定了；

我们并有执行子类中的 private int num = 1;语句！所以num此时并没有赋值！所以为0！

正解

构造D 对象的同时, 会调用B的构造方法.

B 的构造方法中调用了func方法, 此时会触发动态绑定, 会调用到D 中的func

此时 D对象自身还没有构造, 此时num 处在未初始化的状态, 值为 0.

结论: “用尽量简单的方式使对象进入可工作状态”, 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏但又及难发现的问题！

抽象类

基本语法

在刚才的打印图形例子中, 我们发现, 父类Shape中的 draw 方法好像并没有什么实际工作, 主要的绘制图形都是由Shape 的各种子类的 draw 方法来完成的. 像这种没有实际工作的方法, 我们可以把它设计成一个抽象方法(abstractmethod), 包含抽象方法的类我们称为抽象类(abstract class)。

abstract class Shape { 
    abstract public void draw(); 
}

注意事项

抽象类不能直接实例化。

抽象类可以有一般类一样的字段和方法，语法相同。

abstract class Shape {
    protected  int longth;
    protected int wide;
    public int area(){
        return longth*wide;
    }
     abstract public  void draw();
}