疯狂Java笔记之面向对象的陷阱

instanceof运算符的陷阱

instanceof是一个非常简单的运算符。instanceof运算符的前一个操作数通常是一个引用类型的变量,后一个操作数通常是一个类(也可以是接口,可以把接口理解成一个特殊的类),他用于判断前面的对象是否是后面的类或其子类,实现类的实例。如果是,则返回true,否则,返回false.

String obj="Java";
obj instanceof Math

上面程序是无法编译通过的,根据Java语言规范,使用instanceof运算符有一个限制:instanceof运算符前面操作数的编译时类型必须是如下三种情况。

  • 要么与后面的类相同
  • 要么与后面类的父类
  • 要么是后面类的子类

如果前面操作数的编译时类型与后面的类型没有任何关系,程序将没法用过编译。因此,当使用instanceof运算符的时候,应尽量从编译,运行两个阶段来考虑它————如果instanceof运算符使用不当,程序编译时就会抛出异常;当使用instanceof运算符用过编译后,才能考虑它的运算结果是true,还是false.

在极端情况下,instanceof前一个操作数所引用对象的实际类型就是后面的类型,但只要它的编译时类型既不是第二个操作数的类型, 也不是第二个操作数的父类,子类程序就没法通过编译。如下:

Object str="java";
Math math=(Math)str;
System.out.println("字符串是否是String的实例:"+(math instanceof String));()

当编译器编译java程序时,编译器无法检查引用变量实际引用对象的类型,他只检查该变量的编译时类型。最后一句代码math的编译时类型是Math,Math既不是String类型,也不是String类型的父类,还不是String类型的子类,因此程序没法通过编译。至于math实际引用对象的类型是什么,编译器也不关心,编译阶段也没法关心。

至于第二行代码为何没有出现编译错误,这和强制转型机制有关。对于Java的强制转型而言,也可以分为编译,运行两个阶段来分析它。

  • 在编译阶段,强制转型要求被转型变量的编译时类型必须是如下三种情况之一.
  1. 被转型变量的编译时类型与目标类型相同。
  2. 被转型变量的编译时类型是目标类型父类。
  3. 被转型变量的编译时类型是目标类型子类。在这个情况下可以自动向上转型,无须强制转换。 如果被转型变量的编译时类型与目标类型没有任何继承关系,编译器将提示编译错误。通过上面分析可以看出,强制转型的编译阶段只关心引用变量的编译时类型,至于该引用变量实际引用对象的类型,编译器并不关心,也没法关心。
  • 在运行阶段,被转型变量所引用对象的实际类型必须是目标类型的实例,或者是目标类型的子类、实现类的实例,否则在运行时将引发ClassCastExceptivn异常。
String s=null;
System.out.println(s instanceof String);

使null调用instanceof运算符时返回false是非常有用的行为,因为instanceof运算符有了一个额外的功能:它可以保证第一个操作数所引用的对象不是null如果instanceof告知一个引用变量是某个特定类型的实例,那么就可以将其转型为该类型,并调用该类型的方法,而不用担心会抛出ClassGastExeception或NullPointerException异常。

构造器的陷阱

构造器创建对象吗

实际上构造器井不会创建Java对象,构造器只是负责执行初始化,在构造器执行之前,Java对象所需要的内存空间,应该说是由new关键字中请出来的。

绝大部分时候,程序使用new关键字为一个Java对象申请空间之后,都需要使用构造器为这个对象执行初始化。但在某些时候,程序创建Java对象无须调用构造器,以下面两种方式创建的Java对象无须使用构造器。

  • 使用反序列化的方法恢复java对象。
  • 使用clone方法复制java对象。

无限递归的构造器

public class Main {
    Main main;
    {
        main=new Main();
    }

    public Main(){
        System.out.println("执行构造器");
    }

    public static void main(String[] args) {
        Main main=new Main();
    }
}

不管是定义实例变量是指定的初始值,还是在非静态初始化块中执行的初始化操作,最终都将被提取到构造器中执行。所以以上代码到时了构造器递归。

这个程序给出的教训是,无论如何不要导致构造器产生递归调用。也就是说,应该:

  • 尽量不要在定义实例变量时指定实例变量的值为当前类的实例。
  • 尽量不要在初始化块中创建当前类的实例口
  • 尽量不要在构造器内调用本构造器创建Java对象。

持有当前类的实例

对于一个java类而言,他的一个实例持有当前类的另一个实例是被允许的,只要程序初始化它持有当前类的实例时不会引起构造器递归就行。

public class Main {
   private String name;
   private Main instance;
   public Main(){

   }
   public Main(String name){
       instance=new Main();
       instance.name=name;
   }
   public static void main(String[] args){
       Main main=new Main();
       Main main2=new Main("测试");
   }
}

到底调用哪个重载的方法

public class Main {
    public void info(Object obj,double count){
        System.out.println("obj:"+obj);
        System.out.println("count:"+count);
    }
    public void info(Object[] objs,double count){
        System.out.println("objs:"+objs);
        System.out.println("count:"+count);
    }
    public static void main(String[] args){
        Main main=new Main();
        main.info(null,5);
    }
}

上面代码方法的调用看似info(Object[],int)和info(Obejct,int)都是可以匹配的,那到底调用哪个呢。

根据精确匹配原则,当实际调用是传入的实参满足多个方法时,如果某个方法的形参要求参数范围越小,那么这个方法就越精确。很明显,Object[]可以看成Object的子类,info(Object[] ,int)方法匹配的更精确,执行上面程序,将看到如下输出:

objs:null
count:5.0

再看一个极端的例子:

public class Main {
    public void info(Object obj,int count){
        System.out.println("obj:"+obj);
        System.out.println("count:"+count);
    }
    public void info(Object[] objs,double count){
        System.out.println("objs:"+objs);
        System.out.println("count:"+count);
    }
    public static void main(String[] args){
        Main main=new Main();
        main.info(null,5);
    }
}

调用方法时第一个参数调info(Object[] objs,double count)比较好,而第二个参数调info(Obejct obj,int count)比较好,而两个参数中和就不知道了。所以系统报错。

方法重写的陷阱

对于使用private修饰符修饰的方法,只能在当前类中访问该方法,子类无法访问父类中定义的private方法。既然子类无法访问父类的private。方法,当然也就无法重写该方法。

如果子类中定义了一个与父类的private方法具有相同的方法名、相同的形参列表、相同的返回值类型的方法,依然不是重写,只是了类中重新定义了一个新方法。

重写其他访问权限的方法

如果父类中定义了使用默认访问控制符(也就是不使用访问控制符)修饰方法,这个方法同样可能无法被重写。

对于不使用访问控制符修饰的方法,它只能被与当前类处于同一个包中的其他类访问,其他包中的子类依然无法访问该方法。只有与当前类处于同一个包中的其他类才能访问该方法。

非静态内部类的陷阱

非静态内部类的构造器

非静态内部类必须寄生在外部类实例中,没有外部类的对象,就不可能产生非静态内部类的对象。因此,非静态内部类不可能有无参数的构造器————即是系统为非静态内部类提供一个默认的构造器,这个默认的构造器也需要一个外部类形参。

系统在编译阶段总会为非静态内部类的构造器增加一个参数,非静态内部类的构造器的第一个形参总是外部类。因此调用非静态内部类的构造器时必须传入一个外部类对象作为参数,否则程序将会引发运行时异常。

非静态内部类不能拥有静态成员

对于非静态内部类而言,由于它本身就是一个非静态的上下文环境,因此非静态内部类不允许拥有静态成员。

非静态内部类的子类

由于非静态内部类没有无参数的构造器,因此通过非静态内部类派生子类时也可能存在一些陷阱。

class Base{
  class In{
      public void test(){
          System.out.println("In的Test方法");
      }
  }
  class A extends In{

  }
}
public class sub extends Base.In{
    public sub(){

    }
    public static void main(String[] args){
        System.out.println("Hello World");
    }
}

由于非静态内部类In必须寄生在Base对象之内,因此父类Base.In根本没有参数的构造器。而程序定义其子类Base.In时,没有定义构造器,那么系统会为它提供一个无参数的构造器。在sub无参数的构造器内,编译器会增加代码super()————子类总会调用父类的构造器。对于这个super()调用,指定调用父类Base.In无参数的构造器,必然导致编译错误.为了解决这个问题,应该为sub显示定义一个构造器,在该构造器中显示调用Base.In父类对应的构造器。

public class sub extends Base.In{
    public sub(){
        new Base().super();
    }
    public static void main(String[] args){
        System.out.println("Hello World");
    }
}

以上显式的调用父类的构造器。使用new Base()作为主调————即以一个Base对象作为主调,其实这个主调会作为参数擦传入super(),也就是传给In类带一个Base参数的构造器。

static关键字

静态方法属于类

被static关键字修饰的成员(Field,方法,内部类,初始化块,内部枚举类)属于类本身,而不是当个的java对象,具体到静态方法也是如此,静态方法属于类。而不属于Java对象。

静态内部类的限制

当程序使用内部类时,应尽量考虑使用静态内部类,而不是非静态内部类。当程序使用静态内部类时,外部类相当于静态内部类的一个包,因此使用起来比较方便;但另一方面,这也给静态内部类增加了一个限制———静态内部类不能访问外部类的非静态成员。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏微信公众号:Java团长

浅谈Java中的equals和==

  为什么第4行和第5行的输出结果不一样?==和equals方法之间的区别是什么?如果在初学Java的时候这个问题不弄清楚,就会导致自己在以后编写代码时出现一些...

891
来自专栏黑泽君的专栏

Java中方法重写的两个面试题

  方法重写:     在子类中,出现和父类中一模一样的方法声明的现象。(包含方法名、参数列表和返回值类型都一样)   方法重载:     同一...

2901
来自专栏LanceToBigData

JavaSE(四)之接口、访问控制

上面我们学习了几个修饰符,在开发中经常会用的到,所以必须熟练的掌握。接下来我学习一下接口和访问控制。 一、接口 一系列方法的声明,是一些方法特征的集合,一个接口...

2367
来自专栏java一日一条

浅谈Java中的equals和==

为什么第3行和第4行的输出结果不一样?==和equals方法之间的区别是什么?如果在初学Java的时候这个问题不弄清楚,就会导致自己在以后编写代码时出现一些低级...

582
来自专栏marsggbo

strtol函数 将字符串转换为相应进制的整数

+----------------+ |   strtol   | +----------------+ i.e. string to...

2277
来自专栏一“技”之长

深入理解JavaScript函数 原

    从功能上理解,函数是一组可以随时运行的语句,是一段代码块,也是所谓的子程序。在JavaScript中,函数实质上也是一种对象,是Function对象。函...

621
来自专栏工科狗和生物喵

【计算机本科补全计划】Java学习笔记(三) 数据类型

正文之前 Java的面向对象特性太明显了。先开篇告诉你我们的对象是啥意思,然后直截了当的告诉你,每个文件都是一个类。也就是说每个文件都可以给你传出来一种对象,然...

3534
来自专栏猿人谷

const用法小结

常类型是指使用类型修饰符const说明的类型,常类型的变量或对象的值是不能被更新的。因此,定义或说明常类型时必须进行初始化。 概述 1. const有什么...

1857
来自专栏V站

PHP常用系统内置函数,收藏以后别折磨自己写函数类了

1479
来自专栏calmound

C++知识总结

1.*p++和(*p)++的区别      *p++是先取值,然后将指针地址执行++操作      (*p)++是先取值,然后对(*p)这个值进行++操作 2...

3144

扫码关注云+社区

领取腾讯云代金券