精华内容
下载资源
问答
  • 了解Java多态性什么是Java的多态性(向上转型)多态性的前提为什么使用多态性?多态性的使用向下转型instanceof运算符 什么是Java的多态性(向上转型) Java的多态性是事物的多种形态,是运行时行为(向上转型,子类...

    什么是Java的多态性(向上转型)

    Java的多态性是事物的多种形态,是运行时行为(向上转型,子类可以赋值给父类),父亲的行为像儿子。

    多态性的前提

    1. 继承性(必须有父类和子类,才会有把子类赋值给父类的情况)
    2. 子类重写了父类的方法(如果子类不重写父类的方法,调用的就还是父类的方法)

    为什么使用多态性?

    多态性可以减少重载函数的使用,可以调用子类重写后的方法

    多态性的使用

    当调用子父类同名方法同参数的方法时,调用只能调用父类中申明过的方法,但是实际上执行的是子类重写父类的方法(编译看左边,执行看右边)。也就是虚拟方法的调用。
    主函数中,父类调用子类重写的行为

    class Person {
        private String name;
        private String age;
    
        public String getName() {
            System.out.println("我是父类");
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAge() {
            return age;
        }
    
        public void setAge(String age) {
            this.age = age;
        }
    }
    

    在子类Man中

    class  Man extends Person{
        private String name;
        private String age;
    
    
        @Override
        public String getName() {
            return name;
        }
    
        @Override
        public void setName(String name) {
            System.out.println("我是男人的姓名");
            this.name = name;
        }
    
        @Override
        public String getAge() {
            System.out.println("我是男人的年龄");
            return age;
        }
    
        @Override
        public void setAge(String age) {
            this.age = age;
        }
    
        public void earnMoney(){
            System.out.println("男人可以赚钱");
        }
    }
    
      Person person=new Man();
            person.getName();//输出结果:我是男人的姓名
    

    例:多态性减少重载函数的使用
    想要得到父类的年龄,也想得到子类的年龄,要写两个重载函数

      private void testAge(Man man){
            System.out.println(man.getAge());
        }
        private void testAge(Person person){
            System.out.println(person.getAge());
        }
    

    然后再主函数调用

            test.testAge(new Man());
            test.testAge(new Person());
    

    使用Java多态性后,只需要保留一个方法

    private void testAge(Person person){
            System.out.println(person.getAge());
        }
    

    调用时:

            test.testAge(new Man());
            test.testAge(new Person());
    

    向下转型

    在使用多态性的时候,父类new了一个子类时,其实子类的所有方法都会加载,但是如果父类没有申明子类的方法,也就是说子类并没有重写父类的方法,而是自定义了一个方法,那么我们如何使用多态性使得父类的对象能够调用子类的特有的方法呢?意味着需要将父类对象如果直接使用赋值符号,在基本数据类型中是有一个自动类型提升的说法,但是类类型的不能使用自动类型提升,只能使用强制类型转换。

            Person person=new Man();
            Man man=(Man) person;
            man.earnMoney();
    

    强制类型转换的时候会出现异常,比如如下情况:地址值相同但是类型不相同

            Person person=new Man();
            Man man=(Man) person;
            Woman woman=(Woman) person;
    

    为了避免这种情况,我们使用instanceof运算符

    instanceof运算符

    1. a instanceof A 判断a 是不是 instanceof 的实例
    Person person=new Man();
            if (person instanceof Man){
                Man man= (Man) person;
                man.earnMoney();
            }
            if (person instanceof Woman){
                Woman woman= (Woman) person;
                woman.goshopping();
            }
    
    展开全文
  • 主要介绍了Java多态性定义与用法,较为详细的分析了多态的概念、功能以及java定义与实现面向对象多态性的相关操作技巧,需要的朋友可以参考下
  • Java多态性

    2018-06-08 22:34:29
    运行时多态性是面向对象程序设计代码重用的一个最强大机制,Java多态性概念也可以被说成“一个接口,多个方法”。Java实现运行时多态性的基础是动态方法调度,它是一种在运行时而不是在编译期调用重载方法的机制。...
       
    

          运行时多态性是面向对象程序设计代码重用的一个最强大机制,Java多态性的概念也可以被说成“一个接口,多个方法”。Java实现运行时多态性的基础是动态方法调度,它是一种在运行时而不是在编译期调用重载方法的机制。

          方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现,重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法被重写(Overriding)。子类的对象使用这个方法时,将调用子类中的定义,对它而言,父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法,它们或有不同的参数个数或有不同的参数类型,则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现,重载Overloading是一个类中Java多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法被重写 (Overriding)。子类的对象使用这个方法时,将调用子类中的定义,对它而言,父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法,它们或有不同的参数个数或有不同的参数类型,则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

        当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。 (但是如果强制把超类转换成子类的话,就可以调用子类中新添加而超类没有的方法了。)

    展开全文
  • java多态性深入理解

    2013-09-22 11:06:37
    运行时多态是面向对象程序设计代码重用的一个最强大机制,java多态性概念可以被说成“一个接口,多个方法”,java实现运行时多态性的基础是动态方法调度,它是一种在运行时而不是在编译期调用重载方法的机制。...

            运行时多态是面向对象程序设计代码重用的一个最强大机制,java多态性概念可以被说成“一个接口,多个方法”,java实现运行时多态性的基础是动态方法调度,它是一种在运行时而不是在编译期调用重载方法的机制。

            方法重写overriding和重载overloading是java实现多态的不同表现,重写是父类与子类之间多态性的一种表现,重载是一个类中多态性的一种表现。如果子类中一个方法与父类有相同的名称和参数,我们说该方法被重写了。子类的对象在使用该方法时,将调用子类中的定义,对它而言,父类中的定义被“屏蔽”了。如果在一个类中定义了多个同名的方法,它们或有不同的参数个数或不同的参数类型,则称为方法的重载,重载可以改变方法的返回值类型。

           当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是被子类覆盖的方法。(但是如果强制把超类转换成子类的话,就可以调用子类中新添加而超类中没有的方法了)。

           方法调用的优先级,由高至低依次为:this.method(o); super.method(o); this.method(super(o)); super.method(super(o));

    示例如下:

    class A{
    	public String show(D obj){
    		return ("A and D");
    	}
    	public String show(A obj){
    		return ("A and A");
    	}
    }
    
    class B extends A{
    	public String show(B obj){
    		return ("B and B");
    	}
    	public String show(A obj){
    		return ("B and A");
    	}
    }
    
    class C extends B{}
    class D extends B{}
    
    public class test {
    	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(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));
    	}
    }

    输出结果:

    B and A
    B and A
    A and D
    B and B
    B and B
    A and D

    我们看System.out.println(a2.show(c));的结果为什么是B and A。根据调用的有衔接,先看this.method(o),其中this是a2,o是c,A中没有show(C c)方法,所以在看super.method(o),A没有super,所以再看this.method(super(o))方法,即A的show(B b),也没有此方法,在看A的show(A a),有该方法,但是”被引用变量的类型而不是引用变量的类型决定调用哪个方法“,a2引用了一个b变量,而b中重写了show(A a)方法,所以最后调用的是b的show(A a)方法,输出为B and A。如果B中没有重写该方法,那么最后还是调用A中的show(A a)方法。

    这里我们要注意一下,既然是”被引用变量的类型而不是引用变量的类型决定调用哪个方法“,那么为什么不一开始就按如下思路做呢?a2引用的是一个B变量,this.method(o)就是b.show(c),没有该方法,再看super.show(c),也就是a.show(c),也没有再看this.show(super(o))即b.show(b),有该方法,输出B and B。

    因为”这个被调用的方法必须在超类中定义过,也就是被子类覆盖的方法“,B的show(B b)在A中定义过吗?没有!所以这么做是不对的!

    展开全文
  • java多态性

    千次阅读 2016-12-03 19:01:01
    多态性是指同一个名字的若干个方法,有不同的实现(即方法体中的代码不一样)。 多态的两种表现形式:方法重载overloading(静态多态性) 方法覆盖overriding (动态多态性) 方法的重载在Java中每个方法都有签名,...

    多态性是指同一个名字的若干个方法,有不同的实现(即方法体中的代码不一样)。
    多态的两种表现形式:

    方法重载overloading(静态多态性)
    方法覆盖overriding (动态多态性)
    

    方法的重载

    在Java中每个方法都有签名,就是方法名以及参数的个数和类型。如果两个方法参数的个数或类型不同,它们可以具有相同的名字,这种现象叫做重载。当调用方法时,编译器通过比较自变量参数的个数和类型来查找匹配得最好的方法。
    签名不包括返回类型或者抛出异常的列表,所以不能通过这些来重载方法。
    对于重载的多个同名方法,在编译时能够确定执行同名方法中的哪一个,故也称为编译时多态性。

    代码:

    class Father{
        int x=5;
        int addX(int b){
            return x+b;
        }
    }
    class Son extends Father{
        int addX(int b,int c){
            return x+b+c;
        }   
       String addX(String s){
            return x+s;
        }
    }
    public class Test{
        public static void main(String args[]){
        Son a=new Son();
        System.out.println(a.addX(2));
        System.out.println(a.addX(2,3));
        System.out.println(a.addX("2"));
        }
    }
    
    result:
    
    7
    10
    52
    

    方法的覆盖

    在子类和超类中有同名的方法(参数也相同),子类中的方法覆盖超类的方法。
    如果超类和子类有同名且参数相同的方法,那么超类的对象调用超类的方法,子类的对象调用子类的方法。
    通过覆盖可以使同名的方法在不同层次的类中有不同的实现。

    注意:子类中重写的方法和父类中被重写的方法要具有相同的名字,相同的参数表和相同的返回类型,只是函数体不同。

    Code:

    class Father{
        int x=8;
        int addX(int b){
            return x+b;
        }
    }
    class Son extends Father{
        int addX(int c){
            return x+c+10;
        }
    }
    public class Test{
        public static void main(String args[]){
            Son a=new Son();
            System.out.println(a.addX(2));
        }
    }
    //调用被覆盖的父类方法:
    class Son extends Father{
        int addX(int c){
            return super.addX(c);
        }
    }
    

    方法覆盖的原则

    子类方法的名称、参数签名和返回类型必须与其父类的方法的名称、参数签名和返回类型一致。
    子类方法不能缩小父类方法的访问权限。
    子类方法不能抛出比父类方法更多的异常。
    方法覆盖只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载,不能被覆盖。
    父类的静态方法不能被子类覆盖为非静态的方法,反之亦然。
    子类可以定义与父类的静态方法同名的静态方法,以便在子类中隐藏父类的静态方法。
    父类的私有方法不能被覆盖。
    父类的抽象方法可以被子类覆盖:子类实现父类的方法或重新声明父类的抽象方法。
    

    Code:

    class Father{
        int x=8;
        int addX(int b){
            return x+b;
        }
    }
    class Son extends Father{
        @Override
        int addX(int c){
            return x+c+10;
        }
    }
    
    Java注解(annotation),Override确保子类覆盖(重写)超类方法。
    

    动态多态性

    一个特定的变量可以用于引用不同类型的对象,并且自动调用该变量引用的特定类型对象的方法,这样就使得一个方法的调用根据该调用所用到的不同对象类型而响应不同的操作。如果在编译时不能确定,只能在运行时才能确定执行多个同名方法中的哪一个,则称为运行时多态性(动态多态性)。

    Code:

    class Student{
        String name;
        public Student(String n){
            name=n;
        }
        public String toString(){
            return name;
        }
    }
    class Undergraduate extends Student{
        String teacher;
        public Undergraduate(String n,String t){
            super(n);
            teacher=t;
        }
        public String toString(){
                    return name+"的班主任是"+teacher;
        }
    }
    
    class Postgraduate extends Student{
        String director;
        public Postgraduate(String n,String d){
            super(n);
            director=d;
        }
        public String toString(){
                    return name+"的导师是"+director;
        }
    }
    public class Test{
        public static void print(Student s){
           System.out.println ("姓名:"+s.name);
        }
    
        public static void main (String[] args) {
            Student a=new Undergraduate("小张","张老师");
            Student b=new Postgraduate("小王","李教授");
            Undergraduate c=new Undergraduate("小赵","钱老师");
            System.out.println (a.toString());
            System.out.println (b.toString());
            print(c);
        }
    }
    
    result:
    
    小张的班主任是张老师
    小王的导师是李教授
    姓名:小赵
    

    使用多态时必须满足的条件:

    派生类对象的方法调用必须通过一个基类类型的变量进行。
    调用的方法必须在派生类中被定义。
    调用的方法也必须被声明为基类的一个成员。
    基类和派生类中对应的方法的签名必须相同。
    派生类的方法的访问说明符不能比基类有更多的限制。
    

    抽象类

    Abstract关键字可修饰类和方法,被修饰的类称为抽象类,被修饰的方法称为抽象方法。
    抽象类中的方法定义可以没有方法体,只有方法声明。抽象类没有对象,也就是说,一个抽象类不能通过new操作符直接实例化。
    被abstract修饰的方法在非抽象的子类中必须有具体的实现。
    抽象类是专门设计来让子类继承的类。
    抽象类提供一个类型的部分实现,可以有实例变量,构造方法,抽象方法和具体方法。
    抽象类作为系统中多个子类的共同父类,它所体现的是一种模板式设计。
    抽象类作为多个子类的抽象父类,可以被当成系统实现过程中的中间产品,这个中间产品已经实现了系统的部分功能,但这个产品依然不能当成最终产品,必须有更进一步的完善,这种完善可能有几种不同方式。
    
    
    abstract class 类名{  
       成员变量;
       方法( ){ 方法体  };//定义一般方法
       abstract 方法( );    //定义抽象方法
    }
    

    对于成员方法,不能同时用static和abstract说明。对于类,不能同时用final和abstract说明。
    有抽象方法的类一定是抽象类,抽象类不一定有抽象方法。

    代码:

    abstract class Shape{
        protected String name;
    
        public Shape(String name){
            this.name=name;        
        }
    
        abstract protected double getArea();    
    }
    
    class Rectangle extends Shape{
        double width,length;
        public Rectangle(String name, double width, double length){
            super(name);
            this.width=width;
            this.length=length;
        }
    
        public double getArea(){
            return width*length;
        }
    }
    public class Test {
        public static void main(String args[]) {
            Rectangle r=new Rectangle("矩形", 10.0, 23.5);
            System.out.println(r.getArea());
        }
    }
    

    接口

    "接口"是抽象类的概念,实际上是一组相关常量和(或)抽象方法的集合,并且在大多数情况下,它只包含方法。
    接口不会定义方法是什么,而只定义方法的形式,即名称、参数和返回类型,因此接口中的方法都是没有方法体的抽象方法。
    接口中只能定义 static final 域。
    接口定义的仅仅是实现某一特定功能的一组方法的对外接口和规范,而并没有真正地实现这个功能。
    接口的功能实现是在"继承"了这个接口的各个类中完成的,由这些类来具体定义接口中所有抽象方法的方法体。
    通常把对接口的"继承"称为"实现"。
    

    定义接口的格式

    public  interface  接口名  [extends  父接口名列表]  {  
             // 常量域声明
            [public static final]  域类型  域名 = 常量值;
    
               // 抽象方法声明
            [public abstract]  返回值类型  方法名( 参数列表 ) ;
    }
    

    接口的实现

    一个类要实现接口时,要注意下列问题:

    在类的声明部分,用implements关键字声明该类将实现哪些接口。 
    如果实现了某个接口的类不是abstract的抽象类,则在类的定义部分必须实现指定接口的所有抽象方法,即为所有抽象方法定义方法体。
    如果实现了某个接口的类是abstract的抽象类,则它可以不实现指定接口的所有抽象方法。
    接口的抽象方法的访问控制符为public,所以类在实现方法时,必须显式地使用public。
    实现接口的类要实现接口的全部方法。如果不需要某个方法,也要定义成一个空方法体的方法。
            如:public void 方法名()  {  } 
    

    例子:

    interface CalArea {
        double PI = 3.14;
    
        double getArea();
    }
    
    class Circle implements CalArea {
        double r;
    
        public Circle(double r) {
            this.r = r;
        }
    
        public double getArea() {
            // PI=3.14159; 错误,pi隐含为final和static的
            return PI * r * r;
        }
    }
    
    class Square implements CalArea {
        double s;
    
        public Square(double s) {
            this.s = s;
        }
    
        public double getArea() {
            return s * s;
        }
    }
    
    public class Test {
        public static void main(String args[]) {
            Circle a = new Circle(3);
            Square b = new Square(3);
            System.out.println(a.getArea());
            System.out.println(b.getArea());
        }
    }
    

    例子:

    interface Remote {
        void open();
    
        void close();
    }
    
    class Tv implements Remote {
        public void open() {
            System.out.println("打开电视。");
        }
    
        public void close() {
            System.out.println("关闭电视。");
        }
    }
    
    class Vcd implements Remote {
        public void open() {
            System.out.println("打开VCD。");
        }
    
        public void close() {
            System.out.println("关闭VCD。");
        }
    }
    
    public class Test {
        public static void main(String args[]) {
            Remote r = new Tv();
            r.open();
            r.close();
            r = new Vcd();
            r.open();
        }
    }
    

    接口作为系统与外界交互的窗口,体现的是一种规范。
    对接口的实现者而言,接口规定了实现者必须向外提供哪些服务(以方法的形式来提供);
    对于接口的调用者而言,接口规定了调用者可以调用哪些服务,以及如何调用这些服务(就是如何来调用方法)。
    当在一个程序中使用接口时,接口是多个模块间的耦合标准;当在多个应用程序之间使用接口时,接口是多个程序之间的通信标准。

    接口和抽象类的区别

    接口可以多重继承,抽象类不可以。
    抽象类内部可以有实现的方法,接口则没有实现的方法。
    接口与实现它的类不构成类的继承体系,即接口不是类体系的一部分。因此,不相关的类也可以实现相同的接口。而抽象类是属于一个类的继承体系,并且一般位于类体系的顶层。
    接口的优势:通过实现多个接口实现多重继承,能够抽象出不相关类之间的相似性。
    创建类体系的基类时,若不定义任何变量并无需给出任何方法的完整定义,则定义为接口;必须使用方法定义或变量时,考虑用抽象类。

    内部类

    大部分时候,我们把类定义成一个独立的程序单元。在某些情况下,我们把一个类放在另一个类的内部定义,这个定义在其他类内部的类就被称为内部类,包含内部类的类被称为外部类。
    内部类有如下作用:

    ①内部类提供了更好的封装。
    ②内部类方法可以访问外部类私有数据。
    

    内部类的类名只用于定义它的类或语句块之内,在外部引用它时必须给出带有外部类名的完整名称,并且内部类的名字不允许与外部包类的名字相同。
    内部类可以是抽象类或接口,若是接口,则可以由其它内部类实现
    按照内部类是否含有显示的类名,可将内部类分为:

    实名内部类
    局部内部类
    匿名内部类
    

    内部类一般用于定义与其外部的对象有很强关联的对象,并且两者之间通常有紧密的联系。
    当定义内部类的时候,它与其他类成员一样,会成为外部类的一个成员;也可以具有访问属性,并且外部类对它的访问性也是同样取决于这个属性值。

    实名内部类

    格式:
        [类修饰词表] class 类名 [extends 父类名]  [implements 接口名列表]{
            类体
        }
    

    实名内部类的封装性增加了保护模式和私有模式,即实名内部类的修饰词可以是protected或private
    实名内部类的修饰词可以是static,称为静态实名内部类
    没有static修饰的内部类,称为不具有静态属性的实名内部类,它的成员域若有静态属性,则必须有final属性,但不能有静态属性的方法

    代码:

    public class Test {
        JFrame frame=new JFrame("测试窗口"); //窗口
        JPanel panel=new JPanel(); //面板
        private JLabel label=new JLabel("没有操作"); //标签
        private JButton button=new JButton("确定"); //按钮
    
        private class ButtonListerner implements ActionListener{ //监听器类
            @Override
            public void actionPerformed(ActionEvent e) {
                label.setText("点击了按钮");     
            }       
        }
    
        public Test(){
            panel.add(label); //将标签加到面板中
            panel.add(button); //将按钮加到面板中
            frame.add(panel); //将面板加到窗口中        
            button.addActionListener(new ButtonListerner());
    
            frame.setBounds(200, 100, 400, 300);
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setVisible(true);
        }   
    
        public static void main(String args[]) {        
            new Test();         
        }
    }
    

    局部内部类

    如果把一个内部类放在方法里定义,则这个内部类就是一个局部内部类,局部内部类仅在该方法里有效。

    1、在局部内部类前不能用public、protected和private,只允许是abstract、final或不加。
    2、可以定义与外部类同名的变量。
    3、不可以定义静态变量和方法。
    4、可以访问外部类的局部变量,但是变量必须是final的。
    5、可以访问外部类的所有成员。
    

    代码:

    class Outter {
        String str="abc";
        int a=10;
    
        public void sample1() {
            final int b=12;
            String str3="123";
    
            class Inner { // 不能用public、protected和private修饰类
                int a=12;
    
                // static String str3="aaa"; 内部类中不能定义STATIC变量。
                public void sample2() {
                    System.out.println(b); //局部常量b
                    System.out.println(str); //外部类成员变量str
                    System.out.println(Outter.this.a);//外部类成员变量a
                    System.out.println(a); //内部类成员变量a
                    // 不能引用另一方法中定义的内部类中非终态变量 str3
                    // System.out.println("外部类成员变量str3的值"+str3);
                }
            }
            new Inner().sample2();
        }
    }
    public class Test {
        public static void main(String[] args) {
            Outter outter=new Outter();
             outter.sample1();
        }
    }
    

    匿名类

    有时仅仅为了在程序中定义一个对象而定义类,而且这个对象的唯一作用就是将它作为实参传递给方法。在这种情况下,只要类扩展已存在的类或者实现接口,就可以选择将其作为匿名类。
    匿名类没有名字,类的定义和一个实例的创建同时进行,也就是说定义实际上是写在new的代码中,而不是拥有class关键字;匿名类不能有修饰符,也不能定义构造方法。

    new 父类名(父类型的构造方法的调用参数列表){
        类体
    }
    

    代码1:

    interface A {
        void print();
    }
    
    public class Test {
        public static void main(String args[]) {
            A a=new A() {
                public void print() {
                    System.out.println("匿名类");
                }
            };
    
            a.print();
        }
    }
    
    public class Test {
        JFrame frame=new JFrame("测试窗口"); //窗口
        JPanel panel=new JPanel(); //面板
        private JLabel label=new JLabel("没有操作"); //标签
        private JButton button=new JButton("确定"); //按钮
    
        public Test(){
            panel.add(label); //将标签加到面板中
            panel.add(button); //将按钮加到面板中
            frame.add(panel); //将面板加到窗口中
    
            button.addActionListener(new ActionListener() {         
                @Override
                public void actionPerformed(ActionEvent e) {
                    label.setText("点击了按钮"); 
                }
            });
        }
    }
    

    泛型类

    泛型是JDK5.0后出现的新概念,泛型的本质是参数化类型,也就是所操作的数据类型被指定为一个参数。当这种参数类型用在类中时,该类就被称为泛型类。
    泛型类定义的格式:

    [类修饰符] class类名<类型参数列表> [extends 父类名] [implement 接口名列表]{
          类体
    }
    

    类型参数的定义方式有以下三种*:

    类型变量标识符
    类型变量标识符 extends 父类名
    类型变量标识符 extends 父类名1 & 父类名2 ...
    

    规则和限制:

    泛型的类型参数可以有多个。
    泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。
    在static方法中不可以使用泛型,泛型变量也不可以用static关键字来修饰。
    不可以定义泛型数组。
    

    代码:

    class MyClass<T, U> {
      private T a;
      private U b;
    
      public MyClass(T a, U b) {
        this.a = a;
        this.b = b;
      }
    
      public T getA() {
        return a;
      }
    
      public U getB() {
        return b;
      }
    }
    
    public class Test {
      public static void main(String[] args) {
        MyClass<String, Integer> m = new MyClass<String, Integer>("abc", 123);
        String s = m.getA();
        System.out.println(s);
        Integer i = m.getB();
        System.out.println(i);
      }
    }
    

    而不用泛型的代码:

    class MyClass {
     private Object  a;
     private Object  b;
    
      public MyClass(Object a, Object b) {
        this.a = a;
        this.b = b;
      }
    
      public Object getA() {
        return a;
      }
    
      public Object getB() {
        return b;
      }
    }
    
    public class Test {
      public static void main(String[] args) {
        MyClass m = new MyClass("abc", 123);
        String s = (String) m.getA();
        System.out.println(s);
        Integer i = (Integer) m.getB();
        System.out.println(i);
      }
    }
    
    展开全文
  • JavaJava静态多态性与动态多态性

    千次阅读 2014-10-11 17:18:08
    静态多态性指的是程序在编译时,系统就能决定调用哪个函数,如重载。 动态多态性指在运行中才能动态确定操作指针所指的对象,主要通过虚函数和重写来实现。 java 的多态机制遵循一个原则:当父类对象引用变量引用...
  • 深入理解Java多态性

    千次阅读 2013-11-21 13:07:40
    看过一些关于Java多态性的文章,参考了很多人的理解,加入了一些自己的看法,整理出来供大家参考,不一定完全正确,欢迎大家批评指正。 (一)相关类 class A ...{  public String show(D obj)...{  return ("A...
  • java 多态性的理解

    2011-09-05 10:03:44
    运行时多态性是面向对象程序设计代码重用的一个最强大机制,Java多态性概念也可以被说成“一个接口,多个方法”。Java实现运行时多态性的基础是动态方法调度,它是一种在运行时而不是在编译期调用重载方法的机制。...
  • 主要介绍了Java面向对象程序设计多态性,结合实例形式分析了java多态性概念、原理、定义与使用方法及相关注意事项,需要的朋友可以参考下
  • 运行时多态性是面向对象程序设计代码重用的一个最强大机制,动态性的概念也可以被说成“一个接口,多个方法”。Java实现运行时多态性的基础是动态方法调度,它是一种在运行时而不是在编译期调用重载方法的机制,下面...
  • 深入理解java多态性

    万次阅读 多人点赞 2008-04-19 14:14:00
    深入理解java多态性  昨天看到一个关于多态性的帖子,参考了回帖者的理解,加入了一些自己的看法,整理出来供大家参考,不一定完全正确,欢迎大家批评指正。 (一)相关类 class A ...{  public String ...
  • 重载和重写的概念我了解,但是为啥方法的重载体现了编译的多态性,方法的重写体现了运行的多态性? 我是新人,还没有C币,真心求解,谢谢各位~
  • Java多态性的理解

    千次阅读 2015-09-15 13:35:33
    看过一些关于Java多态性的文章,参考了很多人的理解,加入了一些自己的看法,整理出来供大家参考,不一定完全正确,欢迎大家批评指正。 (一)相关类 class A ...{ public String show(D obj)...{ return ...
  • Java多态性理解

    千次阅读 2015-11-05 21:52:12
    这是我们最后一个概念,也是最重要的知识点。多态的定义:指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)实现多态的技术称为:动态...
  • Java多态性探悉

    千次阅读 2008-05-15 15:22:00
    一、基本概念 多态性:发送消息给某个对象,让该对象自行决定响应何种行为。 通过将子类对象引用赋值给超类对象变量, 来实现动态方法调用。 java 的这种机制遵循一个原则:当超类对象引用变量, 引用子类对象时,被...
  • 相比于封装和继承,多态似乎理解起来更加抽象,这篇文章将彻底揭露java多态性,文章内容较多,请耐心观看 1.通过代码体现多态性 我们先准备好三个类,男人类male,女人类female,以及他们共同的父类person类 public ...
  • Java学习-多态性

    千次阅读 2020-08-12 11:38:09
    1、多态性,是面向对象的最重要的概念,在java中有两种体现: 方法的重载(overload)和重写(override) 对象的多态性 ------可以直接应用在抽象类和接口上 2、Java引用变量有两个类型:编译时的类型和运行时的...
  • Java多态性详解——父类引用子类对象

    万次阅读 多人点赞 2013-05-21 21:07:02
     继承是为了重用父类代码,同时为实现多态性作准备。那么什么是多态呢?  方法的重写、重载与动态连接构成多态性Java之所以引入多态的概念,原因之一是它在类的继承问题上和C++不同,后者允许多继承,这确实给...
  • 面向对象JAVA多态性

    千次阅读 2011-12-29 12:21:40
    数据抽象、继承和多态是面向对象程序设计语言的三大特性。多态,我觉得它的作用就是...在Java中,谈论多态就是在讨论方法调用的绑定,绑定就是将一个方法调用同一个方法主体关联起来。在C语言中,方法(在C中称为函数
  • 我们知道面向对象语言的三大特点之一就是多态性,而java作为一种面向对象的语言,自然也满足多态性,我们也知道java中的多态包括重载与重写,我们也知道在C++中动态多态是通过虚函数来实现的,而虚函数是通过一个虚...
  • java多态性学习&子类给父类赋值

    千次阅读 2014-02-22 14:39:44
    ava的多态性 面向对象编程有三个特征,即封装、继承和多态。 封装隐藏了类的内部实现机制,从而可以在不影响使用者的前提下改变类的内部结构,同时保护了数据。 继承是为了重用父类代码,同时为实现多态性作...
  • 静态多态性指的是程序在编译时,系统就能决定调用哪个函数,如重载。 动态多态性指在运行中才能动态确定操作指针所指的对象,主要通过虚函数和重写来实现。 java 的多态机制遵循一个原则:当父类对象引用变量引用...
  • Java多态性理解(重要)

    千次阅读 2018-06-23 04:10:24
    来源:...这是我们最后一个概念,也是最重要的知识点。多态的定义:指允许不同类的对象对同一消息做出响应。即同一消息可以根据发...
  • Java中的多态性

    千次阅读 2016-03-26 09:56:07
    通过讲Java中的上塑造型引出了多态的重要
  • java多态性,instanceof及Object类

    千次阅读 2013-10-30 20:44:37
    注意:粉红色为个人理解,其他为原作者的表述 多态是一个之前一直搞不清楚的概念,... 所谓类的多态性,是指子类对象和父类对象之间的相互转换. 这里分为两部分做笔记:   1.1 子类对象向父类对象转换(向上转换)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 54,787
精华内容 21,914
关键字:

java多态性的概念

java 订阅