Java基础学习笔记2

最新推荐文章于 2024-11-11 21:19:25 发布

小魔怔爱吃鱼

最新推荐文章于 2024-11-11 21:19:25 发布

阅读量146

点赞数 1

分类专栏： java学习笔记文章标签： java

本文链接：https://blog.csdn.net/wu15632548808/article/details/106473090

版权

java学习笔记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

第一章方法

1.1 方法的定义和调用

无参数无返回值的方法调用

public class Method_Demo01{
    public static void main (String [] args){
        print();
    }
    
    private static void print(){
        for (int i = 0;i<5;i++){
            for(int j=0;j<8;j++){
                System.out.print("*");
            }
        }
    }
}
//结果为：
//****************************************

print方法被main函数调用后直接输出结果了，所以不需要传递参数。
注意事项
- 方法定义的先后顺序无所谓
- 方法定义必须是挨着的，不能在一个方法的内部定义另一个方法。
- 方法定义之后不会自己执行，需要我们进行方法的调用才可以执行。

有参方法定义

其实方法就是若干语句的功能集合
举个例子：方法就像是一个工厂

蒙牛工厂

原料：奶牛，饲料，水

产出物：奶制品

这就好比我们方法中的参数和返回值

定义格式
- 修饰符返回值类型方法名 (参数类型参数名称，…){
  
  方法体;
  
  return 返回值;
  
  }
方法名称：命名规则和变量一样，小驼峰。
参数如果有多个用逗号隔开
return：有两个作用，第一停止当前方法，第二讲后的返回值还给调用处
返回值：也就是方法执行后最终产生的结果

注意：return后面的返回值，必须和方法名称前面的返回值类型对应。

public class Demo02MethodDefine {
    public static void main(String[] args) {
        //单独调用
        sum(10,20);
        //打印调用
        System.out.println(sum(50,60));
        //赋值调用
        int number=sum(20,30);
    }
    public static int sum(int a,int b){
        int result = a+b;
        return result;
    }
}

1.2 方法的重载

使用方法

对于功能类似的方法来说，因为猜数列表不一样，却需要记住那么多不同的方法名称，这样太麻烦了。这时就用到了方法的重载。
方法的重载（Overload），多个方法的名称一样，但是参数列表不一样。这样的方法在调用的时候就会根据参数列表去调用相应的方法。
好处，只需要记住一个方法名称就可以根据不同的参数实现不同的功能。

public static void main (String [] args){
    System.out.println(sum(10,20));//30
    System.out.println(sum(10,20,30));//60
    System.out.println(sum(10,20,30,40));//100
}
public static int sum(int a,int b){
    return a+b;
}
public static int sum(int a,int b,int c){
    return a+b+c;
}
public static int sum(int a,int b,int c,int d){
    return a+b+c+d;
}

注意事项

方法重载的形式
- 参数个数不同
  - (int a,int b)和(int a,int b,int c)
- 参数类型不同
  - (int a,int b)和(double a,double b)
- 参数的多类型顺序不同
  - (int a,double b)和(double a,int b)

方法的重载和参数名称无关！

第二章数组

2.1 数组概念

只是一个容器，可以同时存放多个数据值。

2.2 数组的特点

数组是一个引用数据类型
数组中的多个数据，他们的数据类型必须统一
数组的长度在运行期间不能改变

2.3 数组的定义格式

数组初始化的基本格式

在内存当中创建一个数组，并且向其中赋予一些默认值

两种常见的初始化：

动态初始化（指定长度）
静态初始化（指定内容）

动态初始化数组基本格式

数据类型[] 数组名称= new 数据类型[数组长度];
int[] num = new int[10];

解析含义：

左侧的数据类型：也就是数组当中保存的数据，全都是统一的什么类型
左侧中括号：代表我是一个数组
左侧数组名称：给数组取一个名字
右侧的new：代表创建数组的动作
右侧的数据类型：必须和左侧的数据类型保持一致
右侧的中括号和数组长度：规定了数组的长度，可以保存多少个相应数据类型的数据

public static void main (String[] args){
    int [] arrayA = new int [10];
    double [] arrayB = new double [10];
    String [] arrayC = new String [20];
}

静态初始化数组基本格式

数据类型[] 数组名称= new 数据类型[] {元素1,元素2,...};
int[] num = new int[] {5,15,25};

解析含义：

左侧的数据类型：也就是数组当中保存的数据，全都是统一的什么类型
左侧中括号：代表我是一个数组
左侧数组名称：给数组取一个名字
右侧的new：代表创建数组的动作
右侧的数据类型：必须和左侧的数据类型保持一致
右侧的大括号：写入具体的数据

public static void main (String[] args){
    int [] arrayA = new int[] {10,20,30};
    String [] arrayB = new String[] {"World","Hello","java"}
}

静态初始化的省略格式

数据类型[] 数组名称=  {元素1,元素2,...};
int[] num = {5,15,25};

注意事项：
- 静态初始化没有直接指定长度，但是会自动推算得到长度
- 静态初始化可以拆分成两个步骤，动态初始化也一样。
```
int [] array ;
array = new int {10,20,30};
```
- 但是静态初始化如果使用了省略格式就不能在拆开写了

使用建议：如果不确定数组中的具体内容就是用动态初始化，如果一直内容就是用静态初始化。

2.4 访问数组元素进行获取

静态初始化访问

直接打印数组名称，得到的是数组对应的内存地址哈希值。

public static void main (String [] args){
    int [] array = {10,20,30};
    System.out.println(array);//I@75412c2f
}

访问数组元素的格式：数组名称[索引值]

注意：索引值从0开始，一直到“数组长度-1”为止。

public static void main (String [] args){
    int [] array = {10,20,30};
    System.out.println(array);//I@75412c2f
    
    System.out.println(array[0]);//10
    int number = array[1];
    System.out.println(int);//20
}

动态初始化访问

使用动态初始化数组的时候，其中的元素就会自动拥有一个默认值
- 如果是整数类型，0
- 如果是浮点类型，0.0
- 如果是字符类型，’\u0000’
- 如果是布尔类型，false
- 如果是引用类型，null

赋值

public static void main (String [] args){
    int [] array = new int [3];
    System.out.println(array[1]);//0
    array[1]=3;
    System.out.println(array[1]);//3
}

注意事项：静态初始化其实也有默认值的过程，只不过在你写大括号的时候，写了具体数值系统会马上将默认值改成你写的值。

2.5 Java中内存划分

Java中的内存需要划分为五个部分
为什么要划分成五个部分呢：

就比如说你买了一个房子，肯定有厕所，客厅，卧室，厨房。这样分开后更加符合日常使用。同理Java也一样。

栈（Stack）：存放的都是方法中的局部变量

局部变量：方法的参数，或者是方法大括号内部的变量

作用域：一旦超出作用域，立刻从栈内存消失
堆（Heap）：凡是new出来的都会放在堆内存中，堆内存中有一个16进制地制值，堆内存中的数据都有默认值。
方法区（Method）：存储class相关信息，包含方法的信息。
本地方法栈（Native Method Stack）：与操作系统相关
寄存器（pc Register）：与CPU相关

2.6 常用的数组语句

获取数组长度

格式：数组名称.length
这将会得到一个int数字，代表数组的长度
数组一旦创建，程序运行期间，长度不允许改变

int [] array = new int [3];
System.out.println(array.length);//3
array = new int [5];
System.out.println(array.length);//5

注意：上面的这个例子，他并不是改变了数组的长度，而是创建了一个新的数组。只不过两个数组都是用的array表示的。

2.7 数组的遍历输出

遍历数组

就是对数组中的每一个元素都打印输出

public static void main (String[] args){
    int [] array = {10,20,30,40,50,60,70,80,90};
    for(int i=0;i<array.length;i++){
        System.out.println(array[i]);
    }
}

求数组中的最大值

public static void main (String[] args){
    int [] array = {55,26,94,67,15,2,34};
    int max=array[0];
    for(int i=1;i<array.length;i++){
        if(array[i]>max){
            max=array[i];
        }
    }
    System.out.println(max);//94
}

数组元素反转

本来的样子{1,2,3,4}
之后的样子{4,3,2,1}
要求，不能使用新的数组，就是用原来的唯一的一个数组。
分析
- 其实就是数组对称位置的元素进行了互换

public static void main(String[] args){
    int [] array = {1,2,3,4,5};
    for(int i=0;i<array.length;i++){
        System.out.print(array[i]+",");
    }
    System.out.println();
    System.out.println("==================");
    for(int min=0, max=array.length-1;min<max;min++,max--){
        int temp=array[min];
        array[min]=array[max];
        array[max]=temp;
    }
    for(int i=0;i<array.length;i++){
        System.out.print(array[i]+",");
    }
}

数组作为参数

public static void main(String[] args){
    int [] array = {1,2,3,4,5};
    printArray(array);
}

public static void printArray(int[] array){
    for(int i=0;i<array.length;i++){
        System.out.print(array[i]+",");
    }
    System.out.println();
    System.out.println("==================");
    for(int min=0, max=array.length-1;min<max;min++,max--){
        int temp=array[min];
        array[min]=array[max];
        array[max]=temp;
    }
    for(int i=0;i<array.length;i++){
        System.out.print(array[i]+",");
    }
}

数组可以作为方法的参数。
当调用方法的时候，向方法的小括号中进行传参，传递进去的其实是数组的地址值。

数组作为返回值

一个方法可以有零个或者多个参数，但是只能有零或者一个返回值，不能有多个返回值。
如果一个方法中产生了多个结果数据需要进行返回，这就需要一个数组作为返回值类。

public static void main(String[] args){
    int [] result=calculate(10,20,30);
    System.out.println("总和是："+result[0]);
    System.out.println("平均数是："+result[1]);
}
public static int[] calculate(int a,int b,int c){
    int sum= a+b+c;
    int avg= sum/3;
    int [] array={sum,avg};
    return array;
}