Java基础

最新推荐文章于 2021-08-11 22:37:32 发布
最新推荐文章于 2021-08-11 22:37:32 发布
阅读量161 收藏
点赞数 1
分类专栏： 基础 java 文章标签： 多态 抽象类 菱形继承 装箱 分派
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yu670538949/article/details/109687523
版权
本文详细介绍了Java的基础知识，包括数据类型中的自动装箱拆箱机制，以及valueOf方法的使用。接着探讨了多态的概念，包括重载、重写、分派，并解释了静态分派与动态分派的区别。此外，还讨论了接口和抽象类，特别是菱形继承问题及其解决规则。
摘要由CSDN通过智能技术生成

1. 数据类型

1.1 基本数据类型
基本数据类型bytecharshortintlongfloatdoubleboolean
占用字节12248481
包装器类型ByteCharacterShortIntegerLongFloatDoubleBoolean
范围[-27 ,27-1][0,255][-215, 215-1][-231,231-1][-263 ,263-1]
1.2 自动装箱拆箱

Java SE5开始提供自动装箱；

装箱：将基本数据类型转化为包装器类型；拆箱：将包装器类型转化为基本数据类型。

所有的包装类都是不可变类。

什么是不可变对象呢？一旦一个类的对象被创建出来，在其整个生命周期中，它的成员变量就不能被修改。

1.2.1 自动装箱如何实现？
public class Box {
    public static void main(String[] args) {
        Integer i = 10;
        int j = 10;
        j = new Integer(1000);
        Double d = 1.0;
        double dd = 1.0;
        dd = new Double(1000);
    }
}

javac Box.java
javap -c Box

Compiled from "Box.java"
public class com.learn.java.Box {
  public com.learn.java.Box();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: bipush        10
       2: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
       5: astore_1
       6: bipush        10
       8: istore_2
       9: new           #3                  // class java/lang/Integer
      12: dup
      13: sipush        1000
      16: invokespecial #4                  // Method java/lang/Integer."<init>":(I)V
      19: invokevirtual #5                  // Method java/lang/Integer.intValue:()I
      22: istore_2
      23: dconst_1
      24: invokestatic  #6                  // Method java/lang/Double.valueOf:(D)Ljava/lang/Double;
      27: astore_3
      28: dconst_1
      29: dstore        4
      31: new           #7                  // class java/lang/Double
      34: dup
      35: ldc2_w        #8                  // double 1000.0d
      38: invokespecial #10                 // Method java/lang/Double."<init>":(D)V
      41: invokevirtual #11                 // Method java/lang/Double.doubleValue:()D
      44: dstore        4
      46: return
}

由class文件可知，编译后的class在运行时，装箱由包装器类型的 valueOf 方法实现；

拆箱有各个类型对应的“ 类型value” 方法直接返回内置原始类型数据。

1.2.2 valueOf

各个包装器类型实现如下：

包装类型值处理方式备注
Byte[-128,127]从ByteCache.cache数组中直接取
Short[-128,127]从ShortCache.cache数组中直接取
Short[-215,-128)U(127,215-1]new一个新的Short
Integer[-127,size]从IntegerCache.cache数组中直接取size默认128
Integer[-231,-127)U(size,231-1]new一个新的Integer
Long[-128,127]从LongCache.cache数组中直接取
Long[-263 ,-128)U(127,263-1]new一个新的Long
Double所有可取的值new一个新的Double
Float所有可取的值new一个新的Float
Character[0,127]从CharacterCache.cache数组中直接取
Character(127,255]new一个新的Character
Booleantrue,false取中提前创建好的Boolean常量
1.2.3 案例：Integer源码
// Java 5 中引入这个特性的时候，范围是固定的 -128 至 +127。
// 后来在Java 6 后，最大值映射到 java.lang.Integer.IntegerCache.high，
// 可以使用 JVM 的启动参数设置最大值
-XX:AutoBoxCacheMax=size

    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }
        private IntegerCache() {}
    }

2. 语法权限

权限大小：

private(当前类) <default(当前类,同包)<protected(当前类,同包,子孙类)<public(当前类,同包,子孙类,外部包)

子类覆盖父类方法时，对外权限只能越来越大。

final修饰的类或者方法，不能被继承或覆盖。

3. 多态

3.1 重载、重写
区别点重载方法重写方法
参数列表必须修改一定不能修改
返回类型可以修改一定不能修改
异常可以修改可以减少或删除，一定不能抛出新的或者更广的异常
访问可以修改一定不能做更严格的限制（可以降低限制）
3.2 分派：虚拟机对多态的支持

静态类型：即对象的声明类型，编译期可知；

实际类型：对象实际所属类型，编译期不可知，运行时可知。

// m的静态类型是Map,实际类型是HashMap
Map m = new HashMap();

静态分派：所有依赖静态类型来定位方法执行版本的分派，如重载；

动态分配：根据实际类型来确定具体执行方法的分派，如重写。

重载的例子：

public class Super {

    public int test(int i) {
        System.out.println("Super test(int i)");
        return 0;
    }

    public int test(byte i) {
        System.out.println("Super test(byte i)");
        return 1;
    }

    public static void main(String[] args) {
        Super s = new Super();
        s.test((byte) 1);
        s.test(1);
    }
}

执行后输出:

Super test(byte i)
Super test(int i)

通过javap查看字节码：

Compiled from "Super.java"
public class com.basic.Super {
  public com.basic.Super();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public int test(int);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #3                  // String Super test(int i)
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: iconst_0
       9: ireturn

  public int test(byte);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #5                  // String Super test(byte i)
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: iconst_1
       9: ireturn

  public static void main(java.lang.String[]);
    Code:
       0: new           #6                  // class com/basic/Super
       3: dup
       4: invokespecial #7                  // Method "<init>":()V
       7: astore_1
       8: aload_1
       9: iconst_1
      10: invokevirtual #8                  // Method test:(B)I
      13: pop
      14: aload_1
      15: iconst_1
      16: invokevirtual #9                  // Method test:(I)I
      19: pop
      20: return
}

字节码中的main方法中第10行和第16行，分别根据参数类型byte、int定位到了test(byte i)和test(int i)，由此可见，重载是由编译器在编译期完成的。

重写的例子，接上述Super类：

public class Sub extends Super {
    // 重写父类该方法
    public int test(byte i) {
        System.out.println("Sub superInt(byte i)");
        return 1;
    }

    public static void main(String[] args) {
        Super sub = new Sub();
        byte i=2;
        sub.test(i);
    }
}

执行后输出如下：

Sub superInt(byte i)

通过javap查看字节码：

Compiled from "Sub.java"
public class com.basic.Sub extends com.basic.Super {
  public com.basic.Sub();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method com/basic/Super."<init>":()V
       4: return

  public int test(byte);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #3                  // String Sub superInt(byte i)
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: iconst_1
       9: ireturn

  public static void main(java.lang.String[]);
    Code:
       0: new           #5                  // class com/basic/Sub
       3: dup
       4: invokespecial #6                  // Method "<init>":()V
       7: astore_1
       8: iconst_2
       9: istore_2
      10: aload_1
      11: iload_2
      12: invokevirtual #7                  // Method com/basic/Super.test:(B)I
      15: pop
      16: return
}

因为sub对象的静态类型是Super，test方法传入参数的静态类型是byte，所以可以在字节码main方法中第12行看到，编译器定位到了Super.test(byte i )方法。而在运行时时，java虚拟机会根据对象的实际类型(Sub)调用实际类型的方法(Sub.test(byte i))。

3.3 重载方法匹配的优先级

因为java中字面量不需要定义，所以字面量没有显示的类型，它的静态类型只能通过语言上的规则去理解和推断。

----《深入理解java虚拟机》周志明

因此，对于重载方法匹配时存在优先级，参数匹配时，数据类型存在如下自动转换，来匹配更合适的方法。

char->int->long->float->double->装箱类型

3.4 父子间的重载？

父类和子类之间存在重载吗？准确来说父子间的重载没有意义。

因为子类重载父类的方法只有在声明类型是子类的时候才会被调用，而声明类型是具体子类时，会使代码缺乏扩展性，违反开闭原则。

4. 接口、抽象类

4.1 继承、实现

继承：子类与父类之间用 extends 来表示继承关系，子类只能有一个父类。子类继承抽象类时，除非声明当前类是抽象类，否则必须重写抽象方法。

实现：子类与接口之间用implements 来表示实现的接口，除非声明当前类是抽象类，否则必须实现接口声明的所有非默认方法。

4.2 接口、抽象类区别
抽象类接口
非常量成员变量有无
构造方法可以有无
方法实现有jdk8开始有默认方法，default修饰
也可以有接口静态方法, static修饰
抽象方法的修饰符只能为public或者protected，默认为public只能为public
继承方式子类只能继承一个抽象类子类可以实现多个接口
4.3 菱形继承问题

java8中引入接口的默认方法，由此可能会造成同一方法继承自父类或多个接口，当出现此类问题时，按如下规则进行匹配：

规则1.类或者父类中声明的方法的优先级高于任何默认方法
规则2.同函数签名的方法中实现得最具体的那个接口的方法
规则3.显示声明
「已注销」
关注
专栏目录
Java基础课程
06-23
Java基础课程PPT资源；知识点：自定义动画、选择器高级应用、响应式网站开发、行业命名规范、域名注册-搭建个人网站 让学员熟练掌握css、js、JQuery等技术，可做到独立编写PC+移动端网站页面。并且能够独立开发web...
128陷阱解析及其源码解析
qq_56740595的博客
08-11 271
128陷阱： 首先测试一段代码： public static void main(String[] args) { Integer num1 = 127; Integer num2 = 127; System.out.println(num1 == num2); Integer num3 = 128; Integer num4 = 128; System.out.println(num3 == n
Java 重载 - 重写
Syntactic Sugar
10-14 92
Java 重载 - 重写 区别点 重载方法 重写方法 发生范围 同一个类 子类中 参数列表 必须修改 一定不能修改 返回类型 可修改 一定不能修改 异常 可修改 可以减少或删除，一定不能抛出新的或者更广的异常 访问修饰符 可修改 一定不能做更严格的限制（可以降低限制） 发生阶段 编译器 运行期 ...
java基础（一） java基本数据类型和封装类型
菜饼之路
04-28 483
Java基础数据类型 Integer的值缓存范围-128-127，查看源码如下： // 在 -128~127 之间从缓存里取 public static Integer valueOf(int i) { if (i &gt;= IntegerCache.low &amp;&amp; i &lt;= IntegerCache.high) return...
Integer的值范围-128~127
qq_42956376的博客
08-11 2755
看到一道面试题，这个面试题是这样的。 public class Foo { public static void main(String[] args) { Integer a = 120,b = 160; Integer c = 120,d = 160; System.out.println(a==c); System.out.println(a.equals(c)
最快理解128陷阱
dsaggdsd的博客
08-11 167
Integer test01 = 100; Integer test02 = 100; System.out.println(test01==test02); //结果为true Integer test03 = 300; Integer test04 = 300; System.out.println(test03==test04); //结果为false ...
java基础案例教程
01-08
java基础的案例分析和实例教学,适合新手及回顾查阅,对于夯实基础有好处
java基础总结.xmind
03-28
IO、面向对象Object类、API、集合体系、IO体系、面向对象、多线程、递归、相互转换、正则表达式
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
JAVA基础加强
12-04
java基础加强版 ，更人性的巩固基础，万丈高楼平地起，只有打好基础，才能理解更复杂的东西
java基础知识图
01-18
总结了java基础的架构，从JDK安装到反射的知识
NutzWk-java基础
最新发布
09-15
WK-V1V5 Java(//) java基础 java基础 java基础 java基础 java基础
JAVA基础自学教程
09-28
写的很详细，适合初学者，里面的讲解很丰富，很有学习价值，最好是配套一本详细的JAVA基础一起看，会有更好的效果
Integer缓冲池[-128,127]
强强强子的博客
01-10 758
Integer 是 int的封装类。有时候不得不用引用类型。比如集合里面的泛型。 如果在项目中你使用了Integer那么你可能就会陷入一个巨大的坑中。 Integer i=1290; Integer ii=1290; System.out.println(i==ii);//1 false System.out.println(
java基础疑点分析
坚的博客
02-04 346
本篇主要对java基础一些原理性概念以及特性进行讲解,希望大神能够多多指教,提出其中的错误；                    同时可能有些问题没有注意到，也希望大家能够提醒         (1)类型自动转换和类型强制转换                (包括基本数据类型的转换和引用类型的转换)                问:基本数据类型自动转换执行原因以及如何实现类型转换
Java面试题集（1-50）
热门推荐
骆昊的技术专栏
12-15 19万+
下面的内容是对网上原有的Java面试题集及答案进行了全面修订之后给出的负责任的题目和答案，原来的题目中有很多重复题目和无价值的题目，还有不少的参考答案也是错误的，修改后的Java面试题集参照了JDK最新版本，去掉了EJB 2.x等无用内容，补充了数据结构和算法相关的题目、经典面试编程题、大型网站技术架构、操作系统、数据库、软件测试、设计模式、UML等内容，同时还对很多知识点进行了深入的剖析，例如hashCode方法的设计、垃圾收集的堆和代、Java新的并发编程、NIO.2等内容。
Integer的-128~127值缓存问题的思考
罗伯司机的博客
12-11 891
引言 闲来无事，随意点了项目中代码的一些源码，想看看这些代码中依赖的源码中都怎么实现的，机缘巧合进入Integer的源码。复习之后记录一下自己的心得。 例 闲话少说，代码敬上 private static void demo4(){ int a = 128, b = 128; System.out.println("run result NO.1->"+(a == b)); ...
全面掌握Java基础知识要点
以上便是Java基础知识点的概述，对于初学者而言，理解和掌握这些知识点是学习Java的第一步。通过实践操作，不断编写代码和调试程序，可以逐渐加深对Java语言的理解和应用。同时，这些基础知识点也为后续深入学习Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值