Java基础知识详解-优快云博客

本文链接：https://blog.youkuaiyun.com/zdw_xc/article/details/110247055

这篇博客介绍了Java的基础知识，包括标识符的规则、关键字、变量与常量的定义、数据类型及其范围，以及运算符的使用。内容还涉及基本类型的字面值、类型转换、Scanner类的输入方法、分支和循环结构，以及break和continue语句的应用。同时讲解了数组的概念、特点和遍历方式，并提到了Java的Arrays工具类。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一:标识符:

可以简单的理解为一个名字。在Java中，我们需要标识代码的很多元素，包括类名、方法、字段、变量、包名等。我们选择的名称就称为标识符，并且遵循以下规则：

1标识符可以由字母,数字,下划线(_),美元符($)组成，但不能包含其他特殊字符

2不能以数字开头

3标识符严格区分大小写

4标识符的命名最好能反应其作用，做到见名知意

二：关键字有两个保留关键字 const goto 关键字不能做标识符！！！

三:变量常量:

在JAVA中，有的数据值是不固定的，总在变，我们还需要记录这些值，我们可以把这些值理解为变量。我们通过三个元素来描述变量：变量类型，变量名以及变量值。

变量:

int age=18; //声明int类型的变量并赋值

String tel; //声明String类型的变量

注意：

1、变量名必须是一个有效的标识符。

2、变量名不可以使用java关键字

3、变量名不能重复

常量:

在程序运行过程中一致不会改变的量成为常量。

四:数据类型

基本类型有八种

位bit 字节byte 1byte=8bit

	类型名称	字节空间	取值范围
整数型	byte	1	-27到27-1 或者 -128到127
	short	2	-215到215-1
	int	4	-231到231-1
	long	8	-263到263-1
浮点型	float	4	单精度，对小数部分的精度要求不高
浮点型	double	8	双精度，精确的小数部分并操作值很大时
字符	char	2	0到65535
布尔	boolean	1	真true 假false

很重要的东西类型名称和字节空间一定要牢记

最大最小值练习:

package cn.tedu.sp11;

import org.junit.jupiter.api.Test;

public class test {
//练习最大最小值
    @Test
    public void test01(){

        byte a=Byte.MIN_VALUE;
        byte b=Byte.MAX_VALUE;
        System.out.println("最小值是:"+a);
        System.out.println("最大:"+b);
        
        short c=Short.MIN_VALUE;
        short d=Short.MAX_VALUE;
        System.out.println("最小值"+c);
        System.out.println("最大值"+d);
        
        int e=Integer.MIN_VALUE;
        int f=Integer.MAX_VALUE;
        System.out.println("最小值"+e);
        System.out.println("最大值"+f);
        
        long g=Long.MIN_VALUE;
        long h=Long.MAX_VALUE;
        System.out.println("最小值"+g);
        System.out.println("最大值"+h);

        float a1=Float.MIN_VALUE;
        float a2=Float.MAX_VALUE;
        System.out.println("最小值"+a1);
        System.out.println("最大值"+a2);
        
        double b1=Double.MIN_VALUE;
        double b2=Double.MAX_VALUE;
        System.out.println("最小值"+b1);
        System.out.println("最大值"+b2);

        char a3='a';
        System.out.println("a3="+a3);
        char b3=97;
        System.out.println("b3="+b3);
        char c3='b';
        System.out.println("c3="+c3);
        char d3=98;
        System.out.println("d3="+d3);

    }
}

最小值是:-128
最大:127
最小值-32768
最大值32767
最小值-2147483648
最大值2147483647
最小值-9223372036854775808
最大值9223372036854775807
最小值1.4E-45
最大值3.4028235E38
最小值4.9E-324
最大值1.7976931348623157E308
a3=a
b3=a
c3=b
d3=b

Scanner 用法：

使用方法
1、首先需要构造一个Scanner类的对象，并且与标准输入流System.in关联
Scanner sc=new Scanner(System.in);
2、调用Scanner类对象sc的方法从输入流中获取你需要的输入
说明：
当创建了一个Scanner类对象之后，控制台会一直等待输入，直到敲回车键结束，把所输入的内容传给对象sc，若要获取需要的内容，调用sc的方法即可

可以在csdn中搜索了解跟多 Scanner具体用法

练习2：输入个人信息

  public static void main(String[] args) {
        System.out.println("姓名：");
        String name=new Scanner(System.in).nextLine();
        System.out.println("性别:");
        String gender=new Scanner(System.in).nextLine();
        System.out.println("年龄:");
        int age=new Scanner(System.in).nextInt();
        System.out.println("您输入的个人信息是:");
        System.out.println("姓名："+name);
        System.out.println("性別："+gender);
        System.out.println("年龄："+age);
    }

变量交换:

import java.util.Scanner;

 

 

public class Test1 {

 

       public static void main(String[] args) {

              System.out.print("输入整数a:");

              int a=new Scanner(System.in).nextInt();

             

              System.out.print("输入整数b:");

              int b=new Scanner(System.in).nextInt();

             

              int t=a;

              a=b;

              b=t;

              System.out.println(a);

              System.out.println(b);

       }

}

基本类型的字面值（5条）

1.整数字面值是int类型

int a=9999999999999999;//错误，右侧是int类型，但是超出范围，参考最大最小值

2.byte，short，char三种比int小的整数可以用范围内的值直接赋值

byte b=127;//对

byte b=128；//错，超出byte范围是int类型的数据

3.浮点数的字面值是double类型

double a=3.14;//对

float a=3.14;//错，右面double，float是四字节，double是八字节存不下

4.字面值后缀 l f d

L –long 如：long a = 99999999999;//错，超出范围，解决方案加L

F –float 如：float a = 3.14;//错，右面是double类型，解决方案加F

D –double 如：double a=3;//错，右面是int，解决方案加D或者改成3.0

5。进制前缀

0x - 16进制

0 -8进制

\u -char类型，16进制

基本类型的类型转换

1小转大(隐式转换)

byte a=120;

int b=a;//直接转

2.大转小（显式转换）

需要强制类型转换

int a=356;

byte y=(byte)xx; (注意：小数转成整数，小数直接舍弃)

运算规则

package cn.tedu.basic;
		//测试 运算规则
		public class Test2 {
			public static void main(String[] args) {
				//1, 计算结果的数据类型，与最大类型一致
				System.out.println(3/2); //int/int--> int  -- 1 
				System.out.println(3d/2); //double/int --> double -- 1.5   
				
				//2, byte,short,char三种比int小的整数，运算时会先自动转换成int
				byte a = 1 ;
				byte b = 2 ;
				byte c = (byte) (a + b) ;
				//右侧已经变成大类型int了,给左侧的小类型,不可以直接赋值---需要强转 
				
				//TODO 测试short或者char的现象,同byte...
				
				//3,计算：光速运行一年的长度是多少米
				//整数运算时,已经超出了int的范围,就会出现溢出现象
				//解决方案就是,把字面值是int类型,加后缀L转成long类型.
				System.out.println( 30000000L*60*60*24*365  );
				
				//4, java 对于小数运算时会产生不精确的现象
				System.out.println(1-0.8);//0.19999999999999996
				
				//5, 小数运算时的特殊值
				System.out.println(1.5/0);//Infinity
				System.out.println(0/0.0);//NaN -- not a number
				
			}
			
		}

拓展:

char类型变量中能不能存储一个中文汉字，为什么？

char 类型可以存储一个中文汉字，因为 Java 中使用的编码是 Unicode（不选择任何特定的编码，直接使用字符在字符集中的编号，这是统一的唯一方法），一个 char 类型占 2 个字节（16 比特），所以放一个中文是没问题的。

方法+流程控制+循环

运算符:

算术运算符	+ - * /	基本运算
	%	取余数，求模，算整除
	++ --	自增自减
比较运算符	==	相等比较
比较运算符	！=	不等比较
逻辑运算符	&& &	逻辑与(短路与)，两边同为真结果才为真
	\|\| \|	逻辑或(短路或)，两边只要有一个真结果就是真
	+	字符串连接
	！	非，非真是假，非假是真
三元运算符	？：	三项运算 1?2:3 1是真取2，1是假取3
赋值运算符	=	赋值运算
赋值运算符	+= -= *= /=	复合的赋值运算 a+=2;//a=a+2

-1,算术运算符
       + - * / %(取余数) ++ --
   --2,比较运算符:结果是boolean值
       == !=
   --3,逻辑运算符:结果是boolean值
       + !(取反,非真即假,非假即真)
       -- &(逻辑与) -- 表示并且关系
           -- 1 & 2 ,想得到最终的结果是true,要求是:1是true并且2是true
       -- &&(双与/短路与)-- 表示并且关系 --高效
           -- 1 && 2 ,当1为false时,结果早都注定了是false,2的代码就会被短路不用执行了,提高效率
       -- |(逻辑或) -- 表示或者关系
           -- 1 | 2 ,想得到最终的结果是true,要求是:1是true或者2是true
       -- ||(双或/短路或) -- 表示或者关系 --高效
           -- 1 || 2 ,当1为true时,结果早都注定了是true,2的代码就会被短路不用执行了,提高效率
   --4,三元运算符
       1 ? 2 : 3 ---运算结果可能是2,也可能是3.到底是谁?由1决定.
       --当1的位置判断成立时,结果就是2
       --当1的位置判断不成立时,结果就是3
   --5,赋值运算符
       =
       += -= *= /= 复合赋值运算符

练习1：平年闰年

输入年号，判断是否闰年。两个条件：

1.能被4整除，并且不能被100整除

2或者能被400整除

 public static void main(String[] args) {
      //练习平年闰年
        System.out.println("请输入年号:");
        int x=new Scanner(System.in).nextInt();
        String  y="平年";
      /*  if (x%4==0){
            if (x%100!=0){
                y="闰年";
            }
        }
        if (x%400==0){
            y="闰年";
        }
        System.out.println(x+"年是"+y);*/
        //或者
        if ((x%4==0&&x%100!=0)||x%400==0){
            y="闰年";
        }
        System.out.println(x+"年是"+y);
    }
//随意一种都可

练习2: 自增自减

 public static void main(String[] args) {
        int a=1;
        System.out.println(a++);//先取值在变化  1//此时还没有发生变化
        System.out.println(a); //2
        int b=1;
        System.out.println(++b);//先自增在变化 //结果为2

        int c=1;
        int d=c++;
        int e=++c;
        System.out.println(d); //1
        System.out.println(e);//3
    }

练习3：求最大值

  System.out.println("请输入整数a");
        int a = new Scanner(System.in).nextInt();
        System.out.println("请输入整数b");
        int b = new Scanner(System.in).nextInt();
      //  三个数的最大值比较：
      /*  System.out.println("请输入整数c");
        int c = new Scanner(System.in).nextInt();
        int max=a>b?(a>c?a:c):(b>c?b:c);
        System.out.println("三个数的最大值为"+max);*/
        
     //两个数的最大值比较
        int max1=a>b?a:b;
        System.out.println("两个数的最大值为"+max1);

分支结构 1：if

概述:顺序结构的程序虽然能解决计算、输出等问题，但不能做判断再选择。对于要先做判断再选择的问题就要使用分支结构。

单分支：

if(判断条件){

       代码。。。

}

多分支：

if(判断条件){

       代码1。。。

}else{

       代码2。。。

}

嵌套分支：

if(判断条件1){

       代码1。。。

}else if(条件2){

       代码2。。。

} else if(判断条件3){

       代码3。。。

}else{

       代码4。。。

}

分支结构2：switch

概述:当一个case成立，从这个case向后穿透所有case，包括default，直到程序结束或者遇到break程序才结束。

switch(变量或者表达式){

       case 1:

       case 2:

       case 3:  

case 4:  

       default:

}

循环结构1：for
   --1,循环结构用来完成程序中,需要反复执行的一些功能.
   --2,for循环语法
       for( 开始位置 ; 判断条件 ; 更改条件 ){
           循环体;
       }

package cn.tedu.fordemo;
		//测试 for
		public class Test2_For {
			public static void main(String[] args) {
				//输出1000次  你的名字--循环结构执行1000次
		//		for(开始位置;判断条件;更改条件) {
				for( int a = 1 ; a <= 1000 ; a++ ) {
					System.out.println("皮皮霞");
				}
				//练习1：打印0到10 -- TODO  画流程图 !!!!
				//int i = 0 ;  ---从0开始.i表示要打印的值
				//i <= 10 ; --判断条件,只要在范围内就符合判断条件
				//i++ ;  ---每次打印数据的规律,就是0 1 2 3 4 5 ..依次递增
				for( int i = 0 ; i <= 10 ; i++) {
					//打印每次获取到的i的值
					System.out.println(i); 
				}
				//练习2：打印10到0  -- TODO  画流程图 !!!!
		//		for(开始位置;判断条件;更改条件) {}
				for(int i = 10 ; i >= 0 ; i-- ) {
					System.out.println(i);
				}
				
				//练习3：打印8,88,888,8888
		//		for(开始位置;判断条件;更改条件) {}
				for( int i = 8 ; i <= 8888 ; i = i*10+8 ) {
					System.out.println(i);
				}
				//TODO 求【1,100】中，偶数的和
				int sum = 0 ; //定义变量,记录和
				//1,拿到100以内的每个数
				for (int i = 1; i <= 100; i++) {
					//2,判断这个数是不是偶数
					if(i % 2 == 0) {
						//3,给偶数求和
						sum = sum + i ;
					}
				}
				System.out.println("100以内的偶数和是:"+sum);
						
				
				
			}
			
		}

嵌套for循环:

--1,语法
       for(开始条件;判断条件;更改条件){//外循环
           for(开始条件;判断条件;更改条件){//内循环
               循环体;
           }
       }

2.入门案例

package cn.tedu.fordemo;
		//测试 嵌套for循环
		public class Test3_For2 {
			public static void main(String[] args) {
				//总结1 : 当外循环i变化1次时,内循环j要变化5次.
				//当i=1时,判断成立,输出i的值1,并输出j的值1 2 3 4 5
				//当i=2时,判断成立,输出i的值2,并输出j的值1 2 3 4 5
				//当i=3时,判断成立,输出i的值3,并输出j的值1 2 3 4 5
				for(int i = 1 ; i < 4 ; i++ ) {//定义外循环,并执行3次
					System.out.println(i);
					for(int j = 1 ; j < 6 ; j++) {//定义内循环,并执行5次
						System.out.println(j);
					}
				}
				System.out.println();//换行
				//总结2: 外循环控制行,内循环控制列
				//第一轮循环,当i=1时,执行第三大步,同一行展示***,换行
				//第二轮循环,当i=2时,执行第三大步,同一行展示***,换行
				for( int i = 1 ; i <= 2; i++ ) {//提供外循环,执行2次
					for( int j = 1 ; j <= 3; j++ ) {//提供内循环,执行3次
						System.out.print("*");//同行展示
					}
					System.out.println();//换行
				}
				
			}
		}

打印左直角三角形:

//准备第一轮循环:int i = 1 时,内循环条件j <= 1 ;能执行1次,同一行展示*    换行
		//准备第二轮循环:int i = 2 时,内循环条件j <= 2 ;能执行2次,同一行展示**   换行
		//准备第三轮循环:int i = 3 时,内循环条件j <= 3 ;能执行3次,同一行展示***  换行
		//准备第四轮循环:int i = 4 时,内循环条件j <= 4 ;能执行4次,同一行展示**** 换行
		//准备第五轮循环:int i = 5 时,内循环条件j <= 5 ;能执行5次,同一行展示*****换行
				for( int i = 1 ; i <= 5 ; i++ ) {//外循环控制行,执行5次打印5行
					for(int j = 1 ;j <= i ; j++) {//内循环控制列,但是列数一直在变,不能写死
						System.out.print("*");//同行展示
					}
					System.out.println();//换行
				}

打印99乘法表:

//准备第一轮循环:int i = 1 时,内循环条件j=1;j<=1;能执行1次,输出1*1=1	换行
		//准备第二轮循环:int i = 2 时,内循环条件j=1;j<=2;能执行2次,输出2*1=2 2*2=4换行
		//准备第三轮循环:int i = 3 时,内循环条件j=1;j<=3;能执行3次,输出3*1=3 3*2=6 3*3=9换行
		//准备第...轮循环:
				for(int i = 1; i <= 9 ; i++) {//外循环控制行,i表示外循环
					for(int j = 1; j <= i ; j++) {//列数不固定,变化规律和行一样
		//				System.out.print("*");//同行展示
		//				System.out.print("3*2=6");
		//				System.out.print("行*列=积");
		//				System.out.print("i*j=i*j");
						System.out.print(i+"*"+j+"="+i*j+"	");//动态拼接i和j
					}
					System.out.println();//换行
				}

break和continue

用来终止循环，可以用两种方式

break: 中断当前循环，简单粗暴

for(){

       代码1

if(条件){

  代码3…

    break;//如果成立，直接跳出这个for循环

}

代码2…

}

continue：跳出本次循环，进入下一轮

for(){

       代码1

if(条件){

    代码3…

    continue;//如果成立，跳出本次for循环，进入下一轮

}

代码2…

}

循环结构2：while --先判断后执行

1,语法
       while(判断条件){
           循环体;
       }

public static void main(String[] args) {
				//1,产生一个随机数 -- n -- 产生n以内的整数,默认从0开始
				int random = new Random().nextInt(100) ;
				System.out.println(random);
				//4,后两步需要重复执行,放入循环结构中.
		//		while( random > 50 ) {//满足了判断条件才执行循环体
		//		while( true ){//while(true)是经典的死循环的写法! + 必须设置出口!
				for(int i = 1; i >= 1 ;i++){//for形式的死循环,让for的条件永远成立!
					//2,接收用户一直在输入的数字
					int input = new Scanner(System.in).nextInt() ;
					//TODO 3,比较
					if(input > random) {
						System.out.println("大了");
					}else if(input < random) {
						System.out.println("小了");
					}else if(input == random) {
						System.out.println("中了");
						break ; //5,合理的出口,让循环停下来!!
					}
				}
			}

循环结构3：do-while -- 先执行再判断 -- 循环体最少干一次.

1,语法
       do{
           循环体;
       }while(判断条件) ;

public static void main(String[] args) {
				//1,产生一个随机数 -- n -- 产生n以内的整数,默认从0开始
				int random = new Random().nextInt(100) ;
				System.out.println(random);
				//4,后两步需要重复执行,放入循环结构中.
		//		while( random > 50 ) {//满足了判断条件才执行循环体
		//		for(int i = 1; i >= 1 ;i++){//for形式的死循环,让for的条件永远成立!
				do{// !! 保证循环体代码最少执行一次 !!
					//2,接收用户一直在输入的数字
					int input = new Scanner(System.in).nextInt() ;
					//TODO 3,比较
					if(input > random) {
						System.out.println("大了");
					}else if(input < random) {
						System.out.println("小了");
					}else if(input == random) {
						System.out.println("中了");
						break ; //5,合理的出口,让循环停下来!!
					}
				}while( random > 50 ) ;
			}

,总结：
       --for --for(开始位置;循环条件;更改条件){循环体}
       --while -- while(循环条件){循环体}
       --do...while -- do{循环体}while(循环条件);
       --相同点
           -- 都是用来解决程序中重复干活的需求
       --不同点
           -- for:需要知道开始位置,并且知道要循环多少次,还要知道数据的变化规律
           -- while/do...while:不需要知道从哪儿开始循环多少次,只需要指定条件就行.
               -- while -- 是要先满足了判断条件才执行
               -- do...while -- 是要最少执行1次循环体

变量
   --1,随着变量出现的位置不同,作用和名字都不同.
   --2,出现在成员位置(在类里方法外)的变量叫做成员变量--整个类中都有效--不用赋值也有默认值
   --3,出现在局部位置(方法里)的变量叫做局部变量--方法里有效--必须手动赋值
   --4,变量使用时有一个原则:就近原则

package cn.tedu.basic;
		import org.junit.Test;
		//测试 变量
		public class Test3_Variable {
			//2,出现在类里方法外的变量--是成员变量--作用于整个类中--可以不赋值,会有默认值
			//4,成员变量,都有默认值.
			//整数类型默认值是0,小数类型默认值是0.0,boolean类型默认值是false
			int count ;
			int age = 10;
			boolean flag;
			//单元测试JUnit方法:
			//要求:@Test  public void 方法名(){方法体}
			//测试:选中方法名,右键,run as...junit test...
			@Test
			public void show() {
				//1,出现在方法里的变量--是局部变量--必须初始化--作用于方法里
				int age = 0;
				System.out.println(age);//3,就近原则 - 输出0
				System.out.println(count);
				if(! flag) {//flag的默认值是false,取反,就是true,条件成立,输出1.
					System.out.println(1);
				}
			}
			
		}

方法
   --1,被命名的代码块，方法可以含参数可以不含参数
   --2,语法:
       方法的修饰符方法的返回值方法名([参数列表...]){ 方法体 }
   --3,方法的调用 -- 是指调用了指定的方法

package cn.tedu.method;
		//测试方法
		public class Test4_Method {
			public static void main(String[] args) {
				System.out.println(1);
				System.out.println(2);
				//1,调用指定方法
				method() ;
				System.out.println(3);
		//		function() ;//3,调用指定方法
			}
		//	方法的修饰符  方法的返回值  方法名([参数列表...]){  方法体  }
			//4,创建function()
			public static void function() {
				System.out.println("function()...");
			}
			//2,创建method()
			public static void method() {
				System.out.println(4);
				System.out.println(5);
				System.out.println(6);
			}
		}

4,方法的参数

package cn.tedu.method;
		//测试  方法 传参
		public class Test5_Method2 {
			public static void main(String[] args) {
				//1,调用指定方法求平方
				method(10);
				//4,求10的5倍的结果
				function(10);
				//TODO 5, 求 1,2和
				add(1,2);
				add2("jack",5,10);
				add3(5,10,"jack");
			}
			public static void add3(int a,int b,String c) {
				//a+b中  +用来完成加法运算.  +c用来拼接字符串. 
				System.out.println(a+b+c);//15jack
			}
			public static void add2(String a,int b,int c) {
				//+ 在字符串间,用来做拼接
				System.out.println(a+b+c);//jack510
			}
			//TODO 6,创建求和方法
			public static void add(int a,int b) {
				System.out.println(a+b);
			}
			//3, 创建 求5倍的方法
			public static void function(int x) {
				System.out.println(5*x);
			}
			//2, 创建method(参数类型  参数名) --其中,参数类型必须 匹配!!
			public static void method(int  a) {
				System.out.println(a*a);
			}
		}

--5,方法的返回值

//测试 方法返回值
        public class Test6_Method3 {
            public static void main(String[] args) {
                //1, 调用add方法求和 并把结果返回 交给sum保存
                int sum = add(5,10) ;
                System.out.println(sum);
                
                int sum2 = add2(1,2,3);
                System.out.println(sum2);
                
                String sum3 = add3("jack",1,2);
                System.out.println(sum3);//jack12
                
                //TODO random()产生随机整数并返回
                int num = random(100);
                System.out.println(num);
            }
        //    修饰符 返回值类型 方法名(参数列表) {}
            //创建 random(100);
            public static int random(int n){
                return new Random().nextInt(n);//产生n以内的随机数并返回
            }
            
            //创建add3("jack",1,2);
            public static String  add3(String a,int b,int c) {
                return a+b+c;
            }
            //创建add2(1,2,3);
            public static int add2(int a,int b,int c){
                //通过return关键字把结果返回给sum2保存
                return a+b+c ;
            }
            
            //创建add(5,10) ;
            public static int add(int a,int b){
                //3,通过return关键字,把结果返回给外界的调用位置
                return a+b ;
            }
            
        }

方法的重载Overload：

--1,是指在一个类里的现象,存在多个同名的方法,但是,参数列表不同(可以个数相同但是类型不同 ,也可以个数不同)
--2,练习1：数字求和

package cn.tedu.overload;
		//测试 方法重载Overload  -- 在一个类里,存在多个同名的方法,但是参数列表不同
		//目的:为了体现程序的灵活性,对外提供多个同名方法,方便外界使用
		public class Test1_Overload {
			public static void main(String[] args) {
				//数字求和
				add(5,10);//匹配add(int a,int b)
				add(1.1,2.2);
			}
			//add(1,2)
			public static void add(int a,int b) {
				System.out.println(a+b);
			}
			//add(1.1,2.2)
			public static void add(double a,double b) {
				System.out.println(a+b);
			}
			//add("jack",1,2)
			public static void add(String a,int b,int c) {
				System.out.println(a+b+c);
			}
			//add(1,2,"jack")
			public static void add(int a,int b,String c) {
				System.out.println(a+b+c);
			}
		}

练习2：数据的打印

package cn.tedu.overload;
		//测试 方法重载Overload  -- 在一个类里,存在多个同名的方法,但是参数列表不同
		public class Test2_Overload2 {
			public static void main(String[] args) {
		//		练习2：数据的打印
				print(10000);
				print(9.9);
			}
			//为了体现灵活,提供多个print(),啥数据都能打印
			//print(10);
			public static void print(int a) {
				System.out.println(a);
			}
			//print(1.1);
			public static void print(double a) {
				System.out.println(a);
			}
			//print(true);
			public static void print(boolean a) {
				System.out.println(a);
			}
			//print("jack");
			public static void print(String a) {
				System.out.println(a);
			}
		}

数组:--1,概念
       作用就是用来存储多个数据的容器.类似于水杯.英文名称叫Array.标志是[].专门用来存多个相同类型的数据
   --2,特点
       -- 数据都有下标
       -- 下标是从0开始的,下标的最大值是数组的长度-1
       -- 想要获取数组里的数据,存的是啥? -- a[0] a[1] a[2] ...
       -- 数组一旦创建,长度不能改变!!
   --3,创建数组 -- 数组类型[] 数组名 = new 数组类型[数组的长度] ;
       --动态初始化
           -- int[] a = new int[5];
       --静态初始化
           -- int[] b = new int[]{1,2,3,4,5};
           -- int[] c = {1,2,3,4,5};

练习1：数组中存入hello
		package cn.tedu.array;
		//测试 数组
		public class Test3_Array {
			public static void main(String[] args) {
				//1,创建数组
				//静态--char类型的默认值\u0000
				char[] a = new char[] {'h','e','l','l','o'} ;
				char[] b = {'h','e','l','l','o','e','l','l','o','e','				','o','e','l','l','o'} ;
				System.out.println(a.length);//获取数组长度
				System.out.println(b.length);//获取数组长度
				//动态
				char[] c = new char[5];//都是默认值\u0000
				c[0] = 'h' ;//把0下标对应的元素修改为'h'
				c[1] = 'e' ;//把1下标对应的元素修改为'e'
				//c[2] = 'l' ;//2下标没改,就是默认值本身
				c[3] = 'l' ;//把3下标对应的元素修改为'l'
				c[4] = 'o' ;//把4下标对应的元素修改为'o'
				
				//TODO  数组里有下标为5的元素吗?????
				
				System.out.println(a);
				System.out.println(b);
				System.out.println(c);
			}
		}

数组的遍历/循环 --下标
for(开始位置;判断条件;更改条件){循环体}
for(从下标为0开始 ; 下标的最大值是<=数组的长度-1;下标++ ){循环体}

package cn.tedu.array;

		import java.util.Random;

		//  测试  数组的练习
		public class Test4_Array2 {
			public static void main(String[] args) {
				//------练习1：输出每个月的天数
					// 1,创建数组 -- 动态 / 静态
					int[] a = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
					// 2,遍历数组 -- 用下标
					// int i = 0 是指从下标为0的位置开始--i代表下标
					//i < a.length 是指下标的最大值可以取到长度-1
					//i++  是指下标的变化规律是依次递增
					//for(int i = 0 ; i < a.length ; i++) {
					for (int i = 0; i <= a.length - 1; i++) {
						//System.out.println( a[i] );//打印
						System.out.println( i+1+"月有"+a[i]+"天" );//打印
					}

//---------练习2：遍历数组，存入1到10
					//创建数组--动态
					int[] b = new int[10];
					//遍历数组,并存入1-10
					for (int i = 0; i < b.length; i++) {
						b[i] = i+1 ;
					}
					//打印数组
					for (int i = 0; i < b.length; i++) {
						System.out.println( b[i] );
					}

//---------练习3：创建随机数组
					//创建数组--动态
					int[] c = new int[10];
					//遍历数组,并存入随机数
					for (int i = 0; i < c.length; i++) {
						c[i] = new Random().nextInt(100) ; 
					}
					//打印数组
					for (int i = 0; i < c.length; i++) {
						System.out.println(c[i]);
					}
			}
		}

数组工具类Arrays
   --1,Arrays.toString(数组)--把数组里的数据,拼接成字符串展示
   --2,Arrays.sort(数组)--把数组里的数据进行排序,默认是从小到大
   --3,Arrays.copyOf(数组，新的长度)--把原数组进行复制

package cn.tedu.array;

		import java.util.Arrays;

		//测试 数组工具类Arrays
		public class Test5_Arrays {
			public static void main(String[] args) {
				int[] a = new int[] {1,2,3,4,5} ;
				method(a);//toString()---用来把数组里的数据变成字符串展示
				sortArr();//sort()--可以对无序数组进行排序
				copyOfArr();//copyOf()---复制数组
			}
			//copyOf()---复制数组
			public static void copyOfArr() {
				//准备原数组
				double[] a = {1.1,2.2,3.3,4.4,5.5,6.6};
				
				//开始复制--copyOf(m,n)--m是原数组名称--n是新数组的长度
				//当 新数组的长度 > 原数组长度时,会扩充新的位置--相当于扩容
				double[] b = Arrays.copyOf(a, 10);
				//[1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 0.0, 0.0, 0.0, 0.0]
				System.out.println( Arrays.toString(b) );
				
				//当 新数组的长度 < 原数组长度时,会截取前面的一部分数据--相当于缩容
				double[] c = Arrays.copyOf(a, 4);
				//[1.1, 2.2, 3.3, 4.4]
				System.out.println( Arrays.toString(c) );
			}
			//sort()--可以对无序数组进行排序
			public static void sortArr() {
				//创建乱序数组
				int[] a = {9,12,3,7,10};	
				//排序
				Arrays.sort(a);
				//打印数组
				System.out.println(a);//数组在内存中的地址值--[I@15db9742
				System.out.println(  Arrays.toString(a) );//[3, 7, 9, 10, 12]
			}
			//toString()---用来把数组里的数据变成字符串展示
			public static void method(int[] arr) {
				//打印数组里的数据
		//		for (int i = 0; i < arr.length; i++) {
		//			System.out.println(arr[i]);
		//		}
				
		//		String arrs = Arrays.toString(arr);
		//		System.out.println(arrs);//[1, 2, 3, 4, 5]
				
				//1,toString()---用来把数组里的数据变成字符串展示
				System.out.println( Arrays.toString(arr) );//[1, 2, 3, 4, 5]
				
			}
		}