javase笔记day05

最新推荐文章于 2023-12-05 19:42:30 发布
最新推荐文章于 2023-12-05 19:42:30 发布
阅读量152 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46326122/article/details/105361965
版权

方法

**格式说明：**
	修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2 ....){
		方法体;
		return 返回值;
	}
	
	(1): 修饰符 			比较多,后面会详细介绍。目前使用  public static
	(2): 返回值类型 		用于限定返回值的数据类型
	(3): 方法名			就是一个名称，它的存在是为了方便我们调用方法
	(4): 参数类型 			限定调用方法时传入参数的数据类型
	(5): 参数名 			是一个变量，接收调用方法时传入的参数
							        这个参数其实有一个专业的名词,被称之为形式参数,它的作用是用来接收实际参数的.
	(6): 方法体 			完成功能的代码
	(7): return 			结束方法以及返回方法指定类型的值 
	(8): 返回值 			就是功能的结果，由return带回，带回给调用者

**如何写一个方法**
	两个明确
		a:返回值类型 	明确功能结果的数据类型
		b:参数列表 	你要传递几个参数，以及每一个参数的数据类型
	方法调用(有明确返回值的调用)
		a:单独调用,一般来说没有意义，所以不推荐。
		b:赋值调用,推荐方案。
		c:输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作。

**注意事项**
	A:	方法不调用不执行
	B:	方法与方法是平级关系，不能嵌套定义
	C:	方法定义的时候参数之间用逗号隔开
	D:	方法调用的时候不用在传递数据类型
	E:	如果方法有明确的返回值，一定要由return带回一个值

方法练习

根据键盘录入的行数和列数，在控制台输出星形

import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入行数");
        int hang = sc.nextInt();
        System.out.println("请输入列数");
        int lie = sc.nextInt();
        //抽取方法，打印形状
        showStar(hang,lie);
    }
    public static void showStar(int hang,int lie){
        for (int i = 1; i <=hang; i++) {
            for (int j = 1; j <= lie; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

根据键盘录入的数据输出对应的乘法表

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入整数");
        int num = sc.nextInt();
        show(num);
    }

    public static void show(int num) {
        for (int i = 1; i <= num; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + (j * i) + "\t");
            }
            System.out.println();
        }
    }
}

方法重载

在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同，与返回值无关。
	参数列表不同：
		A:参数个数不同
		B:参数类型不同

案例

public class Test {
    public static void main(String[] args) {
        //求两个数，相加的结果
        //求三个数，相加的结果
        //求四个数,相加的结果
        int sum1 = add(1, 2);
        int sum2 = add(1, 2, 3);
        int sum3 = add(1, 2, 3, 4);
        System.out.println(sum1);
        System.out.println(sum2);
        System.out.println(sum3);
        //在调用时。会根据传入的参数个数和参数类型，会自动匹配
        System.out.println("=====================");
        add(20,30.3);

    }
    public static int add(int a, int b) {
        System.out.println("两个整型的方法调用");
        return a + b;
    }

   /*
   不拿返回值类型来区分
   public static double add(int a, int b) {
        return a + b;
    }*/
    public static double add(int a, double b) {
        System.out.println("一个整形一个浮点型的方法调用");
        return a + b;
    }

    public static int add(int a, int b,int c) {
        return a + b+c;
    }

    public static int add(int a, int b, int c,int d) {
        return a + b + c+d;
    }
}

数组

A:数组概念
	数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
	数组既可以存储基本数据类型，也可以存储引用数据类型(后面讲解)。
B:数组定义格式
	格式1： 数据类型[] 数组名；
	格式2： 数据类型   数组名[];
举例：
	int[] a； 	定义了一个int类型的数组a；
	int a[];	定义了一个int类型的a数组；
	推荐使用第一种定义方式。

数组的初始化

A:什么是数组的初始化
	Java中的数组必须先初始化,然后才能使用。
	所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
B:初始化的分类：
	a:动态初始化:	只指定长度，由系统给出初始化值
	b:静态初始化:	给出初始化值，由系统决定长度	
	注意事项： 这两种方式，只能使用一种，不能进行动静结合	
C:动态初始化的格式：
	数据类型[] 数组名 = new 数据类型[数组长度];
	数组长度其实就是数组中元素的个数。
	举例： int[] arr = new int[3];	定义了一个int类型的数组arr，这个数组可以存放3个int类型的值。

举例

public class Test1 {
    public static void main(String[] args) {
        int [] a = new int[4];//动态初始化
        for (int i = 0; i <a.length ; i++) {//遍历数组
            System.out.println(a[i]);
        }
        a[0] = 9;
        a[1] = 12;
        a[2] = 22;
        a[3] = 45;
        System.out.println(a[1]);
        System.out.println("=====================");
        String [] s = new String[4];
        for (int i = 0; i <s.length ; i++) {
            System.out.println(s[i]);
        }
        System.out.println("===============");
        String [] a1 ={"haa","heh","ssw"};//静态初始化
        for (int i = 0; i <a1.length ; i++) {
            System.out.println(a1[i]);
        }
    }
}


public class Test {
    public static void main(String[] args) {
        int[] arr1=new int[3];
        arr1[0]=10;
        arr1[1] = 20;
        arr1[2] = 30;
        int[] arr2 = new int[3];
        arr2[0] = 100;
        arr2[1] = 200;
        arr2[2] = 300;
        int[] arr3=arr1;//arr3和arr1都指向一个对象，所以重新赋值覆盖
        arr3[0]=60;
        arr3[1]=500;
        System.out.println(arr1[0]); //60
        System.out.println(arr1[1]); //500
        System.out.println(arr1[2]); //30
        System.out.println("=============================");
        System.out.println(arr2[0]); //100
        System.out.println(arr2[1]); //200
        System.out.println(arr2[2]); //300
        System.out.println("=============================");
        System.out.println(arr3[0]); //60
        System.out.println(arr3[1]); //500
        System.out.println(arr3[2]); //30

        System.out.println("====================");
        //输出数组的地址值
        System.out.println(arr1);
        System.out.println(arr2);
        System.out.println(arr3);
        //判断两个地址值是否相等
        System.out.println(arr1==arr3);

    }
}

java中内存分配以及栈和堆的区别

  1. 栈内存
存放的是局部变量
	局部变量：在方法定义中或者方法声明上的变量都是局部变量。
	方法
  1. 堆内存
存放的是所有new出来的对象
  1. 方法区内存
字节码文件

数组角标越界与空指针异常问题

public class Test{
	public static void main(String[] args){
		//数组一旦定义，那么数组的长度 就不可变化了。
   	 	//当你访问了没有对应角标的元素，你会出现角标越界
   	 	int [] array = new int[2];
   	 	// array[2]; 报错，原因：ArrayIndexOutOfBoundsException 数组角标越界异常
   	 	
   	 	array = null;//将数组引用为空
   	 	System.out.println(array.length);//报错  错误原因：NullPointerException 空指针异常
   	 	//array为空，无法指向堆内存中数组的内存地址
	}
}

数组遍历

public class Test{
	public static void main(String[] args){
		int[] array = {100,200,300,400,500,600,700};//静态初始化
		//进行数组遍历
		for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

		//反向遍历
		for(int i=array.length-1;i>=0;i--){
            System.out.println(array[i]);
        }
	}
}
举例：获取数组中最大值或最小值
public class Test{
	public static void main(String[] args){
		int[] array = {200, 2100, 300, 800, 8000, -1, 100, 6000, 50};
		int max = array[0];
		for(i = 0;i < array.length; i++){
			if(array[0] > max){
				max = array[i];
			}
		}
		System.out.println("最大值是" + max);
	
	int min = array[0];
		for(i = 0;i < array.length; i++){
			if(array[0] < min){
				min = array[i];
			}
		}
		System.out.println("最小值是" + min);
	}
}
举例：反转数组中的元素
public class Test{
	public static void main(String[] args){
		int[] arr={50,100,200,300,400,500,600,700};//初始化
		for(int i = 0;i < arr.length / 2; i++){//取一半进行遍历
			int t = arr[i];//定义中间值
			arr[i] = arr[arr.length - 1 - i];
			arr[arr.length - 1 - i] = t;
		}
		for(int j;j < arr.length; j++){//遍历
			System.out.println(arr[j] + " ");
		}
	}
}

调用方法实现数组最大值、最小值、数组倒序、数组遍历

public class ArrayUtils {
    public static void main(String[] args) {
        //获取最大值
        int[] arr = {20, 500, 600, 800, 900};//初始化
        int max = getMax(arr);//调用方法
        System.out.println(max);

        int[] arr2 = {20, 500, 600, 800, 900,2000};
        int max2 = getMax(arr2);//调用方法
        System.out.println(max2);

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

        int min = getMin(arr2);
        System.out.println(min);
        System.out.println("===========================");
        //调用倒序方法
        reverseArr(arr);

        System.out.println("===========================");
        //调用遍历方法
        showArr(arr);

    }

    public static int getMax(int[] arr) {//求最大值方法
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }

    public static int getMin(int[] arr) {//最小值方法
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min= arr[i];
            }
        }
        return min;
    }

    public static void reverseArr(int[] arr){//数组倒序方法
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {//实现数组元素交换
            int t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;
        }
        for (int j = 0; j < arr.length ; j++) {//遍历交换后的数组元素
            System.out.print(arr[j] + " ");
        }
        System.out.println();
    }
    public static void showArr(int[] arr){//遍历数组方法
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
        }
    }
}

输出结果

900
2000
============================
20
===========================
900 800 600 500 20 
===========================
900,800,600,500,20,
红鲤驴
关注
JavaSE学习day05(数组)
weixin_42135811的博客
09-20 169
###05.02_Java语言基础（数组的初始化动态初始化）（掌握） A：什么是数组的初始化 就是为数组开辟连续的内存空间，并为每个数组元素赋值 B：如何对数组进行初始化 a:动态初始化 只指定长度，由系统给出初始化值 整数类型byte,short,int,long默认初始化值为0 浮点类型double,float默认初始化值为0.0 布尔类型boolean默认初始化值为fa...
Javase day05_作业
weixin_45019989的博客
08-11 471
作业 /** * 1、定义一个学生类，包括属性：学号（ID），姓名（name）， * 成绩（score）；构造方法（带三个参数）；每个属性的访问器方法。 * */ public class Students { private int ID; private String name; private int score; public Students() { super(); } public Students(int iD, String name, int score) { sup
javaSE 笔记 day05
Zhangxiangyiyi的博客
01-16 110
阶段训练：酒店管理系统
javase笔记 day05：数组排序+多维数组
CODE_MrLEE的博客
08-12 301
2019/07/05 08:26 【数组】： 引用数据类型（地址） for-each不适用于数组遍历，因为没有索引 【数组浅复制】： 需要创建新的存储区域，并依次确定每隔元素的值 【元素交换位置】： 1.利用第三个变量交换数值，简单的方法。 int x =5,y=10; //定义两个变量 int temp = x;　　　　//定义第三临时变量temp并提取x值 x = y;　　　　　...
JavaSE学习笔记 Day1
CHiN_951的博客
11-21 162
Java概述和环境搭建
javase笔记day27
m0_46326122的博客
07-02 194
lambda表达式 Lambda表达式，是JDK1.8引入的一种语法，这种语法可以对匿名内部类的写法，进行简写 JDK1.8 引入了一个箭头符号 -> 这个箭头符号 将Lambda表达式分为 左右两部分。 左边->右边 左边：写的是你实现的这个接口中的抽象方法的 形参列表 右边：写的是你对接口中这个抽象方法的具体实现逻辑。 // Comparator 比较器 是个接口 list.sort(new Comparator<Integer>() {
JavaSE学习笔记 Day11
CHiN_951的博客
12-05 1018
面向对象三大特征之 多态
JavaSE学习笔记 Day6
CHiN_951的博客
11-30 855
方法
JavaSE学习笔记 Day7
CHiN_951的博客
12-04 1056
debug、数组(初始化、遍历、默认值)
JavaSE学习笔记.rar
08-19
在"day23"的笔记中，可能涵盖了上述的一些或所有内容，特别是进阶话题，如异常处理的深入理解，线程的并发控制策略，或者集合框架的高级用法等。这些知识点都是Java开发者必备的技能，对于构建高效、健壮的Java应用...
javase-day01.txt
04-29
### JavaSE基础知识详解...综上所述，本篇笔记涵盖了JavaSE基础知识的核心内容，包括Java程序的执行机制、环境搭建、基本语法以及常用的编程概念。这些内容对于初学者来说至关重要，也是后续深入学习Java技术栈的基础。
javase笔记day10
m0_46326122的博客
04-22 190
抽象类 抽象类特点 a:抽象类和抽象方法必须用abstract关键字修饰 抽象类格式: abstract class 类名 {} 抽象方法格式: public abstract void eat(); b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类 c:抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢? 用于子类访问父类数据时的初始化 ...
javaSE_day05学习笔记 01 —— 模拟注册功能
LIKE_0217的博客
07-21 220
javaSE_day05 目录javaSE_day05模拟注册功能1.使用数组存储个人信息2. 用户注册 register()3. 验证用户名和密码(登录) check()4.修改个人信息 updateInfo()5. 修改密码 updatePwd()6. main方法 模拟注册功能 1.使用数组存储个人信息 public class Demo { //定义存储用户信息的数组 static String[] arrayId = {}; static String[] arrayName = {
基于Java语言的店小二服务平台数字玛丽设计源码
最新发布
10-05
该项目为店小二服务平台提供的数字玛丽设计源码，采用Java语言开发，共包含20个文件，其中10个XML配置文件、7个Java源文件以及2个Git忽略文件。该平台旨在提供高效便捷的服务，适用于相关业务场景。
基于Python、HTML、JavaScript和CSS的豆瓣TOP250电影可视化设计源码
10-05
本项目是一款利用Python、HTML、JavaScript和CSS技术构建的豆瓣TOP250电影可视化设计源码，共包含59个文件，涵盖16个Python脚本、13个JavaScript脚本、13个HTML页面、4个CSS样式表、2个JSON数据文件、2个图片文件以及其他辅助文件。该项目旨在以直观的方式展示豆瓣TOP250电影的详细信息，适用于对电影数据进行分析和展示的用户。
基于Java的商城微服务框架设计源码，集成platform中台基础组件库，一键式接入微服务
10-05
本项目为基于Java的商城微服务框架设计源码，集成了platform中台基础组件库，实现一键式接入微服务功能。项目包含236个文件，涵盖154个Java源文件、41个XML配置文件、10个属性文件、7个YAML配置文件、5个SQL脚本文件以及少量HTML、Shell脚本、文本和Git忽略文件等，旨在为商城业务提供高效、灵活的微服务架构支持。
数据手册-74HC02-datasheet.zip
10-05
数据手册-74HC02-datasheet.zip
mmexport1728042361260.mp4
10-05
mmexport1728042361260.mp4
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值