精华内容
参与话题
问答
  • 重写和重载区别

    千次阅读 2019-05-12 12:58:36
    重写 当子类继承父类的方法,这些方法不满足自身需求时,子类可以重写从父类继承的方法。 重写的规则: 修饰符 返回类型 方法名(参数){ } 返回类型、方法名、参数与父类完全相同。 方法重写要求:返回值类型...

    重写

    当子类继承父类的方法,这些方法不满足自身需求时,子类可以重写从父类继承的方法。

    重写的规则:

    修饰符 返回类型 方法名(参数){

    }

    返回类型、方法名、参数与父类完全相同。

    方法重写要求:返回值类型相同或者的父类返回值类型的子类类型,方法名称相同

    效果:

    子类在调用方法时,会调用自身重写的方法,父类的方法就被覆盖了不可见。

    参数列表相同,访问修饰符必须

    大于或等于父类的访问修饰符,方法重写和参数的的名称没有关系,只和参数的有关系

    如果父类的访问修饰符是public 则子类的必须是public

    如果父类的访问修饰符是protected 则子类的可以是protected 也可以是public

    如果父类的访问修饰符是private或默认 不能继承,谈不上重写

    重载

    方法重载 :在同一类中方法名称相同,方法的参数列表不同,和返回值无关

    参数列表不同的表现形式:参数的类型不同,个数不同,位置不同,参数列表不同和参数名称没有关系

    重载(Overload)与重写(Override)的区别

    1. 重载:一个类,多个方法的方法名相同但是参数不同(与返回类型,修饰符无关)
    2. 重写:两个类(子类与父类),子类的返回类型、方法名、参数、修饰符都与父类的方法一致。
    3. 重写是需要在继承下才能使用的
    4. 而重载是可以在任何环境下都可以使用
    5. 重写是子类重写父类的行为(函数)
    6. 重载是在一个类中存在多个同名函数,而参数类型和参数的个数以及参数类型的顺序不同,进行的函数重载

    代码如下

    package jicheng;
    //父类
    public class Anima {
    	
    	public String kind;
    	String name;
    	int age;
    	char sex ;
    
    	
    		public void Eat() {
    			
    		 System.out.println("好好吃饭");
    			
    			}
    		public void skill() {
    			
    			 System.out.println("展示本领");
    				
    				}
    		
    			
    }
    
    
    package jicheng;
    
    public class Dog extends  Anima{
    
    
    	//重写父类的方法
    		public void skill() {
    			super.name="狗";
    			 System.out.println(name+"在家看门");
    				
    				}
    
    }
    
    package jicheng;
    //子类
    public class Cat  extends Anima{
    	
     public void Eat() {
    
    		this.name="Cat";
    	 System.out.println(name+"好好吃饭");
    		
    		
    	}
     //添加方法
     void work() {
    
    		this.name="Cat";
    	 System.out.println(name+"在外面寻找食物");
    		
    		
    	}
    
    	//重写父类的方法
    	public void skill() {
    		
    		 System.out.println(name+"抓老鼠");
    			
    			}
    	
    	 
    }
    
    package jicheng;
    //测试
    public class Test {
    	public static void main(String[] args) {
    		Cat cat =new Cat();
    		cat.Eat();
    		cat.skill();
    		Dog dog=new Dog();
    		dog.skill();
    		
    	
    	}
    
    }
    

    运行结果:

    Cat好好吃饭
    Cat抓老鼠
    狗在家看门

    展开全文
  • 【面试题】重载和重写区别

    万次阅读 多人点赞 2018-08-27 09:25:39
    重载和重写(覆盖)的特点 Overload 特点 Override 特点 总结 overload(重载) override(重写重载(Overloading) 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在,具有...

    目录

    重载(Overloading)

    重载的规则

    重写方法的规则

    重载和重写(覆盖)的特点

    Overload 特点

    Override 特点

    总结

    overload(重载)

    override(重写)


    重载(Overloading)

    方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在,具有不同的参数个数/类型。重载Overloading是一个类中多态性的一种表现。

    Java的方法重载,就是在类中可以创建多个方法,它们具有相同的名字,但具有不同的参数和不同的定义。

    调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。

    重载的时候,方法名要一样,但是参数类型和个数不一样,返回值类型可以相同也可以不相同。无法以返回值类型作为重载函数的区分标准

    父类方法被默认修饰时,只能在同一包中,被其子类重写,如果不在同一包则不能重写。

    父类的方法被protoeted时,不仅在同一包中,被其子类重写,还可以不同包的子类重写。

    重载的规则

    1. 必须具有不同的参数列表;
    2. 可以有不同的返回类型,只要参数列表不同就可以了;
    3. 可以有不同的访问修饰符;
    4. 可以抛出不同的异常;

    重写方法的规则

    1. 参数列表必须完全与被重写的方法相同,否则不能称其为重写而是重载
    2. 返回的类型必须一直与被重写的方法的返回类型相同,否则不能称其为重写而是重载。
    3. 访问修饰符的限制一定要大于被重写方法的访问修饰符(public>protected>default>private)
    4. 重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如:父类的一个方法申明了一个检查异常IOException,在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常,可以抛出非检查异常。

    重载和重写(覆盖)的特点

    Overload 特点

    1. 在使用重载时只能通过不同的参数样式。例如,不同的参数类型,不同的参数个数,不同的参数顺序(当然,同一方法内的几个参数类型必须不一样,例如可以是fun(int, float), 但是不能为fun(int, int));
    2. 不能通过访问权限、返回类型、抛出的异常进行重载;
    3. 方法的异常类型和数目不会对重载造成影响;
    4. 对于继承来说,如果某一方法在父类中是访问权限是priavte,那么就不能在子类对其进行重载,如果定义的话,也只是定义了一个新方法,而不会达到重载的效果。

    Override 特点

    1. 覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配,才能达到覆盖的效果;
    2. 覆盖的方法的返回值必须和被覆盖的方法的返回一致;
    3. 覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致,或者是其子类;
    4. 被覆盖的方法不能为private,否则在其子类中只是新定义了一个方法,并没有对其进行覆盖。

    总结

    overload(重载)

    1. 参数类型、个数、顺序至少有一个不相同。
    2. 不能重载只有返回值不同的方法名。
    3. 存在于父类和子类、同类中。

    override(重写)

    1. 方法名、参数、返回值相同。
    2. 子类方法不能缩小父类方法的访问权限。
    3. 子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。
    4. 存在于父类和子类之间。
    5. 方法被定义为final不能被重写。
    展开全文
  • JAVA重写和重载区别

    万次阅读 多人点赞 2018-07-11 22:04:05
    问: Java 重载重写是什么?有什么区别? 答:  重载(Overload)是让类以统一的方式处理不同类型数据的一种手段,实质表现就是多个具有不同的参数个数或者类型的同名函数(返回值类型可随意,不能以返回...

    问: Java 重载与重写是什么?有什么区别?

    答:
      重载(Overload)是让类以统一的方式处理不同类型数据的一种手段,实质表现就是多个具有不同的参数个数或者类型的同名函数(返回值类型可随意,不能以返回类型作为重载函数的区分标准)同时存在于同一个类中,是一个类中多态性的一种表现(调用方法时通过传递不同参数个数和参数类型来决定具体使用哪个方法的多态性)。

    图1. Android类中的一个重载例子

    重写(Override)是父类与子类之间的多态性,实质是对父类的函数进行重新定义,如果在子类中定义某方法与其父类有相同的名称和参数则该方法被重写,不过子类函数的访问修饰权限不能小于父类的;若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表,则新方法将覆盖原有的方法,如需父类中原有的方法则可使用 super 关键字。

    图2. Android类中的常见的一个重写例子
    ----------

    **重载规则:**必须具有不同的参数列表; 可以有不同的返回类型;可以有不同的访问修饰符;可以抛出不同的异常。

    重写规则:参数列表必须完全与被重写的方法相同,否则不能称其为重写;返回类型必须一直与被重写的方法相同,否则不能称其为重写;访问修饰符的限制一定要大于等于被重写方法的访问修饰符;重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常,譬如父类方法声明了一个检查异常 IOException,在重写这个方法时就不能抛出 Exception,只能抛出 IOException 的子类异常,可以抛出非检查异常。

    重载与重写是 Java 多态性的不同表现。
      重写是父类与子类之间多态性的表现,在运行时起作用(动态多态性,譬如实现动态绑定)
      而重载是一个类中多态性的表现,在编译时起作用(静态多态性,譬如实现静态绑定)。


    问:Java 构造方法能否被重写和重载?

    答:
      重写是子类方法重写父类的方法,重写的方法名不变,而类的构造方法名必须与类名一致,假设父类的构造方法如果能够被子类重写则子类类名必须与父类类名一致才行,所以 Java 的构造方法不能被重写的。而重载是针对同一个的,所以构造方法可以被重载

    问:下面程序的运行结果是什么,为什么?

    public class Demo {
        
    public boolean equals( Demo other) {
            System.out.println("use Demo equals." );
            return true;    
    }
        
    public static void main(String[] args) {    
        Object o1 =new Demo ();
        Object o2 =new Demo ();        
        Demo o3 =new Demo ();
        Demo o4 =new Demo ();
    
       if (o1.equals(o2)) {
                System.out.println("o1 is equal with o2.");
            }
    
       if(o3.equals(o4)) {             
                System.out.println("o3 is equal with o4.");
            }
        }
    }
    

    答:上面程序的运行结果如下。

    use Demo equals.
    o3 is equal with o4.
    

    因为 Demo 类中的 public boolean equals(Demo other) 方法并没有重写 Object 类中的 public boolean equals(Object obj) 方法,原因是其违背了参数规则,其中一个是 Demo 类型而另一个是 Object 类型,因此这两个方法是重载关系(发生在编译时)而不是重写关系;故当调用 o1.equals(o2) 时,o2 是 Object 类型参数,实际上调用了 Object 类中的 public boolean equals(Object obj) 方法,因为在编译时 o1 和 o2 都是 Object 类型,而Object 类的 equals 方法是通过比较内存地址才返回 false;当调用 o3.equals(o4) 时,实际上调用了 Demo 类中的 equals(Demo other) 方法,因为在编译时 o3 和 o4 都是 Demo 类型的,所以才有上面的打印。

    展开全文
  • 重载重写区别

    万次阅读 2017-12-12 11:32:29
    首先我们来讲讲:重载(Overloading)  (1) 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在,具有不同的参数个数/类型。 重载Overloading是一个类中多态性的一种表现。 ...

    首先我们来讲讲:重载(Overloading)


        (1) 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在,具有不同的参数个数/类型。

    重载Overloading是一个类中多态性的一种表现。


        (2) Java的方法重载,就是在类中可以创建多个方法,它们具有相同的名字,但具有不同的参数和不同的定义。

    调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。


        (3) 重载的时候,方法名要一样,但是参数类型和个数不一样,返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。


        下面是重载的例子:
        package c04.answer;//这是包名
        //这是这个程序的第一种编程方法,在main方法中先创建一个Dog类实例,然后在Dog类的构造方法中利用this关键字调用不同的bark方法。

    不同的重载方法bark是根据其参数类型的不同而区分的。

        //注意:除构造器以外,编译器禁止在其他任何地方中调用构造器。
        package c04.answer;

        public class Dog {
             Dog()
             {
                    this.bark();
             }
             void bark()//bark()方法是重载方法
             {
                    System.out.println(\"no barking!\");
                    this.bark(\"female\", 3.4);
             }
             void bark(String m,double l)//注意:重载的方法的返回值都是一样的,
             {
                    System.out.println(\"a barking dog!\");
                    this.bark(5, \"China\");
             }
             void bark(int a,String n)//不能以返回值区分重载方法,而只能以“参数类型”和“类名”来区分
             {
                    System.out.println(\"a howling dog\");
             }

             public static void main(String[] args)
             {
                    Dog dog = new Dog();
                    //dog.bark(); [Page]
                    //dog.bark(\"male\", \"yellow\");
                    //dog.bark(5, \"China\");

     


      然后我们再来谈谈 重写(Overriding)


        (1) 父类与子类之间的多态性,对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法被重写 (Overriding)。在Java中,子类可继承父类中的方法,而不需要重新编写相同的方法。

    但有时子类并不想原封不动地继承父类的方法,而是想作一定的修改,这就需要采用方法的重写。

    方法重写又称方法覆盖。


        (2)若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表,则新方法将覆盖原有的方法。

    如需父类中原有的方法,可使用super关键字,该关键字引用了当前类的父类。


        (3)子类函数的访问修饰权限不能少于父类的;
        下面是重写的例子:


        概念:即调用对象方法的机制。

     

        动态绑定的内幕:

        1、编译器检查对象声明的类型和方法名,从而获取所有候选方法。试着把上例Base类的test注释掉,这时再编译就无法通过。

     

        2、重载决策:编译器检查方法调用的参数类型,从上述候选方法选出唯一的那一个(其间会有隐含类型转化)。

    如果编译器找到多于一个或者没找到,此时编译器就会报错。试着把上例Base类的test(byte b)注释掉,这时运行结果是1 1。

     

        3、若方法类型为priavte static final ,java采用静态编译,编译器会准确知道该调用哪
        个方法。

     

        4、当程序运行并且使用动态绑定来调用一个方法时,那么虚拟机必须调用对象的实际类型相匹配的方法版本。

    在例子中,b所指向的实际类型是TestOverriding,所以b.test(0)调用子类的test。

    但是,子类并没有重写test(byte b),所以b.test((byte)0)调用的是父类的test(byte b)。

    如果把父类的(byte b)注释掉,则通过第二步隐含类型转化为int,最终调用的是子类的test(int i)。

     

    学习总结

        多态性是面向对象编程的一种特性,和方法无关,
        简单说,就是同样的一个方法能够根据输入数据的不同,做出不同的处理,即方法的
        重载——有不同的参数列表(静态多态性)

      而当子类继承自父类的相同方法,输入数据一样,但要做出有别于父类的响应时,你就要覆盖父类方法,

        即在子类中重写该方法——相同参数,不同实现(动态多态性)

     

        OOP三大特性:继承,多态,封装。

        public class Base
        {
            void test(int i)
            {
                System.out.print(i);
            }
            void test(byte b)
            {
                System.out.print(b);
            }
        }
        public class TestOverriding extends Base
        {
            void test(int i)
            {
                i++;
                System.out.println(i);
            }
              public static void main(String[]agrs)
            {
                Base b=new TestOverriding();
                b.test(0)
                b.test((byte)0)
            }
        }


        这时的输出结果是1     0,这是运行时动态绑定的结果。

     

    重写的主要优点是能够定义某个子类特有的特征:

    public class Father{

       public void speak(){

           System.out.println(Father);

        }

    }

    public class Son extends Father{

        public void speak(){

            System.out.println("son");

       }

    }

    这也叫做多态性,重写方法只能存在于具有继承关系中,重写方法只能重写父类非私有的方法。

    当上例中Father类speak()方法被private时,Son类不能重写出Father类speak()方法,此时Son类speak()方法相当与在Son类中定义的一个speak()方法。

    Father类speak()方法一但被final时,无论该方法被public,protected及默认所修饰时,Son类根本不能重写Father类speak()方法,

    试图编译代码时,编译器会报错。例:

    public class Father{

       final public void speak(){

           System.out.println("Father");

        }

    }

    public class Son extends Father{

        public void speak(){

           System.out.println("son");

        }

    }       //编译器会报错;

     

    Father类speak()方法被默认修饰时,只能在同一包中,被其子类被重写,如果不在同一包则不能重写。

    Father类speak()方法被protoeted时,不仅在同一包中,被其子类被重写,还可以不同包的子类重写。

     

    重写方法的规则

    1、参数列表必须完全与被重写的方法相同,否则不能称其为重写而是重载。

    2、返回的类型必须一直与被重写的方法的返回类型相同,否则不能称其为重写而是重载。

    3、访问修饰符的限制一定要大于被重写方法的访问修饰符(public>protected>default>private)

    4、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如:

    父类的一个方法申明了一个检查异常IOException,在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常,可以抛出非检查异常。

     

    而重载的规则:

    1、必须具有不同的参数列表;

    2、可以有不责骂的返回类型,只要参数列表不同就可以了;

    3、可以有不同的访问修饰符;

    4、可以抛出不同的异常;

     

    重写与重载的区别在于:

    重写多态性起作用,对调用被重载过的方法可以大大减少代码的输入量,同一个方法名只要往里面传递不同的参数就可以拥有不同的功能或返回值。

    用好重写和重载可以设计一个结构清晰而简洁的类,可以说重写和重载在编写代码过程中的作用非同一般.

    展开全文
  • 重载重写区别

    万次阅读 多人点赞 2017-02-15 17:45:11
    重载(Overloading)  方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在,具有不同的参数个数/类型。 重载Overloading是一个类中多态性的一种表现。  Java的方法重载,就是在类中...
  • Java—重写重载区别

    万次阅读 多人点赞 2018-06-03 18:22:24
    Java—重写重载区别 这几周开始看Java的知识,发现有一个有趣的现象就是,前两天刚看过的知识点,过一天又忘掉了。而且很多东西堆在脑子里像浆糊一样。所以边学习边总结是很重要的,今天想写一篇关于重写和重载...
  • 重写重载区别

    2020-11-23 00:11:06
    重载和重写区别 重载就是同样的⼀个⽅法能够根据输⼊数据的不同,做出不同的处理 重写就是当⼦类继承⾃⽗类的相同⽅法,输⼊数据⼀样,但要做出有别于⽗类的响应时,你就要覆盖⽗类⽅法 重载 发⽣在同⼀个类中,...
  • 重写 重写概念 1.重写必须依赖于继承,将父类的方法完善。 2.重写的方法要父类的方法名一致。 3.重写方法的返回值参数不能改变。 重写的好处 子类可以完善父类之中不足之处,使自身的方法更加的完善。 举例 ...
  • Java方法重写重载区别

    万次阅读 多人点赞 2018-08-23 10:26:39
    Java方法重写重载 一、方法重写(0veriding) 在Java程序中,类的继承关系可以产生一个子类,子类继承父类,它具备了父类所有的特征,继承了父类所有的方法变量。 子类可以定义新的特征,当子类需要修改父类...
  • 重写和重载区别?

    千次阅读 2019-01-08 12:48:39
    重载实现的是编译时的多态性,而重写实现的是运行时的多态性。 重载(overload):发生在同一个类中,方法名相同,参数不同,参数包括:参数的个数,参数类型,参数的类型顺序。 重写(override):发生在继承过程...
  • java中重写重载区别

    千次阅读 2019-02-27 17:58:47
    重载:同一个类中不同方法具有相同的名字,但是参数不一样,即参数的名称参数的类型不一样。同类不同参 重写:子父类的,即子类与父类具有相同的方法名字还有参数参数相同相同的返回类型。即同名同参同类型 ...
  • 重载是同一类中 参数个数不同 或者参数类型不同 重写继承父类的方法名返回值参数类型都相同
  • C++_重载重写和重定义的区别

    万次阅读 2015-05-08 18:37:06
    重载:函数名相同,函数的参数个数、参数类型或参数顺序三者中必须至少有一种不同。函数返回值的类型可以相同,也可以不相同。发生在一个类内部。 重定义:也叫做隐藏,子类重新定义父类中有相同名称的非虚函数( .....
  • 面试题来源: 1.重写必须继承,重载不用。 2.重写的方法名,参数数目相同,参数类型兼容,...3.重写的方法修饰符大于等于父类的方法,重载和修饰符无关。 4.重写不可以抛出父类没有抛出的一般异常,可以抛出运行时异常
  • 重写和重载有什么区别

    千次阅读 2019-05-23 22:50:10
    重写和重载有什么区别是面试中经常遇到的一个问题 重载(overLoading) 方法重载就是让类用统一的方式处理不同类型的数据的一种手段,多个同名函数同时存在,具有不同的参数个数类型。返回值的类型可以相同也可以不...
  • php 的重写 重载

    2015-07-21 14:36:46
    //php重载和重写 class base{ function out() { echo 'base print'; } } class a extends base{ function out() { echo 'a print'; } } $a = new a(); $a->out(); clas...
  • 我们知道面向对象主要是封装、继承多态,重写和重载都有面向对象的多态性,而一字相同,区别大不同。重写是子类继承父类中方法,属于动态多态性。重载发生在同一个类中方法名相同参数个数或类型不同,且与返回值...
  • class Animal { private String name; private String sex; private int age; public Animal() { // TODO Auto-generated constructor stub } public void move() { ...animal move...
  • java中重载和重写区别

    千次阅读 2016-07-07 11:12:06
    首先我们来讲讲:重载(Overloading)  (1) 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在,具有不同的参数个数/类型。 重载Overloading是一个类中多态性的一种表现。 ...
  • 重写和重载区别

    2014-11-20 17:06:30
    重写方法的规则如下: 1. 参数列表:必须与被重写方法的参数列表完全匹配。  2. 返回类型:必须与超类中被重写的方法中声明的返回类型或子类型完全相同  3. 访问级别:一定不能比被重写方法强,可以比被...

空空如也

1 2 3 4 5 ... 20
收藏数 142,792
精华内容 57,116
关键字:

重写和重载的区别