上往建站提供服务器空间服务商，百度快照排名，网站托管，百度推广运营,致力于设计外包服务与源代码定制开发，360推广，搜狗推广,增加网站的能见度及访问量提升网络营销的效果,主营：网站公司,百度推广公司电话,官网搭建服务,网站服务企业排名,服务器空间,英文域名等业务，专业团队服务，效果好。

邹平企业网站设计 - 邹平高端网站定制 - 邹平品牌网站搭建 - 上往建站

重载是同样的一个方法写多次变量修饰符不一样，当调用方法时，会自动判断给入数的类型，选取其中符合的方法。

public class Overloading {

    private static int i = 1;

    private static double l = 3.1415;

    private static String k = "我是栗子";

    //参数类型不同

    public void test(int a){

        System.out.println("你输入了整数:"+a);

    }   

    public void test(double a){

        System.out.println("你输入了浮点数:"+a);

    }   

    public void test(String a){

        System.out.println("你输入了字符串:"+a);

    }   

    public static void main(String[] args){

        Overloading lizi = new Overloading();

        lizi.test(i);

        lizi.test(l);

        lizi.test(k);

    }

}

输出结果：

你输入了整数：1

你输入了浮点数：3.1415

你输入了字符串：我是栗子

我一点都不方

   我一点都不方

  274***2310@qq.com

5年前 (2017-06-04)

   九刃

  528***187@qq.com

38

补充：父类申明变量指向子类实例，该父类变量不能调用父类不存在的变量和方法，否则会编译错误

class Animal{

   public void move(){

      System.out.println("动物可以移动");

   }

}

class Dog extends Animal{

   public int age;

   public void move(){

       age = 10;

      System.out.println("狗可以跑和走");

   }

   public void bark(){

      System.out.println("狗可以吠叫");

   }

}

public class TestOverride{

   public static void main(String args[]){

      Animal a = new Animal(); // Animal 对象

      Animal b = new Dog(); // Dog 对象

      a.move();// 执行 Animal 类的方法

      b.move();//执行 Dog 类的方法

      // b.age;//去掉前注释符号，会编译错误

      // b.bark();//去掉前注释符号，会编译错误

   }

}

九刃

   九刃

  528***187@qq.com

5年前 (2017-06-27)

   luzhe610

  sci***n@qq.com

78

重载与重写的简明理解:

 重载反映的是"随机应变". 同样一项功能, 根据数据类型的不同, 采用不同的处理方式. 比如, 同样是吃饭, 去高档餐厅吃西餐, 你会西装革履, 但是去吃火锅, 穿便装就比较合适.

重写反映的是"父子差异". 你"继承"了父亲吃火锅的爱好, 但是吃同一份鸳鸯锅(注意, 数据类型相同) , 你喜欢涮红汤, 你父亲喜欢涮清汤.

luzhe610

   luzhe610

  sci***n@qq.com

5年前 (2017-09-18)

   TJ

  133***99286@163.com

12

关于重载函数参数列表变化的可能性:

/**

 * @author tangjia

 * @date 2017年10月29日 下午4:29:06

 * @version 1.0

 * @since jdk 1.8.0_65

 * 类说明:测试重载函数

 */

public class Main {

    public static void main(String[] args) {

        int age = 10;

        String name = "ii";

        handle(age);

        handle(name);

        handle(name,age);

                handle(age,name);

    }

    public static void handle(int age) {

        System.out.println(age);

    }

    public static void handle(String name) {

        System.out.println(name);

    }

    public static void handle(int age,String name) {

        System.out.println("the age of "+name+" is "+age);

    }

    public static void handle(String name, int age) {

        System.out.println("the age of "+name+" is "+age);

    }

}

 1.参数类型变化，如参数从int 转变为String 类型

 2.参数个数变化，如参数个数从一个转变为两个

 3.参数顺序变化，如从handle(int age, String name)转变为handle(String name,int age)

 4.函数返回值可变可不变

TJ

   TJ

  133***99286@163.com

5年前 (2017-10-29)

   Xander663

  xan***1998@163.com

12

自定义的类重载比较函数的方法：

public class Match implements Comparable{

    public int compareTo(Object o) {

        Match tgt = (Match)o;  

        return ( this.len < tgt.len ? -1 : ( this.len == tgt.len ? 0 : 1));

    }

}

Xander663

   Xander663

  xan***1998@163.com

4年前 (2018-07-15)

   Anchorin

  Anc***in@foxmail.com

20

父类变量指向子类实例时可以使用强制类型转换访问父类没有的子类成员。

import java.io.IOException;

public class Main {

    public static void main(String[] args) throws IOException {

        People a=new People();

        People b=new Up(6);

        a.bark();

        b.bark();

        System.out.println(((Up)b).level); // 强制类型转换

    }

}

class People{

    public void bark(){

        System.out.println("Hello!");

    }

}

class Up extends People{

    public int level;

    public Up(int lv){

        level=lv;

    }

    public void bark(){

        System.out.println("鸽了鸽了，不播了");

    }

}

实例输出结果为：

Hello!

鸽了鸽了，不播了

6

Anchorin

   Anchorin

  Anc***in@foxmail.com

4年前 (2018-08-11)

   独孤尚良

  yut***hanlin@qq.com

23

重写和重载的区别，以红烧为例。

红烧是一种做菜方法，可用来被比作 java 的方法。食材可以被比作为参数。厨师师徒可被比作为父子类。

方法的继承可以看做红烧这个做菜方法厨师老师传给厨师徒弟。

同样的红烧鱼，厨师老师的红烧方法传给厨师徒弟后，厨师徒弟在红烧方法上做了改动，这是红烧方法的重写，就相当于 java 的方法重写。

重写代码类似如下：

class Ct{

    void hongshao(int a){

        System.out.println("这是厨师老师的红烧int的方法");

    }

}

class Cs extends Ct{

    void hongshao(int a) {

        System.out.println("这是厨师徒弟的红烧int的方法");

    }

}

我找厨师徒弟做菜，我说要红烧，我给他鱼他就做的是红烧鱼，我给他排骨他就做的是红烧排骨，我给他鱼和排骨他就做的是红烧鱼和排骨。食材的不同就相当于 java 方法的参数不同，这个是重载。

重载代码类似如下：

class Cs extends Ct{

    void hongshao(int a) {

        System.out.println("这是厨师徒弟的红烧int的方法");

    }

    void hongshao(float b) {

        System.out.println("这是厨师徒弟红烧float的方法");

    }

    void hongshao(int a,float b) {

        System.out.println("这是厨师徒弟红烧int和float的方法");

    }

}

独孤尚良

   独孤尚良

  yut***hanlin@qq.com

4年前 (2019-03-04)

   韶华轻负

  jia***ihua77@163.com

16

对于重写和重载的一些浅薄认识。

重写：我从我的父亲继承了一个中餐馆，但是我觉得中餐馆不够，于是我又在中餐馆的基础上加了个西餐馆。

class Chinese{

  public void style(){

    System.out.printhl("赣菜中餐馆");

  }

}

class western extends Chinese{

  public void style(){

    System.out.printhl("西餐厅");

  }

}

餐厅还是那个餐厅，只是我继承过来加入了自己独有的方法。

重载：本来我只开了一个赣菜馆，但是我觉得菜系不够，于是我又增加了川菜、粤菜....

public class Chinese{

  public void style(){

    System.out.printhl("赣菜中餐馆");

  }

  public void style(int a){

    System.out.printhl("a川菜中餐馆");

  }

   public void style(String b){

    System.out.printhl("b粤菜中餐馆");

  }

}

做饭的方法并没有改变，只是参数不同，返回的值也不一样。

韶华轻负

   韶华轻负

  jia***ihua77@163.com

3年前 (2019-04-11)

   alittlemc

  ali***emc@189.cn

6

重载：同名方法通过传入的参数不同（如类型、个数、排序方式）而区分不同方法函数，与返回值无关

对象：类内的方法之间

例子：void a();void a(int i);int a(String str)等等，关键在传入的参数

class A{

  void a(){

     System.out.printhl("a()");

  }

  int a(){//这样是不合法，因为返回值类型不同不能区分不同的方法

     System.out.printhl("a()");

  }

  void a(int i){//void a()

     System.out.printhl("a("+i+")");

  }

}

重写：在子类中编写与父类 返回值类型相同的同名方法 ，这样原来的父类方法就会被隐藏掉，可以使用super.方法名() 调用

对象：父类和子类之间

class A{

  void a(){

     System.out.printhl("a()");

  }

}

class B extends A{

  /*int a(){//返回值与父类的void不同，报错

     return 0；

  }*/

  void a(int a){//就算是可以有不同的传入

    System.out.printhl("a"+i);

  }

}

可能有错误和不足，仅供参考

alittlemc

   alittlemc

  ali***emc@189.cn

3年前 (2019-10-08)

   aojiaodexiaoyanga

  259***1569@qq.com

11

继承：我有一钱包，钱包里面有一张农行卡，有1000元现金，小明找我借钱包，我把钱包给他，他可以用里面所有的东西。

重写和重载：（取钱为例）

重写：小明从我的农行卡中取出100，而我本来要取1000。

重载：去相同的钱，我选择农业银行，而小明却跑去隔壁的建设银行取钱

aojiaodexiaoyanga

   aojiaodexiaoyanga

  259***1569@qq.com

2年前 (2020-03-19)

class Shape {

    void draw() {}

}

class Circle extends Shape {

    void draw() {

        System.out.println("Circle.draw()");

    }

}

class Square extends Shape {

    void draw() {

        System.out.println("Square.draw()");

    }

}

class Triangle extends Shape {

    void draw() {

        System.out.println("Triangle.draw()");

    }

}

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

以下是一个多态实例的演示，详细说明请看注释：

Test.java 文件代码：

public class Test {

    public static void main(String[] args) {

      show(new Cat());  // 以 Cat 对象调用 show 方法

      show(new Dog());  // 以 Dog 对象调用 show 方法

      Animal a = new Cat();  // 向上转型  

      a.eat();               // 调用的是 Cat 的 eat

      Cat c = (Cat)a;        // 向下转型  

      c.work();        // 调用的是 Cat 的 work

  }  

    public static void show(Animal a)  {

      a.eat();  

        // 类型判断

        if (a instanceof Cat)  {  // 猫做的事情 

            Cat c = (Cat)a;  

            c.work();  

        } else if (a instanceof Dog) { // 狗做的事情 

            Dog c = (Dog)a;  

            c.work();  

        }  

    }  

}

abstract class Animal {  

    abstract void eat();  

}  

class Cat extends Animal {  

    public void eat() {  

        System.out.println("吃鱼");  

    }  

    public void work() {  

        System.out.println("抓老鼠");  

    }  

}  

class Dog extends Animal {  

    public void eat() {  

        System.out.println("吃骨头");  

    }  

    public void work() {  

        System.out.println("看家");  

    }  

}

执行以上程序，输出结果为：

吃鱼

抓老鼠

吃骨头

看家

吃鱼

抓老鼠

虚函数

虚函数的存在是为了多态。

Java 中其实没有虚函数的概念，它的普通函数就相当于 C++ 的虚函数，动态绑定是Java的默认行为。如果 Java 中不希望某个函数具有虚函数特性，可以加上 final 关键字变成非虚函数。

重写

我们将介绍在 Java 中，当设计类时，被重写的方法的行为怎样影响多态性。

我们已经讨论了方法的重写，也就是子类能够重写父类的方法。

当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法。

要想调用父类中被重写的方法，则必须使用关键字 super。

Employee.java 文件代码：

/* 文件名 : Employee.java */

public class Employee {

   private String name;

   private String address;

   private int number;

   public Employee(String name, String address, int number) {

      System.out.println("Employee 构造函数");

      this.name = name;

      this.address = address;

      this.number = number;

   }

   public void mailCheck() {

      System.out.println("邮寄支票给： " + this.name

       + " " + this.address);

   }

   public String toString() {

      return name + " " + address + " " + number;

   }

   public String getName() {

      return name;

   }

   public String getAddress() {

      return address;

   }

   public void setAddress(String newAddress) {

      address = newAddress;

   }

   public int getNumber() {

     return number;

   }

}

假设下面的类继承Employee类：

Salary.java 文件代码：

/* 文件名 : Salary.jav

邹平企业网站设计 - 邹平高端网站定制 - 邹平品牌网站搭建 - 上往建站

上往建站提供搭建网站，域名注册，官网备案服务，网店详情页设计，企业网店，专业网络店铺管理运营全托管公司咨询电话，服务器空间，微信公众号托管，网页美工排版,致力于域名申请，竞价托管，软文推广，全网营销,提供标准级专业技术保障，了却后顾之忧,主营：虚拟主机，网站推广，百度竞价托管，网站建设，上网建站推广服务，网络公司有哪些等业务，专业团队服务，效果好。

服务热线：400-111-6878 手机微信同号:18118153152（各城市商务人员可上门服务）