【JavaSE(二)】Java语法基础(下)


1 方法

1.1 方法的概述

方法,简单的说就是完成特定功能的代码块(注意:在很多语言里面有函数的定义,而在Java中,函数被称为方法)。

格式:

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
    方法体语句;
    return 返回值;
}

格式解释:

  • 修饰符:目前就用 public static,后面再详细讲解其他修饰符
  • 返回值类型:就是功能结果的数据类型
  • 方法名:就是起了一个名字,方便调用该方法
  • 参数类型:就是参数的数据类型
  • 参数名:就是变量
  • 参数分类:
    • 实参:实际参与运算的数据
    • 形参:方法上定义的,用于接收实际参数的变量
  • 方法体语句:就是完成功能的代码块
  • return:结束方法
  • 返回值:就是功能的结果,由return带给调用者

注意:

  • 要明确返回值类型:结果的数据类型
  • 方法与方法是平级关系,不能嵌套定义
  • 参数列表:参数的个数及对应的数据类型,参数之间用逗号隔开
  • 如果方法有明确的返回值,一定要有return带回一个值

方法的调用:

class FunctionDemo {
    public static void main(String[] args) {
        int x = 10;
        int y = 20;

        //方式1:单独调用,没有意义(void类型的方法可以单独调用)
        //sum(x,y);

        //方式2:输出调用(void类型会报错:此处不允许使用 '空' 类型)
        //System.out.println(sum(x,y));
        //System.out.println(30);

        //方式3:赋值调用(void类型会报错:非法的表达式开始)
        int result = sum(x,y);
        //result在这里可以进行操作
        System.out.println(result);
    }

    public static int sum(int a,int b) {
            //int c = a + b;
            //return c;
            return a + b;
    }

}

1.2 方法重载

在同一个类中,方法名相同,参数列表不同。与返回值类型无关

参数列表不同:

  • A:参数个数不同
  • B:参数类型不同
class FunctionDemo {
    public static void main(String[] args) {
        //jvm会根据不同的参数去调用不同的功能
        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
        System.out.println(sum(10,20,30,40));
        System.out.println(sum(10.5f,20f));
    }

    //需求1:求两个数的和
    public static int sum(int a,int b) {
        System.out.println("int");
        return a + b;
    }

    //需求2:求三数的和
    public static int sum(int a,int b,int c) {
        return a + b + c;
    }

    //需求3:求四个数的和
    public static int sum(int a,int b,int c,int d) {
        return a + b + c + d;
    }

    //需求3:求两个浮点数的和
    public static float sum(float a,float b) {
        System.out.println("float");
        return a + b;
    }
}

2 数组

2.1 数组概述

数组是存储同一种数据类型的多个元素的容器。每一个元素都有索引,从0开始,最大索引是长度-1

数组既可以存储基本数据类型,也可以存储引用数据类型。

定义格式:

  • A:数据类型[] 数组名; (推荐)
  • B:数据类型 数组名[];

java中的数组必须先初始化然后才能使用。所谓的初始化即为数组中的数组元素分配内存空间,并为每个数组元素赋值。

数组的初始化:

  • java中的数组必须先初始化然后才能使用
  • A:动态初始化。只给长度,系统给出默认值
    • 举例:int[] arr = new int[3];
  • B:静态初始化。给出值,系统决定长度
    • 举例:int[] arr = new int[]{1,2,3}; 或者 int[] arr = {1,2,3};

2.2 数组内存分配

Java 程序在运行时,需要在内存中的分配空间。为了提高运算效率,就对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。

  • A:栈,通常保存方法中的参数,局部变量。每一个线程包含一个栈区,只保存基本数据类型的对象和自定义对象的引用(不是对象),对象都存放在共享堆中;每个栈中的数据(基本数据类型和对象引用)都是私有的,其他栈不能访问;
  • B:堆,存储所有new出来的,即存储的全部是对象。每个对象都包含一个与之对应的class的信息(class的目的是得到操作指令)。jvm只有一个堆区,被所有线程共享,不存放基本类型和对象引用,只存放对象本身。
  • C:方法区(面向对象部分详细讲解),又叫静态区,跟堆一样,被所有的线程共享。方法区包含所有的class和static变量。方法区中包含的都是在程序中永远的唯一的元素
  • D:本地方法区(系统相关)
  • E:寄存器(CPU使用)

注意:

  • a:局部变量 在方法定义中或者方法声明上定义的变量
  • b:栈内存和堆内存的区别
    • 栈:数据使用完毕,就消失。比如局部变量
    • 堆:每一个new出来的东西都有地址,每一个变量都有默认值
      • byte,short,int,long——0
      • float,double——0.0
      • char——'\u0000'
      • boolean——false
      • 引用类型——null
  • C:数据使用完毕后,在垃圾回收器空闲的时候回收

(1)定义一个数组,输出数组名及元素。然后给数组中的元素赋值,再次输出数组名及元素。

(2)定义两个数组,分别输出数组名及元素。然后分别给数组中的元素赋值,分别再次输出数组名及元素。

(3)定义两个数组,先定义一个数组,赋值,输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。然后给第二个数组赋值,再次输出两个数组的名及元素。

2.3 数组常用操作

(1)遍历

public static void printArray(int[] arr) {
    for(int x=0; x<arr.length; x++) {
        System.out.println(arr[x]);
}

注意:数组提供了一个属性length,用于获取数组的长度。格式:数组名.length

(2)最值

public static int getMax(int[] arr) {
    //从数组中任意的找一个元素作为参照物
    int max = arr[0];
    //然后遍历其他的元素
    for(int x=1; x<arr.length; x++) {
    //依次获取和参照物进行比较,如果大就留下来,如果小,就离开。
        if(arr[x] > max) {
            max = arr[x];
        }
    }
    //最后参照物里面保存的就是最大值。
    return max;
}

public static int getMin(int[] arr) {
    //从数组中任意的找一个元素作为参照物
    int min = arr[0];
    //然后遍历其他的元素
    for(int x=1; x<arr.length; x++) {
    //依次获取和参照物进行比较,如果小就留下来,如果大,就离开。
        if(arr[x] < min) {
            min = arr[x];
        }
    }
    //最后参照物里面保存的就是最小值。
    return min;
}

(3)逆序

方式1:
public static void reverse(int[] arr) {
    for(int x=0; x<arr.length/2; x++) {
        int temp = arr[x];
        arr[x] = arr[arr.length-1-x];
        arr[arr.length-1-x] = temp;
    }
}

方式2:
public static void reverse(int[] arr) {
    for(int start=0,end=arr.length-1; start<=end; start++,end--) {
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
    }
}

(4)查表

public static String getString(String[] strArray,int index) {
    return strArray[index];
}

(5)基本查找

方式1:
public static int getIndex(int[] arr,int value) {
    for(int x=0; x<arr.length; x++) {
        if(arr[x] == value) {
            return x;
        }
    }
    return -1;
}

方式2:
public static int getIndex(int[] arr,int value) {
    int index = -1;
    for(int x=0; x<arr.length; x++) {
        if(arr[x] == value) {
            index = x;
            break;
        }
    }
    return index;
}

2.4 二维数组

二维数组是一个元素是一位数组的数组。

格式:

  • A:数据类型[][] 数组名 = new 数据类型[m][n];
  • B:数据类型[][] 数组名 = new 数据类型[m][];
  • C:数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};
  • D:数据类型[][] 数组名 = {{...},{...},{...}};

PS:m表示这个二维数组有多少个一维数组。n表示每一个一维数组的元素有多少个。

二维数组的遍历:外循环控制的是二维数组的长度,其实就是一维数组的个数。内循环控制的是一维数组的长度。

class Array2 {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};  //arr[0]就是第一个数组,arr[0] = {1,2,3};
        printArray2(arr);
        System.out.println("--------------");
        int[][] arr2 = {{1,2,3},{4,5},{6}};
        printArray2(arr2);
    }

    public static void printArray2(int[][] arr) {
        for(int x=0; x<arr.length; x++) {
            for(int y=0; y<arr[x].length; y++) {  //arr[x]就是第x-1个数组
                System.out.print(arr[x][y]+" ");
            }
            System.out.println();
        }
    }
}

举个二维数组的应用例子

/*

    需求:打印杨辉三角形(行数可以键盘录入)

    1
    1 1 
    1 2 1
    1 3 3 1
    1 4 6 4 1 
    1 5 10 10 5 1

    分析:看这种图像的规律
        A:任何一行的第一列和最后一列都是1
        B:从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。

    步骤:
        A:首先定义一个二维数组。行数如果是n,我们把列数也先定义为n。
          这个n的数据来自于键盘录入。
        B:给这个二维数组任何一行的第一列和最后一列赋值为1
        C:按照规律给其他元素赋值
            从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。
        D:遍历这个二维数组。
*/
import java.util.Scanner;

class Array2Test {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //这个n的数据来自于键盘录入。
        System.out.println("请输入一个数据:");
        int n = sc.nextInt();

        //定义二维数组
        int[][] arr = new int[n][n];

        //给这个二维数组任何一行的第一列和最后一列赋值为1
        for(int x=0; x<arr.length; x++) {
            arr[x][0] = 1; //任何一行第1列
            arr[x][x] = 1; //任何一行的最后1列
        }

        //按照规律给其他元素赋值
        //从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。
        for(int x=2; x<arr.length; x++) {
            //这里如果y<=x是有个小问题的,就是最后一列的问题
            //所以这里要减去1
            //并且y也应该从1开始,因为第一列也是有值了
            for(int y=1; y<=x-1; y++) {
                //每一个数据是它上一行的前一列和它上一行的本列之和。
                arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
            }
        }

        //遍历这个二维数组。
        for(int x=0; x<arr.length; x++) {
            for(int y=0; y<=x; y++) {
                System.out.print(arr[x][y]+"\t");
            }
            System.out.println();
        }
    }
}

3 参数传递问题

Java中的参数传递问题:

  • 基本类型:形式参数的改变对实际参数没有影响
  • 引用类型:形式参数的改变直接影响实际参数
class ArgsDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("a:"+a+",b:"+b); //输出:a:10,b:20
        change(a,b);
        System.out.println("a:"+a+",b:"+b); //输出:a:10,b:20

        int[] arr = {1,2,3,4,5}; 
        change(arr);
        System.out.println(arr[1]); //输出:4
    }

    public static void change(int a,int b) { //a=10,b=20
        System.out.println("a:"+a+",b:"+b); //a:10,b:20
        a = b;  //a=20
        b = a + b; //b=40
        System.out.println("a:"+a+",b:"+b); //a:20,b:40
    }

    public static void change(int[] arr) { //arr={1,2,3,4,5};
        for(int x=0; x<arr.length; x++) {
            if(arr[x]%2==0) {
                arr[x]*=2;
            }
        }
        //arr={1,4,3,8,5};
    }
}
#运行结果:
a:10,b:20
a:10,b:20
a:20,b:40
a:10,b:20
4

4 语言基础综合练习

某个公司采用公用电话传递数据信息,数据是小于8位的整数,为了确保安全,在传递过程中需要加密,加密规则如下:

  • 首先将数据倒序,然后将每位数字都加上5,再用和除以10的余数代替该数字,最后将第一位和最后一位数字交换。 请任意给定一个小于8位的整数,然后,把加密后的结果在控制台打印出来。
题目要求:
        A:数据是小于8位的整数
            定义一个int类型的数据
            int number = 123456;
        B:加密规则
            a:首先将数据倒序
                结果 654321
            b:然后将每位数字都加上5,再用和除以10的余数代替该数字
                结果 109876
            c:最后将第一位和最后一位数字交换
                结果 609871
        C:把加密后的结果输出在控制台

        通过简单的分析,我们知道如果我们有办法把这个数据变成数组就好了。
        不是直接写成这个样子的:
            int[] arr = {1,2,3,4,5,6};

        如何把数据转成数组呢?
            A:定义一个数据
                int number = 123456;
            B:定义一个数组,这个时候问题就来了,数组的长度是多少呢?
                int[] arr = new int[8]; //不可能超过8
                在赋值的时候,我用一个变量记录索引的变化。
                定义一个索引值是0
                int index = 0;
            C:获取每一个数据
                int ge = number%10
                int shi = number/10%10
                int bai = number/10/10%10

                arr[index] = ge;
                index++;
                arr[index] = shi;
                index++;
                arr[index] = bai;
                ...
import java.util.Scanner;

class JiaMiDemo2 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //请输入一个数据
        System.out.println("请输入一个数据(小于8位):");
        int number = sc.nextInt();

        //写功能实现把number进行加密
        //调用
        String result = jiaMi(number);
        System.out.println("加密后的结果是:"+result);
    }

    /*
        需求:写一个功能,把数据number实现加密。
        两个明确:
            返回值类型:String 做一个字符串的拼接。
            参数列表:int number
    */
    public static String jiaMi(int number) {
        //定义数组
        int[] arr = new int[8];

        //定义索引
        int index = 0;

        //把number中的数据想办法放到数组中
        while(number > 0) {
            arr[index] = number%10;
            index++;
            number /= 10;
        }

        //把每个数据加5,然后对10取得余数
        for(int x=0; x<index; x++) {
            arr[x] += 5;
            arr[x] %= 10;
        }

        //把第一位和最后一位交换
        int temp = arr[0];
        arr[0] = arr[index-1];
        arr[index-1] = temp;

        //把数组的元素拼接成一个字符串返回
        //定义一个空内容字符串
        String s = "";

        for(int x=0; x<index; x++) {
            s += arr[x];
        }

        return s;
    }
}

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏我是业余自学C/C++的

vector

1384
来自专栏鬼谷君

python3 内置函数详解

813
来自专栏C/C++基础

字符数组的初始化与赋值

C语言中表示字符串有两种方式,数组和指针,字符数组是我们经常使用的方式。变量的定义包括指明变量所属类型、变量名称、分配空间以及初始化。可以看出,变量的初始化是变...

582
来自专栏debugeeker的专栏

《coredump问题原理探究》Linux x86版6.3节有成员变量的类coredump例子

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/xuzhina/article/detai...

631
来自专栏小白的技术客栈

Python内置数据结构之集合

今天给大家介绍内置数据结构集合的用法。 看一下集合的思维导图: ? 集合的特点 元素是唯一的 元素是无序的,不是线性结构 集合元素是可hash的 聚合的含义和数...

3414
来自专栏前端说吧

JS-高程3(更新中...)

3207
来自专栏C/C++基础

C++学习知识点

答:多态:同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果。在运行时,可以通过指向基类的指针,来调用实现派生类中的方法。 C++中,实现多态有...

602
来自专栏debugeeker的专栏

《coredump问题原理探究》Linux x86版6.2节C++风格数据结构内存布局之有成员变量的类

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/xuzhina/article/detai...

461
来自专栏赵俊的Java专栏

加一

1353
来自专栏debugeeker的专栏

《coredump问题原理探究》Linux x86版6.8节多继承coredump例子

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/xuzhina/article/detai...

482

扫码关注云+社区