java基础知识总结（一）

java基础知识总结

一.java基础

1.1java语言发展史.
java之父:詹姆斯·高斯林（James Gosling）
java语言出生于:1995年
1.2java语言平台版本
JavaSE(Java Platform Standard Edition)标准版:开发普通桌面和商务应用程序
JavaME(Java Platform Micro Edition)小型版:开发电子消费产品和嵌入式设备
JavaEE(Java Platform Enterprise Edition)企业版:开发企业环境下的应用程序
1.3java语言的特点
简单性,可移植性（跨平台）,多线程,健壮性,安全性,面向对象,分布式,动态性,开源
一个java源文件可以有多个类，但是只能有一个公开的类，并且这个公开的类的名字必须和java源文件的名字相同。
在java源文件中只有有类的声明，编译后都会生成一个对应的字节码文件。
1.4jdk,jre与jvm
jdk(java development kit):java开发工具包
jre(java runtime environment):java运行环境
jvm(java virtual machine)java虚拟机:整个java实现跨平台的最核心的部分.
jdk开发完成的java程序,交给jre去运行,由jvm保证跨平台性.
jdk=jre+java开发工具
jre=jvm+核心类库.
1.4.1:什么是跨平台?java语言编写的应用程序在不同的系统平台都可以运行.
1.4.2:跨平台的原理?java虚拟机(jvm)将java源程序编译成与平台无关的字节码文件.
1.5java环境搭建
安装jdk:
windows:https://blog.csdn.net/qq_45624685/article/details/118895400
linux:https://blog.csdn.net/qq_45624685/article/details/118910283
1.5.2:为什么要配置环境变量:
PATH变量:可以使bin目录下的java相关二进制命令可以在任意目录下使用.
CLASSPATH变量:当使用java命令来运行class文件的时候,java虚拟机根据等号右边的路径来找对应的字节码文件,并加载到虚拟机.
1.6第一个java程序
开发java程序需要3个步骤:编写源程序,编译程序,运行程序.
编写源程序

public class HelloWorld{
	//String ... args:可变参数。
	// String[] args:数组。
	//public static void main(String ... args){
	public static void main(String[] args){
	System.out.println("hello world");
	}
}

编译源程序
javac 文件名.java（javac命令用来生成字节码文件。
如果有包结构 javac -d . 文件名（会在当前目录下生成包结构）
包结构一般是域名的倒序。
运行程序
java 文件名(java命令是调用java虚拟机去运行字节码文件，不用加文件后缀)
java 包结构(/或者.) 文件名
1.7注释
编译程序时编译器会忽略这些注释信息,不会编译到字节码文件中。

//单行注释
/*
多行注释
*/
/**
文档注释
*/

1.8关键字
关键字的定义：被编程语言赋予了特殊含义的单词
关键字的特点：全部都小写，常用的代码编辑器会有高亮显示。
1.9计算机的存储单位
计算机存储设备的最小信息叫位(比特位),计算机最基本的存储单元叫字节(byte).
字节是由连续的8个位组成的.
1.10java中没有分号不代表这一句话的结束。
java程序中一个连续的字符串不能分成两行书写。
System.out.println(“这是
一个字符”);//这是错误的。
1.11public 只能是成员变量使用，局部变量不能使用。

二:变量和常量

2.1标识符
所有程序员命名的东西，都被称作标识符。
标识符不能和关键字相同。
2.1.1标识符遵守的规则。
java中的标识符组成规则：由字母（大小写敏感）、数字、下划线（_）、美元符号（$）组成，第一个不能是数字。
不能使用java中的关键字作为标识符也不能使用非法字符。
2.1.2标识符常用规定。
类和接口名使用大驼峰命名法，方法名和变量名使用小驼峰命名法，常量所有的字母全部都使用大写，尽量见名知意。
包：package声明，都是小写字母，一般是公司域名的倒序写法。
2.2常量
2.2.1常量的定义?程序运行过程中,其值不发生变化的量
2.2.2java中常量的分类:整数常量/小数常量/字符常量/布尔常量/字符串常量/空常量
除空常量外，其他常量均可使用输出语句直接输出

public class Constant{
  //静态常量的定义，只能定义在类内，方法外。
   public static final boolean bool = true;
   public static void main(String[] args){
        //常量的定义
        //普通常量定义
        final String s="1";
        //s="2";//错误写法：Constant.java:9: 错误: 无法为最终变量s分配值        
        System.out.println(s);
        System.out.println(bool);
        final double d  = 3.1415926;
        System.out.println(d);
        //字符串常量
        System.out.println("a");
        System.out.println("abc");
        System.out.println("中国");
        //字符常量
        System.out.println('a');
        System.out.println('中');
        //System.out.println('中国');
        //整数
        //二进制0b/0B数字0加一个字母
        //八进制0
        //十进制：直接书写
        //十六进制：0x/0X
        System.out.println(0B1100);
        System.out.println(0b1100);
        int i=012;
        System.out.println(i);
        int j=0xaf123;
        System.out.println(j);
        System.out.println(123);
        System.out.println(10);
        System.out.println(-10);
        System.out.println(0);
        //小数
        System.out.println(3.5);
        System.out.println(3.0005);
        //布尔常量
        System.out.println(true);
        System.out.println(false);
        //空常量
        //java中不能打印出空常量
        //System.out.println(null);
}
}       

2.3变量
2.3.1常量的定义:程序运行过程中,值可以发生变化的量.
变量需要在他的作用范围内才可以使用
临时保存在内存单元中的数据，用于标识内存单元的标识符就称为变量。
java是一个强类型语言,对每一种数据都规定了范围.定义变量时必须声明变量的数据类型，否则程序会报错。
基本数据类型都是小写的。


Java中整数默认是int类型,浮点数默认是double类型.
变量的定义格式:数据类型 变量名
变量的赋值格式:变量名 = 变量值
声明并赋值:数据类型 变量名 = 变量值[,变量名2 = 变量值]
变量的注意点:
1.同一对花括号中,变量名不能重复
2.变量在使用之前,必须初始化
3.定义long类型的变量时，需要在整数的后面加L(大小写均可，建议大写）。因为整数默认是int类型的，整数太大可能超出int范围。
4.定义float类型的变量时，需要在小数的后面加F(大小写均可，建议大写).因为浮点数的默认类型是double（定义时，在后面加上D）,double的取值类型范围是大于float的，类型不兼容。

public class Variable{
    public static void main(String[] args){
        //常量
        //byte 1B -128-127 2的7次方
        byte a = 127;
        //print()不换行，println()换行。
        System.out.println(a);
        //short 2B -32768-32767 2的15次方
        short b = 32767;
        System.out.println(b);
        //int（java虚拟机默认的数字类型，数字默是int类型） 4B -2147483648-2147483647 2的31次方
        int c=2147483647;
        System.out.println(c);
        //long 8B 2的63次方个数字。
        long d = 1234567890123L;
        System.out.println(d);
        //float 4B 负数-3.4E+38到-1.4E-45
        //正数1.4E45到3.4E+38
        float f1 = 3.45F;
        System.out.println(f1);
        //double（小数默认的数据类型） 8B 负数-1.79E+308到-4.9E-324
        //正数4.9E-324到1.7E+308
        double d1 = 3.222222D;
        System.out.println(d1);
        //字符类型 2B(主要是用来存储中文，其他语言1个字符就够了) 0-65535
        //char可以和int类型相互转换根据ASCII码
        //java中可以输出unicode编码
        char c="\u4e2d";
        char e = 'd';
        char e2=65;
        System.out.println(e2);//A
        System.out.println(c);//中
        System.out.println(e);
        //布尔类型 1B true false;
        //boolean不能与int类型相互转换。
        Boolean bool = true;
        System.out.println(bool);
}
}

2.4变量的转换

自动类型转换
定义：把一个表示数据类型范围小的数值或者变量赋值给另一个表示数据范围大的变量。

public class TestChange{
    public static void main(String ... args){
        //自动类型转换，将一个表示数据类型小的赋值给表示数据类型大的变量。
        //将int类型的10直接赋值给double类型
        double num=10;
        System.out.println(num);//输出10.0
}
}

强制类型转换
把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量
强制类型转换的格式：目标数据类型 变量名 = （目标数据类型） 值或变量
错误: 不兼容的类型: 从（大范围）转换到（小范围）可能会有损失(精度丢失)

public class TestChange{
    public static void main(String ... args){
        double num1 = 5.5;
//强制类型转换，将一个数据类型大的赋值给表示数据类型小的值或变量
        int num2 = (int)num1;
        System.out.println(num1);
        int a = 'a';
        System.out.println(a);//输出97        //整数默认的是int类型，byte,short和char数据参与的运算均>会自动转换为int类型
        byte b1 =10;
        byte b2 = 20;
        //byte b3 = b1+b2;//报错，运算后的b1和b2是int类型
        byte b3 = (byte)(b1+b2);
}
}

数字类型参与运算规则（自动提升）
byte，short，char类型将被提升到int类型，不管是否有其他类型参与运算，整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型
等级顺序：byte,short,char---->int---->long---->float----->double
正是由于上述原因，所以在程序开发中我们很少使用byte或者short类型定义整数。也很少会使用char类型定义字符，而使用字符串类型，更不会使用char类型做算术运算。

三、运算符

运算符：对常量或者变量进行操作的符号。
表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。(由运算符和表达式组成的算式，变量在表达式中进行运算时，可能发生自动类型转换。这就是表达式数据类型的自动提升。)
1.算数运算符

  //算数运算符
  //+ - * / %  ++  --
  //整数操作只能得到整数，要想得到小数，必须有浮点数参与
  System.out.println(3-2);
  System.out.println(3*2);
  System.out.println(3/2.0);
  System.out.println(3/2);
  System.out.println(3/2);
  System.out.println(3.0+2);
  //字符串的+操作
  //+既可以当做运算符，也可以看做连接符
  System.out.println(1+99+"年企业"+1+2);//100年企业12
  //字符的+操作
  //a:97   A:65   0:48;
  //可以通过使用字符与整数做算数运算符，得出字符对应的数值是多少  
  char ch1 = 'a';
  System.out.println(ch1+1);//98
  //自增自减
  int i=10;
 //++单独使用
 i++;
 System.out.println(i);
 //++在前，先+1再运算
 System.out.println(++i);
 //++在后，先运算再+1
 System.out.println(i++);
 System.out.println(i);

自增自减练习

 int x=10;
 int y= x++ + x++ + x++;
 int n= x++ + ++x + ++x;
 int n= x++(10) + ++x(12) + ++x(13);
 int y= x++(10) + x++(11) + x++(12);
 System.out.println(y);//33
 System.out.println(n);//44

2.赋值运算符

 //赋值运算符
 //= += -= *= /= %=
 int a =10;
 System.out.println(a);
 a+=10;//a=a+10
 System.out.println(a);
 a-=2;//a=a-2;
 System.out.println(a);
 a*=2;//a=a*2;
 System.out.println(a);
 a/=2;//a=a/2;
 System.out.println(a);
 a%=2;//a=a%2;
 System.out.println(a);

3.关系运算符
关系运算符的结果都是boolean类型，要么是true,要不是false

//>  <   >=  <= ==（基本数据类型数值相等，引用数据类型内存空间相等） !=
System.out.println(10>20);
System.out.println(10<20);
System.out.println(10>=10);
System.out.println(10<=10);
System.out.println(10==10);
System.out.println(10!=10);
//System.out.println(10=="10");// 错误: 不可比较的类型: int和String

4.逻辑运算符
把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式。
&:按位与运算
|：按位或运算
^：按位异或运算
！：逻辑非运算
&&:短路与
||：短路或
>>按位右移
<<按位左移：移动n位，乘以2的n次方
>>>无符号按位右移
与：一假便假，或：一真便真，非：真假相反。
短路：只要能判断一个逻辑表达式的值，就不再往下执行。

System.out.println((10>20)&(10<20));//false & true,输出false逻辑或一假便假
System.out.println((10>10)|(10>20));//false | false,输出false，逻辑与一真便真
System.out.println(!false);//真假相反   
System.out.println(true ^ false);//^两边相同为false，两边不同为true   
int a=10;
System.out.println((false)&&(a++>10));
System.out.println(a);//10;

5.三元运算符
格式：关系表达式 ? 表达式1 : 表达式2;
问号前面的位置是判断的条件，判断结果为boolean型，为true时调用表达式1，为false时调用表达式2。其逻辑为：如果条件表达式成立或者满足则执行表达式1，否则执行第二个。

//关系表达式?表达式1:表达式2;
int a = 10;
int b = 20;
int c = a>b ? a : b;
System.out.println(c);

案例
1.动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同。

public class OperatorTest1{
    public static void main(String[] args){
        //定义两个变量，用来保存老虎的体重，单位为kg
        int weight1=180;
        int weight2=200;
        //用三元运算符实现老虎体重的判断，相同返回true，否则false
        boolean b = weight1==weight2?true:false;
        //输出结果
        System.out.println(b);
}}

2.一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三个和尚的最高身高。

public class OperatorTest2{
    public static void main(String[] args){
        //1.定义三个变量用来保存和尚的身高，单位cm
        int hs1=150,hs2=210,hs3=165;
        //2.用三元运算符获取前两个中的较高着。
        int heightHs = hs1>hs2?hs1:hs2;
        int maxHeightHs = heightHs>hs3?heightHs:hs3;
        //3.输出结果
        System.out.println(maxHeightHs);
}
}

四、流程控制语句

1.顺序结构
按照代码的先后顺序，依次执行。
2.分支语句（if,switch）
if
单分支语句
if(逻辑表达式){
语句体;
}
代码执行到if语句后，先执行逻辑表达式，如果为true，执行语句体，如果为false跳过if语句。

public class IfDemo{
    public static void main(String[] args){
        //定义两个变量
        int a=10;
        int b=10;
        //需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
        if(a==b){
        System.out.println("a等于b");
}
        System.out.println("程序结束");
}
}

单分支语句格式2
if （逻辑表达式）{
语句体；
}else{
语句体2;
}
代码执行到if语句后，先执行逻辑表达式，如果为true，执行语句体，如果为false执行语句体2.

public class IfDemo2{
    public static void main(String[] args){
        //定义两个变量
        int a=10,b=20;
        //判断a是否大于b，如果是，在控制台输出：a的值大于b，否则，>在控制台输出：a的值不大于b
        if(a>b){
        System.out.println("a的值大于b");
        }else{
        System.out.println("a的值小于b");
        }

        System.out.println("程序结束");
}
}

if案例
任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数

import java.util.Scanner;
public class IfTest{
    public static void main(String[] args){
        //输入一个整数
        Scanner sc=new Scanner(System.in);
        int num = sc.nextInt();
        if(num%2==0){
        System.out.println(num+"是偶数");
        }else{
        System.out.println(num+"是奇数");
        }       
}
}

多分支语句格式：
if(逻辑表达式){
语句体1；
}else if(逻辑表达式2){
语句体2；
}else{
语句体3};
代码执行到if语句后，先执行逻辑表达式，如果为true执行语句体1，退出分支结构。若为false执行逻辑表达式2,如果为true执行语句体1，退出分支结构。如果为false执行else语句的内容。
案例：键盘录入一个星期数(1,2,…7)，输出对应的星期一，星期二，…星期日

import java.util.Scanner;
public class IfTest2{
    public static void main(String[] args){
        //输入一个数字
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        //判断星期几
        if(num==1){
        System.out.println("星期一");
        }else if(num==2){
        System.out.println("星期二");
        }else if(num==3){
        System.out.println("星期三");
        }else if(num==4){
        System.out.println("星期四");
        }else if(num==5){
        System.out.println("星期五");
        }else if(num==7){
        System.out.println("星期六");
        }else{
        System.out.println("星期天");
        }
 }
 }

案例：小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。

import java.util.Scanner;
public class IfTest3{
    public static void main(String[] args){
        //获得输入
        Scanner sc=new Scanner(System.in);
        System.out.print("请输入你的分数:");
        int score = sc.nextInt();
        //判断
        if(score>80){
        System.out.println("考的优秀，自己选择奖励");
        }else if(score>60){
        System.out.println("刚刚及格，奖励变形金刚一个");
        }else{
        System.out.println("没及格，还想要东西");
        }
}
}

switch
格式：
switch(值){//()内可以放什么数据类型：byte,short,int,char,String(jdk1.7),enum
case 值1：{
语句体1；
break;
case 值2:
语句体2:
break;
case 值3：
语句体3;
break;
…
default:
语句体n+1
break;
}
首先计算出表达式的值，其次和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束，最后所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

import java.util.Scanner;
public class SwitchDemo{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入一个月份:");
        int month = sc.nextInt();
        //case穿透
        switch(month){
            case 1:
            case 2:
            case 12:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
        }
}
}

3.循环结构(while,do…while,for)
while
格式：
while(条件判断语句){
循环体语句;
条件控制语句;
}
当执行到while语句的时候，先判断条件的真假，如果为true执行循环体语句和条件控制语句，如果为false。

public class WhileDemo{
    public static void main(String[] args){
        int i=1;
        while(i<=5){
        System.out.println(i);
        i++;
        }
}
}

案例：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度?

public class WhileTest{
    public static void main(String[] args){
        //定义一个数字，用来计数
        int count=0;
        double paper=0.1;
        while(paper<=8844430){
        paper *= 2;
        count++;
        }
        System.out.println(count);
}
}

do-while
格式：
初始化语句；
do{
循环体语句；
条件控制语句；
}while(条件判断语句);
案例：输出1-5；

public class DoWhileDemo{
    public static void main(String[] args){
        int j=1;
        do{
        System.out.println(j);
        j++;
        }while(j<=5);
}
}

3.for
格式：for(表达式1;逻辑表达式2；表达式3）{}
表达式1：初始化表达式，只执行一次。
表达式2：循环条件的判断，每循环一次，判断一次。
表达式3：循环变量控制，每一次循环都会执行。

public class ForTest{
    public static void main(String ... args){
        //输出1-10
        for(int i=0;i<=10;i++){
        System.out.println(i);
        }
        //换种写法
        int a=0;
        for(;;){
        if(a>10){
        break;
        }
        System.out.println(a);
        a++;
        }
}
}

for循环的嵌套
外循环执行一次，内循环执行一圈
for循环嵌套非必要,不要超过两层,如果你的for循环超过三层,需要考虑换一个算法
可以给方法起别名。

public class TestFor{
    public static void main(String[] args){
        //nanoTime()
        //返回正在运行的 Java 虚拟机的高分辨率时间源的当前值，以纳>秒为单位。
        //参数：无
        //返回值：以纳秒为单位的时间值
        long start = System.nanoTime();
        System.out.println(start);
        outer:for(int i=1;i<=9;i++){
         inner:for(int j=1;j<=9;j++){
                System.out.print(i*j+"\t");
        }
        }
        System.out.println();
        long end = System.nanoTime()-start;
        System.out.println(end);
}
}

案例：九九乘法表

public class TestJJ{
    public static void main(String[] args){
        for(int i=1;i<=9;i++){
                for(int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+(i*j)+"\t");
        }   
        System.out.println();
        }   
}
} 

break和contine
break:跳出本层循环
continue:跳出本层循环，继续下一次循环
break和continue只能在循环中进行使用，单独使用无任何意义！！
//for的标签：标签名:for（；；）{}

public class Mul{
    public static void main(String ... ar){
        outer:for(int i=0;i<=9;i++){
                inner:for(int j=1;j<=i;j++){
                if(i==9){
                        break inner;
                }
                System.out.print(j+"x"+i+"="+j*i+"\t");
                }
                System.out.println();
        }
}
}

案例：在控制台输出1-5和5-1的数据

public class ForTest1{
    public static void main(String[] args){
        //需求：输出数据1-5
        for(int i=1;i<=5;i++){
        System.out.println(i);
        }
        //需求：输出数据5-1
        for(int j=5;j>=1;j--){
        System.out.println(j);
        }
}
}

案例：求1-100之间的偶数和，并把求和结果在控制台输出

public class ForTest2{
    public static void main(String[] args){
    	//定义一个变量，用于打印结果
        int sum=0;
        for(int i=0;i<=100;i++){
        //将反复进行的事情写入循环结构内部
        if(i%2==0){
        sum+=i;
        }
        }
        System.out.println(sum);
}
}

案例：水仙花数，指的是一个三位数，个位、十位、百位的数字立方和等于原数，例如153 3*3*3 + 5*5*5 + 1*1*1 = 153

public class ForTest4{
    public static void main(String[] args){
        for(int i=0;i<100000;i++){
        int ge=i%10;
        int si=i/10%10;
        int bai=i/10/10%10;
        if(ge*ge*ge+si*si*si+bai*bai*bai==i){
        System.out.println(i);
        }
        }
}
}

三种循环的区别：
for循环和while循环先判断条件是否成立，然后决定是否执行循环体(先判断后执行)
do-while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体(先执行后判断)
for循环和while的区别
条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
死循环的三种格式：
for(;;){} while(true){} do{}while(true)没有do{}while(1);这是c语言中的写法。

五、数组

1.定义：存储数据长度固定的容器。存储多个数据的数据类型要一致。
2.数组的定义格式：数据类型[] 数组名;/数据类型 数组名[];

public class Array{
    public static void main(String[] args){
        int[] arr;
        int arr1[];
}
}

3.数组的初始化：
动态初始化：只给定数组的长度，由系统给出默认初始化值,各种各样的0；
格式：数据类型[] 数组名 = new 数据类型[数组长度];
new:为数组开辟内存空间
[]代表这是一个数组
数组长度，数组能存储的个数。

public class Array{
    public static void main(String[] args){
        int[] arr;
        int arr1[];     
        //动态初始化，给定数组的长度，由系统给出默认值
        byte[] byteArr = new byte[3];//0
        short[] shortArr = new short[3];//0
        int[] intArr = new int[3];//0
        long[] longArr = new long[3];//0
        float[] floatArr = new float[3];//0.0F
        double[] doubleArr = new double[3];//0.0D       
        char[] charArr = new char[3];//''
        String[] StringArr = new String[3];//null
        boolean[] boolArr  = new boolean[3];//false
}
}

静态初始化： 在创建数组时，直接将元素确定,由系统计算出数组的长度
格式：数据类型[] 数组名 = new 数据类型[] （提示这里面不能有数字）{元素1，元素2，元素3}；
简化版:数据类型[] 数组名 = {元素1，元素2，元素3}；

public class ArrayDemo{
    public static void main(String[] args){
        //定义数组
        int[] arr = {1,2,3};
        int arr1[] = {4,5,6}
}
}

4.数组的访问
索引：每一个存储到数组中的元素，都会自动拥有一个编号，从0开始。
数组的访问格式：数组名[下标/索引];

public class ArrayDemo{
    public static void main(String[] args){
        //定义数组
        int[] arr = {1,2,3};
        int arr1[] = {4,5,6}
        //输出数组名；输出的是内存中的引用地址
        System.out.println(arr);
        //通过索引打印出元素
        System.out.println(arr[0]);//1
        System.out.println(arr[1]);//2
}
}

5.数组操作异常:索引越界异常，空指针异常。

public class ArrayDemo{
    public static void main(String[] args){
        //定义数组
        int[] arr = {1,2,3};
        int arr1[] = {4,5,6};
        //输出数组名；输出的是内存中的引用地址
        System.out.println(arr);
        //通过索引打印出元素
        System.out.println(arr[0]);//1
        System.out.println(arr[1]);//2
        //打印了一个超过索引的值
        //ArrayIndexOutOfBoundsException
        //System.out.println(arr[4]);
        //把arr数组置空,会出现空指针异常
        //NullPointerException
        arr=null;
        System.out.println(arr[0]);
}
}

6.数组的遍历

public class ArrayDemo{
    public static void main(String[] args){
        //定义数组
        int[] arr = {1,2,3};
        int arr1[] = {4,5,6};
        for(int a : arr1){
        System.out.println(a);
        }
}
}

案例：数组最值就是从数组的所有元素中找出最大值或最小值

public class ArrayDemo{
    public static void main(String[] args){
        //定义数组
        int[] arr = {1,2,3};
        int arr1[] = {4,5,6};
        //定义一个变量，用来存储最大的量。
        int max=arr1[0];
        for(int i=1;i<arr1.length;i++){
                if(max<arr1[i]){
                //最小值：max>arr[i]
                max=arr1[i];
        }
        }
        System.out.println(max);
}
}

案例：数组中的元素颠倒顺序，例如原始数组为1,2,3,4,5，反转后的数组为5,4,3,2,1

ublic class ErArray{
    public static void main(String[] args){
        int [] arr = {1,2,3,4};
        //定义一个变量，用来接收变量
        int temp;
        for(int min=0,max=arr.length-1;min<=max;min++,max--){
        temp = arr[min];
        arr[min]=arr[max];
        arr[max] = temp;
        }
        for(int i=0;i<arr.length;i++){
        System.out.println(arr[i]);
        }
}
}

7.二维数组：元素为一维数组的数组。
格式1：数据类型[][] 变量名 = new 数据类型[m][n];
格式2：数据类型 变量名[][] = new 数据类型[m][]（n没有给出，表示可以动态给出。）;
格式3：数据类型 变量名[][] = new 数据类型[][]{{元素1},{元素2…},{元素3}};
简化版：数据类型 变量名[][] = {{元素1},{元素2…},{元素3}};

int[][] arr = new int[3][2];
int[][] arr1 = new int[3][];
int arr2[] = {{1,2,3},{1,2},{1}};

m表示这个二维数组有多少个一维数组。
n表示每一个一维数组的元素个数。
案例：
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99
1.求总和

public class ArrayCase{
    public static void main(String[] args){
        //定义这个二维数组
        int arr[][] = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
        //求总和
        int sum=0;
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr[i].length;j++){
                sum+=arr[i][j];
        }
        }
        System.out.println(sum);
}
}

六、方法

1.什么是方法？
将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集。
2.方法的使用。
1.放法必须先创建才能使用，该过程称为方法的定义。
声明方法时需要考虑两点：明确参数列表，明确返回值。
定义位置：类中方法外，不能嵌套定义
方法的声明五部分：修饰符 返回值类型 方法名(参数列表 形参列表) 允许抛出的异常；
修饰符：public static
返回值类型：运行结果的数据类型，方法执行后将结果返回到调用者。void可以是return,不能在return后面写代码，return意味着方法的结束，return后面的代码永远不会执行，属于无效代码;
参数列表：方法在运行过程中的未知变量，调用者调用方法时传递，定义方法时()中的参数，我们称之为：形式参数，在调用该方法时传递的参数，我们称之为：实际参数。
2.方法创建后并不是直接可以运行的，需要手动使用，才执行，该过程称为方法的调用
调用格式：方法名();
调用三种形式：直接调用，赋值调用，输出语句调用。
案例1：在控制台打印10次HelloWorld

public class MethodDemo1{
    public static void main(String[] args){
        for(int i=0;i<10;i++){
        printHelloWorld();
        }
}       
    public static void printHelloWorld(){
        System.out.println("hello wrold");
        }
}

案例2：定义方法实现两个整数的求和计算

public class MethodDemo2{
    public static void main(String[] args){
        System.out.println(erSum(1,2));
}
    public static int erSum(int a,int b){
     return a+b;
        }
}

案例：定义方法实现比较两个整数是否相同

public class MethodDemo4{
    public static void main(String[] args){
        System.out.println(Max(1,2));
}
    public static boolean Max(int a,int b){
       if(a==b){
        return true;
        }else{
        return false;
        }
        }
}

案例：定义方法实现:计算1+2+3…+100的和

public class MethodDemo5{
   public static void main(String[] args){
        System.out.println(heSum(100));
}
    public static int heSum(int n){
      //定义一个变量用来计算和
      int sum=0;
        for(int i=0;i<n;i++){
        sum+=i;
        }
        return sum;
        }
}

方法的重载：
定义:在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同（参数的个数不同，数据类型不同，顺序不同）即可，修饰符和返回值类型可以相同。
重载的方法调用：JVM通过方法的参数列表，调用不同的方法。（编译时，编译器会根据参数挑选一个相对应的方法，所以又常叫编译时多态。）
重载仅对应方法的定义，与方法的调用无关。
不能通过返回值（返回值类型一定相同）来判定两个方法是否互相构成重载。
方法的重载可以屏蔽同一个方法由于参数不同而造成的差异，对用户来说是透明的。
方法重载向上就近原则匹配，但不允许出现模棱两可的情况，重载不仅出现在同一类中，也可以出现在父子类中。

ublic class MethodTest{
    public static void main(String[] args){
        //调用方法
        System.out.println(compare(10,20));
        System.out.println(compare((byte) 10,(byte) 20));       
         //jvm虚拟机会精确匹配该参数的数据类型，如果匹配不到就就>近原则：byte-->short--->int---long---float----double原则。
        System.out.println(compare((short)10,(short)20));
        System.out.println(compare((long)10,(long)20));
        }
   public static boolean compare(int a,int b){
        System.out.println("int");
        return a==b;
        }
   public static boolean compare(byte a,byte b){
        System.out.println("byte");
        return a==b;
        }
  /* public static boolean compare(short a,short b){
        System.out.println("short");
        return a==b;
        }
*/
   public static boolean compare(long a,long b){
        System.out.println("long");
        return a==b;
        }
}

public class TestOverLoad {

	public static void main(String[] args) {
		Math m = new Math();
		System.out.println(m.add((byte)1,2,2,3));
	}
}
class Math{
	public int add(byte a,byte b) {
		return a+b;
	}
	//可变参数，必须是参数的最后一个参数
	public int add(byte a,int ... b) {
		int [] arr = b;
		a=0;
		for(int i=0;i<arr.length;i++) {
			a+=arr[i];
		}
		return a;
	}
	public int add(short a,short b) {
		return a+b;
	}
}

模棱两可的情况
方法重载的时候避免出现模棱两可的情况

class OverloadingCalculation3{
    void sum(int a,long b){
        System.out.println("a method invoked");
    }
    void sum(long a,int b){
        System.out.println("b method invoked");
    }
    public static void main(String args[]){
        OverloadingCalculation3 obj=new OverloadingCalculation3();
        obj.sum(20,20);
    }
}

传送参数：
基本数据类型形参的改变不影响实际参数。
每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失。
对于引用类型的参数，形式参数的改变，影响实际参数的值 。
引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以即使方法弹栈，堆内存中的数据也已经是改变后的结果 。

public class ChanShu{
    public static void main(String[] args){
        int a=10;
        Change(a);
        System.out.println(a);//10
        int[] arr=new int[3];
        changeArray(arr);
        for(int i=0;i<arr.length;i++){
        System.out.println(arr[i]);//2,0,0
        }   
}
        //参数是基本数据类型
    public static int Change(int a){ 
        a=20;
        return a;
        }   
        //参数是引用数据类型
    public static void changeArray(int[] a){ 
        a[0]=2; 
    }   
}=

案例1：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]

public class MethodTest1{
    public static void main(String[] args){
        int arr[] = {1,2,3,4,5};
        printArray(arr);
}
    public static void printArray(int[] a){ 
        System.out.print("[");
        for(int i=0;i<a.length;i++){
        if(i==(a.length-1)){
                System.out.print(a[i]);
        }else{
         System.out.print(a[i]+",");
        }   
        }   
        System.out.println("]");
        }   
}