Java基础学习第九天——多态，抽象类，接口

最新推荐文章于 2023-05-26 14:12:17 发布
最新推荐文章于 2023-05-26 14:12:17 发布
阅读量1.5k 收藏 6
点赞数 1
分类专栏： Java 27天Java基础 文章标签： java基础 多态 抽象类 接口 final关键字
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lutianfeiml/article/details/50805914
版权
文档版本开发工具测试平台工程名字日期作者备注
V1.02016.02.29lutianfeinone

final 关键字

  • final关键字，可以修饰类，成员变量，成员方法。

  • 特点：

    • 修饰的类，类不能被继承
    • 修饰的变量，变量就变成了常量，只能被赋值一次
    • 修饰的方法，方法不能被重写
final关键字面试题

  • Eg1： final修饰局部变量

    • 在方法内部，该变量不可以被改变
    • 在方法声明上，分为基本类型和引用类型作为参数的情况
      • 基本类型，是值不能被改变
      • 引用类型，是地址值不能被改变，但是该对象堆内存的值可以改变。

  • Eg2： final修饰变量的初始化时机

    • 在对象构造完毕前即可

  • Eg 3:程序说明

class Student {
    int age = 10;
}

class FinalTest {
    public static void main(String[] args) {
        //局部变量是基本数据类型
        int x = 10;
        x = 100;
        System.out.println(x);
        final int y = 10;
        //无法为最终变量y分配值
        //y = 100;
        System.out.println(y);
        System.out.println("--------------");

        //局部变量是引用数据类型
        Student s = new Student();
        System.out.println(s.age);
        s.age = 100;
        System.out.println(s.age);
        System.out.println("--------------");

        final Student ss = new Student();
        System.out.println(ss.age);
        ss.age = 100;
        System.out.println(ss.age);

        //重新分配内存空间
        //无法为最终变量ss分配值
        ss = new Student();
    }
}


多态

多态概述
  • 某一个事物，在不同时刻表现出来的不同状态。
    • 举例：
      • 猫可以是猫的类型。猫 m = new 猫();
      • 同时猫也是动物的一种，也可以把猫称为动物。
        • 动物 d = new 猫();
  • 多态前提和体现
    • 有继承关系
    • 有方法重写
    • 有父类引用指向子类对象
      • Fu f = new Zi();
多态的分类
  • 具体类多态：
    • class Fu{}
    • class Zi extends Fu{}
    • Fu f = new Zi();
  • 抽象类多态：
    • abstract class Fu{}
    • class Zi extends Fu{}
    • Fu f = new Zi();
  • 接口多态：
    • interface Fu{}
    • class Zi implements Fu{}
    • Fu f = new Zi();
多态中的成员访问特点

  • A:成员变量:编译看左边，运行看左边。

  • B:构造方法:创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。

  • C:成员方法: 编译看左边，运行看右边。由于成员方法存在方法重写，所以它运行看右边。

  • D:静态方法:编译看左边，运行看左边。

    • (静态和类相关，算不上重写，所以，访问还是左边的)

  • eg:


class Fu {
    public int num = 100;

    public void show() {
        System.out.println("show Fu");
    }

    public static void function() {
        System.out.println("function Fu");
    }
}

class Zi extends Fu {
    public int num = 1000;
    public int num2 = 200;

    public void show() {
        System.out.println("show Zi");
    }

    public void method() {
        System.out.println("method zi");
    }

    public static void function() {
        System.out.println("function Zi");
    }
}

class DuoTaiDemo {
    public static void main(String[] args) {
        //要有父类引用指向子类对象。
        //父 f =  new 子();
        Fu f = new Zi();
        System.out.println(f.num);
        //找不到符号
        //System.out.println(f.num2);

        f.show();
        //找不到符号，不能使用子类独有的方法。
        //f.method();
        f.function();
    }
}

/*
* 运行结果：
100
show Zi
function Fu
*/


多态的优缺点
  • 多态的好处
    • 提高了程序的维护性(由继承保证)
    • 提高了程序的扩展性(由多态保证)

  • 多态的弊端

    • 父类不能访问子类特有功能

  • 如何才能访问子类的特有功能呢?

    • 创建子类对象，调用方法即可。（然而很多时候不合理，且太占内存）
    • 向下转型：把父类的引用强制转换为子类的引用。
      • Zi z = (Zi)f; //要求该f必须是能够转换为Zi的
  • 现象： 子可以当做父使用，父不能当作子使用。
多态中的转型问题
  • 向上转型
    • 从子到父
    • 父类引用指向子类对象

  • 向下转型

    • 从父到子
    • 父类引用转为子类对象

  • 孔子装爹案例（经典，精辟）

//多态的问题理解：
    class 孔子爹 {
        public int age = 40;

        public void teach() {
            System.out.println("讲解JavaSE");
        }
    }

    class 孔子 extends 孔子爹 {
        public int age = 20;

        public void teach() {
            System.out.println("讲解论语");
        }

        public void playGame() {
            System.out.println("英雄联盟");
        }
    }

    //Java培训特别火,很多人来请孔子爹去讲课，这一天孔子爹被请走了
    //但是还有人来请，就剩孔子在家，价格还挺高。孔子一想，我是不是可以考虑去呢?
    //然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子。就开始装爹

    //向上转型:父类引用指向子类对象
    孔子爹 k爹 = new 孔子();
    //到人家那里去了
    System.out.println(k爹.age); //40
    k爹.teach(); //讲解论语，一讲就露馅。
    //k爹.playGame(); //这是儿子才能做的,一做就报错！

    //讲完了，下班回家了
    //脱下爹的装备，换上自己的装备

    //向下转型：父类引用转为子类对象
    孔子 k = (孔子) k爹;
    System.out.println(k.age); //20
    k.teach(); //讲解论语
    k.playGame(); //英雄联盟



  • 多态案例的内存图解


  • 多态练习：猫狗案例
class Animal {
    public void eat(){
        System.out.println("吃饭");
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("狗吃肉");
    }

    public void lookDoor() {
        System.out.println("狗看门");
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}

class DuoTaiTest {
    public static void main(String[] args) {
        //定义为狗
        Animal a = new Dog();
        a.eat();
        System.out.println("--------------");
        //还原成狗
        Dog d = (Dog)a;
        d.eat();
        d.lookDoor();
        System.out.println("--------------");
        //变成猫
        a = new Cat();
        a.eat();
        System.out.println("--------------");
        //还原成猫
        Cat c = (Cat)a;
        c.eat();
        c.playGame();
        System.out.println("--------------");
    }
}


  • 不同地方饮食文化不同的案例

class Person {
    public void eat() {
        System.out.println("吃饭");
    }
}

class SouthPerson extends Person {
    public void eat() {
        System.out.println("炒菜,吃米饭");
    }

    public void jingShang() {
        System.out.println("经商");
    }
}

class NorthPerson extends Person {
    public void eat() {
        System.out.println("炖菜,吃馒头");
    }

    public void yanJiu() {
        System.out.println("研究");
    }
}

class DuoTaiTest2 {
    public static void main(String[] args) {
        //测试
        //南方人
        Person p = new SouthPerson();
        p.eat();
        System.out.println("-------------");
        SouthPerson sp = (SouthPerson)p;
        sp.eat();
        sp.jingShang();
        System.out.println("-------------");

        //北方人
        p = new NorthPerson();
        p.eat();
        System.out.println("-------------");
        NorthPerson np = (NorthPerson)p;
        np.eat();
        np.yanJiu();
    }
}

/*
运行结果：

炒菜,吃米饭
-------------
炒菜,吃米饭
经商
-------------
炖菜,吃馒头
-------------
炖菜,吃馒头
研究
*/


多态中继承

  • 继承的时候：

    • 子类中有和父类中一样的方法，叫重写。
    • 子类中没有而父类有的方法，方法就被继承过来了。

  • Eg:(重难点)


class A {
    public void show() {
        show2();
    }
    public void show2() {
        System.out.println("我");
    }
}

class B extends A {
    /* 此处完全可以认为B中是有show方法的，继承自A。
    public void show() {
        show2(); //因为内存堆中new的是class C，所以调用的将是C的show2()。
    }
    */

    public void show2() {
        System.out.println("爱");
    }
}

class C extends B {
    public void show() {
        super.show();
    }

    public void show2() {
        System.out.println("你");
    }
}

public class DuoTaiTest4 {
    public static void main(String[] args) {
        A a = new B();
        a.show();

        B b = new C();
        b.show();
    }
}

// 运行结果：
//爱
//你


抽象类

抽象类概述
  • 动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。在Java中，一个没有方法体(连大括号也没有)的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
抽象类特点

  • 抽象类和抽象方法必须用abstract关键字修饰

    • 格式
      • abstract class 类名 {}
      • public abstract void eat();

  • 抽象类不一定有抽象方法，有抽象方法的类一定是抽象类。

  • 抽象类不能实例化(抽象类如何实例化呢?)

    • 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
    • 抽象类有构造方法，其作用是为了用于子类访问父类数据的初始化。

  • 抽象类的子类

    • 要么是抽象类
    • 要么重写抽象类中的所有抽象方法。
//abstract class Animal //抽象类的声明格式
abstract class Animal {
    //抽象方法
    //public abstract void eat(){} //空方法体,这个会报错。抽象方法不能有主体
    public abstract void eat();

    public Animal(){}
}

//子类是抽象类
abstract class Dog extends Animal {}

//子类是具体类，重写抽象方法
class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

class AbstractDemo {
    public static void main(String[] args) {
        //创建对象
        //Animal是抽象的; 无法实例化
        //Animal a = new Animal();
        //通过多态的方式
        Animal a = new Cat();
        a.eat();
    }
}


抽象类的成员特点
  • 成员变量
    • 可以是变量
    • 也可以是常量
  • 构造方法
    • 有构造方法，但是不能实例化
    • 那么，构造方法的作用是什么呢?
      • 用于子类访问父类数据的初始化

  • 成员方法

    • 可以有抽象方法 作用：限定子类必须完成某些动作
    • 也可以有非抽象方法 提高代码复用性

  • 抽象定义类练习：

//定义抽象的动物类
abstract class Animal {
    //姓名
    private String name;
    //年龄
    private int age;

    public Animal() {}

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //定义一个抽象方法
    public abstract void eat();
}

//定义具体的狗类
class Dog extends Animal {
    public Dog() {}

    public Dog(String name,int age) {
        super(name,age); //重要知识点！！！
    }

    public void eat() {
        System.out.println("狗吃肉");
    }
}

//定义具体的猫类
class Cat extends Animal {
    public Cat() {}

    public Cat(String name,int age) {
        super(name,age);
    }

    public void eat() {
        System.out.println("猫吃鱼");
    }
}

//测试类
class AbstractTest {
    public static void main(String[] args) {
    //测试狗类

      //具体类用法

        //方式1：
        Dog d = new Dog();
        d.setName("旺财");
        d.setAge(3);
        System.out.println(d.getName()+"---"+d.getAge());
        d.eat();

        //方式2：
        Dog d2 = new Dog("旺财",3);
        System.out.println(d2.getName()+"---"+d2.getAge());
        d2.eat();
        System.out.println("---------------------------");

      //抽象类用法

        //方式1：
        Animal a = new Dog();
        a.setName("旺财");
        a.setAge(3);
        System.out.println(a.getName()+"---"+a.getAge());
        a.eat();

        //方式2：
        Animal a2 = new Dog("旺财",3);
        System.out.println(a2.getName()+"---"+a2.getAge());
        a2.eat();

        //练习：测试猫类
    }
}


  • 抽象教师类练习：
//定义抽象的老师类
abstract class Teacher {
    //姓名
    private String name;
    //年龄
    private int age;

    public Teacher() {}

    public Teacher(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //抽象方法
    public abstract void teach();
}

//基础班老师类
class BasicTeacher extends Teacher {
    public BasicTeacher(){}

    public BasicTeacher(String name,int age) {
        super(name,age);
    }

    public void teach() {
        System.out.println("基础班老师讲解JavaSE");
    }
}

//就业班老师类
class WorkTeacher extends Teacher {
    public WorkTeacher(){}

    public WorkTeacher(String name,int age) {
        super(name,age);
    }

    public void teach() {
        System.out.println("就业班老师讲解JavaEE");
    }
}

class AbstractTest2 {
    public static void main(String[] args) {

        //测试(多态)
        //基础班老师
        Teacher t = new BasicTeacher();
        t.setName("刘意");
        t.setAge(30);
        System.out.println(t.getName()+"---"+t.getAge());
        t.teach();
        System.out.println("--------------");

        t = new BasicTeacher("刘意",30);
        System.out.println(t.getName()+"---"+t.getAge());
        t.teach();
        System.out.println("--------------");

        //就业班老师
        t = new WorkTeacher();
        t.setName("林青霞");
        t.setAge(27);
        System.out.println(t.getName()+"---"+t.getAge());
        t.teach();
        System.out.println("--------------");

        t = new WorkTeacher("林青霞",27);
        System.out.println(t.getName()+"---"+t.getAge());
        t.teach();
    }
}


抽象类的几个小问题

  • 一个类如果没有抽象方法，可以定义为抽象类?如果可以，有什么意义?

    • 可以
    • 禁止创建对象

  • abstract不能和哪些关键字共存

    • private 冲突
    • final 冲突
    • static 无意义(通过类名直接访问没有内容的方法体)


接口

接口概述
  • 狗一般就是看门，猫一般就是作为宠物。但是，现在有很多的驯养员或者是驯兽师，可以训练出：猫钻火圈，狗跳高，狗做计算等。而这些额外的动作，并不是所有猫或者狗一开始就具备的，这应该属于经过特殊的培训训练出来的。所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能。
    所以，为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可。
接口特点

  • 接口用关键字interface表示

    • 格式：interface 接口名 {}

  • 类实现接口用implements表示

    • 格式：class 类名 implements 接口名 {}

  • 接口不能实例化(接口如何实例化呢?)

    • 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态。

  • 接口的实现类（子类）：

    • 抽象类:实现接口，但意义不大
    • 具体类:重写接口中的所有抽象方法

  • 补充：多态的三种形式

    • 具体类多态（几乎没有）
    • 抽象类多态（常用）
    • 接口类多态（最常用 ）
接口成员特点
  • 成员变量
    • 只能是常量
    • 默认修饰符 public static final
  • 构造方法
    • 没有构造方法，因为接口主要是扩展功能的，而没有具体存在。
    • 所有的类都默认继承自一个类：Object。（类Object 是类层次结构的根类。每个类都使用Object作为超类）
  • 成员方法
    • 只能是抽象方法
    • 默认修饰符 public abstract


类与类,类与接口 以及 接口与接口 的关系

  • 类与类

    • 继承关系，只能单继承，但是可以多层继承

  • 类与接口

    • 实现关系，
      • 可以单实现，也可以多实现。
      • 还可以在继承一个类的同时实现多个接口。

  • 接口与接口

    • 继承关系，可以单继承，也可以多继承
抽象类和接口的区别

  • 成员区别

    • 抽象类
      • 成员变量：变量,常量;
      • 构造方法：可以有
      • 成员方法：可以是抽象方法，也可以是非抽象方法;
    • 接口
      • 成员变量：只可以是常量;
      • 构造方法：没有
      • 成员方法：只能是抽象方法

  • 设计理念区别

    • 抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能
    • 接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能

  • 跳高猫练习：

/*
    猫狗案例,加入跳高的额外功能

    分析：从具体到抽象
        猫：
            姓名,年龄
            吃饭，睡觉
        狗：
            姓名,年龄
            吃饭，睡觉

        由于有共性功能，所以，我们抽取出一个父类：
        动物：
            姓名,年龄
            吃饭();
            睡觉(){}

        猫：继承自动物
        狗：继承自动物

        跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口
        接口：
            跳高

        部分猫：实现跳高
        部分狗：实现跳高
    实现；
        从抽象到具体

    使用：
        使用具体类
*/

//定义跳高接口
interface Jumpping {
    //跳高功能
    public abstract void jump();
}

//定义抽象类
abstract class Animal {
    //姓名
    private String name;
    //年龄
    private int age;

    public Animal() {}

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //吃饭();
    public abstract void eat();

    //睡觉(){}
    public void sleep() {
        System.out.println("睡觉觉了");
    }
}

//具体猫类
class Cat extends Animal {
    public Cat(){}

    public Cat(String name,int age) {
        super(name,age);
    }

    public void eat() {
        System.out.println("猫吃鱼");
    }
}

//具体狗类
class Dog extends Animal {
    public Dog(){}

    public Dog(String name,int age) {
        super(name,age);
    }

    public void eat() {
        System.out.println("狗吃肉");
    }
}

//有跳高功能的猫
class JumpCat extends Cat implements Jumpping {
    public JumpCat() {}

    public JumpCat(String name,int age) {
        super(name,age);
    }

    public void jump() {
        System.out.println("跳高猫");
    }
}

//有跳高功能的狗
class JumpDog extends Dog implements Jumpping {
    public JumpDog() {}

    public JumpDog(String name,int age) {
        super(name,age);
    }

    public void jump() {
        System.out.println("跳高狗");
    }
}

class InterfaceTest {
    public static void main(String[] args) {
        //定义跳高猫并测试
        JumpCat jc = new JumpCat();
        jc.setName("哆啦A梦");
        jc.setAge(3);
        System.out.println(jc.getName()+"---"+jc.getAge());
        jc.eat();
        jc.sleep();
        jc.jump();
        System.out.println("-----------------");

        JumpCat jc2 = new JumpCat("加菲猫",2);
        System.out.println(jc2.getName()+"---"+jc2.getAge());
        jc2.eat();
        jc2.sleep();
        jc2.jump();

        //定义跳高狗并进行测试的事情自己完成。
    }
}
  • 运行结果
鹿天斐
关注
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java-多态，抽象类
PreyHard的博客
10-19 246
一.多态 （1）多态的概述 某一个事物在不同时刻表现出来的不同状态 （2）多态的前提 a要有继承关系 b要有方法重写 c要有父类引用指向子类对象。 （3）多态中的成员访问特点 a成员变量 编译看左边，运行看左边 b构造方法 创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化 c成员方法 编译看左边，运行看右边 d静态方法 编译看左边，运行看左边 案例 0 从图片中可以看到，使用多态...
java---多态和抽象类
qq_56537698的博客
04-23 437
在以后的开发中推荐使用多态的格式，此时父类类型引用直接调用的所有方法一定是父类中拥有的方法，若以后更换子类时，只需要将new关键字后面的子类类型修改而其他地方无需改变就可以立即生效，从而提高了代码的可维护性和可扩展性。当父类类型的引用指向子类类型的对象时，对于父子类都有的非静态方法来说，编译阶段调用父类版本，允许阶段调用子类重写的版本。当父类类型的引用指向子类类型的对象时，父类类型的引用不可以直接调用子类独有的方法。当父类类型的引用指向子类类型的对象时，父类类型的引用可以直接调用父类独有的方法。
Java多态+抽象类
xdh1996的博客
08-06 1184
导学 本章节，我们将要学习面向对象三大特性之一的多态，所谓的多态，字面意义来看就是多种形态。它是面向对象程序设置的最核心的特征。从某种意义上来讲，封装和继承都是为了多态而准备的。 多态的概念 在构建对象时，等号左边被称之为对象的引用，等号右边称之为对象 实际上sc时一个对象的名字，sc指向一个具体的对象 多态指的是父类的引用指向的子类对象 造成多态的原因其实是：在堆内存的存储中，子类对象的内存空间套上了一层父类的类型 多态：父类引用指向子类对象 准确来说也并不是 这也是众多方法..
Java-多态、抽象类、接口
HysteriaD的博客
11-22 275
Java多态、抽象类、接口（部分）详解
多态与抽象类（Java）
m0_52083255的博客
09-23 671
JAVA中的多态与抽象类说明：1. 多态1.1 多态的概念1.2 多态的分类1.3 多态实现的条件1.4 再次认识重写1.5 重写与重载的区别2. 向上转型与向下转型2.1 向上转型2.2 向下转型3. 使用多态的优点4. 抽象类4.1 抽象类的概念4.2 抽象类的语法格式4.3 抽象类的特性 说明： 运行环境： JDK8 1. 多态 1.1 多态的概念 通俗来说，就是指完成某个行为，当不同的对象去完成时就会产生出不同的状态； （1）看个简单的例子： 同样是打印机打印，当彩色打印机去打印时，就会出现彩色的
第三周--面向对象之继承、多态，抽象类以及接口
Awww_20的博客
08-13 737
在上周，我们学习了面向对象的第一大特征——封装，这周将封装的知识做了补充，并且学习了面向对象的另外两个特征——继承和多态，还有抽象类以及接口
【3-4】《Java面向对象高级知识》——继承、重写和重载、final关键字、抽象类、接口、多态、Object类、内部类、包装类、可变参数、递归
程序媛乐园
09-27 941
文章目录一、继承格式二、子类实例化内存分析三、super详解四、重写1、重写的概念2、重写和重载的区别五、final关键字六、抽象类1、抽象类的概念2、抽象类常见问题3、抽象类和普通类的区别七、接口1、面向接口编程思想2、接口的编写3、接口和抽象类的区别八、多态1、多态的体现2、instanceof九、Object类概述1、toString2、equals十、内部类概述1、成员内部类（了解）2、局部内部类3、匿名内部类4、静态内部类 一、继承格式 非常重要的部分！！！ 格式：先描述父类，再描述子类，子类通
Java基础——4、面向对象（下）——单例、final、抽象类、接口、内部类
强子的博客
11-11 255
接上一章 面向对象（中） 目录凡是被static修饰的结构，都是随着类的加载而加载，只加载一次1、关键字：static1.1、类变量（static修饰的）和实例变量的内存解析2、23种设计模式创建型模式——5种结构型模式——7种行为型模式——11种3、单例设计模式3.1、单例模式如何实现？饿汉式：懒汉式：3.2、饿汉式 VS 饿汉式3.3、单例设计模式—应用场景4、理解main方法的语法5.1、属性赋值的先后顺序6、关键字：final7、抽象类与抽象方法7.1、思考抽象类的问题?7.2、abstract关键
Java第七章继承、多态、抽象类和接口
最新发布
2303_76552114的博客
05-26 217
如果将draw()方法放置在另外一个类中，让那些需要draw()方法的类继承该类，不需要draw()方法的类继承图形类，又会产生新的问题:所有的子类都需要继承图形类，因为这些类是从图形类中导出的，同时某些类还需要 draw0方法，而 Java中规定类不能同时继承多个父类。如果定义一个图形类，让它处理所有继承该类的对象，根据“向上转型”原则可以使每个继承图形类的对象作为draw方法的参数，然后在draw方法中做一些限定就可以根据不同图形类对象绘制相应的图形。因为鸽子是具体的，鸟是抽象的。
Java 真的不难（七）多态、抽象类
小应学长的的博客
01-05 901
小应学长带你学Java
No_16_0229 Java基础学习第九天
weixin_34419326的博客
03-02 164
文档版本 开发工具 测试平台 工程名字 日期 作者 备注 V1.0 2016.02.29 lutianfei none final 关键字多态多态概述多态的分类：多态中的成员访问特点：多态的优缺点多态中的转型问题多态中继承练习抽象类抽象类概述抽象类特点抽象类的成...
对java多态，抽象类以及接口的理解
Young
03-13 1257
java 的三大特征：继承，封装，多态。 封装：将事物拥有的属性和动作隐藏起来，只保留特定的方法与外界联系。一个类把自己该做的事情封装起来，而不是暴露给其他类去处理，当内部的逻辑发生变化时，外部调用不用因此而修改，他们只调用开放的接口，而不用去关心内部的实现 继承：提高代码的复用性，同时也是多态的基础。 多态：父类引用指向子类对象，通过子类的方法重写，父类对象在向下转型中，不同子类可能会表现出...
2021-10-21 迈向程序猿的第十一步
qq_48654729的博客
10-21 372
目录 一.多态 1.1 多态核心 1.2 多态直接引用 1.3 多态以传参方式出现 1.4 多态以返回值形式出现 二.抽象类 2.1 抽象类概述 一.多态 生活中的多态：客观事物在人脑中的主观反应；也就是说对象与某个类间存在“is a”关系 例如：大黄是一条狗，也是一个动物，这种关系就是多态的形成 程序中的多态：父类引用指向子类对象，在程序中形成了多态 用法： 可以调用父类的方法，但是不能调用子类独有的方法 1.1 多态核心 //案例：...
用孔子装爹学习java三大特性之多态
qq_45251343的博客
07-27 468
孔子装爹例子学多态一、 概述1.1引入1.2 定义1.3 前提【重点】2 例子一2.1 父类2.2 子类2.3 启动类2.4 打印二.、例子2：孔子装爹（只是个名字）2.1 孔子爹2.2孔子2.3 多态启动类2.4 我们更改一下各项三 、多态的体现四、多态的好处五、引用类型转换1. 向上转型2. 向下转型3. 为什么要转型 一、 概述 1.1引入 多态是继封装，继承之后，面向对象的第三大特征。 生活中，比如跑得动作，小猫小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫，鸟类和飞机，飞起来也
Java学习笔记——参数传递的方式、super的使用、多态、抽象类、接口
GZAY的博客
03-06 968
我们对接口的理解，不能独立于其实现的类，接口应该说是实现类的一部分，对实现类实例化对象的方法调用可以看做对接口方法的实现，接口和实现类有种连接关系，就像一个发电站，给不同实现类所需的能量，而实现类用这个电去做什么，就要看具体用在什么地方了。
JavaSE学习总结第09天_面向对象4
diaoji9561的博客
05-17 157
09.01 final关键字引入 例: 1 class Fu 2 { 3 public final void show() 4 { 5 System.out.println("访问底层资源"); 6 } 7 } 8 class Zi extends Fu 9 { 10 public void...
java面向对象之封装、继承、多态
thisfeng
08-11 590
————一、封装 概念 封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。 面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象， 这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术，在java中通过关键字priv
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值