`
winie
  • 浏览: 224322 次
  • 性别: Icon_minigender_1
  • 来自: 重庆
社区版块
存档分类
最新评论

Java语法总结 - 方法

    博客分类:
  • java
阅读更多
一、方法的重写。

1、重写只能出现在继承关系之中。当一个类继承它的父类方法时,都有机会重写该父类的方法。一个特例是父类的方法被标识为final。重写的主要优点是能够定义某个子类型特有的行为。
    class Animal {
        public void eat(){
            System.out.println ("Animal is eating.");
        }
    }
   
    class Horse extends Animal{
        public void eat(){
            System.out.println ("Horse is eating.");
        }
    }

2、对于从父类继承来的抽象方法,要么在子类用重写的方式设计该方法,要么把子类也标识为抽象的。所以抽象方法可以说是必须要被重写的方法。

3、重写的意义。
重写方法可以实现多态,用父类的引用来操纵子类对象,但是在实际运行中对象将运行其自己特有的方法。
    public class Test {
        public static void main (String[] args) {
            Animal h = new Horse();
            h.eat();   
        }
    }

    class Animal {
        public void eat(){
            System.out.println ("Animal is eating.");
        }
    }
   
    class Horse extends Animal{
        public void eat(){
            System.out.println ("Horse is eating.");
        }
        public void buck(){
        }
    }

一个原则是:使用了什么引用,编译器就会只调用引用类所拥有的方法。如果调用子类特有的方法,如上例的h.buck(); 编译器会抱怨的。也就是说,编译器只看引用类型,而不是对象类型。

4、重写方法的规则。
若想实现一个合格重写方法,而不是重载,那么必须同时满足下面的要求!

A、重写规则之一:重写方法不能比被重写方法限制有更严格的访问级别。
(但是可以更广泛,比如父类方法是包访问权限,子类的重写方法是public访问权限。)
比如:Object类有个toString()方法,开始重写这个方法的时候我们总容易忘记public修饰符,编译器当然不会放过任何教训我们的机会。出错的原因就是:没有加任何访问修饰符的方法具有包访问权限,包访问权限比public当然要严格了,所以编译器会报错的。

B、重写规则之二:参数列表必须与被重写方法的相同。
重写有个孪生的弟弟叫重载,也就是后面要出场的。如果子类方法的参数与父类对应的方法不同,那么就是你认错人了,那是重载,不是重写。

C、重写规则之三:返回类型必须与被重写方法的返回类型相同。
父类方法A:void eat(){}  子类方法B:int eat(){}  两者虽然参数相同,可是返回类型不同,所以不是重写。
父类方法A:int eat(){}   子类方法B:long eat(){}  返回类型虽然兼容父类,但是不同就是不同,所以不是重写。

D、重写规则之四:重写方法不能抛出新的异常或者比被重写方法声明的检查异常更广的检查异常。但是可以抛出更少,更有限或者不抛出异常。
    import java.io.*;
    public class Test {
        public static void main (String[] args) {
            Animal h = new Horse();
            try {
                h.eat();   
            }
            catch (Exception e) {
            }
        }
    }

    class Animal {
        public void eat() throws Exception{
            System.out.println ("Animal is eating.");
            throw new Exception();
        }
    }
   
    class Horse extends Animal{
        public void eat() throws IOException{
            System.out.println ("Horse is eating.");
            throw new IOException();
        }
    }
这个例子中,父类抛出了检查异常Exception,子类抛出的IOException是Exception的子类,也即是比被重写的方法抛出了更有限的异常,这是可以的。如果反过来,父类抛出IOException,子类抛出更为宽泛的Exception,那么不会通过编译的。
注意:这种限制只是针对检查异常,至于运行时异常RuntimeException及其子类不再这个限制之中。

E、重写规则之五:不能重写被标识为final的方法。

F、重写规则之六:如果一个方法不能被继承,则不能重写它。
比较典型的就是父类的private方法。下例会产生一个有趣的现象。
    public class Test {
        public static void main (String[] args) {
            //Animal h = new Horse();
            Horse h = new Horse();
            h.eat();
        }
    }

    class Animal {
        private void eat(){
            System.out.println ("Animal is eating.");
        }
    }
   
    class Horse extends Animal{
        public void eat(){
            System.out.println ("Horse is eating.");
        }
    }
这段代码是能通过编译的。表面上看来违反了第六条规则,但实际上那是一点巧合。Animal类的eat()方法不能被继承,因此Horse类中的eat ()方法是一个全新的方法,不是重写也不是重载,只是一个只属于Horse类的全新的方法!这点让很多人迷惑了,但是也不是那么难以理解。
main()方法如果是这样:
    Animal h = new Horse();
    //Horse h = new Horse();
    h.eat();
编译器会报错,为什么呢?Horse类的eat()方法是public的啊!应该可以调用啊!请牢记,多态只看父类引用的方法,而不看子类对象的方法!


二、方法的重载。
重载是有好的,它不要求你在调用一个方法之前转换数据类型,它会自动地寻找匹配的方法。方法的重载是在编译时刻就决定调用哪个方法了,和重写不同。最最常用的地方就是构造器的重载。

1、基本数据类型参数的重载。
    public class Test {
        static void method(byte b){
            System.out.println ("method:byte");
        }
        static void method(short s){
            System.out.println ("method:short");
        }
        static void method(int i){
            System.out.println ("method:int");
        }
        static void method(float f){
            System.out.println ("method:float");
        }
        static void method(double d){
            System.out.println ("method:double");
        }
        public static void main (String[] args) {
            method((byte)1);
            method('c');
            method(1);
            method(1L);
            method(1.1);
            method(1.1f);
        }
    }
输出结果:
method:byte
method:int
method:int
method:float
method:double
method:float

可以看出:首先要寻找的是数据类型正好匹配方法。如果找不到,那么就提升为表达能力更强的数据类型,如上例没有正好容纳long的整数类型,那么就转换为 float类型的。如果通过提升也不能找到合适的兼容类型,那么编译器就会报错。反正是不会自动转换为较小的数据类型的,必须自己强制转换,自己来承担转变后果。

char类型比较特殊,如果找不到正好匹配的类型,它会转化为int而不是short,虽然char是16位的。


2、重载方法的规则。

A、被重载的方法必须改变参数列表。
参数必须不同,这是最重要的!不同有两个方面,参数的个数,参数的类型,参数的顺序。

B、被重载的方法与返回类型无关。
也就是说,不能通过返回类型来区分重载方法。

C、被重载的方法可以改变访问修饰符。
没有重写方法那样严格的限制。

D、被重载的方法可以声明新的或者更广的检查异常。
没有重写方法那样严格的限制。

E、方法能够在一个类中或者在一个子类中被重载。


3、带对象引用参数的方法重载。
    class Animal {}
    class Horse extends Animal{}
   
    public class Test {
        static void method(Animal a){
            System.out.println ("Animal is called.");
        }
        static void method(Horse h){
            System.out.println ("Horse is called.");
        }
        public static void main (String[] args) {
            Animal a = new Animal();
            Horse h = new Horse();
            Animal ah = new Horse();
           
            method(a);
            method(h);
            method(ah);
        }
    }
输出结果是:
Animal is called.
Horse is called.
Animal is called.
前两个输出没有任何问题。第三个方法为什么不是输出“Horse is called.”呢?还是那句老话,要看引用类型而不是对象类型,方法重载是在编译时刻就决定的了,引用类型决定了调用哪个版本的重载方法。


4、重载和重写方法区别的小结。
如果能彻底弄明白下面的例子,说明你对重载和重写非常了解了,可以结束这节的复习了。
    class Animal {
        public void eat(){
            System.out.println ("Animal is eating.");   
        }
    }
    class Horse extends Animal{
        public void eat(){
            System.out.println ("Horse is eating.");   
        }
        public void eat(String food){
            System.out.println ("Horse is eating " + food);
        }
    }
   
    public class Test {
        public static void main (String[] args) {
            Animal a = new Animal();
            Horse h = new Horse();
            Animal ah = new Horse();
           
            a.eat();
            h.eat();
            h.eat("apple");
            ah.eat();
            //a.eat("apple");
            //ah.eat("apple");
        }
    }

四个输出分别是什么?被注释的两条语句为什么不能通过编译?
第一条:a.eat(); 普通的方法调用,没有多态,没什么技术含量。调用了Animal类的eat()方法,输出:Animal is eating.
第二条:h.eat(); 普通的方法调用,也没什么技术含量。调用了Horse类的eat()方法,输出:Horse is eating.
第三条:h.eat("apple"); 重载。Horse类的两个eat()方法重载。调用了Horse类的eat(String food)方法,输出:Horse is eating apple
第四条:ah.eat(); 多态。前面有例子了,不难理解。输出:Horse is eating.
第五条:a.eat("apple"); 低级的错误,Animal类中没有eat(String food)方法。因此不能通过编译。
第六条:ah.eat("apple"); 关键点就在这里。解决的方法还是那句老话,不能看对象类型,要看引用类型。Animal类中没有eat(String food)方法。因此不能通过编译。

小结一下:多态不决定调用哪个重载版本;多态只有在决定哪个重写版本时才起作用。
重载对应编译时,重写对应运行时。够简洁的了吧!


三、构造方法。
构造方法是一种特殊的方法,没有构造方法就不能创建一个新对象。实际上,不仅要调用对象实际类型的构造方法,还要调用其父类的构造方法,向上追溯,直到Object类。构造方法不必显式地调用,当使用new关键字时,相应的构造方法会自动被调用。

1、构造方法的规则。
A、构造方法能使用任何访问修饰符。包括private,事实上java类库有很多都是这样的,设计者不希望使用者创建该类的对象。

B、构造方法的名称必须与类名相同。这样使得构造方法与众不同,如果我们遵守sun的编码规范,似乎只有构造方法的首字母是大写的。

C、构造方法不能有返回类型。
反过来说,有返回类型的不是构造方法
    public class Test {
        int Test(){
            return 1;
        }
    }
这个方法是什么东西?一个冒充李逵的李鬼而已,int Test()和其他任何普通方法没什么两样,就是普通的方法!只不过看起来很恶心,类似恶心的东西在考试卷子里比较多。

D、如果不在类中创建自己的构造方法,编译器会自动生成默认的不带参数的构造函数。
这点很容易验证!写一个这样简单的类,编译。
class Test {
}
对生成的Test.class文件反编译:javap Test,可以看到:
D:"JavaCode"bin>javap Test
Compiled from "Test.java"
class Test extends java.lang.Object{
    Test();
}
看到编译器自动添加的默认构造函数了吧!

E、如果只创建了带参数的构造方法,那么编译器不会自动添加无参的构造方法的!

F、在每个构造方法中,如果使用了重载构造函数this()方法,或者父类的构造方法super()方法,那么this()方法或者super()方法必须放在第一行。而且这两个方法只能选择一个,因此它们之间没有顺序问题。

G、除了编译器生成的构造方法,而且没有显式地调用super()方法,那么编译器会插入一个super()无参调用。

H、抽象类有构造方法。


四、静态方法的重载与重写(覆盖)。

1、静态方法是不能被覆盖的。可以分两种情况讨论:

A、子类的非静态方法“覆盖”父类的静态方法。
这种情况下,是不能通过编译的。

class Father{
    static void print(){
        System.out.println ("in father  method");
    }
}
class Child extends Father{
    void print(){
        System.out.println ("in child method");
    }
}

static方法表示该方法不关联具体的类的对象,可以通过类名直接调用,也就是编译的前期就绑定了,不存在后期动态绑定,也就是不能实现多态。子类的非静态方法是与具体的对象绑定的,两者有着不同的含义。

B、子类的静态方法“覆盖”父类静态方法。
这个覆盖依然是带引号的。事实上把上面那个例子Child类的print方法前面加上static修饰符,确实能通过编译!但是不要以为这就是多态!多态的特点是动态绑定,看下面的例子:

class Father{
    static void print(){
        System.out.println ("in father  method");
    }
}
class Child extends Father{
    static void print(){
        System.out.println ("in child method");
    }
}

class Test{
    public static void main (String[] args) {
        Father f =new Child();
        f.print();
    }
}

输出结果是:in father  method
从这个结果可以看出,并没有实现多态。
但是这种形式很迷惑人,貌似多态,实际编程中千万不要这样搞,会把大家搞懵的!
它不符合覆盖表现出来的特性,不应该算是覆盖!
总而言之,静态方法不能被覆盖。

2、静态方法可以和非静态方法一样被重载。
这样的例子太多了,我不想写例程了。看看java类库中很多这样的例子。
如java.util.Arrays类的一堆重载的binarySearch方法。
在这里提一下是因为查资料时看到这样的话“sun的SL275课程说,静态方法只能控制静态变量(他们本身没有),静态方法不能被重载和覆盖……”
大家不要相信啊!可以重载的。而且静态与非静态方法可以重载。

从重载的机制很容易就理解了,重载是在编译时刻就决定的了,非静态方法都可以,静态方法怎么可能不会呢?
分享到:
评论

相关推荐

    JAVA语法总结 - 内部类

    ### JAVA语法总结 - 内部类 #### 一、内部类概述 内部类(Inner Class)自Java 1.1版本引入以来,一直是Java编程语言中的一个重要特性。它允许开发者在一个类的内部定义另一个类,这有助于更好地组织代码并实现更...

    Java基础语法--Java方法

    本章是Java基础语法的学习总结

    125集专攻JAVA基础 JAVA零基础入门学习视频教程 动力节点JAVA视频教程.txt

    北京动力节点-Java编程零基础教程-119-Java基本语法-方法详解-方法的调用过程-方法调用过程中栈内存的变化.avi 北京动力节点-Java编程零基础教程-120-Java基本语法-方法的重载-什么是方法重载.avi 北京动力节点-...

    mysql-connector-java-5.1.20-bin.jar

    在这个压缩包中,`mysql-connector-java-5.1.20-bin.jar`是核心文件,它包含了实现JDBC接口的类和方法,用于建立、执行SQL查询以及管理MySQL数据库的连接。 在Java开发中,为了连接到MySQL数据库,我们需要引入这个...

    Java语言语法-控制结构

    在北大青鸟赠送的光盘资料中,关于Java语言控制结构的介绍提供了基本的语法结构及其使用方法。控制结构是编程语言中的基础概念之一,用于控制程序执行流程的方向,使得程序可以根据不同的条件执行不同的代码块或者...

    Java语法总结.zip

    本压缩包文件"Java语法总结.zip"提供了对Java语言核心语法的全面概述,旨在帮助初学者和有经验的开发者巩固和提升Java编程技能。 首先,我们要了解Java的基础知识,包括数据类型、变量和常量。Java有两大类数据类型...

    mysql-connector-java-5.1.6-bin.rar

    总结来说,`mysql-connector-java-5.1.6-bin.rar`是MySQL数据库与Java应用程序交互的关键组件,通过它,开发者可以编写Java代码实现对MySQL数据库的各种操作,从而构建基于Java的数据库驱动的应用程序。在实际开发中...

    MySQL基础语法总结--内有案例

    MySQL基础语法总结-新手教程 内容包括了: 1.SQL语言 的介绍 2.MySQL数据类型 3.约束类型 4.数据库语句 -表相关的语句-数据相关的语句 5.导入sql文件 6.DML语句(insert update delete)-truncate语句 7....

    中信java培训资料------第一部分

    【course1.txt】作为课程的第一部分,可能会详细讲解Java语言的基础语法,如方法定义、返回值、数组、字符串操作以及异常处理。这部分内容是后续深入学习Java编程的基石。 总之,这份【中信java培训资料------第一...

    eclipse-java-2021-03-R-win32-x86_64.zip

    JDT提供了一整套的Java编程工具,包括语法高亮、代码自动完成、重构工具、调试器以及对Java标准版(Java SE)和企业版(Java EE)的支持。 3. **2021-03-R版本**: 这个版本代表了Eclipse在2021年3月发布的一个修订...

    luajava-1.1-x64-lua51

    总结来说,luajava-1.1-x64-lua51是将Lua脚本无缝集成到Java应用程序中的关键工具。它通过JNI实现了高效的数据交换和方法调用,为开发者提供了一种混合编程的新方式,提高了软件的可扩展性和可维护性。无论你是Java...

    Java知识总结-完整版

    ### Java知识总结——关键知识点详解 #### 一、Java概述 - **面向对象特性**:Java是一种完全面向对象的编程语言,它继承了C++的一些面向对象特性,并且简化了一些复杂的概念,如去掉了指针操作,使得程序更加安全...

    java基础总结-经典

    ### Java基础总结——核心知识点详解 #### 一、Java概述 - **起源与发展**:Java 语言最初由 Sun 公司的 James Gosling 等人在 1991 年开发,当时命名为 Oak,目的是为了控制有线电视交换盒和个人数字助理(PDA)等...

    java学习总结-j2se Java学习资料

    java学习总结1 -- j2se 项目环境: jdk8 字符集:UTF-8 开发工具:Eclipse 包括内容: basic 基本语法 oop 面向对象 api 常用api及工具类 javadoc javaDoc的使用 debug 代码调试方法 datastructure 基本数据结构 ...

    拓薪教育-java基础语法-任亮.docx

    ### 拓薪教育-java基础语法-任亮 #### 一、标识符 在Java语言中,标识符是...以上是对拓薪教育提供的Java基础语法文档的主要知识点的总结和扩展。通过学习这些基础知识,可以为后续深入学习Java编程打下坚实的基础。

    蓝桥杯Java试题汇总-共48页.pdf

    蓝桥杯Java试题汇总-共48页.pdf 该资源汇总了蓝桥杯Java试题,共48页,涵盖了多种Java编程题目,包括历届试题、基础练习等。题目涵盖了Java基本语法、数据结构、算法、面向对象编程等多方面内容。 一、历届试题 1...

    Java语法大全史上最全语法

    根据提供的文件信息,本文将对Java语法进行详细的解析与总结,包括基本的语法结构、关键字、数据类型、变量声明及转换等内容。 ### Java语言概述 Java是一种广泛使用的面向对象编程语言,由Sun Microsystems开发并...

    java基础语法 汇总

    ### Java基础语法汇总 本文将基于给定的文件信息,对Java的基础语法进行一次全面而深入的解析。Java作为一种广泛使用的编程语言,在软件开发、Web应用、移动应用等多个领域都有着重要的地位。对于初学者而言,掌握...

    90.088.JAVA基础教程_Java基本语法-每天一考(90).rar

    总结来说,这个“90.088.JAVA基础教程_Java基本语法-每天一考(90)”的教程将带你走过Java编程的每一步,从理解基本语法元素到掌握面向对象的概念,再到实际编写和调试代码。每天的学习和练习将助你在Java编程的世界...

Global site tag (gtag.js) - Google Analytics