JAVA基础-1
终于是又开坑学java了，简单记录一下自己的java学习笔记。毕竟是网安跨不过的坎，本文可能有些长，供作者自己学习。
开发步骤
1.编写代码
注意：
（1）代码的结构
类{
方法{
语句;
}
}
（2）必须把代码文件保存为xx.java
文件名建议和类名一样
2.编译
编译工具：javac.exe
使用格式：javac xx.java
3.运行
工具：java.exe
格式：java 主类名（包含main方法的类名）
helloworld
public class helloworld{
public static void main(String[] args){
System.out.println("hello world");
}
}
其中有一个方法public static void mian(String[] args)这是最特殊的一个方法，叫做主方法，main方法。他是java程序的入口。他的格式是固定的。
基础知识
中文编码问题
如果xx.java文件的编码是UTF-8的，又不想改文件的编码，所以在编译的时候，可以加一个参数-encoding UTF-8
除了在编译的时候使用指定编码进行编译，也可以通过编辑器上面的选项来进行修改文件本身的编码。
大小写问题
java代码中是严格区分大小写的。
但是在编译的时候，其文件名是可以随意大小写的。注意：只是在编译的时候，运行的时候，文件名是不可以随意大小写的。（win系统）
xx.class文件的文件名也是区分大小写的。因为xx.class文件名，代表的就是类名。
文件名和类名的一致问题
如果class不是public的，那么xx.java源文件名可以和类名不一样
如果class是public的，那么xx.java源文件名必须和类名一样
所以建议都保持一致即可。
java关键字
关键字：有特殊意义的和特殊作用的单词，java一共有50个关键字。
其中还有两个保留字，相当于还未正式启用的关键字。（const,goto）他俩是c语言的关键字，但是java没有用它。
还有三个特殊值，他们不是关键字，但是又特殊意义。他们不在关键字表中：true,false,null
值得注意的是，50个关键字全部都是小写的。
标识符
凡是代码中需要自己“命名”的地方都是标识符。给变量、类、方法等命名的字符序列就是标识符。
标识符的命名规则：
1.只能使用26个英文字母大小写，数字0-9，下划线_，美元符号$
按理说，所有unicode编码中的字符都能用，但是对于中文来说，还要解决编码问题，所以不要用
2.数字不能开头
3.不能直接使用关键字，保留字，特殊字，但是可以包含。
4.严格区分大小写
5.不能包含空格
命名规范（人为规定）：
1.见名知意
2.类名，每个单词的首字母大写
3.变量名，方法名：从第二个单词开始首字母大写
4.包名，所有单词都小写，单词与单词之间使用.分隔。
5.常亮所有单词都大写
数据类型
java的数据类型主要分为两大类
第一种是基本数据类型（8种，延续的c语言中的数据类型，因为java是由c语言发展而来）
整数类型：byte,short,int,long
小数类型：float,double 这两种都叫做浮点型，不精确
单字符类型：char
布尔型：boolean 只有两个值，true,false
第二大类是应用数据类型：
数组，类，接口，枚举，注解等。
常量
代码里面写死的，固定不变的。
如下就是整数常量值1.
public class ConstantValue{
public static void main(String[] args){
System.out.println(1);
}
}
变量
变量必须先声明后使用
变量在使用之前必须初始化
变量值的类型必须与变量申明的类型一致或者兼容
变量有作用域，同一个作用域中不能重复申明
public class Variable{
public static void main(String[] args){
int age = 1;
System.out.println(age);
age = 3;
System.out.println("年龄：" + age);//java中也可以使用加号进行拼接，输出的时候拼接就可。
}
}
最终变量\常量
这算是一个特殊的常量或者变量。也就是申明了一个变量之后，这个变量在整个代码中不能更改，申明一个最终变量就可以了。
如何申明，将变量申明为final，如下
final int max = 150;
进制的表示
值得注意的是，输出的时候都是以十进制的形式来输出的。
程序中表示字符的方法
在java中除了直接用双引号表示的字符之外，也可以用数字的形式来定义一个字符。
如下
public class TestChar{
public static void main(String[] args){
char c1 = 'a';
char c2 = 97;
System.out.println(c1);
System.out.println(c2);
}
}
输出的就是两个a，因为在unicode编码中，97就是a。（编码可以使用十六进制或者十进制）
注意：部分字符需要转义的方式使用，比如说\，换行符，单引号，双引号等等
基本数据类型的转换问题
基本数据类型的转换分为两种：自动类型转换（隐式转换），强制类型转换（显式转换）
（1）自动类型转换
A：当把存储范围小的值（常量值，变量值，表达式的结果值）赋值给存储范围大的变量时，就会发生自动类型转换。
byte->short->int->long->float->double
值得注意的是，short和char同级。
B：当多种数据类型的数据混合运算时，会自动提升为他们中存储范围最大的哪一个。
如果将char加上整数型，那么表达式的结果就是整数型。
（2）强制类型转换
想要将数据或者变量强制转换成响应的类型可以使用如下语法
byte b1 = 127;
byte b2 = 2;
int b3 = b1 + b2;//b1+b2自动提升为int类型
byte b4 = (byte)(b1+b2);//强制转换为byte类型
扩展：
虽然字符串类型不是基本数据类型，但是还是值得说一下的。
我们运行如下代码
public class TestChar{
public static void main(String[] args){
char c1 = 'a';
char c2 = 'b';
System.out.println(c1 + c2);
System.out.println("c1+c2="+c1+c2);
System.out.println(c1 + c2 + "");
System.out.println(c1 + "" + c2);
}
}
输出结果为：
195 //char+char自动提升为int类型
c1+c2=ab //前面的"c1+c2="属于的是string常量，一旦这个常量参与了，后面的加号就变成了“拼接”。
195 //虽然后面有一个空字符串，但是因为我们先计算的前面两个值。
ab //因为空字符串在中间，所以加号代表的就是拼接。
运算符的分类
运算符有两种分类标准。
A：按照运算符的功能分类
1.算术运算符：
加减乘除，模取余（模和取余在java中是一样的）
自增，自减 ++
正负号
2.比较运算符/关系运算符
大于小于，大于等于，大于小于，等于，不等于
3.逻辑运算符
逻辑与：&
逻辑或：|
逻辑非：!
逻辑异或：^
短路与：&&
短路或：||
4.条件运算符
条件表达式 ? 结果表达式 : 结果表达式
5.位运算符
左移：<<
右移：>>
无符号右移：>>>
按位与：&
按位或：|
按位取反:~
按位异或：^
6.赋值运算符
=,+=,-=,/=,&=等等
扩展
在处理自增的时候，java优先从左开始
java反编译
可以通过在命令行中是用javap命令来进行反编译任意一个java类，-c参数代表打印类中每个方法的反汇编代码，例如包含java字节码的指令。
运算符优先级
IDEA开发工具
安装卸载我这里就不写啦，之前安装过了，而且网上有很多教程
创建空工程和模块
在创建工程的时候，可以先创建一个空工程，没有必要马上创建一个java工程。
在空工程中创建一个新的模块，在选模块的时候就可以选择java模块。方便。
快捷键与代码模板介绍
按两次shift就可以弹出搜索框，可以搜索任何东西，不过中英文的切换导致一直弹出也不好，可以自行选择取消。
在对的位置输入main之后，按下回车就可以自动生成主方法的代码，也就是public static void main(String[] args){}
同样，输入sout之后按下回车就可以自动填充输出的代码，也就是System.out.printlb("")
psvm:public static void main(String[] args){}
main:public static void main(String[] args){}
soutp:System.out.println("xxx:"+方法形参);
soutm:System.out.println("xx类，当前方法名");
soutv:System.out.println("变量名="+变量);
变量.sout:System.out.println("变量名="+变量);
注释快捷键
单行注释：ctrl+/
多行注释：ctrl+shift+/
复制行：ctrl+D
剪切行：ctrl+X
删除行：ctrl+Y
变量重命名
选中变量声明的位置：shift+f6
格式化代码
ctrl+alt+L
转换大小写
ctrl+shift+U
自动声明变量接收方法调用表达式结果
ctrl+v
移动单行代码
ctrl+shift+↑(↓)
光标定位在红的地方，智能提示错误
alt+回车
流程控制语句
表达式和语句
java中有：
（1）常量和变量：代表数据值
（2）表达式
计算和判断、赋值表达式
方法调用表达式（听名字就感觉是一个函数然后返回一个值）
（3）语句
不是所有的表达式直接加分号都可以构成语句，只有部分可以，例如：
A：方法调用表达式
B：new表达式
C：自增自减表达式
语句的分类：
两大类：
单语句：独立一条语句，例如System.out.println("");（特殊的单语句，空语句，就是一个分号;）
复合语句：多语句组成一个整体。通常都会用{}把多个语句包围起来。例如ifelse。
复合语句因为有很多语句组成，所以有流程控制语句概念：
（1）顺序结构：从上往下依次执行
（2）分支结构：多个语句可能只执行其中一个
（3）循环结构：某个语句会被反复或者重复执行
几种输出语句
System.out.println(""); //输出并换行，（）中只能写一个值，如果有多个值必须使用加号拼接起来。
System.out.print(""); //这个东西不能输出空行，上面可以。
第三种作为了解，名字为格式化输出。就是py里面的感觉就是，可以用%d来当做占位符，下面将演示一下。
输出不同的数据类型，并且小数显示小数点后两位。也就是System.out.printf("num=%d",num)
各种类型的数据输入
控制台键盘输入：
1.先声明一个scanner类型的变量
scanner：是一个文本扫描仪类型，他的全名是java.util.Scanner,她的核心是类库中定义好的，可以直接使用
Scanner是一个类，不是基本数据类型，是引用数据类型，所以必须给他赋值一个“对象”。
2.接收用户输入的数据，并且赋值给何时的变量
scanner声明小技巧：
//java.util.Scanner input = new java.util.Scanner(System.in);
//int Anint = input.nextInt();
先在上面加入导包语句，随后可以简单的调用
import java.util.Scanner;
Scanner input = new Scanner(System.in);
//这句代码唯一可以改的是input，他是一个变量名。
像上面使用的方法nextInt其他数据类型都可以替换int，除了字符串类型
input.next(); //接收一个字符串，很多个字符
input.next().charAt(0); //表示从多个字符中取一个字符，取第一个，那个0就是顺序之类的。
注意，在使用完之后，需要使用代码input.close()将这个东西关闭，避免占领过多的内存！
扩展：
next()和nextlint()的区别
next方法，在读取用户输入的数据时，遇到空格或者是其他的空白符，tab之类的，就会认为输入结束。
同时，nextint方法不会读取回车或者换行符，所以如果使用的nextint方法，必须要使用nextline将回车读取掉才可以。
练习，输出个人信息
就是让用户输入个人信息，用变量存储，然后依次输出即可，本身就有代码基础，写这个练习单纯是为了更方便适应java的开发。
public class hello {
public static void main(String[] args) {
System.out.println("请输入您的姓名：");
java.util.Scanner input = new java.util.Scanner(System.in); //声明了一个类
String name = input.nextLine();
System.out.println("请输入您的年龄");
int age = input.nextInt();
input.nextLine(); //将回车读取掉
System.out.println("请输入您的性别：");
String sex = input.nextLine();
System.out.println("以下是您的个人信息：");
System.out.println("姓名："+name);
System.out.println("年龄："+age);
System.out.println("性别："+sex);
input.close();
}
}
双分支条件判断else..if..
用以下例子来进行学习
//从键盘输入一个整数，如果是偶数，就输出偶数，否则就输出技术。
import java.util.Scanner;
public class hello {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入一个整数：");
int num = input.nextInt();
input.nextLine(); //将回车读取掉
if(num%2 == 0){
System.out.println(num+"是偶数");
}else{
System.out.println(num+"是奇数");
}
}
}
多分支条件判断
if(){
}else if(){
}else{
}
大概就这样，执行特点：
（1）从上往下执行，如果上面的条件成立了，下面的条件就不会判断了。
选择结构switch case
switch(表达式){
case 常量值1:
语句块1
case 常量值2:
语句块2
default:
}
特点:
1.入口
2.出口
3.一旦找到入口，就会一直执行下去，直到找到出口。必须要在里面加入出口的语句。（穿透性，有些地方可以利用，还是py好啊，什么穿透性不穿透性，太麻烦了。）
也就是必须要加入break或者return
值得注意的是，case后面只能是常量，不能使用变量！
循环结构 while
首先值得注意的是，无论哪种循环都可以是实现其他循环达到的事情。
while(循环条件){
循环体语句块;
}
特点
1.先判断循环条件表达式，如果成立就执行循环语句块
循环结构 do..while
do{循环体语句块;
}while(循环条件)
例子:
import java.util.Scanner;
public class hello {
public static void main(String[] args) {
int i = 1;
do{
i++;
}while(i < 10);
System.out.println(i);
}
}
特点：
1.首先是执行do里面的东西，再进行判断。也就是至少会执行一次循环体结构。
2.do while语句的while后面有一个分号
关键字continue和break
break：
中断，用于switch和循环结构。
作用是，结束本层循环。
continue：
继续，只能用于循环结构。
作用是，提前结束本次循环。
数组
什么是数组：
数组代表一组数
数组是一组相同数据类型的元素（数据）按照一定顺序排列的集合。
其中每一个元素我们通过索引进行区分。索引从零开始
一组数据的总个数称为数组的长度（length）
数组的分类：
根据维度分：一维数组和二维数组
定义以及使用
声明一个数组的语法如下：
//元素的数据类型[] 数组名;
int[] num;
int[] num ={1,2,3};
数组名.length
使用这个可以获取数组的长度
//数组名[索引]
//可以用来访问数组元素
import java.util.Scanner;
public class hello {
public static void main(String[] args) {
int[] num ={1,2,3};
System.out.println(num[0]);
}
}
遍历，可以用for循环遍历。例子如下
public class hello {
public static void main(String[] args) {
int[] num ={100,100,70,70};//存储考研四科的成绩
for(int i = 0;i<num.length;i++){
System.out.println("这一科为："+num[i]);
}
}
}
一维数组的内存分析
数组有几个特点：
1.数组的长度一旦确定就不能修改，感觉和py不一样。
2.数组的元素是联系存储的，即数组是需要在内存中开辟一整块的存储空间。
3.因为是连续的，数组元素的访问速度是非常快的。
JVM java虚拟机
其在运行时，分为几个部分：
1.方法区：存储已经被虚拟机加载的类信息，常量，静态变量，即时编译器编译后的代码等数据
2.堆内存：存储对象（包括数组对象），new来创建的，都存储在堆内存
3.java虚拟机栈：用于存储正在执行的每个java方法的局部变量表等。局部变量表存放了编译器可知长度的各种基本数据类型、对象引用，方法执行完，自动释放
4.本地方法栈：当程序中调用了native的本地方法时，本地方法执行期间的内存区域
5.程序计数器：CPU中的寄存器，他包含每一个线程下一条要执行的指令的地址
public class hello {
public static void main(String[] args) {
int[] num = new int[3];
System.out.println(num);//[I@4554617c
}
}
//num是数组名，同时也是变量，是一个应用数据类型的变量。他里面存储的是地址值。
//new了一个数组之后，jvm就会存储他的首地址和占用内存，这样就可以通过这两个值找到所有的元素。
//虽然num里面存储的是首地址，但是和真实的首地址还是不能划等号，因为java不会对外暴露内存地址。本质上：I代表的是int內型，@后面的数字是数组对象的hashCode值的十六进制值。
//hashCode：就是一个数字，有点像身份证号码。只有当对象存储到哈希表等哈希结构的容器中才有用。
扩展：
java中自动打印一个对象，会自动调用它的toString方法。
而在默认库的定义中，toString方法return的就是一个，內型名称@"Integer.toHexString(hashCode())"
所以直接println(num)和println(num.toString())返回值是一样的
变量：
基本数据类型的变量：存数据值
引用数据类型的变量：存地址值
结论
1.数组的元素是存储在堆中
2.数组的元素是连续存储的
3.数组名是记录数组对象的首地址
4.下标[0]开始，表示第一个元素不用跨过任何元素，从首地址直接取值
数组的算法：元素统计
数组的基础算法：
1.对数组元素的统计：
统计偶数的个数、正数的个数，累计和，求平均值
public class hello {
public static void main(String[] args) {
int[] arr = new int[10];
for(int i = 0;i<arr.length;i++){
arr[i] = (int)(Math.random()*100);
}
//统计里面偶数的个数，元素的总和，平均值，所有元素的乘积
int count = 0;
double sum = 0;
int multiply = 1;
double average;
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
for(int i=0;i<arr.length;i++){
sum += arr[i];
multiply *= arr[i];
}
average = sum/arr.length;
for(int i=0;i<arr.length;i++){
if(arr[i] % 2 == 0){
count += 1;
}
}
System.out.println("总和："+sum);
System.out.println("偶数的个数："+count);
System.out.println("平均值："+average);
System.out.println("所有元素的乘积："+multiply);
}
}
二维数组的初始化
分为动态初始化和静态初始化：
1.静态初始化
数组名 = new 元素的数据类型[][]{{},{}}
2.动态初始化
就是通过内外循环，分别给列和行赋值即可。额感觉太麻烦了吧。
IDEA的单步调试Debug
Debug的步骤：
1.打断点，在代码的左边（行号）的位置单击出现小红圈，就是断点
2.以Debug模式运行
3.单步调试
Step Over（f8）
往下走一行。
面向对象基础
面向对象编程思想
面向过程：
1.以步骤为核心
2.代码的结构以函数为单位，程序是由一个一个函数组成
3.数据是在函数内核函数歪，内部是局部数据，外部是全局数据。
面向对象：
1.以类和对象为核心的
2.代码的结构是以类为单位。程序是由一个一个类组成的。
3.数据是在类里面的。数据分为类中方法外和类中方法内。
类和对象的定义
一类事物的一个具体实实在在的个体。
类是很多对象共同特征的描述的提取
写代码的角度：先有类，再有对象，没有类就无法new一个对象。
下面先举一个小例子：
public class hello {
String name;
int age;
char gender;
void eat(){
if(age >=25 && age <= 60){
System.out.println("吃的口味比较重");
}
if (age < 25 || age >60){
System.out.println("吃的口味比较清淡");
}
}
}
//其中eat()就是方法。
以上定义了一个类，那么我们可以通过一个类，来创建一个对象。
class test{
public static void main(String[] args) {
hello teacher1 = new hello();
teacher1.age = 19;
teacher1.name = "dhk";
teacher1.gender = '女';
teacher1.eat();
}
}
//new了一个名为teacher1的对象，输出结果是
//吃的口味比较清淡
类的声明格式：
类的定义/声明格式：
【修饰符】class 类名{
}
【修饰符】可以缺省：
后面也会学习更多的修饰符详细内容
这里补充一下，如果class前面有public，那么就要求.java文件的名字必须和这个class名完全一致。
同时，如果有public那么这个类就可以跨包使用，如果没有的话，就不可以跨包使用。
下面讲一下对象的定义语法格式：
new 类名(实参列表)//吐过没有把对象复制给一个变量，那么这个对象就是一个匿名对象，匿名对象打印出来同样也是hash
hello teacher1 = new hello();//将对象放到一个变量中
//如果希望一个对象反复使用，那么就把对象给到一个变量中
成员变量
1.成员变量声明的位置，必须在类中方法外。
2.成员变量声明的格式
【修饰符】 class 类名{
【修饰符】 数据类型 变量名;
}
数据类型可以是八种数据类型，也可以是引用数据类型。
public class test{
int a = 1;//成员变量
}
同时需要注意的是：成员变量定义之后是默认有值的，在其他类没有赋值成员变量的时候引用，那么就是使用的默认值。
包
包的作用：
1.避免类的重名
2.组织管理不同模块的类
3.可以限定部分类或成员的可见性范围
如何声明包：
package 包名;
要求：
1.一个.java文件只能有一句package，并且必须放在代码首行
2.如果某个.java文件声明了一个package语句，那么这个.java文件必须在对应的目录结构中
包命名的规则和规范：
1.命名规则和其他的标识符一样
2.命名规范
所有单词都小写，每一个单词之间使用点来分隔，每一个点代表一级目录
跨包的使用方法：
1.使用类的全名称
2.使用import语句导包
导入包的时候可以使用如下语句进行简化：
import com.test.package.*;//其中*代表的是省略的类名。
实例变量的内存分析
java对象保存在内存中时，由以下三部分组成：
对象头：
1.mark word：记录了和当前对象有关的GC、锁等信息。
2.指向类的指针
3.数组长度
实例数据：
即实例变量的值
对齐填充：
因为JVM要求java对象占的的内存大小应该是8bit的倍数，如果不满足该大小，则需要补齐至8bit的倍数，没有特别的功能。
每一个对象的实例变量值在内存中都有自己的独立的内存空间。
面向对象小练习-员工和生日类
这里做一个小扩展吧，员工和生日类，
三个文件
//主文件
package TEST;
import TEST.Employee.*;
public class test {
public static void main(String[] args) {
Employee e1 = new Employee();
e1.name = "dhk";
//值得注意的是MyDate是引用数据类型，那么凡是引用数据类型，就要赋值对象。
//e1的birthday在员工类中就声明了，在这里就只需要赋值。
e1.birthday = new MyDate();
e1.birthday.year = 2000;
e1.birthday.month = 12;
e1.birthday.day = 1;
e1.age = 20;
e1.info();
}
}
//员工类文件
package TEST;
public class Employee {
String name;
int age;
MyDate birthday;
void info(){
System.out.println("我是名为"+name+"的员工，生日是"+birthday.year+"-"+birthday.month+"-"+birthday.day+
"，今年"+age+"岁了");
}
}
//MyDate类文件
package TEST;
public class MyDate {
int day;
int month;
int year;
}
我是给他们放一个包里面的，大概流程是首先定义了一个MyDate类，然后员工类文件中引用了这个类，在主文件又引用了员工类的文件。但是值得注意的是，一旦使用了引用数据类型，必须先赋值一个对象。
输出：
我是名为dhk的员工，生日是2000-12-1，今年20岁了
方法的概念、声明和调用
什么是方法？
方法，又称函数，他代表一段独立的可复用的功能代码。
例如：
Math.random() //random()他是一个方法
方法的特点/原则：
1.必须先声明后使用
2.方法不能嵌套定义
3.格式：
【修饰符】 class类{
【修饰符】 返回值类型 方法名(【形参列表】){
方法体语句
}
}
4.方法名从第二个单词首字母开始大写
返回值类型：
这个方法完成指定功能后，需要返回的结果值的类型。
如果没有结果值返回，那么就要用void。
如果有结果值返回，那么就必须用对应的数据类型表示。
演示：
package TEST;
//这是主类
public class test {
public static void main(String[] args) {
MyMathTools tools = new MyMathTools();//在使用的时候需要先创建一个对象，用这个对象再调用它里面的方法
int re = tools.add(4,9);
System.out.println(re);
}
}
package TEST;
//这是MyMathTools类
public class MyMathTools {
public int add(int a,int b){ //没有返回值就把int换成void就可以了
int sum = a+b;
return sum;
}
}
方法调用内存分析
方法不调用不执行，调用一次执行一次，每次调用会在栈中有一个入栈动作，即给当前方法开辟一块独立的内存区域，用于存储当前方法的局部变量的值，当方法执行结束后，会释放该内存，称为出栈，如果方法有返回值，就会把结果返回调用处，如果没有返回值，就直接结束，回到调用处结束执行下一条指令。
实例变量与局部变量的区别
1.声明的位置和方式
实例变量：在类中方法外
局部变量：在方法体{}中或方法的形参列表、代码块中。
2.内存中存储的位置不同
实例变量：堆
局部变量：栈
3.生命周期
实例变量：跟随对象创建。随着对象消亡
局部变量：随着方法调用，方法结束消亡
4.作用域
实例变量：通过对象就能使用
局部变量：出了作用域就不能使用
5.修饰符
实例变量：public,protected,private,final,volatile,transient
局部变量：final
6.默认值
实例变量：有默认值
局部变量：没有，必须手动初始化。其中的形参比较特殊，靠实参给他初始化。
形参和实参的概念
1.形参
在声明方法时，()中声明的变量，没调用这个方法之前，他的值是不确定的。
需要传入实际的数据，他才有意义。
2.实参
在调用方法时，()中传入的数据，他可能是常量值，也可能是变量，也可能是表达式。
扩展：
可变参数：
在JDK1.5之后，当定义一个方法时，形参的类型可以确定，但是形参的个数不确定，那么可以考虑使用可变参数，可变参数的格式
【修饰符】 返回值类型 方法名(【非可变参数部分的形参列表，】参数类型...形参名){ }
可变参数的特点和要求：
1.一个方法只能有一个可变参数
2.如果一个方法包含可变参数，那么可变参数必须是形参列表的最后一个
3.在声明它的方法中，可变参数当成数组使用
4.其实这个书写"≈"
//可变参数扩展案例：写一个方法实现整数相加
//这是主类，调用tools的addall方法来实现4和9的相加。
package TEST;
public class test {
public static void main(String[] args) {
MyMathTools tools = new MyMathTools();
int re = tools.addall(4,9);
System.out.println(re);
}
}
//这是MyMathTools类定义了一个方法addall
package TEST;
public class MyMathTools {
public int addall(int...ints){
int sum = 0;
for(int i=0;i < ints.length;i++){
sum += ints[i];
}
return sum;
}
}
转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。后续可能会有评论区，不过也可以在github联系我。