Java基础语法3

方法

概念

假设有一个程序，程序在运行过程中要不断的获取一些值中的最大值。获取最大值的代码假设需要10行，在每次获取最值的地方都需要重复地编写这10行代码，这样程序会变得很臃肿，重复的代码会很多。为了解决代码重复编写的问题，可以将获取最值的代码提取出来放在一个大括号中，并为这段代码起个名字，这样在每次获取最值的地方通过这个名字来调用获取最值的代码就可以了。上述过程中，所提取出来的打吗可以被看作是程序中定义的一个方法，程序在需要获取最值时调用该方法即可。
它是封装思想的一种体现。

含义

方法就是完成特定功能的代码块，它在很多语言里面都有函数的定义，函数在JAVA中被称为方法。

如何写一个方法

返回值类型：明确功能结果的数据类型
参数列表：明确有几个参数，以及参数的类型
操作案例：求两个数据之和的案例

public static void main(String[] args) {
   getSum(4, 5);
 }
 /**
  * 求两个数据的和
  * @param num1
  * @param num2
  */
 private static void getSum(int num1, int num2) {
   int sum = num1 + num2;
   System.out.println(sum);
 }

特点

方法不调用不执行
方法与方法是平级关系，不能嵌套定义
方法定义的时候参数之间用逗号隔开
方法调用的时候直接传递变量或者常量值
如果方法有明确的返回值，一定要有return带回一个值

return

如果该方法有返回值（不是void）：一定要有return，并且return后面的值的类型必须和定义的返回值类型一致。
如果该方法没有返回值（void）：可以没有return，也可以return，提前结束该方法。

练习题

1.键盘录入两个数据，比较两个数是否相等

public static void main(String[] args) {

 

   String result = isEqual(3, 3);

   System.out.println(result);

 }

 

 private static String isEqual(int num1, int num2) {

   String result = (num1 == num2) ? "相等" : "不相等";

   return result;

 }

2.键盘录入三个数据，返回三个数中的最大值

public static void main(String[] args) {

 

   int max = getMax(3, 4, 1);

   System.out.println(max);

 }

 

 private static int getMax(int num1, int num2, int num3) {

   int result = (num1 == num2) && (num1 > num3) ? num1 : (num2 > num3) ? num2 : num3;

   return result;

 }

3.定义一个方法：传入两个double值，返回这两个值的差

public static double getCha(double a, double b) {

   return a - b;

 }

4.定义一个方法：传入一个名字a，打印“a你真漂亮”

public static void print(String a) {

   System.out.println(a + ",你真漂亮");

   return;

 }

5.定义一个方法：传入一个整数，并判断这个整数是不是偶数，如果是，返回true，如果不是返回false

public static boolean isDouble(int a) {

   if (a % 2 == 0) {

    return true;

   } else {

    return false;

   }

//  return a%2==0;

 }

6.定义一个方法，传入两个整数，分别输出这两个数的和，差，积，商

public static void calc(int a, int b) {

   System.out.println("a+b=" + (a + b));

   System.out.println("a-b=" + (a - b));

   System.out.println("a*b=" + (a * b));

   System.out.println("a/b=" + (a / b));

 }

7.定义一个方法，传入两个int参数a，b，打印b个a

public static String bgea(int a, int b) {

   String str = "";

   for (int i = 0; i < b; i++) {

    str += a;

   }

   return str;

 }

8.自动售货机
需求：
屏幕显示：请选择您要购买的商品编号：1：雪碧（3元）2：矿泉水（2元）3：红牛（6元）
用户输入编号后，屏幕显示请输入金额，用户输入金额
结果：如果购买成功输出：您购买的商品*，价格*，实收*，找零*，谢谢惠顾！
如果购买失败输出：对不起您的金额不足！

方法一：

public static void main(String[] args) {

   Scanner sc = new Scanner(System.in);

   System.out.println("请选择您要购买的商品编号1：雪碧(3元) 2：矿泉水(2元) 3:红牛(6元)");

   int num = sc.nextInt();// 获取要买的商品编号

   double money = sc.nextDouble();// 获取用户输入的金额

 

   String result = printResult(num, money);

   System.out.println(result);

 

 }

 

 public static String getNameByNum(int num) {

   if (num == 1) {

    return "雪碧";

   } else if (num == 2) {

    return "矿泉水";

   } else if (num == 3) {

    return "红牛";

   } else {

    return "无此商品";

   }

 }

 

 public static double getPriceByNum(int num) {

   if (num == 1) {

    return 3;

   } else if (num == 2) {

    return 2;

   } else if (num == 3) {

    return 6;

   } else {

    return -1;

   }

 }

 

 public static String printResult(int num, double money) {

   String result = "";

   // 1. 根据num得到商品价格

   double price = getPriceByNum(num);

   // 2. 用用户的金额减去商品的金额

   double cha = money - price;

   // 3.开始判断

   if (cha < 0) {

    result = "对不起您的金额不足！";

   } else {

    result = "您购买的商品" + getNameByNum(num) + ",价格" + price + ",实收" + money + ",找零" + cha + ",谢谢惠顾";

   }

   return result;

 }

方法二：

public static double getPrice(int proNo,double p){

   if(proNo == 1){

    return p-3;

   }else if(proNo == 2){

    return p-2;

   }else{

    return p-6;

   }

 }

 

 public static String getNameByType(int proNo){

   if(proNo == 1){

    return "雪碧";

   }else if(proNo == 2){

    return "农夫山泉";

   }else{

    return "红牛";

   }

 }

 public static double getPriceByType(int proNo){

   if(proNo == 1){

    return 3.0;

   }else if(proNo == 2){

    return 2.0;

   }else{

    return 6.0;

   }

 }

 public static String getReulst(double cha,int proNo,double price){

   if(cha>=0){

    return "您购买的商品"+getNameByType(proNo)+

       ",价格"+getPriceByType(proNo)+"，实收"+price+"，找零"+cha+"，谢谢惠顾！";

   }else{

    return "对不起您的金额不足";

   }

 }

 

 public static void main(String[] args) {

   

   Scanner sc = new Scanner(System.in);

   System.out.println("请选择您要购买的商品编号1：雪碧(3元) 2：矿泉水(2元) 3:红牛(6元)");

   int proNo = sc.nextInt();

   if(proNo >3||proNo<1){

    System.out.println("您购买的商品不存在");

    return;

   }

   System.out.println("请输入金额：");

   double price = sc.nextDouble();

   

   

   //获取差价：用输入的金额-商品的价格

   double d = getPrice(proNo, price);

   

   String str = getReulst(d,proNo,price);

   System.out.println(str);

 }

hasNextInt（）方法是判断控制台接收是否为数字，当你在控制台输入一个字符的时候，hasNextInt（）判断你输入这个字符是不是数字，而不是接收值，当if判断通过之后执行接收，也就是你输入的那个字符

方法重载

概念：

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

特点：

与返回值类型无关，只看方法名和参数列表
JVM在调用时通过参数列表的不同来区分同名方法

方法的功能一样，仅仅是参与运算的位置内容不同时，可以定义多函数，却使用统一方法名称，这样方便阅读。在调用时，虚拟机通过参数列表的不同来区分同名方法。

方法的功能一样，仅仅是参与运算的未知内容不同时，可以定义多函数，却使用统一方法名称，这样方便阅读。在调用时，虚拟机通过参数列表的不同来区分同名方法。

练习题：

比较两个数据是否相等。参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，并在main方法中进行测试

public static boolean equals(byte b1, byte b2) {

   System.out.println("调用的是byte的方法");

   return b1 == b2;

 }



 public static boolean equals(short s1, short s2) {

   System.out.println("调用的是short方法");

   return s1 == s2;

 }



 public static boolean equals(int a, int b) {

   System.out.println("调用的是int方法");

   return a == b;

 }



 public static boolean equals(long a, long b) {

   System.out.println("调用的是long方法");

   return a == b;

 }

数组

引用

需求：现在需要统计某公司员工的工资情况，例如计算平均工资，找到最高工资等。假设该公司有80名员工，用前面所学的知识，程序首先需要声明80个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦。为了解决这种问题，Java就提供了数组供我们使用。

概念

数组是存储同一种数据类型多个元素的集合，也可以看成是一个容器。

特点

1.多个变量的数据类型要一致
2.数组既可以存储基本数据类型，也可以存储引用数据类型。

格式

格式1：数据类型[] 数组名；
格式2：数据类型 数组名[]；

注意：这两种定义做完了，数组中是没有元素值的。如何对数组的元素进行初始化呢？

初始化

Java中的数组必须先初始化，然后才能使用。

所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

分类：

动态初始化：

特点：初始化时只指定数组长度，由系统为数组分配初始值。

格式：数据类型[] 数组名 = new 数据类型[数组长度] ；

举例：int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。

赋值：
数组名[索引] = 值；
索引从0开始

练习题：
1.创建一个4个长度的float类型的数组，分别赋值为12.1,12,123.3,3
2.创建一个5个长度的布尔类型的数组，将其中的三个元素赋值为true，并打印每个元素值
3.创建一个10个长度的char数组，将[跟okk一起学大数据]分别存进去，使用for循环打印里面的每个元素。

float[] arr2 = new float[4];

   arr2[0] = 12.1f;

   arr2[1] = 12;

   arr2[2] = 123.3f;

   arr2[3] = 3;

 

   boolean[] arr3 = new boolean[5];

   arr3[0] = true;

   arr3[2] = true;

   arr3[4] = true;

 

   char[] chs = new char[7];

   chs[0] = '跟';

   chs[1] = 'o';

   chs[2] = 'k';

   chs[3] = 'k';

   chs[4] = '一';

   chs[5] = '起';

   chs[6] = '学';

   chs[7] = '大';

   chs[8] = '数';

   chs[9] = '据';

 

   for (int i = 0; i < chs.length; i++) {

    System.out.println(chs[i]);

   }

静态初始化：

特点：初始化时指定每个数组元素的初始值，由系统决定数组长度。数组长度其实就是数组中元素的个数。

格式：数据类型[] 数组名 = new 数据类型[] {元素1，元素2…}；

举例：int[] arr = new int[]{1,2,3};
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1，2，3。

其实这种写法还有一个简化的写法：
int[] arr = {1,2,3};
只能在定义数组的时候这么用，重新赋值的时候不能简写

int[] arr = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };



   // arr ={1,2,3};//错误：重新赋值的时候不能简写



   // int[] arr2 = new int[4]{1,2,3,4};//错误：动态初始化和静态初始化不能混合使用

练习题：
1.使用静态初始化定义一个String类型的数组，存储三个元素：
“javase”,“hadoop”,“spark”

2.使用静态初始化定义一个boolean类型的数组，存储 true false true false true

String[] s1 = new String[] { "javase", "hadoop", "spark" };



   // System.out.println(s1[0]);



   boolean[] s2 = { true, false, true, false, true };



   // System.out.println(s2[2]);

如何获取数组里的元素：数组为每个元素都分配了编号，从0开始。获取的时候只要数组名配合编号即可。这个编号专业叫法称：索引。

常见问题

1.数组索引越界
ArrayIndexOutOfBoundsException
访问到了数组中的不存在的索引时发生。

2.空指针异常
NullPointerException
数组引用没有指向实体，却在操作实体中的元素。

int[] arr = null;

   System.out.println(arr);// null

   // System.out.println(arr[0]);//用null去调用数组里边的东西就会产生空指针

   // System.out.println(arr.length);



   arr = new int[4];

   System.out.println(arr[0]);

   System.out.println(arr[4]);// 当你访问的索引不再正常范围（0-length-1）内就会产生这个异常

练习题

1.数组遍历（依次输出数组中的每一个元素）

int[] arr = {1,2,3,4,5,6,7,8};

//  ArrayUtil.printArr(arr);//直接调用工具类中的方法，需要导包

2.数组获取最值（获取数组中的最大值最小值）

int[] arr = {-12,23,43,5332,3,54};

 ArrayUtil.getMaxAndMin(arr);

3.数组元素查找（查找指定元素第一次在数组中出现的索引）

public static void main(String[] args) {

   int[] arr = { -12, 4, 54, 645, 32, 9, 4 };

   // int num = 4;

   Scanner sc = new Scanner(System.in);

   System.out.println("请输入您要查找的数");

   int num = sc.nextInt();

   int location = ArrayUtil.indexOf(arr, num);

   if (location >= 0) {

    System.out.println("该元素的索引为：" + location);

   } else {

    System.out.println("该元素在数组中不存在");

   }

 }

4.数组元素对调（数组中任意两个元素交换位置）

public static void main(String[] args) {

   int[] arr = { 0, 1 };

   System.out.println(arr[0]);

   System.out.println(arr[1]);

 

   int temp = arr[0];

   arr[0] = arr[1];

   arr[1] = temp;

   System.out.println(arr[0]);// 1

   System.out.println(arr[1]);// 0

 

   int[] arr1 = { 1, 2, 3, 4, 5, 6, 7 };

   ArrayUtil.printArr(arr1);

   swap(arr1, 0, 6);

   ArrayUtil.printArr(arr1);

 }

5.数组元素逆序（就是把元素对调）

public static void main(String[] args) {

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

   // 一系列的代码

   for (int i = 0; i < arr.length / 2; i++) {

    // i和arr.length-1-i 做交换

    int temp = arr[i];

    arr[i] = arr[arr.length - 1 - i];

    arr[arr.length - 1 - i] = temp;

   }

   ArrayUtil.printArr(arr);



   for (int start = 0, end = arr.length - 1; start < end; start++, end--) {

    int temp = arr[start];

    arr[start] = arr[end];

    arr[end] = temp;

   }

   ArrayUtil.printArr(arr);

 }

6.点名系统
1.构建一个字符串的数组，数组中存放全班同学的名字
2.生成一个随机数，当做随机索引，随机数索引，随机数的范围应该是从0----数组的长度-1
3.通过随机的索引值，获取数组中的元素

public static void main(String[] args) {

   // 1. 使用静态初始化的方式构建数组

   String[] names = { "姓名1","姓名2" };



   // 2. 生成一个范围为 0-----数组的长度-1

   Random r = new Random();

   int index = r.nextInt(names.length);

//names.length是随机数的上限,产生的随机数为0-names.length的整数,不包括names.length。



   // 随机抽取一名幸运观众

   String name = names[index];

   System.out.println("请【" + name + "】回答问题！");

 }

工具类的封装

遍历：

for(int i = 0;i<arr.length;i++) {

       if(arr.length == 1) {

         System.out.print("["+arr[0]+"]");

       }else if(i == 0) {

         System.out.print("["+arr[i]+",");

       }else if(i == arr.length-1) {

         System.out.print(arr[i]+"]");

       }else {

         System.out.print(arr[i]+",");

       }

      }

    }

求最值：

public static int[] getMaxAndMin(int[] arr) {

   // 获取最大值：假设第一个元素就是最大值

   int max = arr[0];

   // 获取最小值：假设第一个元素就是最小值

   int min = arr[0];

   // 遍历剩余的元素和当前最大值以及最小值进行比较

   for (int i = 1; i < arr.length; i++) {

    // 把当前索引对应的值取出来

    int remainder = arr[i];

    // 然后进行比较，一旦发现后面的元素值比当前的最大值大的话，那就进行替换。

    if (remainder > max) {

      max = remainder;

    }

    if (remainder < min) {

      min = remainder;

    }

   }

   int[] array = { max, min };

   return array;

 }

元素查找：

public static void search(int[] arr){

    Scanner sc=new Scanner(System.in);

    System.out.println("请输入要查找的元素值：");

    int key =sc.nextInt();

    //声明一个位置变量

    int location=-1;

    //遍历数组查找指定元素Key

    for(int i=0;i<arr.length;i++ ){

      if(arr[i]==key){

       location=i;

       break;   

      }

    }

    //根据location的值输出不同的文案

    if(location==-1){

      System.out.println("该元素不在数组中");

    }else{

      System.out.println("你要查找的元素在该数组中的索引位置是："+location);

    }   

   }

元素交换：

// 定义一个方法，传入三个参数，第一个参数是一个int类型的数组，第二和参数和第三个参数分别是两个int值x,y

// 把索引为x的元素和索引为y的元素做交换

 public static void swap(int[] arr, int x, int y) {

   int temp = arr[x];

   arr[x] = arr[y];

   arr[y] = temp;

 }

二维数组

引用：大数据班每个班有很多个学生，所以，可以用数组来存储。而我们又同时有很多个大数据班。这个也应该用一个数组来存储。如何来表示这样的数据呢？Java就提供了二维数组供我们使用。

含义：二位数组就是一个元素为一维数组的数组。

格式：

格式1

数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组
n表示每一个一维数组的元素个数
举例：
int[][] arr = new int[3][2];
定义了一个二维数组arr
这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
每个一维数组有2个元素，可以通过arr[m][n]来获取
表示获取第m+1个一维数组的第n+1个元素

--------------------------------------------------------

格式2

数据类型[][] 变量名 = new 数据类型[m][];
m表示这个二维数组有多少个一维数组
这一次没有直接给出一维数组的元素个数，可以动态的给出。
举例：
int[][] arr = new int[3][];
arr[0] = new int[2];
arr[1] = new int[3]
arr[2] = new int[1];
------------------------------------------------

格式3

数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
 

简化版格式：

数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
举例：
int[][] arr =  {{1,2,3},{4,6},{6}};

练习题：
1.二维数组遍历

for(int i=0;i<arr.length;i++){

    int[]a = arr[i];

    ArrayUtil.printArr(a);

   }

2.打印出100-999所有的“水仙花数”，所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数本身

 // 遍历

   for (int i = 100; i < 1000; i++) {

    // 个位

    int ge = i % 10;

    // 十位

    int shi = i / 10 % 10;

    // 百位

    int bai = i / 100 % 10;

 

    if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {

      System.out.println(i);

    }

   }

----------------------------------------------

153

370

371

407

3.打印杨辉三角

 Scanner sc = new Scanner(System.in);



   System.out.println("请输入你准备打印的是一个多少行的杨辉三角：");

   int n = sc.nextInt();



   int[][] arr = new int[n][n];



   for (int x = 0; x < n; x++) {

    arr[x][0] = 1;

    arr[x][x] = 1;

   }



   // 第三行开始

   for (int x = 2; x < n; x++) {

    // 第二列开始,一定要记得减去最后一列

    for (int y = 1; y <= x - 1; y++) {

      arr[x][y] = arr[x - 1][y - 1] + arr[x - 1][y];

    }

   }



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

   // 输出的时候，千万要和九九乘法表的输出类似。

   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();

   }

Java的内存分配

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

栈(stack)：存储局部变量,方法的执行，没有初始值

堆(heap)：存储new出来的东西，有初始值

方法区：

            静态区：存放所有用static修饰的内容

            class区：存放字节码文件的

本地方法区：(和系统相关)

寄存器：(给CPU使用)

1：局部变量

a:方法定义中或者方法声明上的所有变量

b:使用完毕，立即消失

2：new出来的东西，实体，对象。

a:每一个实体都有首地址值

b:每一个实体内的数据都有默认值

     byte,short,int,long 0

     float,double 0.0

     char ‘\u0000’

     boolean false

     引用类型：null

c:使用完毕后，会被垃圾回收器空闲的时候回收。

---

   int[] arr;//声明了一个数据，并没有赋初值

   //System.out.println(arr);//局部变量不赋初值不能使用

   

   int[] arr1 = new int[4];//定义了一个4个长度的数组，

   System.out.println(arr1);// [I@15db9742

   System.out.println(arr1[0]);//0，打印数组中的第一个元素

   System.out.println(arr1[3]);//0，打印数组中的最后一个元素

   arr1[2] = 10;//将数组中索引值为2的元素赋值为10

   System.out.println(arr1[2]);//10

---

栈内存中无引用指向堆内存时，堆内存的数据就会当作垃圾，等待JVM的回收。