JAVA学习
方法
定义方法的格式
修饰符 返回值类型 方法名称(参数类型 参数名称, …){
方法体
return 返回值
}
修饰符： 现阶段固定写法，public static
返回值类型： 也就是方法最终产生的数据是什么类型
方法名称： 方法的名字，规则和变量一样，小驼峰
参数类型： 进入方法的数据是什么类型
参数名称： 进入方法的数据对应的变量名称
Ps： 参数如果有多个，使用逗号进行分隔
方法体： 方法需要做的事，若干行代码
return： 两个作用，第一停止当前方法，第二将后面的返回值还给调用处（带着返回值回到方法的调用出；谁在调用我，我就把结果还给谁；像下面例子种的赋值调用，sum在调用它，就把结果还给sum，所以sum就是7，然后继续下面的+=，就是107）
注意： return后面的“返回值”必须和方法名称前面的“返回值类型”保持对应
注意事项：
- 方法定义的先后顺序无所谓。
- 方法定义不能产生嵌套包含关系。
方法定义好了之后，不会执行的。如果要想执行，一定要进行方法的调用。
方法的三种调用格式
1.单独调用： 方法名称(参数);
2.打印调用： System.out.println(方法名称(参数));
3.赋值调用： 数据类型 变量名称 = 方法名称(参数);
单独调用：只能让方法执行，方法产生的结果，都无法进行使用。
打印调用：就是把方法调用写到一个打印输出语句当中，这样方法先执行，执行完后，return后面的结果将会进行打印显示。
赋值调用：不打印，而是把它的结果向左赋值给变量，然后变量在想怎么玩，就怎么玩。
注意：当返回值类型写为void，这种方法只能够单独使用，不能进行打印调用或者赋值调用。但是可以在方法里面完成打印等操作。
void不需要返回值。只要不是void，剩下的都有返回值；
无返回值的用void，有返回值的用定义方法的完整格式
完整格式和三种调用方式例子:
/*
定义两个int数字相加的方法。三要素：
返回值类型： int
方法名称： sum
参数列表： int a,int b
*/
public class abcd {
public static void main(String[] args) {
sum(1,2); //单独调用
System.out.println(sum(1,4)); //打印调用
int number = sum(3,4); //赋值调用
number+=100;
System.out.println(number);
}
public static int sum(int a, int b) {
int result = a + b;
return result;
}
}
对比有无返回值的区别：
方法练习
/*
题目要求:
定义一个方法，用来求出1-100之间所有数字的和值。*/
public class Demo02MethodSum{
public static void main(String[]args){
System.outprintln("结果是:"+getSum());
/* I
三要素
返回值:有返回值，计算结果是一个int数字方法名称:getSum
参数列表:数据范围已经确定，是固定的，所以不需要告诉我任何条件，不需要参数
*/
public static int getSum(){
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
return sum;
}
}
方法注意事项
public class 方法注意事项 {
/*使用方法的时候，注意事项:
1.方法应该定义在类当中，但是不能在方法当中再定义方法。不能嵌套。
2.方法定义的前后顺序无所谓。
3.方法定义之后不会执行，如果希望执行，一定要调用:单独调用、打印调用、赋值调用。
4.如果方法有返回值，那么必须写上“return 返回值:"，不能没有。
5.return后面的返回值数据，必须和方法的返回值类型，对应起来。
6.对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。
7.对于void方法当中最后一行的return可以省略不写。
8、一个方法当中可以有多个return语句，但是必须在不同的逻辑条件下。*/
public static int method1() {
return 10;
}
public static void method2() {
//return 10; 错误的写法!方法没有返回值，return后面就不能写返回值。
return; //没有返回值，只是结束方法的执行而已。
}
public static void method3() {
System.out.println("AAA");
System.out.println("BBB");
return;//最后一行的return可以省略不写。
}
public static int getMax(int x , int y){
if(x > y){
return x;
}else {
return y;
}
}
}
重载方法
public class 重载方法 {
/**
*
* 对于功能类似的方法来说，因为参数列表不一样，
* 却需要记住那么多不同的方法名称，太麻烦。
* 方法的重载(Overload):多个方法的名称一样，但是参数列表不一样。
* 好处:只需要记住唯一一个方法名称，就可以实现类似的多个功能。
*
*/
public static void main(String[] args) {
System.out.println(sum(10, 20));//两个参数的方法
System.out.println(sum(10, 20, 30));//三个参数的方法
System.out.println(sum(10, 20, 30, 4));//四个参数的方法
//System.out.println(sum(10，20，30，40，50))://找不到任何方法来儿配，所以错误
}
public static int sum(int a, int b) {
System.out.println("有2个参数的方法执行!");
return a + b;
}
public static int sum(int a, int b, int c) {
System.out.println("有3个参数的方法执行!");
return a + b + c;
}
public static int sum(int a, int b, int c, int d) {
System.out.println("有4个参数的方法执行!");
return a + b + c + d;
}
}
执行结果： 有2个参数的方法执行!
30
有3个参数的方法执行!
60
有4个参数的方法执行!
64
数组
数组的概念：是一种容器，可以同时存放多个数据值。
数组的特点：
1.数组是一种引用数据类型
2.数组当中的多个数据，类型必须统一
3.数组的长度在程序运行期间不可改变
数组初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。
动态初始化
动态初始化（指定长度）：在创建数组的时候，直接指定数组当中的数据元素数。
动态初始化基本格式：
数据类型 [] 数组名称 = new 数据类型[数组长度];
解析含义：
左侧数据类型：也就是数组当中保存的数据，全部都是统一的类型
左侧的中括号：代表我是一个数组。
左侧数组名称：给数组取个名字。
右侧new：代表创作数组的动作。
右侧的数据类型：必须和左边的数据类型保持一致。
右侧中括号的长度：也就是数组当中，到底可以保存多少个数据，是一个int数字。
例如：
public class 动态初始化 {
public static void main(String[] args) {
// 格式：数据类型[] 数组名称 = new 数据类型[数组长度];
//创建一个数组，里面可以存放300个int数据
int [] arrayA = new int[300];
//创建一个数组，能存放10个double类型的数据
double [] arrayB = new double[10];
//创建一个数组，能存放5个字符串
System[] arrayC = new System[5];
}
}
静态初始化
静态初始化（指定内容）:在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。
静态初始化基本格式：
数据类型 [] 数组名称 = new 数据类型 [] { 元素1,元素2, …. };
注意事项：
虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来。
例如：
public class 静态初始化 {
public static void main(String[] args) {
//直接创建一个数组，里面装的全部都是int数字，具体为： 5、15、25
int[] arrayA =new int[] {
5,15,25 };
//创建一个数组，用来装字符串："hello"、"world"、"java"
String[] arrayB = new String[] {
"hello","world","java"};
}
}
静态初始化省略格式：
标准格式：数据类型 [] 数组名称 = new 数据类型 [] { 元素1,元素2, …. };
省略格式：数据类型 [] 数组名称 = { 元素1,元素2, …. };
注意事项：
- 静态初始化没有直接指定长度，但仍然会自动推算得到长度。
- 静态初始化标准格式可以才分为两个步骤。
- 动态初始化也可以拆分成为两个步骤。
- 静态初始化一旦使用省略格式，就不能拆分为两个步骤了。
使用建议：如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体内容，用静态初始化。
例如：
public class 静态初始化 {
public static void main(String[] args) {
//省略格式的静态初始化
int[] arrayC = {
10,20,30};
//静态初始化的标准格式，可拆分成为两个步骤
int[] arrayD;
arrayD = new int[]{
1,2,3};
//动态初始化也可以拆分为两个步骤
int[] arrayE;
arrayE = new int[5];
}
}
访问数组元素进行获取
直接打印数组名称，得到的是数组对应的内存地址哈希值。
访问数组元素的格式： 数组名称[索引值];
索引值：就是一个int数字，代表数组当中元素的编号。
注意：索引值从0开始，一直到数组的长度-1为止。
例如：
public class 访问数组元素进行获取 {
public static void main(String[] args) {
//静态初始化的省略格式
int[] array = {
10,20,30};
//直接打印数组当中的元素
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
//也可以将数组当中的某一个单个元素，赋值交给变量
int num = array[0];
System.out.println(num);
}
}
执行结果： 10
20
30
10
访问数组元素进行赋值
使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值。
规则如下：
如果是整数类型，那么默认为0；
如果是浮点类型，那么默认为0.0；
如果是字符类型，那么默认为’\u00000’；
如果是布尔类型，那么默认为false；
如果是引用类型，那么默认为null；
注意事项：
静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成为了大括号当中的具体数值。
例如：
public class 访问数组元素进行赋值 {
public static void main(String[] args) {
//动态初始化一个数组
int [] arrayA = new int[3];
System.out.println(arrayA);//内存地址哈希值
System.out.println(arrayA[0]);//0
System.out.println(arrayA[1]);//0
System.out.println(arrayA[2]);//0
//将数据123赋值交给数组arratA当中的1号元素
arrayA[1]=123;
System.out.println(arrayA[0]);//0
System.out.println(arrayA[1]);//123
System.out.println(arrayA[2]);//0
}
}
执行结果：
[I@7c30a502]
0
0
0
0
123
0
数组索引越界异常
如果访问数组元素的时候，索引编号并不存在，那么将会发生数组索引越界异常
ArrayIndexOutOfBoundsException
原因：索引编号写错了。
解决：修改成为存在的正确索引编号。
例如：
public static void main(String[] args) {
int[] aa = {
1,2,3,4};
System.out.println(aa[4]);
}
执行结果：
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4
报错原因分析：因为索引是从0开始的，aa数组中，第四个元素不存在，所以aa[4]时会报错。
空指针错误
/*
所有的引用类型变量，都可以赋值为一个null值。但是代表其中什么都没有。
数组必须进行new初始化才能使用其中的元素。如果只是赋值了一个null，没有进行new创建那么将会发生:
空指针异常NullPointerException
原因:忘了new
解决:补上new
*/
public static void main(String[] args) {
int[] array = null;
// array=new int[3];
System.out.println(array[0]);
}
输出结果:Exception in thread "main" java.lang.NullPointerException
情况2：
1、没有对你new出来的对象进行实例化，或者你去数据库里查询一个空的对象，就是空指针
2、空指针的异常NullPointer 无非是因为对象为null的情况下去调用该对象所拥有的方法或者成员变量造成的
解决办法：在调用有可能为空的变量的时候，最好做一下非空的判断。
获取数组长度
格式：数组名称.length;
这将会得到一个int数字，代表数组的长度
例如：
public static void main(String[] args) {
int[] arrayA = new int[3];
int[] arrayB = {
1,2,3,4,5,32,2,3,2,45,5,2,5,2,4,2,2,4,2,66};
int len = arrayB.length;
System.out.println("arrayB数组的长度是"+len);
}
注意：数组一旦创建，程序运行期间，长度不可以改变。
例如下列代码：它的长度只要你new了，就永远是3，只要你new了，就永远是5，除非你创建一个新的，否则老数组是几，永远是几，长度不能发生改变。
public static void main(String[] args) {
int[] arrayC = new int[3];
System.out.println(arrayC.length);//3
arrayC = new int[5];
System.out.println(arrayC.length);//5
}
数组的遍历输出
遍历数组，说的就是对数组当中的每个元素进行逐个、挨个处理。默认的处理方式就是打印输出。
例如：
public static void main(String[] args) {
int[] array = {
1,2,3,4,5};
//首次使用原始的方式
System.out.println(array[0]); //1
System.out.println(array[1]); //2
System.out.println(array[2]); //3
System.out.println(array[3]); //4
System.out.println(array[4]); //5
//使用循环，次数其实也就是数组的长度。
for (int i = 0; i < 5; i++) {
System.out.println(array[i]);
}
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
小练习
求数组最值
最大值获取:从数组的所有元素中找出最大值。
实现思路:
1 定义变量，保存数组0索引上的元素
2 遍历数组，获取出数组中的每个元素
3 将遍历到的元素和保存数组0索引上值的变量进行比较
4 如果数组元素的值大于了变量的值，变量记录住新的值
5 数组循环遍历结束，变量保存的就是数组中的最大值
最大值例：
public static void main(String[] args) {
int[] array = {
5,15,30,20,100000};
int max =array[0];
for (int i = 1; i < array.length; i++) {
// 如果当前元素，比max更大，则换
if (array[i] > max){
max=array[i];
}
}
System.out.println("最大值是："+max);
}
最小值例：
public static void main(String[] args) {
int[] array2 = {
5,15,30,20,100000,4,1};
int min =array2[0];
for (int i = 1; i < array2.length; i++) {
// 如果当前元素，比min更小，则换
if (array2[i] <min){
min=array2[i];
}
}
System.out.println("最小值是："+min);
}
数组的优点和缺点
1.1、数组的优点和缺点，并且要理解为什么。
第一:空间存储上，内存地址是连续的。
第二:每个元素占用的空间大小相同。
第三:知道首元素的内存地址。
第四:通过下标可以计算出偏移量。
通过一个数学表达式，就可以快速计算出某个下标位置上元素的内存地址，直接通过内存地址定位，效率非常高。
优点:检索效率高。
缺点:随机增删效率较低，数组无法存储大数据量。
注意:数组最后一个元素的增删效率不受影响。
二维数组
二维数组的静态初始化和动态初始化
静态初始化:
int[][] arr = {
{
1,2,34}，
{
54,4,34,3}，
{
2,34,4,5}
};
Object[][] arr={
{
new Object()，new object()}，
{
new Object()，new object(()}，
{
new object()，new object()，new object()}
};
动态初始化:
int [][] arr= new int[3][4];
Objeat [][] arr=new object[4][4];
Animal [][] arr=new Animal[3][4];
//Person类型数组，里面可以存储Person类型对象，以及Person类型的子类型都可以。
Person [][] arr = new Person[2][2];
....
二维数组的遍历
for(int i=0;i<arrlength;i++){
//外层for循环负责遍历外面的一维数组
//里面这个for循环负责遍历二维数组里面的一维数组。
for(int j=o;j<arr[i].length;j++){
System.out.print(arr[i][j]);
}
// 换行。
system.out.println();
}