当前位置：首页 > news >正文

Java语法基础知识点1

news 来源：原创 2025/6/15 7:02:37

一、数组

1.1数组的初始化：

1.2数组的遍历方法：

1.3数组的常见使用方法：

二、类和对象

2.1构造方法：

2.2this关键字:

三、封装

3.1访问限定符：

3.2static关键字：

3.3代码块：

一、数组

1.1数组的初始化：

int[] arr={1,2,3,4};//   1   直接对数组初始化并含有初始值
int[] arr=new int[num];//  2   创建一个长度为num长度的数组，开始默认数组有num个0值
int[] arr=new int[]{1,2,3,4};//    3    初始化数组有四个值，系统会自动计算数组长度；

//二维数组初始化
int[][] arr={{},{},...,{}};//     4    与1类似

// 5    特别注意的是，二维数组有可能是不规则的，所以不能够new int[][num],否则会编译错误
可以new int[num1][num2],或者new int[num][];
int[][] arr=new int[num][];

//6    与一维数组的3类似
int[][] arr=new int[][]{{},{},...,{}};

1.2数组的遍历方法：

常见的有两种：

//1.for each遍历数组，缺点是不能获得数组下标的值，优点是简洁
int[] arr={1,2,3,4};
for(int x:arr){       //x是把每一个arr数组的值给到x，再打印，类似python中的for循环
    System.out.println(x);  
}

//2.常见的for(int i=0;i<arr.length;i++)

//3.二维数组遍历
for(int i=0;i<arr.length;i++){
    for(int j=0;j<arr[i].length;j++){
    }
}

1.3数组的常见使用方法：

1.升序排序 Arrays.sort(arr);

        int[] arr={3,4,2,1};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));//{1，2，3，4}

2.数组打印字符串 Arrays.toString(arr);

3.数组拷贝 int[] arr2=Arrays.copyOf(arr,arr.length)； //特别注意的是，copyOf还具有对数组扩容的功能,具体要扩容多少，就看给的第二个参数的多少；

        int[] arr={3,4,2,1};

        int[] arr2=Arrays.copyOf(arr,arr.length);
        System.out.println(Arrays.toString(arr2));

Arrays.copyOfRange(arr,from,to)；这个方法可以决定拷贝数组的范围

        int[] arr={3,4,2,1};

        int[] arr2=Arrays.copyOfRange(arr,1,3);//范围是左闭右开
        System.out.println(Arrays.toString(arr2));//输出结果为4,2

4.合并两个数组使用System.arraycopy();

int[] arr1={1,2,3,4};
int[] arr2={5,6,7,8};
int[] arr=new int[arr1.length+arr2.length];


//其中第一个参数是源数组，也就是要复制的数组
//第二个参数是从源数组的起始位置，也就是要从哪个下标开始进行复制
//第三个参数是目标数组
//第四个参数是从目标数组的起始位置，也就是在目标数组的哪个索引下标开始放置复制的元素
//第五个参数是要从源数组复制元素的个数
System.arraycopy(arr1,0,arr,0,arr1.length);
System.arraycopy(arr2,0,arr,arr1.length,arr2.length);

//最终结果为{1，2，3，4，5，6，7，8}

数组在Java中是如何存储的？

在Java虚拟机运行时数据区有5个：方法区，虚拟机栈，本地方法栈，堆，程序计数器

int[] arr={1,2,3,4};在这个数组中，arr是引用变量，存储在虚拟机栈中，如果我们直接输出的是arr，那么我们得到的结果就是这个数组的地址，而不是{1,2,3,4}；而数组的值{1,2,3,4}存放在堆中

二、类和对象

2.1构造方法：

作用就是对对象中的成员变量进行初始化，并不负责给对象开辟空间，如果用户没有显示定义，那么编译器会自动生成一个无参的构造方法；如果用户定义了有参构造方法，那么编译器自动生成的无参构造方法就会消失，再想调用无参构造方法的话，编译就会报错

class Dog{
    public String name;
    public int age;

    //没有定义构造方法，但是编译器会自动生成一个无参的构造方法
    //类似public Dog(){},就是一个无参的构造方法，


    public Dog(String name, int age) {    //定义了有参构造方法，编译器自动生成的无参就消失，
        this.name = name;
        this.age = age;
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog1=new Dog();//编译器生成的无参构造消失，那么用实例化无参构造时就会报错
        Dog dog2=new Dog("小黑",7);//显示定义有参构造方法，实例化正确

    }
}

2.2this关键字:

this关键字用在构造方法当中的第一条语句，如果不是第一条语句，就会报错

特别注意的是，使用this关键字时，避免形成环，

    public Dog(){
        this("小黑",7);
    }
    public Dog(String name, int age) {    //定义了有参构造方法，编译器自动生成的无参就消失，
        this();    //形成环，变成递归构造
        this.name = name;
        this.age = age;
    }

三、封装

3.1访问限定符：

有四个

private，私有权限，安全性最高，在同一个包同一个类中能访问

default，包访问权限，只能在同一个包下访问

protected，包子权限，在同一个包下能够访问，在不同包的子类能够访问

public，公共权限，所有都能够访问

如果想要访问私有权限，那么我们要通过公共的方法进行访问，也就是通过get和set方法访问到私有成员变量

class Dog{
    private String name;
    private int age;
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog=new Dog("小黑",7);
        System.out.println(dog.getName());//不能够直接访问dog.name，因为name是私有成员变量，只能通过getName()得到name的值，如果要设置name，那么可以通过setName方法修改
        System.out.println(dog.getAge());
    }
}

3.2static关键字：

static修饰成员变量/方法，那么这就意味着这个成员变量已经不是对象所特有的，我们可以通过类名.变量能够访问，就算不实例化对象，一样可以访问到被static修饰的成员变量或者方法，被static修饰的成员变量/方法叫做类变量/类方法。

class Dog{
    public static String name;
    public int age;
    public Dog(String name, int age) {
        this.name=name;
        this.age = age;
    }
    public static void Bark(String name){
        System.out.println(name+"汪汪叫");
    }
    public void Sleep(String name){
        System.out.println(name+"在睡觉");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog=new Dog("小黑",7);
        System.out.println(Dog.name);//被static修饰，可以通过类名直接访问
        Dog.Bark(Dog.name);  //被static修饰，可以通过类名直接访问
        dog.Sleep(Dog.name);//不被static修饰，只能通过对象dog访问
    }
}

特别注意的是，在被static修饰的方法中，也就是在静态方法中，不能够出现任何非静态方法因为非静态方法中有this引用；相反，在非静态成员方法中却可以出现静态方法。

    public static void Bark(String name){
        System.out.println(name+"汪汪叫");
        Sleep(name);     //错误，有非静态成员方法
    }
    public void Sleep(String name){
        System.out.println(name+"在睡觉");
        Bark(name);  //正确
    }

如果在静态方法中非要用到非静态成员方法，只需要实例化对象，通过对象就可以访问到非静态成员方法了！

3.3代码块：

代码块有三种，静态代码块，实例代码块（构造代码块），普通代码块

静态代码块：用static定义的代码块，常用于初始化静态成员变量

实例代码块（构造代码块）：定义在类中的且不被修饰符修饰代码块，一般用于初始化实例成员变量

普通代码块：定义在方法中的代码块

    public static String name;
    public int age;
    
    //静态代码块       1
    static {
        name="小红";
    }
    
    //实例代码块       2
    {
        this.age=9;
    }

    public Dog(int age) { //普通代码块       3
        this.age = age;
    }

需要特别注意的是，如果实例化对象之后，代码块的访问顺序是1，2，3；如果连续两次实例化对象，那么代码块的访问顺序就是12323，原因就是静态代码块只会执行一次，用完一次之后就会消失，也就访问不到静态代码块啦！