精华内容
下载资源
问答
  • java接口实现多态
    千次阅读
    2019-03-05 16:35:49

    https://blog.csdn.net/oguro/article/details/53086720

    多态: 父类的引用类型变量指向了子类的对象
    或者是 接口类型的引用类型变量指向了接口实现类 的对象。
    这里主要讲第二种,接口的对象指向了实现类的对象

    实现关系下的多态:

    接口 变量 = new 接口实现类的对象。

    这样接口的对象就可以访问实现类中的方法。

    interface Dao{  //接口的方法全部都是非静态的方法。
    
    	public void add();
    
    	public void delete();
    }
    
    //接口的实现类
    class UserDao implements Dao{
    	
    	public void add(){
    		System.out.println("添加员工成功!!");
    	}
    
    	public void delete(){
    		System.out.println("删除员工成功!!");
    	}
    }
    
    class Demo3 
    {
    	public static void main(String[] args) 
    	{
    		//实现关系下的多态
    		Dao d = new UserDao(); //接口的引用类型变量指向了接口实现类的对象。
    		d.add();
    	}
    }
    
    

    输出结果:添加员工成功!

    更多相关内容
  • Java接口多态

    2022-02-08 11:11:48
    就像我们现实生活中电脑的usb接口,我们既可以接受手机对象,又可以接受相机对象,等等,体现了接口多态,查看以下代码 接口: package InterfaceM; public interface Interface { public void join(); ...
    • 多态参数

    就像我们现实生活中电脑的usb接口,我们既可以接受手机对象,又可以接受相机对象,等等,体现了接口的多态,查看以下代码

    接口:

    package InterfaceM;
    
    public interface Interface {
        public void join();
        public void stop();
    }
    

    手机类:

    package InterfaceM;
    
    public class Phone implements Interface{
    
        @Override
        public void join() {
            System.out.println(this.toString()+"接入了电脑");
        }
    
        @Override
        public void stop() {
            System.out.println(this.toString()+"离开了电脑");
        }
    }
    

    相机类;

    package InterfaceM;
    
    public class Camera implements Interface {
        @Override
        public void join() {
            System.out.println(this.toString()+"接入了电脑");
        }
    
        @Override
        public void stop() {
            System.out.println(this.toString()+"离开了电脑");
        }
    }
    

    电脑类:

    package InterfaceM;
    
    public class Computer {
        public void work(Interface interF){
            interF.join();
            interF.stop();
        }
    
        public static void main(String[] args) {
            Camera camera=new Camera();
            Phone phone=new Phone();
            //将相机接入电脑
            Computer computer=new Computer();
            computer.work(camera);
            computer.work(phone);
        }
    }
    

    •  多态数组

    在computer类型的数组中,我们即可以存放多种对象类型的数组。而且对应不同的数组对象,我们可以做出不同的事件。

    在刚才的上述代码中我们在phone类中加入call功能,要求有插入phone时,调用call函数

    package InterfaceM;
    
    public class Computer {
        public void work(Interface interF){
            interF.join();
            interF.stop();
        }
    
        public static void main(String[] args) {
            Camera camera=new Camera();
            Phone phone=new Phone();
            //将相机接入电脑
            Interface []interf=new Interface[2];
            interf[0]=camera;
            interf[1]=phone;
            Computer computer=new Computer();
            for (int i=0;i<interf.length;i++){
                computer.work(interf[i]);
                if (interf[i]instanceof Phone){
                    phone.call();
                }
            }
        }
    }
    

    •  接口的多态传递现象

    如果我们运行以下代码,由于ih并没有被teacher继承,会发生报错,但是当我们用ig继承ih之后,我们可以发现这样就不会报错。这样体现出了多态的继承传递现象。

    public class Test {
        public static void main(String[] args) {
            IG ig=new Teacher();
            IH ih=new Teacher();
        }
    }
    interface IH{}
    interface IG{}
    class Teacher implements IG{
        
    }
    
    public class Test {
        public static void main(String[] args) {
            IG ig=new Teacher();
            IH ih=new Teacher();
        }
    }
    interface IH{}
    interface IG extends IH{}
    class Teacher implements IG{
    
    }
    

    展开全文
  • Java 语言程序设计:第5章接口多态.ppt
  • Java接口public interface 类名接口Java方法的合集,用于给不同的类实现同名的方法,接口是一个只有抽象方法的抽象类,1、接口中可以定义变量,但是变量必须有固定的修饰符修饰,public static final所以接口中...

    Java 的接口

    public    interface   类名

    接口是Java方法的合集,用于给不同的类实现同名的方法,

    接口是一个只有抽象方法的抽象类,

    1、接口中可以定义变量,但是变量必须有固定的修饰符修饰,public static final所以接口中的变量也称之为常量,其值不能改变。后面我们会讲解static与final关键字

    2、接口中可以定义方法,方法也有固定的修饰符,public abstract

    3、接口不可以创建对象。

    4、子类必须覆盖掉接口中所有的抽象方法后,子类才可以实例化。否则子类是一个抽象类。

    接口的子集 使用关键词implements来继承,也叫做实现。

    一个普通类只能单继承(接口允许多继承)但是允许多实现,

    举例:我们都知道电脑上留有很多个插口,而这些插口可以插入相应的设备,这些设备为什么能插在上面呢?主要原因是这些设备在生产的时候符合了这个插口的使用规则,否则将无法插入接口中,更无法使用。发现这个插口的出现让我们使用更多的设备。

    总结:接口在开发中的它好处

    1、接口的出现扩展了功能。

    2、接口其实就是暴漏出来的规则。

    3、接口的出现降低了耦合性,即设备与设备之间实现了解耦。

    接口的出现方便后期使用和维护,一方是在使用接口(如电脑),一方在实现接口(插在插口上的设备)。例如:笔记本使用这个规则(接口),电脑外围设备实现这个规则(接口)。

    总结接口和抽象类的区别:

    相同点:

    l 都位于继承的顶端,用于被其他类实现或继承;

    l 都不能直接实例化对象;

    l 都可以包含抽象方法,其子类都必须覆写这些抽象方法;

    区别:

    l 抽象类为部分方法提供实现,避免子类重复实现这些方法,提高代码重用性;接口只能包含抽象方法;

    l 一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承)

    l 抽象类是这个事物中应该具备的内容, 继承体系是一种 is..a关系

    l 接口是这个事物中的额外内容,继承体系是一种 like..a关系

    二者的选用:

    l 优先选用接口,尽量少用抽象类;

    l 需要定义子类的行为,又要为子类提供共性功能时才选用抽象类;

    多态

    多态体现为父类引用变量可以指向子类对象。

    多态的前提是必须有子父类关系或者类实现接口关系,否则无法完成多态。

    在使用多态后的父类引用变量调用方法时,会调用子类重写后的方法。

    023c3ec2b799cf37436335e0a0e6954d.png

    l 多态成员变量

    当子父类中出现同名的成员变量时,多态调用该变量时:

    编译时期:参考的是引用型变量所属的类中是否有被调用的成员变量。没有,编译失败。

    运行时期:也是调用引用型变量所属的类中的成员变量。

    简单记:编译和运行都参考等号的左边。编译运行看左边。

    l 多态成员方法

    编译时期:参考引用变量所属的类,如果类中没有调用的方法,编译失败。

    运行时期:参考引用变量所指的对象所属的类,并运行对象所属类中的成员方法。

    简而言之:编译看左边,运行看右边。

    1.1 instanceof关键字

    5c4094eb14cf2c48f9ac7cf12a321795.png

    展开全文
  • 多态用一句话概括就是:事物在运行过程中存在不同的状态。。多态的存在有三个前提: 1.要有继承关系 2.子类要重写父类的方法 3.父类引用指向子类对 综合实际应用,我们做出以下总结: ① 成员变量 编译看左边(父类),...
  • 初级Java接口多态问题

    2017-10-15 02:47:22
    ![图片说明](https://img-ask.csdn.net/upload/201710/15/1508035599_479108.png) 请问上图中应该如何转型才能够正常运行呢
  • 多态 多态的概念 定义 多态 polymorphism :对象根据所接收的消息而做出动作,同样的消息为不同的对象接收时可导致完全不同的... 即 在程序运行时才把调用方法名与具体方法绑定在一起继承多态、接口多态 为何需要多态?

    多态

    多态的概念

    定义

    多态 polymorphism :对象根据所接收的消息而做出动作,同样的消息为不同的对象接收时可导致完全不同的行动,该现象 称为多态性

    静态绑定

    编译时多态 指在编译程序时就根据调用方法提供的信息,把它所对应的具体方法确定下来。即 在编译时就把调用方法名与具体方法绑定在一起方法重载

    动态绑定

    运行时多态 指在编译程序时还不能确定方法调用所对应的具体方法,只有在程序运行过程中才能确定具体的方法。 即 在程序运行时才把调用方法名与具体方法绑定在一起继承多态、接口多态

    为何需要多态?

    1. 在设计一个程序系统时,可以通过在abstract类中声明若干
      abstract方法,表明这些方法在整个系统设计中的重要性,方法体的内容细节由它的非abstract子类去完成
    2. 使用多态进行程序设计的核心技术之一是使用向上转型对象,即 abstract类声明对象作为其子类的向上转型对象,那么这个向上转型对象就可以调用子类重写的方法
    3. 当将absctract类声明对象按需实际引用不同的子类对象时,就能达到以一变应万变的目的
    4. 所谓面向抽象编程,是指当设计某种重要的类时,不让该类面向
      具体的类,而是面向抽象类,即所设计类中的重要数据是抽象类声明的对象,而不是具体类声明的对象

    在这里插入图片描述

    继承与多态

    继承基本概念

    继承: 以存在的类为基础定义新的类,新类即拥有基类的数据成员和成员方法。

    继承的目的: 代码重用(减少代码重复编写 code reuse)

    继承的本质: 描述自然界中广泛存在的一种关系——类属关系(is-a)

    实现过程:(略)

    使用 extends 关键字

    方法重写 Override

    注意

    1. 子类重写的方法的权限不能低于父类方法的访问权限
    2. 子类重写的方法不能抛出比父类方法抛出的异常多
    3. 被重写的父子类方法须同时为static的,或同时为非static的静态方法按类绑定,实例方法按实际所引用的对象实例绑定
    4. 父类的private方法不能被重写,本质上它不是为了继承而生
    5. 重写和重载区别:重载(overload)是形式参数列表丌一样.重写 则是方法头部( 包括形式参数列表)要一致;重写只能出现在继承过程中.
    6. 对象调用被重写的非静态方法时,使用对象引用实际引用的实 例所对应的版本(即运行时绑定

    继承的构造

    点击跳转

    父类对象引用子类实例(重点)

    Java运行时某个类型的引用变量引用其子类的实例,而且可以对这个引用变量进行类型转换

    简单的记: b = d;

    在这里插入图片描述

    继承的多态所需的三个条件:

    1. 继承 子类继承基类
    2. 重写 子类重写基类同名同参方法
    3. 父类对象引用子类实例 b = d

    实例一:

    // 基础版多态
    class Person {
    	public String toString() {
    		return "Person";// 重写Object的toString方法
    	}
    }
    class Man extends Person {
    	public String toString() {
    		return "Man";// 重写父类的toString方法
    	}
    	public void show() {
    		System.out.println("这是子类独有的方法");// 子类新加的方法
    	}
    }
    public class Test_extends_poly1 {
    	public static void main(String[] args) {
    		
    		/*---编译时多态--- */ 
    		 Person q = new Person();// b = b
    		 Man m = new Man(); // d = d
    		 System.out.println(q.toString());// 执行自己的方法 Person
    		 System.out.println(m.toString());// 执行自己的方法 Man
    		 
    		 /*---运行时多态--- */ 
    		 Person p = new Man(); // b = d  父类对象引用子类实例
    		 System.out.println(p.toString());// 运行时多态
    		 /*
    		   Java从实例所属的类开始寻找匹配的方法执行
    		   如果当前类没有重写匹配的方法,则沿着继承关系逐级向上寻找
    		   直到Object类为止
    		  */
    		 p.show(); // 编译Error:**The method show() is undefined for the type Person**
    		 // 编译阶段,p的类型是Person,其中没有show方法,编译不通过
    	}
    }
    /*
    	输出的结果为:
    	Person
    	Man
    	Man
    */
    

    实例二:

    // 进阶版多态
    class A {
    	public String show(A obj) {
    		return ("AA") ;
    	}
    	public String show(D obj) {
    		return ("AD") ;
    	}
    }
    class B extends A {
    	public String show(A obj) {
    		return ("BA");
    	}
    	public String show(B obj) {
    		return ("BB");
    	}
    }
    class C extends B {
    	
    }
    class D extends B {
    	
    }
    public class Test_extends_poly2 {
    	public static void main(String[] args) {
    		A a1 = new A();
    		A a2 = new B();
    		B b = new B();
    		C c = new C();
    		D d = new D();
    		System.out.println(a1.show(b));// 向上转型
    		System.out.println(a1.show(c));// 向上转型
    		System.out.println(a1.show(d));// 向上转型
    		System.out.println(a2.show(b));
    		System.out.println(a2.show(c)); 
    		System.out.println(a2.show(d)); 
    		System.out.println(b.show(b));  
    		System.out.println(b.show(c));  
    		System.out.println(b.show(d)); 
    	}
    }
    
    
    结果:
    	AA 
    	AA 
    	AD 
    	BA 
    	BA 
    	AD 
    	BB 
    	BB 
    	AD 
    

    规则:

    1. 运行时绑定:实例方法与引用变量实际引用的对象的方法
    2. 编译时绑定静态方法与引用变量所声明的类型的方法
    3. 编译时绑定成员变量(包括静态变量和实例变量)与引用变量所声明的类型成员变量

    在这里插入图片描述

    (俗称:编译看左边,运行看右边)

    接口与多态

    接口基本概念

    接口是一种特殊的引用类型,没有构造方法,也不能被实例化

    传统接口的接口体仅能包含两样:

    1. 公开的静态常量: 隐式 public static final 修饰组合,且必须显式初始化
    2. 公开的抽象方法: 隐式 public abstract 修饰组合

    实现过程:(略)

    使用 implements 关键字

    接口和继承的区别

    区别
    抽象类1.对行为和属性的抽象,是多个类(对象)共同的抽象
    2.可视作"“类模板”:使用-个抽象类派生的各子类,是有共性的
    3.抽象类的各子类,都是抽象类的对象,继承抽象类的子类和抽象
    4.类是一种is-A关系
    接口1.对行为(动作/方法)的抽象,不是对一类事物的抽象,属协议规范
    2.实现接口的类可以是不相关的类,只是它们都具有某种表现不同的行为而已
    3.接口是让类拥有或者具备某种功能

    接口实现多态(重点)

    接口和实现类→接口变量引用实例类对象实例 i=o → 调用实现方法

    实例:

    // 先创建好一个接口
    public interface Fly {
    	
    	public void fly() ;
    	
    }
    
    // 创建接口的实现类
    class Plane implements Fly {
    
    	@Override
    	public void fly() {
    		// TODO Auto-generated method stub
    		System.out.println("飞机用机翼飞行");
    	}
    	
    }
    class Bird implements Fly {
    	
    	@Override
    	public void fly() {
    		// TODO Auto-generated method stub
    		System.out.println("小鸟用翅膀飞行");
    	}
    }
    // 进行调试
    public class Test_interface_poly1  {
    
    	public static void main(String[] args) {
    		Fly Cfly;
    		Bird bird = new Bird();
    		Plane plane = new Plane();
            
    		Cfly = bird;// 接口引用实现类对象实例
    		Cfly.fly();// 调用实现方法
            
    		Cfly = plane;// 接口引用实现类对象实例
    		Cfly.fly();// 调用实现方法
    
    	}
    }
    /*结果:
    
    小鸟用翅膀飞行
    飞机用机翼飞行
    
    */
    

    接口与匿名内部类

    匿名类:用在其只用-次并简化代码的地方.
    匿名类必须:要么继承一个类,要么实现一个接口.

    实例:

    // 使用回上述的Fly接口
    // 新建一个类用于测试
    public class Test_interface_poly2 {
    	
    	public static void main(String[] args) {
    		Fly XFly = new Fly() {
    			
    			@Override
    			public void fly() {
    				// TODO Auto-generated method stub
    				System.out.println("匿名类也飞了");
    			}
    		}; // 分号“;”不能缺少
    		XFly.fly();
    	}
    }
    

    构造过程实例:

    public class A {
    	A(int p) {
    		System.out.println("带参构造子" + p);
    	}
    
    	A() {
    		System.out.println("无参构造子");
    	}
    
    	void method() {
    		System.out.println("fromA");
    	}
    
    	public static void main (String []args) {
    		new A().method(); 
    		A z = new A(){ 
    			void method() { 
                    System.out.println("fram 匿名类0"); 
                }
    		};// 分号不可缺
    		
    		z.method() ;
    		A a = new A(1) {}; 
    		a.method() ;
    		A b = new A(2) { 
    			void method() { 
                    System.out.println("from 匿名类2"); 
    			};
    		};// 分号不可少
            
    		b.method();
    	}
    }
    
    结果:
    无参构造子
    fromA
    无参构造子
    fram 匿名类0
    带参构造子1
    fromA
    带参构造子2
    from 匿名类2
    

    在Java创建线程或监听器对象时,经常使用这种匿名类语法

    匿名类最后必须写上“;” 因为匿名类是一种语法

    资料参考:仲恺农业工程学院——信科院课程组——《面向对象程序设计(Java)》

    展开全文
  • Java 接口多态

    2020-12-10 00:54:13
    Java 接口多态一、接口二、多态 一、接口 1、了解 生活 中的 接口的 例子 USB 插座 男女约会的口号,也就是 两个不同事物通过约定的方式能够用结合在一起,能够实现这种功能的 都是接口。 USB接口:1.提供了标准...
  • java——接口多态

    2019-05-09 17:01:55
  • Java多态总结

    2021-03-17 14:31:37
    这篇可能是今年最后一篇总结类的博文了,希望能够写的好点吧 _至此,博客中java基础方面的内容零零散散地也逐渐总结完了,基本上面试经常问到的内容都涵盖了,希望大家喜欢概念介绍定义多态,是面向对象的程序设计...
  • Java接口是如何实现多态的特性的

    千次阅读 2021-03-01 08:08:47
    Java多态是个很难理解的概念,但同时又是非常重要的概念,Java三大特性(封装、继承、多态)之一,我们从字面上理解,就是一种类型的多种状态,一下通过卖小汽车的例子再次说明什么是多态,其中利用到了接口。...
  • 一、接口  概念:可以理解为时一个特殊的抽象类,当抽象类中的方法都是抽象的,那么该类可以通过接口的形式来定义  class:用于定义类  interface 用于定义接口  语法:访问权限修饰符 interface 接口名{ ...
  • 定义USB接口(具备开启功能、关闭功能),笔记本要使用USB设备,即笔记本在生产时需要预留可以插入USB设备的USB接口,即就是笔记本具备使用USB设备的功能,但具体是什么USB设备,笔记本并不关心,只要符合USB规格的...
  • 下面小编就为大家带来一篇Java多态和实现接口的类的对象赋值给接口引用的方法(推荐)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • JAVA多态接口练习题

    2021-11-26 20:37:46
    有一个接口Operation,如下所示: interface Operation{ void open( ); void show( ); void close( );} (1)编写窗帘类Curtain和灯类Light来实现接口Operation。 (2)编写一个ElectricCurtain类继承...
  • Java接口多态

    千次阅读 2019-03-07 20:23:54
    1.一个类可以实现多个接口 2.一个类可以从一个类派生(子类)同时实现n个接口 3.接口可以嵌套 4.接口支持常量(final) 5.接口可以继承 package cn.zzx.base.demo; public interface PC{ // public String ...
  • Java 接口 多态 求代码

    2017-05-21 06:14:31
    ![图片说明](https://img-ask.csdn.net/upload/201705/21/1495346943_93300.png) ![图片说明](https://img-ask.csdn.net/upload/201705/21/1495346963_363678.png)
  • //接口是一类对象的抽象,比如交通工具,不论是汽车还是飞机都是交通工具,他们可以有一个共同的方法run();interfaceVehicle{voidrun();}//那么所有的实现了vehicle这个接口的类必须重写接口内的方法//汽车...
  • 1.多态的基础是继承2.什么是多态?下边就是多态!假设Animal是Dog类的父类在测试函数中 就可以在main()中Animal obj1=new Animal();//本类Animal obj2=new Dog();//父类的引用是可以指向子类和本类的对象,Dog obj...
  • 主要介绍了java接口多态、继承、类计算三角形和矩形周长及面积的方法,涉及java面向对象中类、接口多态等的使用技巧,需要的朋友可以参考下
  • 官方解释: Java接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现 ,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能)。 包含内容: (Java ...
  • Java接口多态特性

    2022-03-24 19:54:43
    Java接口多态特性
  • Java---多态接口

    2022-02-27 23:06:21
    多态 多态,简单来说就是具有多种表示形态的能力。 多态指的是同一个方法调用,由于对象不同可能会有不同的行为。现实生活中,同一个方法, 具体实现会完全不同。 比如:同样是调用人“吃饭”的方法,中国人用筷子...
  • 多态 & java泛型

    2021-12-10 00:21:43
    多态 & java泛型 文章目录多态 & java泛型1、回顾java的多态性1)什么是多态(“多”对1 + 不同“态” => 统一与差异)2)接口和抽象类的比较(同: ...Java接口多态 1)什么是多态(“多”对1 + 不同“态
  • java-接口多态练习

    2021-08-01 08:09:18
    * 接口,是Java语言中一种引用类型,是方法的集合。 使用interface关键字接口,其中可以定义抽象方法,默认方法,私有方法,静态方法等方法。 什么叫做多态,条件是什么? * 一类事物的行为,具有多种表现形式...
  • Java多态接口

    2021-07-21 20:22:15
    一、多态 1、同一个引用类型,使用不同的实例而执行不同操作。 2、多态使用的前提 (1)要有类的继承关系 (2)方法的重写 3、多态的应用 (1)使用父类作为方法的形参 (2)使用父类作为方法的返回值 4、...
  • // 编译直接报错,提示:只有含有此静态方法的接口类才能调用此静态方法 注:staticMethod() 是接口和实现类都有的静态方法 但是下面的代码没有错误: Fu obj = new Zi(); obj.staticMethod(); // 编译通过,而且只...
  • Java多态的实现原理

    千次阅读 2021-08-26 16:59:08
    这里的接口不应理解得太死板,比如在 Java 里面,继承一个类和实现一个接口本质上都是一种继承行为,因此都可以理解为多态的体现。 从静态和动态的角度进行划分,多态可以分为编译时多态和运行时多态。 编译时多态...
  • java多态

    千次阅读 2021-02-12 09:20:29
    1.多态的概述:是面向对象的三大特性之...②Java多态的代码体现在一个子类对象(实现类对象)既可以给这个子类(实现类对象)引用变量赋值,又可以给这个子类(实现类对象)的父类(接口)变量赋值。普通类与普通类,抽象...
  • Java多态的理解

    2022-02-04 22:56:27
    面向对象的三大特性:封装、继承、多态。从一定角度来看,封装和继承几乎都是为多态而准备的。这是我们最后一个概念,也是最重要的知识点。 2.多态的定义:指允许不同类的对象对同一消息做出响应。即同一消息可以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 152,145
精华内容 60,858
关键字:

java接口多态

java 订阅