学Java第五天

一、方法的重载

1.方法重载定义
在同一个类中，方法名相同，参数不同，与返回值类型类型不同
可用@overload检测
2.解释：在同一个类中表示重载的方法只能出现在一个类中
方法名必须相同，区分大小写
参数不同 可以参数类型不同，参数个数不同
返回值类型无关即返回值类型也可以不同
3.方法重载的意义
方法重载是是为了将相同功能的方法合并起来，减轻程序员的记忆负担，便于扩展与维护
4例子
定义一个方法 求两个整数之和
定义一个方法 求出三个整数之和
定义一个方法 求出两个小数之和

public class Test01 {
/**
* 求两个整数之和
* @param num1
* @param num2
* @return
*/
public static int show01(int num1,int num2){
return num1+num2;
}
/**
* 求三个整数之和
* @param num1
* @param num2
* @param num3
* @return
*/
public static int show02(int num1,int num2,int num3){
return num1+num2+num3;
}
/**
* 求两个小数之和
* @param num1
* @param num2
* @return
*/
public static double show03(double num1,double num2){
return num1+num2;
}
}

用方法重载

public class Test02 {
public static void main(String[] args) {
System.out.println(getSum(10, 20));
System.out.println(getSum(20.5, 30.5));
System.out.println(getSum(10, 20, 30));
}
public static int getSum(int num1,int num2){
return num1+num2;
}
public static int getSum(double num3,int num4){
return (int)num3+num4;
}
public static int getSum(int num1,int num2,int num3){
return num1+num2+num3;
}
public static double getSum(double num1,double num2){
return num1+num2;
}
}

二、数组

1.概念：数组就是存储一种相同数据类型的数据的容器，数组是容器
2.数组长度固定
3.数组动态初始化
数组类型 [] 数组名 = new 数组类型 [数组长度]

int [] nums = new int[3];

4.数组静态初始化
数组类型 [] 数组名 = new 数组类型 {元素的罗列，用逗号隔开}
其中new 数组类型可以省略
数组类型 [] 数组名 = {元素的罗列，用逗号隔开}

int [] nums = new int[]{10,20,30};
int [] nums1 = {10,20,30};

5.数组的取值赋值
1）.注意点:
数组的索引是从0开始的 数组的索引的最大值: 数组的长度-1
数组的长度 =数组的名称.length 来获取
2）.数组的赋值
语法:数组的名称[索引] =数据 例子：num[0]=80;
3）.数组取值:
语法：数组的名称[索引] 例子:num[0]

public class Test06 {
public static void main(String[] args) {
      String [] arrays = new String[3];
    //给数组进行赋值
      arrays[0]="汪峰";
      arrays[1]="王力宏";
      arrays[2]="霍尊";
    //数组取值
     System.out.println(arrays[0]);
     System.out.println(arrays[1]);
     System.out.println(arrays[2]);
     System.out.println(arrays);
}
}

注意：单独输出数组名（不带索引值）时得到数组的地址
6.数组的异常
1）空指针异常 NullPointerException
产生原因：栈内存未指向任何堆内存地址 又要向堆内存调用数据
解决方法：进行非空验证

public class Test08 {
public static void main(String[] args) {
//定义一个数组
int [] nums ={20,30,40};
nums=null;
if (nums !=null &&nums.length>0){
System.out.println(nums[0]);
}
}
}

2）数组下标越界异常 ArrayIndexOutOfBoundsException
原因：获取数组数据的下标超过数组长度减一
解决办法：获取数组中的元素 需要对索引进行判断 长度必须在0 - 数组.length-1范围之内
但一般都是debug找到报错点更改代码

public class Test09 {
public static void main(String[] args) {
//定义一个数组
int [] nums = {20,30,40};
if (3 >=0 && 3<nums.length){
System.out.println(nums[3]);
}
}
}

三、jvm的内存划分

1.编写的java代码是存在硬盘中 硬盘中的数据是永久保存的 运行的java程序会在内存中开辟空间
jvm将内存划分为五块 便于对数据的管理 以及对内存的优化(房子 厨房 客厅 卧室)
2.jvm内存划分
A. 栈内存 所有的局部变量 以及方法在运行的时候都会在栈内存中开辟空间
特点：先进后出 压栈与弹栈
B.堆内存 所有new 的资源 数组 对象都是在存在堆内存中
C.方法区 所有的字节码文件 class文件 以及静态资源都是存在方法区
例如:public static native Thread currentThread();
D.本地方法区 所有使用native 都是存在本地方法区中，就是调用c/c++代码
E. 程序计数器 主要用于控制代码的执行
方法创建内存图

数组创建内存图

四、数组的循环操作即遍历

1.数组取值赋值

import java.util.Scanner;
public class Test04 {
public static void main(String[] args) {
//实例化Scanner
Scanner input = new Scanner(System.in);
//动态初始化一个数组
int [] scores = new int[5];
//使用循环来进行赋值 循环遍历的是索引 索引是从0开始
for (int i=0;i<scores.length;i++) {
System.out.println("请输入第"+(i+1)+"个同学的成绩");
//int score = input.nextInt();
//将数据存入到数组中
//scores[i]=score;
scores[i] = input.nextInt();
}
//定义一个变量来记录总分
double sum =0;
//使用循环来遍历数组
for (int j=0;j<scores.length;j++){
//int num = scores[j];
//sum+=num;
sum+=scores[j];
}
//求出平均分
System.out.println(sum/scores.length);
}
}

2.数组最大值
最小值即将大于改为小于

public class Test05 {
public static void main(String[] args) {
//静态初始化一个数组
// int [] nums = {20,10,90,50,30};
// System.out.println(getMax(nums));
System.out.println(getMax(new int[]{20, 10, 90, 50, 30}));
}
public static int getMax(int [] nums) {
int max=-1;
//进行非空验证
if (nums !=null && nums.length>0){
//定义一个擂主
max = nums[0];
for (int i=0;i<nums.length;i++) {
//使用if选择结构来进行比较
if (nums[i] > max) {
max = nums[i];
}
}
}
return max;
}
}

3.数组反转

import java.util.Arrays;
public class Test06 {
public static void main(String[] args) {
/* int [] arrays = reversArrays(new );*/
//将数组转换为字符串
/* System.out.println(Arrays.toString(arrays));*/
System.out.println(Arrays.toString(reversArrays(new int[]{20, 30, 40,
50, 60})));
}
/**
* 控制反转
* @param nums 数组
* @return 控制反转后的数组
*/
public static int [] reversArrays(int[] nums){
//对数组进行非空验证
if (nums !=null && nums.length >0) {
//使用循环来遍历
for (int i=0;i<nums.length/2;i++){
//进行值的交互 定义一个中间变量
int temp = nums[i];
nums[i]=nums[nums.length-1-i];
nums[nums.length-1-i] = temp;
}
}
return nums;
}
}

4.数组找指定索引即下标

public class Test07 {
public static void main(String[] args) {
System.out.println(findNum(new int[]{20, 30, 40, 50, 60}, 40, 0, 4));
}
public static int findNum(int [] arrays,int num,int start,int end){
//定义一个变量来记录索引
int index =-1;
//对数组进行非空验证
if (arrays !=null && arrays.length>0){
//对开始的索引 与结束的循环进行判断
if (start >=0 && end >start && end <= arrays.length-1) {
for (int i =start;i<=end ;i++){
if (num ==arrays[i]){
index = i;
break; //结束循环
}
}
}
}
return index;
}
}

5.数组冒泡排序

import java.util.Arrays;
public class Test08 {
public static void main(String[] args) {
//System.out.println(Arrays.toString(sortArrays(new int[]{4,3,1,2,5})));
int [] nums ={4,3,1,2,5};
int[] arrays= sortArrays(nums);
String str = Arrays.toString(arrays);
System.out.println(str);
}
public static int[] sortArrays(int [] nums) {
//需要进行非空验证
if (nums !=null && nums.length>0){
//使用双重for循环
for (int i=0;i<nums.length-1;i++) {
for (int j=0;j<nums.length-1-i;j++) {
//数组中元素前后进行比较
if (nums[j] >nums[j+1]){
//进行值的交换 就是两个变量来交互值
int temp =nums[j];
nums[j]= nums[j+1];
nums[j+1]= temp;
}
}
}
}
return nums;
}
}

6.数组插入元素

public class Day05Work04 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        char [] chars ={'a','b','c','e','f','p','u','z'};
        System.out.println("待插入的字符");
        String s = sc.next();
        char intc = s.charAt(0);
        char [] ch = new char[9];
        for(int i=0;i<chars.length;i++){
            ch[i] = chars[i];
        }
        int index = -1;
        for (int i = 0; i < ch.length; i++) {
                if(ch[i]>intc){
                    index = i;
                    System.out.println("插入字符的下标是："+index);
                    break;
                }
        }
        //对数组的元素进行移动
       for (int j=ch.length-1;j > index ;j--){
                       ch[j]= ch[j-1];
       }
        //进行数据插入
        ch[index] = intc;
       //打印数组
       System.out.println(Arrays.toString(ch));
       

    }
}