【无标题】

最新推荐文章于 2024-08-22 03:52:51 发布

墨染云中

最新推荐文章于 2024-08-22 03:52:51 发布

阅读量1k

点赞数 10

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_71314983/article/details/140355918

版权

1，static 是否能修饰类，属性，局部变量，方法，代码块，如果能说明其特点，及加载顺序

在Java中，static关键字可以用于修饰类、属性（字段）、方法和代码块，但不能用于修饰局部变量。

1. `static` 修饰类

内部类：static 只能修饰内部类，不能修饰顶级类。
特点：静态内部类可以直接访问外部类的静态成员，但不能直接访问外部类的非静态成员。

2. `static` 修饰属性（字段）

特点：
- 静态属性属于类而不是类的实例。
- 所有类的实例共享同一个静态属性。
- 静态属性在类加载时初始化，只会初始化一次。

3. `static` 修饰方法

特点：
- 静态方法属于类而不是类的实例。
- 静态方法可以直接通过类名调用，不需要创建类的实例。
- 静态方法只能直接访问类的静态成员（包括静态变量和静态方法），不能直接访问非静态成员。

4. `static` 修饰代码块

特点：
- 静态代码块在类加载时执行，并且只执行一次。
- 静态代码块用于初始化类的静态变量。

5. 局部变量

特点：
- 局部变量不能使用 static 关键字修饰。
- 局部变量的生命周期是从声明开始，到所在的块（例如方法、构造函数）结束。

加载顺序

静态变量和静态代码块按它们在类中的顺序加载：静态变量和静态代码块会在类加载时按照它们在类中出现的顺序依次执行。
静态变量先初始化，然后执行静态代码块。
类加载时，静态成员只会初始化和执行一次。

2，权限修饰符，protected 和默认之间的差别并用例子来验证

修饰符1：

package xiushifu;

public class Xiushifu {


    protected int i=10;
    int b=20;
}

xiushifu2：

package xiushifu;

public class Xiushifu2 {


   public void print(){
       Xiushifu x=new Xiushifu();
       System.out.println(x.b);
       System.out.println(x.i);

   }
}

xiushifu3；

package xiushifuTest;

import xiushifu.Xiushifu;

public class Xiushifu3 extends Xiushifu {

    private void print(){
        Xiushifu x=new Xiushifu();
        //跨包访问在继承的前提下可以访问到protected修饰的
        System.out.println(i);
        //无法访问到默认修饰符 报错
        //System.out.println(b);
    }

xiushifu4:

package xiushifuTest;

import xiushifu.Xiushifu;

public class xiushifu4 {

    private void print(){
        Xiushifu x=new Xiushifu();
        //无法访问
//        System.out.println(i);
//        System.out.println(b);
    }

}

在Java中，权限修饰符（访问控制修饰符）定义了类成员（字段、方法、构造函数）的访问级别。主要有四种权限修饰符：public、protected、默认（不使用任何修饰符时，即包级私有）、private。其中，protected和默认权限（包级私有）之间的区别是访问范围不同。

权限修饰符的访问级别

public: 对所有类可见。
protected: 对同一个包中的类和任何子类可见。
默认（包级私有）: 对同一个包中的类可见，但对子类不可见。
private: 仅对同一个类可见。

`protected` 和默认权限的区别

protected:
- 可被同一包中的类访问。
- 可被不同包中的子类访问。
默认（包级私有）:
- 仅可被同一包中的类访问。
- 不可被不同包中的子类访问。

总结：

protected成员可以被同一包中的类和不同包中的子类访问。
默认权限成员只能被同一包中的类访问，不能被不同包中的子类访问。

3，数组的数据类型是引用类型还是基本类型。

在Java中，数组的数据类型是引用类型。尽管数组可以存储基本类型的数据，如int、char等，但数组本身是对象，它们的行为和其他引用类型一致。以下是详细解释：

数组是引用类型

数组是对象：
- 在Java中，数组是特殊的对象，存储在堆内存中。
- 当你创建一个数组时，实际上是在堆上分配了内存，并返回了一个引用。

数组引用：

当你声明一个数组变量时，这个变量实际上是一个引用，指向数组对象在堆中的位置。

可以将数组引用传递给方法，数组引用也可以被赋值给另一个数组引用变量。

public class Main {
    public static void main(String[] args) {
        int[] array = new int[5];  // 创建一个数组对象并将引用赋值给 array 变量
        System.out.println("Array hash code: " + array.hashCode());  // 输出数组对象的哈希码

        modifyArray(array);  // 将数组引用传递给方法
        System.out.println("Array[0] after modification: " + array[0]);  // 验证数组内容被修改

        int[] anotherArray = array;  // 将数组引用赋值给另一个变量
        System.out.println("Another array hash code: " + anotherArray.hashCode());  // 输出另一个数组引用的哈希码

        anotherArray[0] = 42;  // 修改另一个数组引用的内容
        System.out.println("Array[0] after another modification: " + array[0]);  // 验证原数组内容被修改
    }

    public static void modifyArray(int[] arr) {
        arr[0] = 10;  // 修改数组内容
    }
}

数组创建：
int[] array = new int[5]; 创建了一个长度为5的整型数组，数组对象存储在堆内存中，array变量保存该数组对象的引用。
数组引用传递：
modifyArray(array); 将数组引用传递给modifyArray方法。在方法内部，修改数组内容会影响原数组，因为方法接收的是数组的引用。
数组引用赋值：
int[] anotherArray = array; 将array引用赋值给anotherArray。两个变量都引用同一个数组对象，因此通过任何一个引用修改数组内容，都会影响另一个引用看到的数组内容。

结论

在Java中，数组的数据类型是引用类型。数组变量存储的是数组对象的引用，而不是数组元素本身。当数组作为参数传递时，传递的是引用，修改数组内容会影响原数组。这与其他引用类型对象（如类的实例）的行为一致。

4，如何理解二维数组

public class TwoArray {

    //规则的二维数组

    public static void main(String[] args) {
        int [][] b={{1,2,3,5 },{5,6,9,3}};
        //查询0，1处为何值
        int value=b[0][1];
        //将0,3位置处的值更改为6
        b[0][3]=6;
        for (int i=0;i<b.length;i++){
            for (int j=0;j<b[i].length;j++){
                System.out.print(b[i][j]+" ");

            }

        }
        System.out.println("---------------------");

//不规则的二维数组

        int [] [] c={{1,5,6,8,9},{6,5,3},{9,6,38,4,1,96}};

        for (int i=0;i<c.length;i++){
            for (int j=0;j<c[i].length;j++){
                System.out.print(c[i][j]+" ");
            }
        }

    }
}

5，集合类与数组的转化

   public static void main(String[] args) {
        //Arrays.sort();
        String [] a={"张","三","李","四"};
        ArrayList<String> list=new ArrayList<>();

        for (String b:a){
            list.add(b);
        }
        for (String c:list){
            System.out.print(c);
        }

        ArrayList<String> list1=new ArrayList<>();

        list1.add("liu");
        list1.add("jun");
        String [] e=list1.toArray(new String[5]);
        for (String f:e){

            System.out.println(f);
        }