精华内容
下载资源
问答
  • 【Java】Java方法详解篇

    万次阅读 2020-06-11 16:24:18
    【Java】java方法详解篇 文章目录【Java】java方法详解篇方法void修饰的方法的调用方法的重载方法的形参是基本数据类型方法的形参是引用类型递归结构 方法 方法:完成特定功能的饿代码块 作用: 提高代码复用性...

    【Java】java方法详解篇



    方法

    方法:完成特定功能的饿代码块
    作用:

    • 提高代码复用性和可维护性
    • 但是并不能提高程序的运行效率

    定义格式:

    • 修饰符
    • 返回值类型:用于限定返回值的数据类型
    • 方法名:方法的名字,便于我们调用
    • 参数类型:用于限定调用方法时传入数据的类型
    • 参数名:用于接收调用方法时传入数据的变量(用于告诉方法的使用者,调用该方法时的需要)
    • 方法体:完成我们需要的功能的代码
    • return语句:结束方法,并把返回值传递给调用者
    修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2……){
    		方法体;
    		return 返回值;
    }
    

    注意事项

    • 实参的数目,数据类型和顺序需和所调用的方法声明的形式参数列表匹配
    • return终止方法的运行并指定返回数据
    • java中进行方法调用中传递参数时,遵循值传递的原则(传递的都是数据的副本)
    • 基本数据类型传递的时该数据的copy值
    • 引用数据类型传递的是该对象引用的copy值,但指向的是同一个对象

    void修饰的方法的调用

    void:

    • 当没有方法返回值时,返回值类型写void

    注意:

    • 返回值类型为void的方法只能单独调用
    • void作为返回值类型的方法,可以不写return语句,或使用ruturn;结束方法,
    public static void testOne(){
    	System.out.println("HelloWorld");
    	//可以不写return,方法中的代码执行完毕后,方法会自动结束
    }
    
    public static void testTwo(){
    	System.out.println("HelloWorld");
    	rerurn;
    	System.out.println("这句话不会执行,因为上面结束了方法");
    }
    
    public static void testThree(){
    	System.out.println("HelloWorld");
    	return 0;
    	//void方法不能return值,因为返回值的话必须要有返回值类型
    }
    

    方法的重载

    方法的重载

    • 英文Overload

    • 概念:在同一个类中,有多个方法名相同,参数列表不同的方法

    • 方法重载的特点

      • 参数个数不同
      • 参数的数据类型不同(包括数据类型相同,但数据顺序不同,例如:int a,double b 和 double b,int a也是不一样的)
    • 方法重载和什么无关

      • 和返回值类型无关
      • 和参数变量名无关
      • 和方法体无关

    方法的形参是基本数据类型

    • 方法的形参是基本数据类型,形参的值改变不会影响实际参数
      • 原因:因为形参是在方法内部定义的一个新的局部变量,与方法外的实际参数变量是2个不同的变量,所以互不影响

    方法的形参是引用类型

    注意

    • 方法的形参是引用数据类型:形参的值改变是否影响实际参数要看引用关系
      • 如果形参是修改自身保存的引用,不会影响实际参数
        • 原因:因为形参是调用方法中的一个单独变量,实际参数是定义在main方法中的另一个单独变量,形参改变其保存的引用指向,并不影响实际参数的引用指向
      • 如果形参是通过引用修改堆内存中保存的数据,会影响实际参数获取的值
        • 原因:因为形参是调用方法中的一个单独变量,实际参数是定义在main方法中的另一个单独变量,形参通过引用修改的是堆内存中的数据,而实际参数也是指向该堆内存中的数据,所以形参修改后,实际参数获取的值也会改变
    // 形参是引用数据类型,是否影响实际参数
    public class demo{
    	public static void main(String[] args) {
    		// 数组
    		System.out.println("------------修改数组的引用指向------------");
    		int[] arr = {1, 2, 3};
    		System.out.println("原始值: arr=" + Arrays.toString(arr));
    		changeArr(arr);
    		System.out.println("修改后: arr=" + Arrays.toString(arr));
    		
    		
    		System.out.println("------------通过数组引用修改堆内存中数组的元素值------------");
    		System.out.println("原始值: arr=" + Arrays.toString(arr));
    		changeArrElement(arr);
    		System.out.println("修改后: arr=" + Arrays.toString(arr));
    	}
    	
    	// 修改数组的引用: 不会影响实际参数
    	private static void changeArr(int[] arr) {
    		arr = new int[]{999, 999};
    	}
    	
    	// 通过数组变量的引用修改堆内存中数组的元素: 会影响实际参数
    	private static void changeArrElement(int[] arr) {
    		arr[0] = -1;
    		arr[1] = -1;
    		arr[2] = -1;
    	}
    }
    

    结果:
    在这里插入图片描述


    递归结构

    递归是一种常见的解决问题的方法,即把问题逐渐简单化。递归的基本思想就是“自己调用自己”,一个使用递归技术的方法将会直接或者间接的调用自己。

    利用递归可以用简单的程序来解决一些复杂的问题。比如:斐波那契数列的计算、汉诺塔、快排等问题。

    例如

    void aa(int a) {
    		
    		if (a<10) {
    			a++;
    			aa(a);
    		}
    		
    	}
    

    递归结构包括两个部分:

    1. 定义递归头。解答:什么时候不调用自身方法。如果没有头,将陷入死循环,也就是递归的结束条件。
    2. 递归体。解答:什么时候需要调用自身方法。

    递归的缺陷
    简单的程序是递归的优点之一。但是递归调用会占用大量的系统堆栈,内存耗用多,在递归调用层次多时速度要比循环慢的多,所以在使用递归时要慎重。

    展开全文
  • java对象信息

    千次阅读 多人点赞 2019-09-02 14:27:14
    java开发几年了,但一直不知道如下问题: 1. 一个java对象到底占用了多少内存空间,应该如何...3. java对象是在那里设置了指针指向对应的方法区中的元数据的? 4. 在jvm垃圾回收时被标记为可回收但还未执行回...

    做java开发几年了,但一直不知道如下问题:

    1. 一个java对象到底占用了多少内存空间,应该如何计算?

    2. 为什么在jdk1.6后,synchronized关键字性能有所提高,为什么会提高?并且很多文章中都说synchronized锁有偏向锁、轻量锁、重量锁等状态?

    3. java对象是在那里设置了指针指向对应的方法区中的元数据的?

    4. 在jvm垃圾回收时被标记为可回收但还未执行回收时,java对象是什么状态?

    5. jvm怎么确定 一个java对象的GC年龄?

    6. 为什么对象在经历过最多15次GC后,就会被移动到老年代中?

    带着上述问题,最近终于找到了答案,于是记录了下来。

    在java中,一个对象是具有相关的状态的,这状态都是保存在java对象的对象头中的。本文以64位进行说明。

    1. 概述

    java对象由如下几部分组成:

    1. 对象头:Mark word和klasspointer两部分组成,如果是数组,还包括数组长度

    2. 实例属性

    3. 对齐填充

    如何能看到上图结构?

    注意:要打印上述内存结构图,需要引入如下依赖:

    <!-- https://mvnrepository.com/artifact/org.openjdk.jol/jol-core -->
            <dependency>
                <groupId>org.openjdk.jol</groupId>
                <artifactId>jol-core</artifactId>
                <version>0.9</version>
            </dependency>

    2. 对象头

    64位对象头由Mark Word、klass pointer两部分组成,如果对象是数组,则还要加上数组长度,即三部分组成。

    Mark Word由64位8个字节组成。

    klass pointer由64位8个字节组成,但我们使用的64位 JVM会默认使用选项 +UseCompressedOops 开启指针压缩,将指针压缩至32位。即上面截图中的klass pointer为4个字节32位。

    类指针klass pointer和数组长度,很简单这里不在描述,重点描述下Mark Word部分。

    Mark Word的64位,不同的位表示的意思不一样,具体如下所示:

    |--------------------------------------------------------------------------------------------------------------|
    |                                              Object Header (128 bits)                                        |
    |--------------------------------------------------------------------------------------------------------------|
    |                        Mark Word (64 bits)                                    |      Klass Word (64 bits)    |       
    |--------------------------------------------------------------------------------------------------------------|
    |  unused:25 | identity_hashcode:31 | unused:1 | age:4 | biased_lock:1 | lock:2 |     OOP to metadata object   |  无锁
    |----------------------------------------------------------------------|--------|------------------------------|
    |  thread:54 |         epoch:2      | unused:1 | age:4 | biased_lock:1 | lock:2 |     OOP to metadata object   |  偏向锁
    |----------------------------------------------------------------------|--------|------------------------------|
    |                     ptr_to_lock_record:62                            | lock:2 |     OOP to metadata object   |  轻量锁
    |----------------------------------------------------------------------|--------|------------------------------|
    |                     ptr_to_heavyweight_monitor:62                    | lock:2 |     OOP to metadata object   |  重量锁
    |----------------------------------------------------------------------|--------|------------------------------|
    |                                                                      | lock:2 |     OOP to metadata object   |    GC
    |--------------------------------------------------------------------------------------------------------------|

    lock:  锁状态标记位,该标记的值不同,整个mark word表示的含义不同。

    biased_lock:偏向锁标记,为1时表示对象启用偏向锁,为0时表示对象没有偏向锁。

    age:Java GC标记位对象年龄,4位的表示范围为0-15,因此对象经过了15次垃圾回收后如果还存在,则肯定会移动到老年代中。

    identity_hashcode:对象标识Hash码,采用延迟加载技术。当对象使用HashCode()计算后,并会将结果写到该对象头中。当对象被锁定时,该值会移动到线程Monitor中。

    thread:持有偏向锁的线程ID和其他信息。这个线程ID并不是JVM分配的线程ID号,和Java Thread中的ID是两个概念。

    epoch:偏向时间戳。

    ptr_to_lock_record:指向栈中锁记录的指针。

    ptr_to_heavyweight_monitor:指向线程Monitor的指针。

    2.1 无锁状态时Mark Word-001

    当一个对象才new且调用了hashcode方法后(如果不调用hashcode方法,那么存放hashcode的31位全部为0),正常情况下处于无锁状态,无锁状态时,Mark Word的64位分别为:前25位未使用,接下来的31位为对象的hashcode,接下来的1位未使用,接下来的4位表示对象的GC年龄,接下来的一位为偏向锁状态,最后2位表示锁状态。如下图所示:

    2.2 偏向锁状态时的Mark Word-101

    理论上而言,u对象应该是无锁状态啊,变成为偏向锁了呢?如果把sleep注释掉真的就是无锁状态。

    JVM启动时会进行一系列的复杂活动,比如装载配置,系统类初始化等等。在这个过程中会使用大量synchronized关键字对对象加锁,且这些锁大多数都不是偏向锁。为了减少初始化时间,JVM默认延时加载偏向锁。这个延时的时间大概为4左右,具体时间因机器而异。当然我们也可以设置JVM参数 -XX:BiasedLockingStartupDelay=0 来取消延时加载偏向锁。

    此时占用 thread 和 epoch 的 位置的均为0,说明当前偏向锁并没有偏向任何线程。此时这个偏向锁正处于可偏向状态,准备好进行偏向了!你也可以理解为此时的偏向锁是一个特殊状态的无锁

    2.3 轻量级锁状态时的Mark Word-000

    所谓轻量级锁是指虽然代码中有synchronized关键字加锁,但jvm在执行时,不存在并发问题,这时jvm会优化成轻量级锁,如下代码所示:

    public class SyncTest {
    
        public static void main(String[] args) throws Exception {
            final User a = new User();
    
            Thread thread1 = new Thread(){
                @Override
                public void run() {
                    synchronized (a){
                        System.out.println("thread1 locking");
                        System.out.println(ClassLayout.parseInstance(a).toPrintable());
                    }
                    try {
                        //thread1退出同步代码块,且没有死亡
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
    
            Thread thread2 = new Thread(){
                @Override
                public void run() {
                    synchronized (a){
                        System.out.println("thread2 locking");
                        System.out.println(ClassLayout.parseInstance(a).toPrintable());
                    }
                }
            };
            thread1.start();
    
            //让thread1执行完同步代码块中方法。
            Thread.sleep(3000);
            thread2.start();
        }
    }

    2.4 重量级锁状态时的Mark Word-010

    即在执行代码时真的会存在锁争抢的情况,如下代码所示:

    public class SyncTest {
    
        public static void main(String[] args) throws Exception {
            final User a = new User();
    
            Thread thread1 = new Thread(){
                @Override
                public void run() {
                    synchronized (a){
                        System.out.println("thread1 locking");
                        System.out.println(ClassLayout.parseInstance(a).toPrintable());
                    }
                    try {
                        //thread1退出同步代码块,且没有死亡
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
    
            Thread thread2 = new Thread(){
                @Override
                public void run() {
                    synchronized (a){
                        System.out.println("thread2 locking");
                        System.out.println(ClassLayout.parseInstance(a).toPrintable());
                        try {
                            //thread1退出同步代码块,且没有死亡
                            Thread.sleep(3000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
            thread1.start();
            thread2.start();
        }
    }

    3.对象属性数据区

    int---4个字节

    long--8个字节

    double--8个字节

    float--4个字节

    short--2个字节

    char--2个字节(为什么是2个字节,不应该是一个字节么?难道跟编码有关?)

    Boolean--1个字节

    byte--1个字节

    java对象--4个字节

    4. 对齐填充区

    Java对象占用空间是8字节对齐的,即所有Java对象占用字节数必须是8的倍数。如下图所示:

    这个对象一个占用了24个字节,其中MarkWord+klasspointer+short+char+boolean+byte+对齐填充=18+对齐填充,而比18大且是8的整数倍的最小值为24,因此这个对象的对齐填充为6,整个对象大小为24字节。

    对此,本章节前的几个问题就都有了答案,get get get!!!

     

    展开全文
  • java对象 MarkWord

    万次阅读 多人点赞 2019-06-05 20:41:15
    原文链接:[https://blog.csdn.net/scdn_cp/article/details/86491792#comments] 我们都知道,Java对象存储在堆(Heap)内存。那么一个Java对象到底包含什么呢?概括起来分为对象、对象体和对齐字节...

    原文链接:[https://blog.csdn.net/scdn_cp/article/details/86491792#comments]

    我们都知道,Java对象存储在堆(Heap)内存。那么一个Java对象到底包含什么呢?概括起来分为对象头、对象体和对齐字节。如下图所示:

    对象的几个部分的作用:

    1.对象头中的Mark Word(标记字)主要用来表示对象的线程锁状态,另外还可以用来配合GC、存放该对象的hashCode;

    2.Klass Word是一个指向方法区中Class信息的指针,意味着该对象可随时知道自己是哪个Class的实例;

    3.数组长度也是占用64位(8字节)的空间,这是可选的,只有当本对象是一个数组对象时才会有这个部分;

    4.对象体是用于保存对象属性和值的主体部分,占用内存空间取决于对象的属性数量和类型;

    5.对齐字是为了减少堆内存的碎片空间(不一定准确)。

    了解了对象的总体结构,接下来深入地了解对象头的三个部分。


    一、Mark Word(标记字)

    以上是Java对象处于5种不同状态时,Mark Word中64个位的表现形式,上面每一行代表对象处于某种状态时的样子。其中各部分的含义如下:

    lock:2位的锁状态标记位,由于希望用尽可能少的二进制位表示尽可能多的信息,所以设置了lock标记。该标记的值不同,整个Mark Word表示的含义不同。biased_lock和lock一起,表达的锁状态含义如下:

    biased_lock:对象是否启用偏向锁标记,只占1个二进制位。为1时表示对象启用偏向锁,为0时表示对象没有偏向锁。lock和biased_lock共同表示对象处于什么锁状态。

    age:4位的Java对象年龄。在GC中,如果对象在Survivor区复制一次,年龄增加1。当对象达到设定的阈值时,将会晋升到老年代。默认情况下,并行GC的年龄阈值为15,并发GC的年龄阈值为6。由于age只有4位,所以最大值为15,这就是-XX:MaxTenuringThreshold选项最大值为15的原因。

    identity_hashcode:31位的对象标识hashCode,采用延迟加载技术。调用方法System.identityHashCode()计算,并会将结果写到该对象头中。当对象加锁后(偏向、轻量级、重量级),MarkWord的字节没有足够的空间保存hashCode,因此该值会移动到管程Monitor中。

    thread:持有偏向锁的线程ID。

    epoch:偏向锁的时间戳。

    ptr_to_lock_record:轻量级锁状态下,指向栈中锁记录的指针。

    ptr_to_heavyweight_monitor:重量级锁状态下,指向对象监视器Monitor的指针。

      我们通常说的通过synchronized实现的同步锁,真实名称叫做重量级锁。但是重量级锁会造成线程排队(串行执行),且会使CPU在用户态和核心态之间频繁切换,所以代价高、效率低。为了提高效率,不会一开始就使用重量级锁,JVM在内部会根据需要,按如下步骤进行锁的升级:

            1.初期锁对象刚创建时,还没有任何线程来竞争,对象的Mark Word是下图的第一种情形,这偏向锁标识位是0,锁状态01,说明该对象处于无锁状态(无线程竞争它)。

            2.当有一个线程来竞争锁时,先用偏向锁,表示锁对象偏爱这个线程,这个线程要执行这个锁关联的任何代码,不需要再做任何检查和切换,这种竞争不激烈的情况下,效率非常高。这时Mark Word会记录自己偏爱的线程的ID,把该线程当做自己的熟人。如下图第二种情形。

            3.当有两个线程开始竞争这个锁对象,情况发生变化了,不再是偏向(独占)锁了,锁会升级为轻量级锁,两个线程公平竞争,哪个线程先占有锁对象并执行代码,锁对象的Mark Word就执行哪个线程的栈帧中的锁记录。如下图第三种情形。

            4.如果竞争的这个锁对象的线程更多,导致了更多的切换和等待,JVM会把该锁对象的锁升级为重量级锁,这个就叫做同步锁,这个锁对象Mark Word再次发生变化,会指向一个监视器对象,这个监视器对象用集合的形式,来登记和管理排队的线程。如下图第四种情形。

    二、Klass Word(类指针)
    这一部分用于存储对象的类型指针,该指针指向它的类元数据,JVM通过这个指针确定对象是哪个类的实例。该指针的位长度为JVM的一个字大小,即32位的JVM为32位,64位的JVM为64位。

    如果应用的对象过多,使用64位的指针将浪费大量内存,统计而言,64位的JVM将会比32位的JVM多耗费50%的内存。为了节约内存可以使用选项+UseCompressedOops开启指针压缩,其中,oop即ordinary object pointer普通对象指针。开启该选项后,下列指针将压缩至32位:

    每个Class的属性指针(即静态变量)
    每个对象的属性指针(即对象变量)
    普通对象数组的每个元素指针
    当然,也不是所有的指针都会压缩,一些特殊类型的指针JVM不会优化,比如指向PermGen的Class对象指针(JDK8中指向元空间的Class对象指针)、本地变量、堆栈元素、入参、返回值和NULL指针等。
    三、数组长度

     如果对象是一个数组,那么对象头还需要有额外的空间用于存储数组的长度,这部分数据的长度也随着JVM架构的不同而不同:32位的JVM上,长度为32位;64位JVM则为64位。64位JVM如果开启+UseCompressedOops选项,该区域长度也将由64位压缩至32位。

    展开全文
  • JAVA 对象解析

    千次阅读 2019-06-12 14:44:34
    一个Java对象在JVM中是由一个对应角色的oop对象来描述的, 比如instanceOopDesc用来描述普通实例对象,arrayOopDesc用来描述数组对象,而这些类型的oop对象均是继承自oopDesc。 class oopDesc { friend class ...

    一个Java对象在JVM中是由一个对应角色的oop对象来描述的,

    比如instanceOopDesc用来描述普通实例对象,arrayOopDesc用来描述数组对象,而这些类型的oop对象均是继承自oopDesc

     

    class oopDesc {
      friend class VMStructs;
      friend class JVMCIVMStructs;
     private:
      // 对象头  
      volatile markOop _mark;
      // 元数据
      union _metadata {
        // 对应的Klass对象  
        Klass*      _klass;
        narrowKlass _compressed_klass;
      } _metadata;

    oopDesc主要包含两部分,一部分是_mark,一部分是_metadata

    • _mark _mark是一个markOop实例,它描述了一个对象的头信息,用于存储对象的运行时记录信息,如哈希值、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等:

     

     

     

    源码位置:  hostspot/share/oops/markOop.hpp   (jdk10)

    • _metadata 包含一个普通_klass和一个压缩后的_compressed_klass,详细信息参见OpenJDK Wiki

     

    markOop描述了对象的头部信息。

    注意标记不是真正的oop而是一个单词。

    由于历史原因,它被放置在oop层次结构中。

    对象头的位格式:

      
    32 bits:
      --------
                 hash:25 ------------>| age:4    biased_lock:1 lock:2 (normal object)
                 JavaThread*:23 epoch:2 age:4    biased_lock:1 lock:2 (biased object)
                 size:32 ------------------------------------------>| (CMS free block)
                 PromotedObject*:29 ---------->| promo_bits:3 ----->| (CMS promoted object)
    
      64 bits:
      --------
      unused:25 hash:31 -->| unused:1   age:4    biased_lock:1 lock:2 (normal object)
      JavaThread*:54 epoch:2 unused:1   age:4    biased_lock:1 lock:2 (biased object)
      PromotedObject*:61 --------------------->| promo_bits:3 ----->| (CMS promoted object)
      size:64 ----------------------------------------------------->| (CMS free block)
    
      unused:25 hash:31 -->| cms_free:1 age:4    biased_lock:1 lock:2 (COOPs && normal object)
      JavaThread*:54 epoch:2 cms_free:1 age:4    biased_lock:1 lock:2 (COOPs && biased object)
      narrowOop:32 unused:24 cms_free:1 unused:4 promo_bits:3 ----->| (COOPs && CMS promoted object)
      unused:21 size:35 -->| cms_free:1 unused:7 ------------------>| (COOPs && CMS free block)
    
    
    
    


     

    问题:  Java对象如何存储?

    对象的实例(instantOopDesc)保存在堆上,对象的元数据(instantKlass)保存在方法区(元空间?),对象的引用保存在栈上。

     

    hash: 保存对象的哈希码
    age: 保存对象的分代年龄
    biased_lock: 偏向锁标识位
    lock: 锁状态标识位
    JavaThread* 保存持有偏向锁的线程ID
    epoch: 保存偏向时间戳

    markOop中不同的锁标识位,代表着不同的锁状态:

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 全网最详细的Java方法解析

    万次阅读 多人点赞 2019-02-13 15:09:10
    Java语言中的“方法”(Method)在其他语言当中也可能被称为“函数”(Function)。对于一些复杂的代码逻辑,如果希望重复使用这些代码,并且做到“随时任意使用”,那么就可以将这些代码放在一个大括号“{}”当中,...
  • java方法的重写

    万次阅读 多人点赞 2017-11-28 09:38:13
    方法的重写
  • Eclipse中java文件注释格式设置

    万次阅读 2016-07-04 16:33:19
    Eclipse中java文件注释格式设置 Eclipse中java文件注释格式设置 Eclipse中java文件注释格式设置 windows->preferences->java->Code Templates->comments->Type->edit  Eclipse注释规范模版...
  • intellij自动生成java代码注释,包括java文件头部的注释,java方法的注释
  • Java的对象和对象组成详解

    万次阅读 多人点赞 2018-07-20 10:46:47
    目录 一,对象 1,Mark Word 2,指向类的指针 3,数组长度 ...java的对象由以下三部分组成: 1,Mark Word 2,指向类的指针 3,数组长度(只有数组对象才有)   1,Mark Word Mar...
  • java peek方法 ArrayDeque类peek()方法 (ArrayDeque Class peek() method) peek() Method is available in java.lang package.peek()方法java.lang包中可用。 peek() Method is used to return the head element ...
  • myeclipse中java文件注释格式设置

    千次阅读 2016-02-02 14:25:37
    myeclipse中java文件注释格式设置(转载...myeclipse中java文件注释格式设置 windows->preferences->java->Code Templates->comments->Type->edit
  • java获取URL响应

    千次阅读 2017-06-19 08:57:47
    import java.io.IOException; import java.net.URL; import java.net.URLConnection; import java.util.List; import java.util.Map; import java.util.Set;public class Test{ public static void main(String[]
  • Java 抽象方法

    千次阅读 多人点赞 2018-09-06 09:31:06
    新建一个抽象父类: ...//抽象类中不一定有抽象方法 public abstract class Animal { private String name; private String color; public Animal() { super(); } public Animal(Strin...
  • 深入理解java方法调用时的参数传递

    千次阅读 2017-11-09 18:08:20
    深入理解java方法调用与参数传递,解决以下问题:Java方法调用是如何传递参数的?被调用方法对调用方法内的变量有什么影响?java能使用返回值void的中间方法对变量进行加工吗?为什么静态成员变量的改变影响是全局的...
  • java 请求设置header

    千次阅读 2019-11-18 17:58:17
    直接上代码 public static JSONObject ******(String url, String id)throws Exception { HttpGet httpGet = new HttpGet(); CloseableHttpClient httpclient = HttpClients.createDefault(); List <Nam...
  • 如何在jsp中写一个java方法

    万次阅读 2017-02-23 22:57:25
    一般用在jsp中写java方法 代码如下: try{ //得到要下载的文件名 String fileName = request.getParameter("filename"); fileName = new String(fileName.getBytes("iso8859-1"),"UTF-8"); //上传的文件都是...
  • 64位JVM的Java对象详解

    千次阅读 2020-02-22 15:42:31
    关注“Java艺术”一起来充电吧!我们编写一个Java类,编译后会生成.class文件,当类加载器将class文件加载到jvm时,会生成一个Klass类型的对象(c++),称为类描述元数...
  • Java面试题大全(2020版)

    万次阅读 多人点赞 2019-11-26 11:59:06
    发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~ 本套Java面试题大全,全的不能再全,哈哈~ 一、Java 基础 1. JDK 和 JRE 有什么区别? JDK:Java ...
  • Java基础问题整理

    万次阅读 多人点赞 2020-04-07 11:44:14
    备注:针对基本问题做一些基本的总结,不是详细解答!...4.HashMap1.7与HashMap1.8的区别,从数据结构上、Hash值的计算上、链表数据的插入方法、内部Entry类的实现上分析? 5.Hash1.7是基于数组...
  • 深入理解Java并发之synchronized实现原理

    万次阅读 多人点赞 2017-06-04 17:44:44
    【版权申明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权) ... 出自【zejian的博客】...深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深...
  • 通过java后台设置请求头部 可以根据需求修改或者添加请求信息。 修改请求代码 根据不同的请求方式,在main方法中选择调用不同的方法(get/post ) package com.iao.controller.feedback; import java.io....
  • 百度后得知是因为文件带bom,解析的时候就会报错,需要去掉bom。结果网上的方法让人啼笑皆非,用EditPuls来转换成无bom编码。我就纳闷了,难道项目运行时,还要人工一个个的去这样操作吗?肯定不行,得用java的...
  • JAVA HTTPclient中增加自定义的属性

    千次阅读 2016-07-10 14:45:27
    场景是这样的,第三方页面访问需要鉴权,所以需要在HTTP中增加鉴权的属性和内容发送给第三方网页...我试过用response.addHeader("Authorization","xxxxxxxxx")方法,但发送的请求还是不带Authorization属性,还请大
  • Java中的关键字有哪些?Java的关键字(keyword)有多少个?Java的保留字(reserveword)有多少个?分别是什么?Java的关键字分别是什么,作用是什么?
  • 深入理解Java的对象mark word

    千次阅读 多人点赞 2020-06-19 12:49:55
    上一篇博客我们编译了Linux源码来证明了Java中有偏向锁,但是我们从周志明大佬的《深入理解java虚拟机》的书中知道,我们可以通过分析Java对象中MarkWord来查看是那种锁,下面是32位JVM的对象中的Mark Word图,...
  • 一些常用Java操作方法封装:Java Utils

    千次阅读 2017-04-17 19:00:59
    封装了一些常用Java操作方法,便于重复开发利用. 另外希望身为Java牛牛的你们一起测试和完善,欢迎入群263641914 一起封装和完成常用的Java代码。节约撸码时间以方便有更多的时间去把妹子~ 开发环境 Win7x64 JDK1.7...
  • JAVA基础——接口(全网最详细教程)

    万次阅读 多人点赞 2018-05-10 09:46:42
    官方解释:Java接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能)。 我的解释:接口...
  • 问题描述Java中为什么静态方法不能被重写?为什么静态方法不能隐藏实例方法?诸如此类。前期准备首先理解重写的意思,重写就是子类中对父类的实例方法进行重新定义功能,且返回类型、方法名以及参数列表保持一致,且...
  • 最近开发中需要调外部厂商提供的API接口,接口文档中定义需要传递一个消息+消息体。参考httpClient工具类中没有相关方法,所以自己写出来,并和大家分享。 代码来一波 import org.apache....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 475,726
精华内容 190,290
关键字:

java方法头

java 订阅