精华内容
下载资源
问答
  • Java继承和多态

    2016-12-10 17:38:34
    Java继承和多态
  • JAVA继承和多态

    2019-03-13 15:12:02
    JAVA继承和多态的使用 继承(inheritance) 简单的说,继承就是在一个现有类型的基础上,通过增加新的方法或者重定义已有方法(下面会讲到,这种方式叫重写)的方式,产生一个新的类型。继承是面向对象的三个基本特征...

    JAVA继承和多态的使用

    继承(inheritance)

    简单的说,继承就是在一个现有类型的基础上,通过增加新的方法或者重定义已有方法(下面会讲到,这种方式叫重写)的方式,产生一个新的类型。继承是面向对象的三个基本特征–封装、继承、多态的其中之一,我们在使用JAVA时编写的每一个类都是在继承,因为在JAVA语言中,java.lang.Object类是所有类最根本的基类(或者叫父类、超类),如果我们新定义的一个类没有明确地指定继承自哪个基类,那么JAVA就会默认为它是继承自Object类的。

    JAVA中的类分为以下三种:

    类:使用class定义且不含有抽象方法的类。
    抽象类:使用abstract class定义的类,它可以含有,也可以不含有抽象方法。
    接口:使用interface定义的类。

    同时这三种类型之间存在着以下继承规律:

    1. 类可以继承(extends)类,可以继承(extends)抽象类,可以继承(implements)接口。
    2. 抽象类可以继承类,可以继承抽象类,可以继承接口。
    3. 接口只能继承接口。

    多态(Polymorphism)

    多态又分为设计时多态和运行时多态,例如重载又被称为设计时多态,而对于覆盖或继承的方法,JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。总而言之,面向对象的设计的典型特点就是继承,封装和多态,这些特点也是面向对象之所以能如此盛行的关键所在。

    博客设置页面,选择一款你喜欢的代码片高亮样式,下面展示同样高亮的 代码片.

    //汽车接口 
    interface Car { 
      // 汽车名称 
      String getName(); 
      
      // 获得汽车售价 
      int getPrice(); 
    } 
      
    // 宝马 
    class BMW implements Car { 
      public String getName() { 
        return "BMW"; 
      } 
      
      public int getPrice() { 
        return 300000; 
      } 
    } 
      
    // 奇瑞QQ 
    class CheryQQ implements Car { 
      public String getName() { 
        return "CheryQQ"; 
      } 
      
      public int getPrice() { 
        return 20000; 
      } 
    } 
      
    // 汽车出售店 
    public class CarShop { 
      // 售车收入 
      private int money = 0; 
      
      // 卖出一部车 
      public void sellCar(Car car) { 
        System.out.println("车型:" + car.getName() + " 单价:" + car.getPrice()); 
        // 增加卖出车售价的收入 
        money += car.getPrice(); 
      } 
      
      // 售车总收入 
      public int getMoney() { 
        return money; 
      } 
      
      public static void main(String[] args) { 
        CarShop aShop = new CarShop(); 
        // 卖出一辆宝马 
        aShop.sellCar(new BMW()); 
        // 卖出一辆奇瑞QQ 
        aShop.sellCar(new CheryQQ()); 
        System.out.println("总收入:" + aShop.getMoney()); 
      } 
    } 
    
    

    运行结果:
    车型:BMW 单价:300000
    车型:CheryQQ 单价:20000
    总收入:320000

    继承是多态得以实现的基础。从字面上理解,多态就是一种类型(都是Car类型)表现出多种状态(宝马汽车的名称是BMW,售价是300000;奇瑞汽车的名称是CheryQQ,售价是2000)。

    将一个方法调用同这个方法所属的对象或类关联起来叫做绑定,分前期绑定后期绑定两种。下面解释一下它们的定义:

    前期绑定:在程序运行之前进行绑定,由编译器和连接程序实现,又叫做静态绑定。比如static方法和final方法,注意,这里也包括private方法,因为它是隐式final的。
    后期绑定:在运行时根据对象的类型进行绑定,由方法调用机制实现,因此又叫做动态绑定,或者运行时绑定。除了前期绑定外的所有方法都属于后期绑定。

    多态就是在后期绑定这种机制上实现的。多态给我们带来的好处是消除了类之间的耦合关系,使程序更容易扩展。

    展开全文
  • java 继承和多态的讲解
  • java继承和多态PPT教案学习.pptx
  • java 继承和多态

    2012-02-07 15:05:23
    学习java的好工具,让你更加容易理解java的基本概念!
  • java继承和多态ppt

    2011-12-05 20:20:15
    java 继承和多态PPT教程
  • Java 继承和多态

    千次阅读 2018-09-04 14:12:26
    //子类继承父类后自动拥有父类的 publicprotected的 属性方法 //把多个子类中重复的代码提取到父类中可以减少代码量 //父类的 构造方法 无法继承给子类 public class Dog extends Animal { /...

    新建一个父类

    public class Animal {
    
        private String name;
        private String color;
    
        public Animal() {
            super();
        }
    
        public Animal(String name, String color) {
            super();
            this.name = name;
            this.color = color;
        }
    
    
    
        public void eat () {
            System.out.println("吃东西...");
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getColor() {
            return color;
        }
    
        public void setColor(String color) {
            this.color = color;
        }
    
    }

    建一个 子类 Dog

    //extends   继承
    //Dog   子类  Animal  父类
    //子类继承父类后自动拥有父类的 public和protected的 属性和方法
    //把多个子类中重复的代码提取到父类中可以减少代码量
    //父类的 构造方法 无法继承给子类
    public class Dog extends Animal {
    
        //子类可以添加自己的属性和和方法
        private int age;
    
        //子类构造方法 必须使用 super 调用父类的构造方法
        public Dog() {
            super();
        }
    
        public Dog(String name, String color) {
            //super调用父类的属性和方法
            //this 调用当前类的属性和方法
            super(name, color);
        }
    
        public Dog(String name, String color,int age) {
    
            super(name, color);//把name 和 color 赋值给父类的属性
            this.age = age;//把age 赋值给当前类的属性
        }
    
    
    
        //子类可以重写父类的方法,对父类提供的功能做出不同的表现
        @Override//子类重写父类必须加@Override 标识做出说明
        public void eat () {
            System.out.println("啃骨头...");
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
    }

    建立一个人的类

    public class Person {
    
        private Animal animal;//人养宠物
    
        public Animal getAnimal() {
            return animal;
        }
    
        public void setAnimal(Animal animal) {
            this.animal = animal;
        }
    
    
    
    }

    建立一个可执行main方法类

    
    public class Application {
    
        public static void main(String[] args) {
    
            //Animal animal = new Animal("老板","灰白");
    
            Dog dog = new Dog("总裁","黑白");
    //      dog.setName("总裁");
    //      dog.setColor("黑白色");
            dog.setAge(2);
            dog.eat();
    
            Cat cat = new Cat("妙妙","黑白","折耳猫");
    
            Person person = new Person();
    
            //多态
            //使用父类类型(Animal)表示一系列的子类类型(Dog,Cat...)
            //可以把子类对象(dog)赋值给父类变量(animal)
            //实际调用的方法是子类的方法
    
            //好处:
            //1、对于同一个方法(eat)随着传入的子类对象不同,可以做出不同的响应
            //2、让程序具有良好的的扩展性
            //     例如:不需要修改person 即可喂养更多的宠物
    
            //条件:
            //1、存在继承关系(Dog.Cat都继承自Animal)
            //2、存在父类类型表示一组子类类型(private Animal animal)
            //3、子类对象赋值给父类类型变量(person.setAnimal(dog))
            //4、子类重写父类的方法
    
    
            person.setAnimal(dog);
            person.getAnimal().eat();
    
            person.setAnimal(cat);
            person.getAnimal().eat();
    
        }
    
    }
    展开全文
  • (所属课程Java语言程序设计 ) 院系 专业班级 姓名 学号 实验地点 指导老师 本实验项目成绩 教师签字 日期 1实验目的 掌握类的继承机制 熟悉类中成员变量方法的访问控制 (3 )熟悉方法或构造方法多态性 实验内容 (1)...
  • PAGE 3 教 案 单元内容 继承和多态 单元序号 14 单元...继承的定义 多态的概念 多态的形式使用 任务定位 教学重点 必须达成的 继承的概念 多态的使用 教学难点 不利因素 多个同名方法共存 Java特性的理解 教学关键
  • 实验项目名称 继承多态 所属课程 Java 语言程序设计 院 系 专业班级 ...2. 实验内容 1模拟编写程序理解类的继承多态继承多态规则 2 独立编程实现类的继承多态 3. 实验作业 设计一个类 Shape 图形包含求面积周长
  • 文章目录第1关:练习-Java继承和多态之综合练习答案 第1关:练习-Java继承和多态之综合练习 任务描述 本关任务:按照动物、宠物、猫蜘蛛的关系,通过编程实现各自的关系并声明自己的属性方法。 编程要求 仔细...

    第1关:练习-Java继承和多态之综合练习

    任务描述

    本关任务:按照动物、宠物、猫和蜘蛛的关系,通过编程实现各自的关系并声明自己的属性和方法。 编程要求

    仔细阅读右侧编辑区内给出的代码框架及注释,在 Begin-End 中实现如下要求:

    动物类 Animal为抽象类,具有两个属性:种类和腿条数,并有 eat() 和 walk() 的方法;
    宠物 Pet 为接口,有三个功能:setName()、getName() 和 play();
    蜘蛛类 Spider 继承动物类,重写 eat() 方法;
    猫类 Cat 继承动物类并实现宠物接口,本身有一个属性:名称。
    

    测试说明

    平台将使用测试集运行你编写的程序代码,若全部的运行结果正确,则通关。 可在右侧“测试结果”区查看具体的测试集详情。

    开始你的任务吧,祝你成功!

    答案

        /**
         * 按照动物、宠物、猫和蜘蛛的关系,通过编程实现各自的关系并声明自己的属性和方法。
         */
        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
        /********** Begin **********/
        // 创建Animal类,它是所有动物的抽象父类
        abstract class Animal {
            // 声明一个受保护的字符串类型属性type,它记录动物的种类
            protected String type;
            // 声明一个受保护的整数类型属性legs,它记录动物的腿的数目
            protected int legs;
            // 定义一个受保护的有参构造器,用来初始化type和legs属性
            protected Animal(String type,int legs){
                this.type = type;
                this.legs = legs;
            }
            // 声明抽象方法eat,无返回值
            public abstract void eat();
            // 声明具体方法walk来打印动物是如何行走的(包括腿的数目)。
            // 输出格式:用 xx 条腿走路
            public void walk(){
                System.out.println(type +"用 " + legs +  " 条腿走路");
            }
        }
        // 定义蜘蛛类 Spider继承Animal类
        class Spider extends Animal{
            // 定义默认构造器,它调用父类构造器来指明动物类别是spider,且所有蜘蛛都是8条腿。
            public Spider(){
                super("spider",8);
            }
            // 实现eat方法,输出:spider eating
            @Override
            public void eat() {
                System.out.println("spider eating");
            }
        }
        // 创建pet(宠物)接口
        interface Pet {
            // 提供setName(String name) 为该宠物命名
            public void setName(String name);
            // 提供getName() 返回该宠物的名字,返回类型为String
            public String getName();
            // 提供 play()方法,无返回值
            public void play();
        }
        // 定义公开的猫类 Cat 继承动物类并实现宠物接口
        public class Cat extends Animal implements Pet{
            // 定义一个name属性来存宠物的名字
            private String name;
            // 定义一个有参构造器,它使用String参数指定猫的名字
            // 该构造器必须调用超类构造器来指明动物种类是cat,且所有的猫都是四条腿
            public Cat(String name){
                super("cat",4);
                this.name = name;
            }
            // 另定义一个无参的构造器。该构造器调用前一个构造器(用this关键字)并传递一个空字符串作为参数
            public Cat(){
                this("");
            }
            // 实现 Pet接口的方法
            // 设置猫的名称
            @Override
            public void setName(String name) {
                this.name = name;
            }
            // 获取猫的名称
            @Override
            public String getName() {
                return name;
            }
            // 重写 Animal 类的play(),输出:Cat is playing
            @Override
            public void play() {
                System.out.println("Cat is playing");
            }
            // 重写 Animal 类的eat(),输出:xx eating
            // xx 表示姓名
            @Override
            public void eat() {
                System.out.println(name+" eating");
            }
        }
        /********** End **********/
    
    展开全文
  • java继承和多态的试题分析

    千次阅读 2018-08-02 19:27:25
    java继承和多态的试题分析 第一题:写出下面题目的运行结果 题目: interface A{} class B implements A { public String func() { return "func"; } } class Demo { public stati...

    java继承和多态的试题分析

    第一题:写出下面题目的运行结果

    • 题目:
        interface A{}
        class B implements A {
            public String func() {
                return "func";
            }
        }
        class Demo {
            public static void main(String[] args) {
                A a=new B();
                System.out.println(a.func());
            }
        }
    • 答案:
    • 分析:题目中只有 A a=new B(),并没有向下转型,接口中没有定义func()函数,所以不能调用,什么都不能输出。

    第二题:写出程序结果

    • 题目:
        class Fu {
            boolean show(char a){
                System.out.println(a);
                return true;
            }
        }
        class Demo extends Fu {
            public static void main(String[] args) {
                int i=0;
                Fu f=new Demo();
                Demo d=new Demo();
                for(f.show('A'); f.show('B')&&(i<2);f.show('C')) {
                    i++;
                    d.show('D');
                }   
            }
            boolean show(char a) {
                System.out.println(a);
                return false;
            }
        }
    • 答案:
      A
      B
    • 分析:判断中首先判断起始条件,执行了子类的show(‘A’) 然后,执行 show(‘B’)=false 所以条件不成立,直接结束循环。

    第三题:写出程序结果

    • 题目:
        interface A{}
        class B implements A {
            public String test()
            {
                return "yes";
            }
        }
        class Demo {
            static A get() {
                return new B();
            }
            public static void main(String[] args) {
                A a=get();
                System.out.println(a.test());
            }
        }
    
    • 答案:

    • 分析:test()是B特有方法,所以要进行强制转换 B b=(B) a;通过b.test()来输出为空。

    第四题:写出程序结果

    • 题目:
        class Super {
            int i=0;
            public Super(String a) {
                System.out.println("A");
                i=1;    
            }
            public Super() {
                System.out.println("B");
                i+=2;
            }
        }
        class Demo extends Super {
            public Demo(String a) {
                System.out.println("C");
                i=5;                
            }
            public static void main(String[] args) {
                int i=4;
                Super d = new Demo("A");
                System.out.println(d.i);
            }
        }
    
    • 答案:
      B
      C
      5
      5

    • 分析:系统默认了一个super(),会先执行父类构造函数,打印B C,然后调用调用Demo的构造器打印C 和 5,最后再调用对象的i值5。

    第五题:写出程序结果

    • 题目:
        class Fu {
            int num=4;
            void show() {
                System.out.println("showFu");
            }
        }
        class Zi extends Fu {
            int num=5;
            void show() {
                System.out.println("showZi");
            }
        }
        class T {
            public static void main(String[] args) {
                Fu f=new Zi();
                Zi z=new Zi();
                System.out.println(f.num); 
                System.out.println(z.num); 
                f.show();
                z.show(); 
            }
        }
    
    • 答案:
      4
      5
      showzi
      showzi

    • 分析:多态的特性编译的时候能不能访问看父类,运行时看父类所以打印了4,第二个是本来的引用变量所以打印5;f.show()、z.show()因为父类中有这个方法但是在子类中被重写了。

    第六题:写出程序结果

    • 题目:
        interface A {
            void show();
        }
        interface B {
            void add(int a,int b);
        }
        class C implements A,B {
            private int a,b;
            public void add(int a,int b){
                this.a =a;
                this.b = b;
            }
            public void show() {
               System.out.println(a+b); 
            }
        }
        class D {
            public static void main(String[] args) {
                C c=new C();
                c.add(4,2);
                c.show();
            }
        }
    
    • 答案:
      6

    • 分析:c.add(4,2)将值传入了c指向的对象,c.show()将两个值加起来打印出来了。

    第七题:写出程序结果

    • 题目:
        class Super {
            int i=0;    
            public Super(String s) {
                i=1;    
            }
        }
        class Demo extends Super{
            public Demo(String s){
                i=2;            
            }
            public static void main(String[] args){
                Demo d=new Demo("yes");
                System.out.println(d.i);
            }
        }
    
    • 答案:
      2

    • 分析:系统加了一个默认的super()构造器,然后在调用了Demo(String s)构造器将i的值更改为2。

    第八题:写出程序结果

    • 题目:
        class Super{
            public int get()
            {return 4;}
        }
        class Demo15 extends Super{
            public long get(){return 5;}
            public static void main(String[] args){
                Super s=new Demo15();
                System.out.println(s.get());
            }
        }
    
    • 答案:

    • 分析:返回类型不一样不能完成覆盖,会报错。

    展开全文
  • 本关任务:按照动物、宠物、猫蜘蛛的关系,通过编程实现各自的关系并声明自己的属性方法。 编程要求 仔细阅读右侧编辑区内给出的代码框架及注释,在 Begin-End 中实现如下要求: 动物类 Animal为抽象类,具有两...
  • Java继承和多态实现例子

    千次阅读 2018-10-19 10:45:21
    我们想做一个类用于存放CD,DVD等光碟,要应用多态和继承,去除重复性代码,便于以后维护(添加新的格式光碟,如:MP3,MP4),因此我们首先创建一个工程demo,创建database类用于存放光碟数据,创建光碟类ltem,...
  • 封装 继承 多态:封装:用private修饰的成员变量可以看做是进行了封装继承:可以继承类,抽线类 接口单继承,多实现接口子类继承不了父类中使用private修饰的变量,方法多态多态的前提:有继承有方法的重写向上...
  • jvm视角看java继承和多态

    千次阅读 2017-09-21 10:12:59
    首先,明确一下,Java多态的三个必要条件: 1、 继承 2、 子类重写父类方法 3、 父类引用指向子类对象   然后看一个例子 package test.xing; class Father{ protected int age; public ...
  • 继承可以理解为一个类从另一个类获取方法属性的过程。如果类B继承于类A,那么B就拥有A的方法属性。 继承使用 extends 关键字。 例如我们已经定义了一个类 People: class People{ String name; int age; i
  • 当对不存在继承关系的对象进行强制类型转换时,java 运行时将抛出 java.lang.ClassCastException 异常。 在继承链中,我们将子类向父类转换称为“向上转型”,将父类向子类转换称为“向下转型”。 很多时候,...
  • // 定义一个Dog的公开类,并继承Animal类 public class Dog extends Anaimal{ //定义小狗的性别sex,字符串类型 private String sex; // 定义获取设置小狗性别的方法。 public String getSex() { return sex;...
  • java继承和多态、接口小结

    千次阅读 2015-10-06 12:17:35
    java继承只能是单继承。一个类之所以能够调用父类成员,是由于java编译器会自动为子类添加一个引用名为super的父类成员对象。创建子类对象的过程就是从底层的基类往上,一层层地来调用构造方法。如果调用父类的有...
  • Java继承和多态的底层原理

    千次阅读 2018-10-24 17:51:05
    当子类继承父类以后,子类的对象为什么可以访问到父类中定义的方法?当子类Override了父类中的方法以后,访问的是子类Override以后的方法,这是怎么实现的?当子类Override了父类的方法以后,还有办法得到父类的方法...
  • 本关任务:按照动物、宠物、猫蜘蛛的关系,通过编程实现各自的关系并声明自己的属性方法。 编程要求 仔细阅读右侧编辑区内给出的代码框架及注释,在 Begin-End 中实现如下要求: 动物类 Animal为抽象类,具有两...
  • 三分钟理解Java继承和多态原理

    千次阅读 2015-03-31 11:48:21
     这道题,如果不是对java继承处理有深刻理解,还是很难答对的。 其实掌握一个原则,就万变不离其宗了:   对于成员方法是覆盖,对于成员变量静态方法是隐藏 怎么理解这句话呢?  1.如果子类重写了...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 160,691
精华内容 64,276
关键字:

java继承和多态

java 订阅