Java基础学习笔记2

第一章 方法

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函数调用后直接输出结果了，所以不需要传递参数。

• 注意事项

  • 方法定义的先后顺序无所谓
  • 方法定义必须是挨着的，不能在一个方法的内部定义另一个方法。
  • 方法定义之后不会自己执行，需要我们进行方法的调用才可以执行。

有参方法定义

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

1. 蒙牛工厂

   原料：奶牛，饲料，水

   产出物：奶制品

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

• 定义格式

  • 修饰符 返回值类型 方法名 (参数类型 参数名称，…){

    ​ 方法体;

    ​ 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也一样。

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

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

   作用域：一旦超出作用域，立刻从栈内存消失

2. 堆（Heap）：凡是new出来的都会放在堆内存中，堆内存中有一个16进制地制值，堆内存中的数据都有默认值。

3. 方法区（Method）：存储class相关信息，包含方法的信息。

4. 本地方法栈（Native Method Stack）：与操作系统相关

5. 寄存器（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;
}