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，如下

1	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.赋值运算符
=,+=,-=,/=,&=等等

扩展

1	在处理自增的时候，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("变量名="+变量);

1
2
3

注释快捷键
单行注释：ctrl+/
多行注释：ctrl+shift+/

1
2
3

复制行：ctrl+D
剪切行：ctrl+X
删除行：ctrl+Y

1 2	变量重命名选中变量声明的位置：shift+f6

1 2	格式化代码 ctrl+alt+L

1 2	转换大小写 ctrl+shift+U

1 2	自动声明变量接收方法调用表达式结果 ctrl+v

1 2	移动单行代码 ctrl+shift+↑(↓)

1 2	光标定位在红的地方，智能提示错误 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，除了字符串类型

1 2	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

首先值得注意的是，无论哪种循环都可以是实现其他循环达到的事情。

1
2
3

while(循环条件){
    循环体语句块;
}

1 2	特点 1.先判断循环条件表达式，如果成立就执行循环语句块

循环结构 do..while

1 2	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
2
3

特点：
1.首先是执行do里面的东西，再进行判断。也就是至少会执行一次循环体结构。
2.do while语句的while后面有一个分号

关键字continue和break

break：
中断，用于switch和循环结构。
作用是，结束本层循环。

continue：
继续，只能用于循环结构。
作用是，提前结束本次循环。

数组

什么是数组：
数组代表一组数
数组是一组相同数据类型的元素（数据）按照一定顺序排列的集合。
其中每一个元素我们通过索引进行区分。索引从零开始
一组数据的总个数称为数组的长度（length）

1 2	数组的分类：根据维度分：一维数组和二维数组

定义以及使用

声明一个数组的语法如下：

1
2
3

//元素的数据类型[] 数组名;
int[] num;
int[] num ={1,2,3};

1 2	数组名.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

变量：
基本数据类型的变量：存数据值
引用数据类型的变量：存地址值

结论
1.数组的元素是存储在堆中
2.数组的元素是连续存储的
3.数组名是记录数组对象的首地址
4.下标[0]开始，表示第一个元素不用跨过任何元素，从首地址直接取值

数组的算法：元素统计

1
2
3

数组的基础算法：
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.数据是在类里面的。数据分为类中方法外和类中方法内。

类和对象的定义

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那么这个类就可以跨包使用，如果没有的话，就不可以跨包使用。

下面讲一下对象的定义语法格式：

1
2
3

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类，然后员工类文件中引用了这个类，在主文件又引用了员工类的文件。但是值得注意的是，一旦使用了引用数据类型，必须先赋值一个对象。

1 2	输出：我是名为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

1.声明的位置和方式
实例变量：在类中方法外
局部变量：在方法体{}中或方法的形参列表、代码块中。

1
2
3

2.内存中存储的位置不同
实例变量：堆
局部变量：栈

1
2
3

3.生命周期
实例变量：跟随对象创建。随着对象消亡
局部变量：随着方法调用，方法结束消亡

1
2
3

4.作用域
实例变量：通过对象就能使用
局部变量：出了作用域就不能使用

1
2
3

5.修饰符
实例变量：public,protected,private,final,volatile,transient
局部变量：final

1
2
3

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;
    }

}