JAVA基础语法1

最新推荐文章于 2022-09-01 20:25:34 发布
最新推荐文章于 2022-09-01 20:25:34 发布
阅读量210 收藏
点赞数
分类专栏： Java基础 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaosongshi/article/details/120378059
版权

第一节 Java运行环境

1.1 计算机存储单元

  • 位（bit）：一个数字0或者一个数字1，代表一位。
  • 字节（Byte）：每逢8位是一个字节，这是数据存储的最小单位。

1Byte=8 bit 1KB=1024Byte
1MB=1024KB 1GB=1024MB
1TB=1024GB 1PB=1024TB

eg.办理100Mbps的宽带，实际下载速率100/8=12.5MB/s。

1.2 命令提示符（cmd）

  • 启动：【win+R 输入cmd回车】
  • 切换盘符：【盘符名称：】
  • 进入文件夹：【cd 文件夹名称】
  • 进入多级文件夹：【cd 文件夹1\文件夹2\文件夹3】
  • 返回上一级：【cd…】
  • 直接回根路径：【cd\】
  • 查看当前内容：【dir】
  • 清屏：【cls】
  • 退出：【exit】

1.3开发环境搭建

  1. Java虚拟机——JVM（Java Virtual Machine）：跨平台，java编写的软件可以运行在任何操作系统上，是运行所有java程序的假象计算机，是java程序的运行环境。

Java的虚拟机本身不具备跨平台功能，每个操作系统下都有不同版本的虚拟机。

  1. JRE（Java Runtime Environment）：是java程序的运行时环境，包含JVM和运行时所需要的核心类库。
  2. JDK（Java Development Kit）：是java程序开发工具包，包含JRE和开发人员使用的工具。

我们想要运行一个已有的java程序，只需安装JRE即可。
我们想要开发一个全新的java程序，必须安装JDK。

第二节 HelloWorld案例

程序开发步骤：编写源程序➡编译源程序➡运行

javac.exe：编译器
java.exe：解释器

public class HelloWorld {
	public static void main(String[] args){
		System.out.println("Hello,World!");
	}
}

//这是一行注释
public class HelloWorld {//单行注释
	public static void main(String[] args){
	/*
	无论这里占用多少行，只要在这个范围之内都算多行注释（多行注释）
	*/
	/*   这一行没有进行换行，也照样是多行注释（区块注释）*/
		System.out.println("Hello,World!");
	}
}

//第一行的第三个单词必须和所在文件名称完全一样，大小写也要一样。
//public class后面代表定义一个类的名称，类是Java当中所有源代码的基本组织单位。
public class HelloWorld {
	//第二行的内容是万年不变的固定写法，代表main方法
	//这一行代表程序执行的起点
	public static void main(String[] args){
		//第三行代表打印输出语句
		//希望显示什么东西，就在小括号当中填写什么内容
		System.out.println("Hello,World!");
	}
}

第三节 关键字&标识符

关键字的特点：

  • 完全小写的字母
  • 开发工具中有特殊颜色（上文紫色）

标识符：自己定义的内容，比如类的名字、方法的名字和变量的名字等等。

  • 标识符可以包含英文字母（区分大小写）、0-9数字、$（美元符号）、_（下划线）
  • 标识符不能以数字开头
  • 标识符不能有关键字

建议
类名规范：首字母大写，后面每个单词首字母大写。HelloWorld
变量名规范：首字母小写，后面每个单词首字母大写。helloWorld
方法名规范：同变量名。

第四节 常量&变量

4.1 数据类型

基本数据类型

  • 整数型 byte short int long
  • 浮点型 float double
  • 字符型 char
  • 布尔型 boolean
    八种基本数据类型

引用数据类型

  • 类 class
  • 数组 []
  • 接口 interface

1.字符串不是基本类型，而是引用类型。
2.浮点型可能只是一个近似值，并非精确的值。
3.数据范围与字节数不一定相关，例如float数据范围比long更加广泛，但是float是4字节，long是8字节。
4.浮点数当中默认类型是double，如果一定要使用float类型，需要加上一个后缀F；如果是整数，默认为int类型，如果一定要使用long类型，需要加上一个后缀L，推荐使用大写字母后缀。

4.2 常量

常量：在程序运行期间，固定不变的量。
常量的分类：

  • 字符串常量：凡是用双引号引起来的部分，叫做字符串常量。例如：“abc”、“Hello”、“123”
  • 整数常量：直接写上的数字，没有小数点。例如：100、200、-250、0
  • 浮点数常量：直接写上的数字，有小数点。例如：2.5、-100、0.0
  • 字符常量：凡是用单引号引起来的单个字符，有且仅有一个，叫做字符常量。例如：‘A’、‘b’、‘9’、‘中’
  • 布尔常量：只有两种取值。true、false
  • 空常量：代表没有任何数据。null
public class Demo01Const{
	public static void main(String[] args){
		//字符串常量
		System.out.println("ABC");
		System.out.println("");//字符串两个双引号中间的内容为空，则不输出任何内容
		System.out.println("XYZ");
		//整数常量
		System.out.println("99");
		//浮点数常量（小数点）
		System.out.println("-3.14");
		//字符常量
		System.out.println('0');
		//System.out.println('');//错误写法，两个单引号中间必须有且仅有一个字符，没有不行
		System.out.println("XYZ");
		//布尔常量
		System.out.println(true);
		System.out.println(false);
		//空常量，空常量不能直接用来打印输出
		//System.out.println(null);//错误写法
	}
}

4.3 变量

变量：程序运行期间，内容可以发生改变的量。

创建一个变量并且使用的格式：
数据类型 变量名称；//创建了一个变量
变量名称 = 数据值；//赋值，将右边的数据值，赋值交给左边的变量

一步到位的格式：
数据类型 变量名称 = 数据值；//在创建一个变量的同时，立刻放入指定的数据值

public class Demo02Variable{
	public static void main (String[] args){
		//创建一个变量
		//格式：数据类型 变量名称;
		int num1;
		//向变量当中存入一个数据
		//格式：变量名称 = 数据值;
		num1 = 10;
		//当打印输出变量名称的时候，显示出来的是变量的内容
		System.out.println(num1);//输出10
		
		//改变变量当中本来的数字，变成新的数字
		num1 = 20;
		System.out.println(num1);//输出20

		//使用一步到位的格式来定义变量
		//格式：数据类型 变量名称 = 数据值;
		int num2 = 100;
		System.out.println(num2);//输出100

		num2 = 200;
		System.out.println(num2);//输出200
		System.out.println("------------------");

		byte num3 = 30;//注意：右侧数值的范围不能超过左侧数据类型的取值范围
		System.out.println(num3);//输出30
		//byte num4 = 400;//右侧超出了byte数据范围，错误！

		short num5 = 2000;
		System.out.println(num5);//输出2000
		
		long num6 = 3000000000L;
		System.out.println(num6);//输出3000000000

		float num7 = 3.14F;
		System.out.println(num7);//输出3.14

		double num8 = 1.5;
		System.out.println(num8);//输出1.5

		char zifu1 = 'A';
		System.out.println(zifu1);//输出A

		zifu1 = '十';
		System.out.println(zifu1);//输出十

		boolean var1 = true;
		System.out.println(var1);//输出true

		var1 = false;
		System.out.println(var1);//输出false

		//将一个变量的数据内容，赋值交给另一个变量
		//右侧的变量名称var1已经存在，里面装的是false布尔值
		//将右侧变量里面的false值，向左交给var2变量进行存储
		boolean var2 = var1;
		System.out.println(var2);//输出false
	}
}

/*
使用变量的时候，有一些注意事项：
1、如果创建多个变量，那么变量之间的名称不可以重复
2、对于float和long类型来说，字母后缀F和L不要丢掉
3、如果使用byte或者short类型的变量，那么右侧数值不能超过左侧类型的范围
4、没有进行赋值的变量，不能直接使用；一定要赋值之后，才能使用
5、变量使用不能超过作用域的范围
【作用域】：从定义变量的一行开始，一直到直接所属的大括号结束为止
6、可以通过一个语句来创建多个变量，但是一般情况不推荐这么写
*/
public class Demo03VariableNotice{
	public static void main(String[] args){
	int num1 = 10;//创建一个新的变量，名叫num1
	//int num1 = 20;//又创建了另一个新的变量，名字也叫num1，错误！
	int num2 = 20;

	int num3;
	num3 = 30;

	//int num4;//定义了一个变量，但是没有进行赋值
	//System.out.println(num4);//直接使用打印输出就是错误的！

	//System.out.println(num5);//在创建变量之前，不能使用这个变量

	int num5 = 500;
	System.out.println(num5);//输出500

	{
		int num6 = 60;
		System.out.println(num6);//输出60
	}
	//int num6//重新定义是正确的
	//System.out.println(num6);//已经超出了大括号的范围，超出了作用域，变量不能再使用了

	/*单独创建三个变量
	int a = 10;
	int b = 20;
	int c = 30;
	*/
	//同时创建了三个全都是int类型的变量
	int a,b,c;
	//各自分别赋值
	a = 10;
	b = 20;
	c = 30;
	System.out.println(a);//输出10
	System.out.println(b);//输出20
	System.out.println(c);//输出30

	//同时创建三个int变量，并且同时各自赋值
	int x = 100,y = 200,z = 300;
	System.out.println(x);//输出100
	System.out.println(y);//输出200
	System.out.println(z);//输出300
	}
}

第五节 数据类型转换

当数据类型不一样时，将会发生数据类型转换。

自动类型转换（隐式）
1、特点：代码不需要进行特殊处理，自动完成
2、规则：数据范围从小到大

强制类型转换（显式）
1、特点：代码需要进行特殊的格式处理，不能自动完成
2、格式：范围小的类型 范围小的变量名 = （范围小的类型）原本范围大的数据；

public class Demo01DataType {
    public static void main (String[] args){
        System.out.println(1024);//这是一个整数，默认就是int类型
        System.out.println(3.14);//这是一个浮点数，默认就是double类型

        //左边是long类型，右边是默认的int类型，左右不一样
        //一个等号代表赋值，将右侧的int常量，交给左侧的long变量进行存储
        //int-->long，符合了数据范围从小到大的要求
        //这一行代码发生了自动类型转换
        long num1=100;
        System.out.println(num1);//输出100

        //左边是double类型，右边是float类型，左右不一样
        //float-->double，符合从小到大的规则
        //发生自动类型转换
        double num2 = 2.5F;
        System.out.println(num2);//输出2.5

        //左边是float类型，右边是long类型，左右不一样
        //long-->float，符合从小到大的规则
        //发生自动类型转换
        float num3 = 30L;
        System.out.println(num3);//输出30.0
    }
}

public class Demo02DataType {
    public static void main(String[] args){
        //左边是int类型，右边是long类型，不一样
        //long-->int，不是从小到大
        //不能发生自动类型转换！
        //        int num = 100L;
        //        System.out.println(num);//错误！

        //格式：范围小的类型 范围小的变量名 = （范围小的类型）原本范围大的数据；
        int num = (int) 100L;
        System.out.println(num);
    }
}

注意事项：
1、强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出
2、byte/short/char这三种类型都可以发生数学运算，例如加法“+”
3、byte/short/char这三种类型在运算的时候，都会被首先提升成为int类型，然后再计算
4、boolean类型不能发生数据类型转换
5、对于byte/short/char/三种类型来说，如果右侧赋值的数值没有超过范围，那么javac编译器将会自动隐含地为我们补上一个（byte）（short）（char）
6、在给变量进行赋值的时候，如果右侧的表达式当中全都是常量，没有任何变量，那么编译器javac将会直接将若干个变量表达式计算得到结果

public class Demo03DataType {
    public static void main(String[] args){
        //long强制转换为int类型
        int num2 = (int)6000000000L;
        System.out.println(num2);//输出1705032704，数据溢出

        //double-->int，强制类型转换
        int num3 = (int) 3.5;
        System.out.println(num3);//输出3，并不是四舍五入，所有的小数位都会被舍弃掉，精度损失

        char zifu1 = 'A';//这是一个字符型变量，里面是大写字母A
        System.out.println(zifu1 + 1);//输出66，也就是大写字母A被当作65进行处理
        //一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译成为一个数字

        byte num4 = 40;//注意，右侧数值大小不能超过左侧的类型范围
        byte num5 = 50;
        //byte + byte --> int + int --> int
        int result1 = num4 + num5;
        System.out.println(result1);//输出90

        short num6 = 60;
        //byte + short --> int + int --> int
        //int强制转换为short，注意必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据溢出
        short result2 = (short) (num4 + num6);
        System.out.println(result2);
    }
}

/**
 * 数字和字符的对照关系表（编码表）：
 * ASCII码表：美国信息交换标准代码
 * Unicode码表：万国码，也是数字和符号的对照关系，开头0-127部分和ASCII完全一样，但是从128开始包含有更多字符。(emoji)
 48-'0'
 65-'A'
 97-'a'
 */
public class Demo03DataTypeChar {
    public static void main(String[] args){
        char zifu1 = '1';
        System.out.println(zifu1 + 0);//输出49

        char zifu2 = 'A';
        char zifu3 = 'c';
        int num = zifu3;
        System.out.println(num);//输出99

        char zifu4 = '中';
        System.out.println(zifu4 + 0);//输出20013
    }
}

第六节 运算符

运算符：进行特定操作的符号。例如：+、-
表达式：用运算符连起来的式子叫做表达式。例如：20+5；a+b

6.1 算术运算符

注意事项：
一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种

//首先计算表达式的结果，然后再打印输出这个结果
//对于一个整数的表达式来说，除法用的是整除，整数除以整数，结果仍是整数，只看商，不看余数
//只有对于整数的除法来说，取模运算符才有余数的意义

public class Demo04Operator {
    public static void main (String[] args){
        //两个常量之间可以进行数学运算
        System.out.println(20+30);//50
        //两个变量之间也可以进行数学运算
        int a = 20;
        int b = 30;
        System.out.println(a - b);//-10
        //变量和常量之间可以混合使用
        System.out.println(a - 50);//-30
        //除法
        int x = 10;
        int y = 3;
        int result1 = x / y;
        System.out.println(result1);//3
        //取模%
        int result2 = x % y;
        System.out.println(result2);//1
        //int + double --> double + double --> double
        double result3 = x + 2.5;
        System.out.println(result3);//12.5
    }
}

四则运算当中的加号“+”有常见的三种用法：
1、对于数值来说，那就是加法
2、对于字符char类型来说，在计算之前，char会被提升成为int，然后再计算
char类型字符和int类型字符，之间的对照关系表：ASCII、Unicode
3、对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作；任何数据类型和字符串进行连接的时候，结果都会变成字符串

public class Demo05Plus {
    public static void main(String[] args){
    //字符串类型的变量基本使用
    //数据类型 变量名称 = 数据值；
        String str1 = "Hello";
        System.out.println(str1);//Hello

        System.out.println("Hello"+"World");//HelloWorld

        String str2 = "Java";
        //String + int --> String
        System.out.println(str2 + 20);//Java20
        //优先级问题
        System.out.println(str2 + 20 + 30);//Java2030
        System.out.println(str2 + (20 + 30));//Java50
    }
}

自增运算符：++
自减运算符：–
基本含义：让一个变量涨一个数字1，或者让一个变量降一个数字1
使用格式：写在变量名称之前，或者写在变量名称之后，例如：++num，也可以num++
使用方式：
1、单独使用；不和其他任何操作混合，自己独立成为一个步骤
2、混合使用：和其他操作混合，例如与赋值混合，或者与打印操作混合等
使用区别：
1、在单独使用的时候，前++和后++没有任何区别，也就是++num；和num++；是完全一样的
2、在混合的时候，有重大区别
A.如果是前++，那么变量立刻马上+1，然后拿着结果进行使用【先加后用】
B.如果是后++，那么首先使用变量本来的数值，然后再让变量+1【先用后加】

注意事项：
只有变量才能使用自增、自减运算符，常量不可发生改变，所以不能用。

public class Demo06Operator {
    public static void main(String[] args){
        int num1 = 10;
        System.out.println(num1);//10
        ++num1;//单独使用，前++
        System.out.println(num1);//11
        num1++;//单独使用，后++
        System.out.println(num1);//12
        System.out.println("------------");

        //与打印操作混合的时候
        int num2 = 20;
        System.out.println(++num2);//混合使用，先++，变量立刻变成21，然后打印结果21
        System.out.println(num2);//21
        System.out.println("------------");

        int num3 = 30;
        System.out.println(num3++);//混合使用，后++，首先使用变量本来的30，再让变量+1得到31
        System.out.println(num3);//31

        //和赋值操作混合
        int num4 = 40;
        int result1 = --num4;
        System.out.println(result1);//混合使用，前--，变量立刻变为39，将结果交给result1打印输出
        System.out.println(num4);//39
        System.out.println(--result1);//38

        int num5 = 50;
        int result2 = num5--;
        System.out.println(result2);//混合使用，后--，首先把本来的50交给result2，打印输出50之后，再-1变成49
        System.out.println(num5);//49

        int x = 10;
        int y = 20;
        int result3 = ++x + y--;
        System.out.println(result3);//输出31
        System.out.println(x);//11
        System.out.println(y);//19
    }
}

6.2 赋值运算符

赋值运算符分为：
基本赋值运算符：就是一个等号“=”，代表将右侧的数据交给左侧的变量，int a = 10；
复合赋值运算符：

  • += a += 3 相当于 a = a + 3
  • -= b -= 4 相当于 b = b - 4
  • *= c *= 5 相当于 c = c * 5
  • /= d /= 6 相当于 d = d / 6
  • %= e %= 7 相当于 e = e % 7

注意事项：
1、只有变量才能使用赋值运算符，常量不能进行赋值
2、复合赋值运算符其中隐含了一个强制类型转换

public class Demo07Operator {
    public static void main(String[] args){
        int a = 10;
        a += 5;
        System.out.println(a);//15

        int x = 10;
        x %= 3;
        System.out.println(x);//1

        byte num = 30;
        //num = num + 5
        //num = byte + int
        //num = int + int
        //num = int
        //num = (byte) int
        num += 5;
        System.out.println(num);//35
    }
}

6.3 比较运算符

比较运算符包括：==、>、<、>=、<=、!=

注意事项：
1、比较运算符的结果一定是一个boolean值，成立就是true，不成立就是fasle
2、如果进行多次判断，不能连着写（数学当中的写法：1<x<3，程序中不允许这种写法）

public class Demo08Operator {
    public static void main (String[] args){
        System.out.println(10>5);//true
        int num1 = 10;
        int num2 = 12;
        System.out.println(num1 < num2);//true
        System.out.println(num2 >= 100);//false
        System.out.println(num2 <= 100);//true
        System.out.println(num2 <= 12);//true
        System.out.println(10 == 10);//true
        System.out.println(20 != 25);//true
        System.out.println(20 != 20);//false
        int x = 2;
        //System.out.println(1 < x < 3);//错误写法！编译报错，不能连着写
    }
}

6.4 逻辑运算符

  • 与（并且）“&&” 全都是true，才是true；否则就是false
  • 或（或者）“||” 至少一个是true，就是true；全都是false，才是false
  • 非（取反）“！” 本来是true，变成false；本来是false，变成true

注意事项：
1、与“&&”，或“||”，具有短路效果：如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定的性能
2、逻辑运算符只能用于boolean值
3、与、或需要左右各自有一个boolean值，但是取反只要有唯一的一个boolean值即可
4、与、或两种运算符，如果有多个条件，可以连续写（多个条件：条件A && 条件B && 条件C）
TIPS：
对于1<x<3的情况，应该拆成两个部分，然后使用与运算符连接起来：
int x = 2;
1 < x && x < 3;

public class Demo09Logic {
    public static void main(String[] args){
        System.out.println(true && false);//false
        System.out.println(true && true);//true
        System.out.println(3 < 4 && 10 > 5);//true
        System.out.println(true || false);//true
        System.out.println(true);//true
        System.out.println(!true);//false
        int a = 10;
        // false && ...
        System.out.println(3 > 4 && ++a < 100);//false
        System.out.println(a);//10
        int b = 20;
        // true || ...
        System.out.println(3 < 4 || ++b < 100);//true
        System.out.println(b);//20
    }
}

6.5 三元运算符

  • 一元运算符：只需要一个数据就可以进行操作的运算符，例如：取反！、自增++、自减–
  • 二元运算符：需要两个数据才可以进行操作的运算符，例如：加法+、赋值=
  • 三元运算符：需要三个数据才可以进行操作的运算符

格式：
数据类型 变量名称 = 条件判断 ？ 表达式A ：表达式B；
流程：
首先判断条件是否成立：如果成立为true，那么将表达式A的值赋值给左侧的变量；
如果不成立为false，那么将表达式B的值赋值给左侧的变量；二者选其一

注意事项：
1、必须同时保证表达式A和表达式B都符合左侧数据类型的要求
2、三元运算符的结果必须被使用

public class Demo10Operator {
    public static void main(String[] args){
        int a = 10;
        int b = 20;
        //数据类型 变量名称 = 条件判断 ？ 表达式A ：表达式B；
        //判断a>b是否成立，如果成立将a的值赋值给max；如果不成立将b的值赋值给max，二者选其一
        int max = a > b ? a : b;//最大值的变量
        System.out.println("最大值："+max);//20
        //int result = 3 > 4 ? 2.5 : 10;//错误写法！
        System.out.println(a > b ? a : b);//20 正确写法！
        //a > b ? a : b;//错误写法！
    }
}

第七节 方法入门

定义一个方法的格式：
public static void 方法名称（）{
方法体
}
方法名称的命名规则和变量一样，使用小驼峰
方法体：也就是大括号当中可以包含任意条语句

注意事项：
1、方法定义的先后顺序无所谓
2、方法的定义不能产生嵌套包含关系
3、方法定义好了之后，不会执行的；如果要想执行，一定要进行方法的【调用】

如何调用方法，格式：
方法名称（）；

public class Demo11Method {
    public static void main(String[] args){
        num1();
        num2();
        num3();
    }
    public static void num1(){
        System.out.println("222");
    }
    public static void num2(){
        System.out.println("333");
    }
    public static void num3(){
        System.out.println("444");
    }
}

第八节 选择结构

8.1 顺序结构

在这里插入图片描述

public class Demo01Sequence {
    public static void main(String args[]){
        System.out.println("小松狮");
        System.out.println("小锦鲤");
    }
}

8.2 判断语句

  • 判断语句1：单if语句

格式：
if（关系表达式）{
语句体；
}

在这里插入图片描述

public class Demo02If {
    public static void main(String[] args){
        System.out.println("今天天气不错，正在压马路，突然发现一个快乐的地方：网吧");
        int age = 19;
        if (age >= 18){
            System.out.println("进入网吧，开始High！");
            System.out.println("遇到一群猪队友，开始骂街");
            System.out.println("感觉不爽，结账走人");
        }
        System.out.println("回家吃饭");
    }
}
  • 判断语句2：标准if…else语句

格式：
if(关系表达式){
语句体1；
} else {
语句体2；
}

在这里插入图片描述

public class Demo03IfElse {
    public static void main(String[] args){
        int num = 13;
        if (num % 2 == 0){//如果除以2能够余数为0，说明是偶数
            System.out.println("偶数");
        }else {
            System.out.println("奇数");
        }
    }
}
  • 判断语句3：复合if…else语句

格式：
if(判断条件1){
执行语句1；
}else if (判断条件2){
执行语句2；
}
…
else if (判断条件n){
执行语句n；
}else{
执行语句n+1；
}

在这里插入图片描述

//x和y的关系满足如下：
//如果x >= 3 ，那么y = 2x + 1;
//如果-1 < x < 3，那么y = 2x;
//如果x <= -1，那么y = 2x - 1;
public class Demo04IfElseExt {
    public static void main(String[] args){
        int x = 10 ;
        int y;
        if (x >= 3){
            y = 2 * x + 1;
        }else if (-1 < x && x < 3){
            y = 2 * x;
        }else {
            y = 2 * x - 1;
        }
        System.out.println("结果是："+ y);//21
    }
}


//考试成绩 练习
public class Demo05IfElsePractice {
    public static void main(String[] args){
        int score = 120;
        if (score >= 90 && score <= 100){
            System.out.println("优秀");
        }else if (score >= 80 && score < 90){
            System.out.println("好");
        }else if (score >= 70 && score < 80){
            System.out.println("良");
        }else if (score >= 60 && score < 70){
            System.out.println("及格");
        }else if (score >= 0 && score < 60){
            System.out.println("不及格");
        }else {//单独处理边界之外的不合理情况
            System.out.println("数据错误");
        }
    }
}

//使用三元运算符和标准if-else语句实现：取两个数字当中的最大值
public class Demo06Max {
    public static void main (String[] args){
        int a = 10;
        int b = 20;
        //使用三元运算符
        //int max = a > b ? a : b;
        //System.out.println("最大值："+max);//20
        //使用if语句实现
        int max;
        if (a > b){
            max = a;
        } else {
            max = b;
        }
        System.out.println("最大值："+max);
    }
}

8.3 选择语句

格式：
switch(表达式){
case 常量值1:
语句体1；
break;
case 常量值2:
语句体2；
break;
…
default:
语句体n+1；
break；
}

public class Demo07Switch {
    public static void main (String[] args){
        int num = 3;
        switch (num){
            case 1 :
                System.out.println("星期一");
                break;
            case 2 :
                System.out.println("星期二");
                break;
            case 3 :
                System.out.println("星期三");
                break;
            case 4 :
                System.out.println("星期四");
                break;
            case 5 :
                System.out.println("星期五");
                break;
            case 6 :
                System.out.println("星期六");
                break;
            case 7 :
                System.out.println("星期天");
                break;
            default:
                System.out.println("数据不合理");
                break;//最后一个break语句可以省略，但强烈建议不要省略
        }
    }
}

switch语句使用的注意事项：
1、多个case后面的数值不可以重复
2、switch后面小括号当中只能是下列数据类型：
基本数据类型：byte/short/char/int
引用数据类型：String字符串、enum枚举
3、switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句还可以省略
“匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止”

public class Demo08SwitchNotice {
    public static void main(String[] args){
        int num = 2;
        switch (num){
            case 1:
                System.out.println("你好");
                break;
            case 2:
                System.out.println("我好");
                //break;
            case 3:
                System.out.println("大家好");
                break;//输出我好 大家好
            default:
                System.out.println("他好我也好");
                break;
        }
    }
}

8.4 循环语句

循环结构的基本组成部分，一般可以分为四部分：
1、初始化语句：在循环开始最初执行，而且只做唯一一次
2、条件判断：如果成立，则循环继续；如果不成立，则循环退出
3、循环体：重复要做的事情内容，若干行语句
4、步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次

  • 循环语句1：for

for (初始化表达式1；布尔表达式2；步进表达式3){
循环体1
}

在这里插入图片描述

//for循环 打印100次小松狮
public class Demo09For {
    public static void main(String[] args){
        for(int i = 1; i <= 100; i++){
            System.out.println("小松狮"+ i);
        }
        System.out.println("程序停止");
    }
}
  • 循环语句2：while

标准格式：
while(条件判断){
循环体；
}
扩展格式：
初始化语句；
while(条件判断){
循环体；
步进语句；
}

在这里插入图片描述

public class Demo10While {
    public static void main(String[] args){
        int i = 1;//初始化语句
        while(i <= 100){//条件判断
            System.out.println("小松狮");//循环体
            i++;//步进语句
        }
    }
}
  • 循环语句3：do…while

标准格式：
do{
循环体
}while(条件判断)；
扩展格式：
初始化语句
do{
循环体
}while(条件判断)；

public class Demo11DoWhile {
    public static void main(String[] args){
        int i = 1;//初始化语句
        do {
            System.out.println("小松狮");//循环体
            i++;//步进语句
        }while (i <= 10);//条件判断
    }
}

//求出1-100之间的偶数和
//思路：
//1、既然范围以及确定了是1到100，那么就从1、2、3...一直到100一个一个进行检查
//2、总共100个数字，并非所有数字都能用，必须是偶数，判断（if语句）偶数：num%2 == 0
//3、需要一个变量，用来进行累加操作
public class Demo12HundredSum {
    public static void main(String args[]){
        int sum = 0;
        for (int i =1; i <= 100; i++){
            if (i % 2 == 0){
                sum += i;
            }
        }
        System.out.println("结果是："+ sum);
    }
}

public class Demo12HundredSum {
    public static void main(String args[]){
        int sum = 0;
        int i = 1;
        while (i <= 100){
            if (i %2 ==0){
                sum += i;
            }
            i++;
        }
        System.out.println("结果是："+sum);
    }
}

public class Demo12HundredSum {
    public static void main(String args[]){
        int sum = 0;
        int i = 1;
        do {
            if (i % 2 ==0) {
                sum += i;
            }
            i++;
        }while (i <= 100);
        System.out.println("结果是：" + sum);
    }
}

三种循环的区别：
1、如果条件判断从来没有满足过，那么for循环和while循环将会执行0次，但是do…while循环会执行至少一次
2、for循环的变量在小括号当中定义，只有循环内部才可以使用，while和do…while循环初始化语句本来就在外面，所以出来循环之后还可以继续使用

8.5 循环控制语句

break关键字的用法有常见的两种：
1、可以用在switch语句当中，一旦执行，整个switch语句立刻结束
2、还可以用在循环语句当中，一旦执行，整个循环语句立刻结束，打断循环
关于循环的选择，有一个小建议：
凡是次数确定的场景多用for循环，否则多用while循环

public class Demo14Break {
    public static void main(String[] args){
        for (int i = 1; i <= 10; i++){
            //如果希望从第4次开始，后续全都不要了，就要打断循环
            if (i == 4){//如果当前是第4次
                break;//那么就打断整个循环
            }
            System.out.println("小松狮"+ i );
        }
    }
}

另一种循环控制语句是continue关键字
一旦执行，立刻跳过当前次循环剩余内容，马上开始下一次循环

public class Demo15Continue {
    public static void main(String[] args){
        for (int i = 1; i <= 10; i++){
            if (i == 4){
                continue;
            }
            System.out.println( i + "层到了");
        }
    }
}

8.6 死循环

永远停不下来的循环，叫做死循环

死循环的标准格式：
while(true){
循环体
}

public class Demo16DeadLoop {
    public static void main(String[] args){
        while (true){
            System.out.println("小松狮哈哈哈");
        }
    }
}

8.7 循环嵌套

标准格式：
for(初始化表达式1；循环条件2；步进表达式3){
for(初始化表达式4；循环条件5；步进表达式6){
执行语句；
}
}

public class Demo17LoopHourAndMinute {
    public static void main(String[] args){
        for (int hour = 0; hour < 24; hour++){//外层控制小时
            for (int minute = 0; minute < 60; minute++){//内层控制分钟
                for (int seconds = 0; seconds <60; seconds++ ) {//控制秒
                    System.out.println(hour + "点" + minute + "分" + seconds + "秒");
                }
            }
        }
    }
}

第九节 方法

//5*10矩形打印
public class Demo01Method {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 10; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

9.1 方法格式

方法入门
定义格式：
public static void 方法名称(){
方法体
}
调用格式：
方法名称();
注意事项：
1、方法定义的先后顺序无所谓
2、方法定义必须是挨着的，不能在一个方法的内部定义另一个方法
3、方法定义之后，自己不会执行的，如果希望执行，一定要进行方法的调用

//5*10矩形打印
public class Demo01Method {
    public static void main(String[] args) {
        printMethod();
    }
    public static void printMethod(){
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 10; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

方法其实就是若干语句的功能集合

参数(原料)：就是进入方法的数据
返回值(产出物)：就是从方法中出来的数据

定义方法的完整格式：
修饰符 返回值类型 方法名称(参数类型 参数名称，…){
方法体
return 返回值；
}

修饰符：现阶段的固定写法，public static
返回值类型：也就是方法最终产生的数据结果是什么类型
方法名称：方法的名字，规则和变量一样，小驼峰
参数类型：进入方法的数据是什么类型
参数名称：进入方法的数据对应的变量名称
PS：参数如果有多个，使用逗号进行分隔
方法体：方法需要做的事情，若干行代码
return：两个作用，第一停止当前方法，第二将后面的返回值还给调用处
返回值：也就是方法执行后最终产生的数据结果
return后面的“返回值”，必须和方法名称前面的“返回值类型”，保持对应

9.2 方法调用

方法的三种调用格式：
1、单独调用：方法名称(参数);
2、打印调用：System.out.println(方法名称(参数));
3、赋值调用：数据类型 变量名称 = 方法名称(参数);
注意：此前学习的方法，返回值类型固定写为void，这种方法只能够单独调用，不能进行打印调用或赋值调用

//定义一个两个int数字相加的方法，三要素：
//返回值类型：int
//方法名称：sum
//参数列表：int a，int b
public class Demo02MethodDefine {
    public static void main(String[] args) {
        //单独调用
        sum(10, 20);
        System.out.println("--------");
        //打印调用
        System.out.println(sum(10, 20));//30
        System.out.println("--------");
        //赋值调用
        int number = sum(20, 30);
        System.out.println(number);//50
    }
    public static int sum(int a, int b){
        System.out.println("方法执行啦！");
        int result = a + b;
        return result;
    }
}

有参数：小括号当中有内容，当一个方法需要一些数据条件，才能完成任务的时候，就是有参数
例如两个数字相加，必须知道两个数字是各自多少，才能相加
无参数：小括号当中留空，一个方法不需要任何数据条件，自己就能独立完成任务，就是无参数
例如定义一个方法，打印固定10次HelloWorld

public class Demo03MethodParam {
    public static void main(String[] args) {
        method1(10, 20);
        System.out.println("-------");
        method2();
    }
    //两个数字相乘，必须知道两个数字各自是多少，否则无法进行计算
    //有参数
    public static void method1(int a, int b){
        int result = a * b;
        System.out.println(result);
    }
    //例如打印输出固定10次文本字符串
    //无参数
    public static void method2(){
        for (int i = 0; i < 5; i++) {
            System.out.println("小松狮" + i);
        }
    }
}

对于有返回值的方法，可以使用单独调用、打印调用或者赋值调用
对于无返回值的方法，只能使用单独调用，不能使用打印调用或赋值调用

public class Demo04MethodReturn {
    public static void main(String[] args) {
        int num = getSum(20, 30);
        System.out.println("返回值是" + num);
        printSum(10, 30);
        System.out.println(getSum(20, 50));//正确写法
        getSum(50, 60);//正确写法
        //对于void没有返回值的方法，只能单独调用
        //System.out.println(printSum(20, 30););//错误写法
        //int num2 = printSum(10, 50);//错误写法
    }
    //有返回值int，谁调用我，我就把计算结果告诉谁
    public static int getSum(int a, int b){
        int result = a + b;
        return result;
    }
    //没有返回值，不会把结果告诉任何人，而是自己打印输出
    public static void printSum(int a, int b){
        int result = a + b;
        System.out.println("结果是"+ result);

    }
}

//定义一个方法，用来判断两个数字是否相同
public class Demo05MethodSame {
    public static void main(String[] args) {
        System.out.println(isSame(10, 20));//false
        System.out.println(isSame(20,20));//true
    }
    public static boolean isSame(int a, int b){
        //boolean same;
        /*1、if (a == b){
            same = true;
        }else {
            same = false;
        }*/
        // 2、boolean same = a==b ? true : false;
        // 3、boolean same = a == b;
        return a == b;
    }
}

//定义一个方法，用来求出1-100之间所有数字的和值
public class Demo06MethodSum {
    public static void main(String[] args) {
        System.out.println("结果是"+getsum());
    }
    public static int getsum(){
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
             sum += i;
        }
        return sum;
    }
}


//定义一个方法，用来打印指定次数的小松狮
public class Demo07MethodPrint {
    public static void main(String[] args) {
        printCount(20);
    }
    public static void printCount(int num){
        for (int i = 1; i <= num; i++) {
            System.out.println("小松狮"+ i);
        }
    }
}

9.3 方法重载

对于功能类似的方法来说，因为参数列表不一样，却需要记住那么多不同的方法名称，太麻烦
方法的重载（Overload）：多个方法的名称一样，但是参数列表不一样
好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能

方法重载与下列因素相关：
1、参数个数不同
2、参数类型不同
3、参数的多类型顺序不同
方法重载与下列因素无关：
1、与参数的名称无关
2、与方法的返回值类型无关

public class Demo08MethodOverload {
    public static void main(String[] args) {
        System.out.println(sum(10,20));
    }
    public static int sum(int a, int b){
        System.out.println("两个参数的方法执行");
        return a + b;
    }
    public static int sum(int a, int b, int c){
        System.out.println("三个参数的方法执行");
        return a + b + c;
    }
    public static int sum(int a, int b, int c, int d){
        System.out.println("四个参数的方法执行");
        return a + b + c + d;
    }
}

//比较两个数据是否相等
//参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型
//并在main方法中进行测试
public class Demo09MethodOverloadSame {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        System.out.println(isSame(a , b));
        System.out.println(isSame((short)10,(short)20));
        System.out.println(isSame(20,10));
        System.out.println(isSame(10L,10L));
    }
    public static boolean isSame(byte a, byte b){
        System.out.println("两个byte参数的方法执行");
        boolean same;
        if (a == b){
            same = true;
        }else {
            same = false;
        }
        return same;
    }
    public static boolean isSame(short a, short b){
        System.out.println("两个short参数的方法执行");
        boolean same = a == b ? true : false;
        return same;
    }
    public static boolean isSame(int a, int b){
        System.out.println("两个int参数的方法执行");
        return a == b;
    }
    public static boolean isSame(long a , long b){
        System.out.println("两个long参数的方法执行");
        if (a == b){
            return true;
        }else {
            return false;
        }
    }
}

第十节 数组

数组：是一种容器，可以同时存放多个数据值
数组的特点：

  • 数组是一种引用数据类型
  • 数组当中的多个数据，类型必须统一
  • 数组的长度在程序运行期间不可改变

10.1 数组的初始化

概念：在内存当中创建一个数组，并且向其中赋予一些默认值

  • 两种常见的初始化方式：
  • 1、动态初始化(指定长度)
  • 2、静态初始化(指定内容)

动态初始化数组的格式：
数据类型[] 数组名称 = new 数据类型[数组长度]；
左侧数据类型：也就是数组当中保存的数据，全都是统一的什么类型
左侧中括号：代表我是一个数组
左侧数组名称：给数组取一个名称
右侧的new：代表创建数组的动作
右侧数据类型：必须和左边的数据类型保持一致
右侧中括号的长度：也就是数组当中，到底可以保存多少个数据，是一个int数字

public class Demo01Array {
    public static void main(String[] args) {
        //创建一个数组，里面可以存放300个int数据
        //数据类型[] 数组名称 = new 数据类型[数组长度];
        int [] arrayA = new int[300];
        //创建一个数组，能存放10个double类型的数据
        double [] arrayB = new double[10];
        //创建一个数组，能存放5个字符串
        String [] arrayC = new String[5];
    }
}
  • 动态初始化（指定长度）：在创建数组的时候，直接指定数组当中的数据元素个数
  • 静态初始化（指定内容）：在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定

静态初始化数组基本格式：
数据类型[] 数组名称 = new 数据类型[] {元素1，元素2，…}；
注意事项：
虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度
使用静态初始化数组的时候，格式还可以省略一下
省略格式：
数据类型[] 数组名称 = {元素1，元素2，…}；

public class Demo02Array {
    public static void main(String[] args) {
        //直接创建一个数组，里面装的全都是int数字，具体为：5、15、20
        int[] arrayA = new int[] {5,15,20};
        //创建一个数组，用来装字符串
        String[] arrayB = new String[] {"Hello","World","Java"};
    }
}

public class Demo03Array {
    public static void main(String[] args) {
        //省略格式的静态初始化
        int[] arrayA = {10, 20, 30};
        //静态初始化的标准格式，可以拆分成为两个步骤
        int[] arrayB;
        arrayB = new int[] {11, 21, 31};
        //动态初始化也可以拆分成为两个步骤
        int[] arrayC;
        arrayC = new int[5];
    }
}

注意事项：
1、静态初始化没有直接指定长度，但是仍然会自动推算得到长度
2、静态初始化标准格式可以拆分成为两个步骤
3、动态初始化也可以拆分成为两个步骤
4、静态初始化一旦使用省略格式，就不能拆分成为两个步骤了
使用建议：
如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化

10.2 访问数组

访问数组元素的格式：
数组名称[索引值]
索引值：就是一个int数字，代表数组当中元素的编号
【注意】索引值从0开始，一直到“数组的长度-1”为止

//直接打印数组名称，得到的是数组对应的：内存地址哈希值
public class Demo04ArrayUse {
    public static void main(String[] args) {
        int[] array = {10, 20, 30};
        System.out.println(array);//[I@119d7047
        System.out.println(array[0]);//10
        System.out.println(array[2]);//30
        int num = array[1];
        System.out.println(num);//20
    }
}

使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值，规则如下：
如果是整数类型，默认为0；
如果是浮点类型，默认为0.0；
如果是字符类型，默认为‘\u0000’；
如果是布尔类型，默认为false；
如果是引用类型，默认为null；
注意事项：
静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成了大括号当中的具体数值``

public class Demo05ArrayUse {
    public static void main(String[] args) {
        int[] array = new int[3];
        System.out.println(array);//内存地址值
        System.out.println(array[0]);//0
        System.out.println(array[2]);//0
        array[2] = 123;
        System.out.println(array[2]);//123
    }
}

10.3 内存划分

Java的内存需要划分成为5个部分：
1、栈(Stack)：存放的都是方法中的局部变量，方法的运行一定要在栈当中
局部变量：方法的参数，或者是方法{}内部的变量
作用域：一旦超出作用域，立刻从栈内存当中消失
2、堆(Heap)：凡是new出来的东西，都在堆当中
堆内存里面的东西都有一个地址值：16进制
堆内存里面的数据，都有默认值

如果是整数类型，默认为0；
如果是浮点类型，默认为0.0；
如果是字符类型，默认为‘\u0000’；
如果是布尔类型，默认为false；
如果是引用类型，默认为null；

3、方法区(Method Area)：存储.class相关信息，包含方法的信息
4、本地方法栈(Native Method Stack)：与操作系统有关
5、寄存器(pc Register)：与CPU相关

public class Demo06ArrayOne {
    public static void main(String[] args) {
        int[] array = new int[3];//动态初始化
        System.out.println(array);//地址值
        System.out.println(array[0]);//默认0
        array[1] = 10;
        array[2] = 20;
        System.out.println(array);//地址值
        System.out.println(array[0]);//默认0
        System.out.println(array[1]);//10
    }
}

public class Demo08ArraySame {
    public static void main(String[] args) {
        int[] arrayA = new int[3];//动态初始化
        System.out.println(arrayA);//地址值
        System.out.println(arrayA[0]);//默认0
        arrayA[1] = 10;
        arrayA[2] = 20;
        System.out.println(arrayA);//地址值
        System.out.println(arrayA[0]);//默认0
        System.out.println(arrayA[1]);//10

        //将arrayA数组的地址值，赋值给arrayB数组
        int[] arrayB = arrayA;//动态初始化
        System.out.println(arrayB);//地址值
        System.out.println(arrayB[0]);//默认0
        arrayB[1] = 100;
        arrayB[2] = 200;
        System.out.println(arrayB);//地址值
        System.out.println(arrayB[0]);//默认0
        System.out.println(arrayB[1]);//100
    }
}


/*
* 数组的索引编号从0开始，一直到“数组的长度-1”为止
* 如果访问数组元素的时候，索引编号不存在，那么将会发生数组索引越界异常
* ArrayIndexOutOfBoundsException
* 原因：索引编号写错
* 解决：修改成为存在的正确索引编号
* */
public class Demo09ArrayIndex {
    public static void main(String[] args) {
        int[] array = {15, 25, 35};
        System.out.println(array[0]);//15
        System.out.println(array[1]);//25
        System.out.println(array[2]);//35
        //System.out.println(array[3]);//错误写法，并不存在3号元素，发生数组索引越界异常
    }
}

//所有的引用类型变量，都可以赋值为一个null值，但是代表其中什么都没有
//数组必须进行new初始化才能使用其中的元素
//如果只是赋值了一个null，没有进行new创建，那么将会发生空指针异常
//NullPointerException
//原因：忘了new
//解决：补上new
public class Demo10ArrayNull {
    public static void main(String[] args) {
        int[] array = null;
        array = new int[3];
        System.out.println(array[0]);//0
    }
}

10.4 获取数组长度

如何获取数组的长度，格式：
数组名称.Length
这将会得到一个int数字，代表数组的长度

数组一旦创建，程序运行期间，长度不可改变

public class Demo11ArrayLength {
    public static void main(String[] args) {
        int[] arrayA = new int[3];
        int[] arrayB = {10, 20, 30,30,54,8,6,1,2,4,8,6,66,};
        int len = arrayB.length;
        System.out.println("arrayB数组的长度是" + len);//13
        int[] arrayC = new int[3];
        System.out.println(arrayC.length);//3
        arrayC = new int[5];
        System.out.println(arrayC.length);//5
    }
}

10.5 遍历数组

遍历数组：说的就是对数组当中的每一个元素进行逐一、挨个处理，默认的处理方式就是打印输出

public class Demo12Array {
    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50};
        System.out.println(array[0]);//10
        System.out.println(array[1]);//20
        System.out.println(array[2]);//30
        System.out.println(array[3]);//40
        //使用循环，次数其实就是数组的长度
        for (int i = 0; i < 4; i++) {
            System.out.println(array[i]);
        }
        int len = array.length;
        for (int i = 0; i < len; i++) {
            System.out.println(array[i]);
        }
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

//获取数组最大值
public class Demo13ArrayMax {
    public static void main(String[] args) {
        int[] array = {10, 35, 20, 60, 21};
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max){
                max = array[i];
            }
        }
        System.out.println("最大值" + max);
    }
}


/*
* 数组元素的反转：
* 本来的样子：【1，2，3，4】
* 之后的样子：【4，3，2，1】
* 要求不能使用新数组，就用原来的唯一一个数组
* */
public class Demo14ArrayReverse {
    public static void main(String[] args) {
        int[] array = {10, 20, 40, 50, 5, 30};
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        /*
        * 初始化语句：int min = 0, max = array.length - 1
        * 条件判断：min < max
        * 步进表达式：min++, max--
        * 循环体：用第三个变量倒手
        * */
        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.println(array[i]);
        }
    }
}

/*
* 数组可以作为方法的参数
* 当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值
* */
public class Demo15ArrayParam {
    public static void main(String[] args) {
        int[] array = {10, 20, 30, 50};
        System.out.println(array);//地址值[I@119d7047
        printArray(array);//传递进去的就是array当中保存的地址值
        System.out.println("AAA");
        printArray(array);
        System.out.println("BBB");
    }
    public static void printArray(int[] array){
        System.out.println("printArray方法收到的参数是：");
        System.out.println(array);//地址值[I@119d7047
            for (int i = 0; i < array.length; i++) {
                System.out.println(array[i]);
            }
    }
}

/*
* 一个方法可以有0、1、多个参数；但是只能有0或者1个返回值，不能有多个返回值
* 如果希望一个方法当中产生了多个结果数据进行返回
* 解决方法：使用一个数组作为返回值类型即可
*
* 任何数据类型都能作为方法的参数类型，或者返回值类型
* 数组作为方法的参数，传递进去的其实是数组的地址值
* 数组作为方法的返回值，返回的其实也是数组的地址值
* */
public class Demo16ArrayReturn {
    public static void main(String[] args) {
        int[] result = calculate(10, 50, 60);
        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 = new int[2];
        array[0] = sum;
        array[1] = avg;
        //int[] array = {sum, avg};
        return array;
    }
}
小松狮
关注
专栏目录
Java方法重载（OverLoad)
qq_45789558的博客
08-28 423
【代码】Java方法重载（OverLoad)
public class 和 class的使用注意
Bear的博客
06-29 8197
public class 后面跟的是这个类的名字 而且关键的是一个类文件里面只能声明一个public class无法声明多个，否则就会报错 报错The public type boyd1 must be defined in its own file，也就是说公共文件类型必须在自己的文件里面定义，也符合上面的规定public class后面跟自己的类文件名 但是可以允许声明多个类文件 ...
Java基础28（方法重载）
chenjiap的博客
09-01 691
方法重载的概念及使用方法
JAVA初学者需要知道什么?
m0_61651765的博客
01-19 319
1、public class 后面的名字必须和你的java源程序文件名一样。比如: 文件名为Love.java，那么程序代码显示为public class Love。 2、必须有一个main函数。就是说，必须有这一行public static void main(String[ ] args)，除了可以把 String[ ] args 改为 String args[ ]，其它地方不可以改动。有了这一行，代码才可以运行。仅有一种情况，使用静态代码块绕过java对函数的检测时不需要这一行。 3、花括号必须配
定义三个重载方法max()，第一个方法求两个int值中的最大值，第二个方法求两个double值中的最大值，第三个方法求三个double值中的最大值，并分别调用三个方法。
Madge_jodie的博客
10-22 5130
重载方法练习2：定义三个重载方法max()，第一个方法求两个int值中的最大值，第二个方法求两个double值中的最大值，第三个方法求三个double值中的最大值，并分别调用三个方法。 方法1： public class Circle { public void max(int x,int y) {//求两个int值中的最大值 if(x > y) { System.out.println("最大值是：" + x); } else { System.out.println("最
Java基础[02-Java基础语法1].ppt
11-30
本章节讲的是java基础部分，主要涉及的方面是:注释、标识符、关键字、类型转换、常量、运算符、数据类型、语句这几个方面的相关知识讲解
Java入门之~Java基础语法
Ara-追着风跑
03-12 7202
Java入门之基础语法篇，收藏学起来
Java基础语法练习.zip
08-12
这个"Java基础语法练习.zip"文件显然旨在帮助初学者巩固和理解Java的基础知识。下面，我们将详细探讨其中涉及到的一些核心概念。 1. **打印三角形**： 在Java中，打印三角形通常涉及到循环和字符串拼接。例如，...
Java基础语法)教案
04-05
### Java基础语法教案知识点解析 #### 一、Java开发环境搭建 **1.1 Java语言概述** - **视频摘要:** 引入Java语言的历史和发展，包括它的起源、发展历程及其广泛的应用场景。通过介绍Java的特点（如面向对象、跨...
【JavaSE】方法重载基本使用
兮动人
10-06 364
方法重载(OverLoad) 1. 基本介绍 java 中允许同一个类中，多个同名方法的存在，但要求 形参列表不一致！ 比如：System.out.println(); out 是 PrintStream 类 2. 重载的好处 减轻了起名的麻烦 减轻了记名的麻烦 3. 快速入门案例 OverLoad01.java 案例：类：MyCalculator 方法：calculate calculate(int n1, int n2) //两个整数的和 calculate(int n1, double
（C++实例）编写重载函数Max1分别求取两个整数，三个整数，两个双精度数，三个双精度数的最大值。
热门推荐
m0_54158068的博客
04-19 1万+
（C++实例）编写重载函数Max1分别求取两个整数，三个整数，两个双精度数，三个双精度数的最大值。
用重载函数分别实现求10个整型数据的最大值、三个浮点型数据的最大值
wuwuliuliu0524的博客
11-11 1643
#include<iostream> using namespace std; int main() { float a[3]; int i, b[10]; void print(float a[3]); cout << "请输入3个浮点数" << endl; for (i = 0;i < 3;i++) cin >> a[i]; print(a); cout << end...
第二节 HelloWorld案例
小灰灰的博客
08-07 145
HelloWorld案例前言一、HelloWorld程序的代码编辑二、HelloWorld程序的代码编译三、HelloWorld程序常见问题四、HelloWorld程序注释总结 前言 初学java语言的小白，日常记录个人所学、所思、所感、所获。 请java语言行业的前辈们多多指教， 目前从事汽车制造行业。 属于零基础自学，愿未来自己感谢今天的选择和努力。加油！ 一、HelloWorld程序的代码编辑 2021、8、5更新 笔记：了解二进制与十进制的关系转换 二、HelloWorld
建立类Max，利用方法重载建立max()方法分别输出2个数中的最大值以及3个数中的最大值。
自强不息 厚德载物
03-27 5412
public class  Max{ int a,b,c; void setA(int a){ this.a=a; } void setB(int b){ this.b=b; } void setC(int c){ this.c=c; } void Max(int x,int y){ int s; if (x>y) s=x; else s=y; System.
java 静态变量声明_java静态变量怎么声明？
weixin_36022526的博客
02-12 3986
展开全部个人的总结1 静态变量e69da5e6ba9062616964757a686964616f31333337616564只有一份被类的所有实例共享2 静态变量的声明在编译时已经明确了内存的位置3 延迟初始化是改变静态变量的值引用Java静态变量的初始化(static块的本质)在网上看到了下面的一段代码：1. public class Test {2. static {3. ...
JAVA
weixin_60475929的博客
11-02 1230
软件开发 软件，即一系列按照特定顺序组织的计算机数据和指令的集合，有系统软件和应用软件 del *.txt (.txt文件全部删去） jvm可以使程序在三个不同的操作系统都可执行
java中使用 类来管理和处理文件名_Java中类名与文件名的关系
weixin_42501035的博客
02-16 319
1.Java保存的文件名必须与类名一致；2.如果文件中只有一个类，文件名必须与类名一致；3.一个Java文件中只能有一个public类；4.如果文件中不止一个类，文件名必须与public类名一致；5.如果文件中不止一个类，而且没有public类，文件名可与任一类名一致。当编写一个Java源代码文件时，此文件通常被称为编译单元(有时也称为转译单元)。每个编译单元都必须要有一个后缀为.java，而在编...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值