每日小问题

给丫丫带束花

已于 2022-10-07 14:22:32 修改

阅读量112

点赞数

文章标签： java 开发语言

于 2022-09-20 14:46:14 首次发布

本文链接：https://blog.csdn.net/JSKKJK/article/details/126952019

版权

问题1.形参与实参

1.形参

定义：进行方法或函数声明时设置的在调用方法时应该传递的参数类型和参数名为形参（方法名后面括号中的参数），形参是一个虚拟变量，在调用方法时会分配内存空间，赋初值，方法调用结束则内存空间释放，在方法未被调用时形参类似于一个占位符。

作用范围：只在方法体中生效，在方法体外处于过期状态。

生命周期：从调用该方法开始生命周期开始。方法结束则生命周期结束；。

2.实参

定义：调用方法时为形参赋值的变量，常量或者表达式（方法调用时括号中的参数），在声明之后即分配好内存空间，并且应该具有一个明确的值，所以实参应提前赋好值。

代码演示：

/**
 * 测试方法
 */
public class test1 {
    public static void main(String[] args) {
        //方法调用（demoOne的形参类型为int，demoTwo的形参类型为String）
        // 本次调用演示方法1的实参是数字6为int类型
        demoOne(6);
        //本次调用演示方法2参数是"老涛子"为字符串类型
        demoTwo("老涛子");
        //或者
        //声明一个int类型的变量和一个String的变量
        int id=16;
        String name="小黑子";
        //需要提前为实参赋好值，并且实参数据类型要与形参保持一致
        demoOne(id);//int
        demoTwo(name);//string
    }

    /**
     * 演示方法1形参为int型
     * @param id int类型
     */
    public static void demoOne(int id) {
        System.out.println("方法参数值：id=" + id);
    }

    /**
     * 演示方法2的形参为string类型
     * @param name string类型
     */
    public static void demoTwo(String name) {
        System.out.println("方法参数值：name=" + name);
    }
}

运行结果为：

问题2：重写和重载

重载：

定义：在同一个类或者接口中，方面名相同但参数列表不同的两个方法或多个方法，参数列表不同是指参数个数不同，或参数类型不同，或参数个数与类型均不同的情况就是方法的重载，最常见的方法重载就是构造类的有参构造和无参构造。

重写：

定义：对于继承的父类或者实现接口的方法进行方法体的重新编码，抽象方法和接口的方法必须重写，一般方法可重写也可不重写。

代码演示：

重载：

public class test2Impl {
    public static void main(String[] args) {
        System.out.println("------------------------无参方法----------------------");
        domeOne();
        System.out.println("----------------------int参数方法---------------------");
        domeOne(6);
        System.out.println("-----------------------string方法---------------------");
        domeOne("小黄");
        System.out.println("------------------------双参方法----------------------");
        domeOne(8,"老八");
    }


    public static void domeOne(){
        System.out.println("这是demo的无参方法");
    }

    public static void domeOne(int id){
        System.out.println("这是demo的int参数方法");
        System.out.println("int参数："+id);
    }

    public static void domeOne(String name){
        System.out.println("这是demo的String参数方法");
        System.out.println("string参数"+name);
    }

    public static void domeOne(int id,String name){
        System.out.println("这是demo的两个参数的方法");
        System.out.println("方法4参数："+id+"  and  "+name);
    }
}

运行结果：

重写：

/**
 * 测试类接口
 */
public interface test2 {
    //获取id方法
    void getId(int id);
    //获取name方法
    void getName(String name);
}


//----------------------------------------------------------

public class test2Impl implements test2 {

    //重写test2接口的getId方法
    @Override
    public void getId(int id) {
        System.out.println("重写获取id方法");
    }

    //重写test2接口的getname方法
    @Override
    public void getName(String name) {
        System.out.println("重写获取name方法");
    }
}

问题3：数组

定义:相同类型数据的有序的集合，储存的数据有下标，各种操作可指定下标操作
空间分配：数据在定义时可指定一串连续空间长度，指定后不可动态修改长度，且存储的元素个数小于分配空间个数剩余的空间仍无法在让其他操作调用。
数组声明和使用规则：

代码演示：

//声明方法1
        int ints2[];
        //声明方法二，长度由声明时的存入的元素个数决定的
        int[] ints1={10,11,12,13,14,15,16,17,18,19};
        //int为类型指定，10为数组分配的空间
        int[] ints = new int[10];
        //下标从0开始，此例子最大下标为9（数组长度-1）
        ints[0] = 0;
        ints[1] = 1;
        ints[2] = 2;
        ints[3] = 3;
        ints[4] = 4;
        ints[5] = 5;
        ints[6] = 6;
        ints[7] = 7;
        ints[8] = 8;
        ints[9] = 9;
        //下标10已超出最大下标
        ints[10]=10;
        //将数组转化为字符串
        String s = Arrays.toString(ints);
        System.out.println(s);

打印ints2的结果

打印ins则会报错：

接口与抽象类

接口

默认权限修饰符：public

方法全为抽象方法

在JDK1.8之后，可以写一个非抽象的默认方法

多实现

抽象类

只要存在一个抽象方法，此类就会是抽象的

可以存在多个非抽象的方法

共同特性：继承或实现时抽象方法都需要重写

深克隆和浅克隆

深克隆：创建新的对象，将内容复制给新对象

浅克隆：地址唯一，多个位置对此地址进行引用

sleep和wait的区别

sleep:

属于thread类的方法

有时间参数

通过释放线程执行权实现睡眠，不释放锁

时间参数写入的时间一到，睡眠就结束

wait:

属于object类的方法

无参数

通过释放锁来实现等待

必须通过notify或者notifyAll来结束等待

基本类型和包装类

	整型	浮点型	字符型	大浮点型	布尔型	短整型	长整型	字节型
基本类型	int	float	char	double	boolean	short	long	byte
包装类型	Integer	Float	Character	Double	Boolean	Short	Long	Byte

装箱：将基本类型转换成包装类对象,用Integer.valueOf()实现

拆箱：将包装对象转换成基本类型的值，用Integer.intValue()实现

java装箱和拆箱功能主要使用于集合的泛型，泛型不能为基本类型。

拆箱和装箱实现原理：javac编译器的语法糖，编译器编译时会自动补充实现的代码。

区别：（以int类型和他的包装类为例）

（1）Integer是引用类型，int是基本类型

（2）Integer变量必须实例化之后才能使用，而int变量不需要

（3）Integer是对象的引用，new一个Integer时，实际上生成指针指向此对象；而int则直接存储数据值

（4）Integer的默认值是null，int的默认值是0

Integer缓存问题：

Integer存在一个缓存区，范围在-128至127，若多次new一个缓存区范围的Integer值，则new的Integer不是一个新的对象，仅仅是对第一次new的地址的重复引用。

例子：

public static void main(String[] args) {
    //Integer缓存区范围：-128->127
    //127在Integer的缓存区内
    Integer a = 127;
    Integer b = 127;
    //128不再Integer的缓存区内
    Integer c = 128;
    Integer d = 128;
    //双等号比较地址与值
    System.out.println("a==b:"+(a == b));
    System.out.println("c==d:"+(c == d));
}

结果：