------- android培训、java培训、期待与您交流！ ----------
JAVASE基础语法包括:
关键字
标识符
注释
常量、进制和进制转换
变量
数据类型和类型转换
运算符
语句
关键字概述:
被Java语言赋予特定含义的单词
关键字特点:
组成关键字的字母全部小写
标识符概述
就是给类,接口,方法,变量等起名字时使用的字符序列
组成规则
英文大小写字母
数字字符
$和_
注意事项
不能以数字开头
不能是Java中的关键字
区分大小写
标识符(常见命名规则)
包(其实就是文件夹,用于解决相同类名问题)
单级和多级分别举例 liuyi,cn.itcast
类或者接口
一个单词和和多个单词分别举例 Student,HelloWorld
方法和变量
一个单词和和多个单词分别举例 name,main,studentName
常量
一个单词和和多个单词分别举例 MAX,STUDENT_MAX_AGE
注释概述
用于解释说明程序的文字
Java中注释分类格式
单行注释
格式： //注释文字
多行注释
格式： /* 注释文字 */
文档注释
格式：/** 注释文字 */
注释是一个程序员必须要具有的良好编程习惯。
初学者编写程序可以养成习惯：先写注释再写代码。
将自己的思想通过注释先整理出来，在用代码去体现。
因为代码仅仅是思想的一种体现形式而已。
常量概述
在程序执行的过程中其值不可以发生改变
Java中常量分类
字面值常量
自定义常量(面向对象部分讲)
字面值常量:
字符串常量 用双引号括起来的内容 注意：字符串和其他类型的数据 使用 + 号运算的时候，会把字符串与其他类型的数据相连接，返回连接后的新字符串
"Hello" "java"
整型常量： 所有的整数byte，short，int，long
123 100 10000 -12
小数常量： 所有的小数 float、double
3.14 1.23
布尔常量:blooen
true真 false假
字符常量： 代表一个字符，使用一对单引号''char（0~65335）
'a' 'A' '0'
空常量： 什么都没有（数组的时候，具体的讲解）
null
class ConstantDemo ConstantDemo(常量名）ConstantDemo
{
//程序执行的主入口
//JVM通过main()来执行代码的
public static void main(String[] args)
{
//字符串常量
System.out.println("Hello");
//整型常量
System.out.println(12345);
//小数常量
System.out.println(3.14);
//布尔常量
System.out.println(true);
System.out.println(false);
//字符常量
System.out.println('a');
System.out.println('A');
System.out.println('0');
//错误的
//System.out.println('abc');
}
}
/*
不同进制数据的演示
十进制： 0-9
二进制： 0,1 , 前面加0b 或者0B
八进制： 0-7 , 前面加0 表示8进制
十六进制：0-9 A(10) B(11) C(12) D(13) E(14) F(15) , 前面加0x 或者0X
注意： 相同的数据，进制越大， 值就越大
*/
class JinZhiDemo
{
public static void main(String[] args)
{
//十进制数据
System.out.println(100);
//二进制数据
System.out.println(0b100);
//八进制数据
System.out.println(0100);
//十六进制数据
System.out.println(0x100);
}
}
/*
不同进制数据的演示
十进制： 0-9
二进制： 0,1 , 前面加0b 或者0B
八进制： 0-7 , 前面加0 表示8进制
十六进制：0-9 A(10) B(11) C(12) D(13) E(14) F(15) , 前面加0x 或者0X
注意： 相同的数据，进制越大， 值就越大
*/
class JinZhiDemo
{
public static void main(String[] args)
{
//十进制数据
System.out.println(100);
//二进制数据
System.out.println(0b100);
//八进制数据
System.out.println(0100);
//十六进制数据
System.out.println(0x100);
}
}
/*
原码、反码、补码的练习
已知某数X的原码为10110100B，试求X的补码和反码。
符号位 数值位
原码： 1 0110100
反码： 1 1001011
补码： 1 1001100
已知某数X的补码11101110B，试求其原码。
符号位 数值位
补码： 1 1101110
反码： 补码-1得到反码
1 1101101
原码： 数值位取反
1 0010010
java中的数据类型:
基本数据类型：
占用的字节数
整数类型：
byte 1
short 2
int 4
long 8
浮点数类型：
float 4
double 8
字符类型：
char 2
布尔类型：
boolean 1
注意： 整数默认：int 小数默认：double
引用数据类型；后面讲解
数组
类
接口
class DataTypeDemo
{
public static void main(String[] args)
{
//整数byte类型 -128 -- 127
System.out.println(100);
//short类型
System.out.println(1000);
//int类型
System.out.println(10000);
//long类型, 需要在数据的后面加上l或者L
System.out.println(100000000000000L);
//浮点数
//float类型， 需要再数据的后面加上f 或者F
System.out.println(3.14F);
//double类型
System.out.println(3.199999999);
//字符类型
// char 类型 占用2个字节
System.out.println('a');
System.out.println('A');
//错误的
//System.out.println('Aasd');
//boolean 类型
System.out.println(true);
//-----------------------------------
//定义变量的格式：
// 数据类型 变量名 = 初始化值;
//整数 int
int x = 5;
x = 100;
System.out.println(x);
}
}
不同数据类型的变量演示
变量的格式：
格式1：
数据类型 变量名 = 初始化值；
方式2：
数据类型 变量名;
变量名 = 初始化值;
注意： 变量在使用前，必要要初始化
class DataTypeDemo2
{
public static void main(String[] args)
{
//整数
//变量格式： 数据类型 变量名 = 初始化值;
//方式1
int x = 20;
System.out.println(x);
//方式2
int y;
y = 20;
System.out.println(y);
//小数
float f = 3.14F;
System.out.println(f);
//char字符类型
char c = 'a';
c = 'h';
System.out.println(c);
//布尔类型 boolean 值 true, false
boolean b = true;
b = false;
System.out.println(b);
}
}
变量使用的注意事项：
1： 变量在使用之前，需要初始化
2： 在一个方法中，同名的变量只能有一个
变量的使用范围在当前的大括号内有效
3: 在一行上建议只定义一个变量
class DataTypeDemo3
{
public static void main(String[] args)
{
int x = 20;
//int x = 30;
int a,b;
a= 10;
b= 20;
System.out.println(a);
System.out.println(b);
//-------------------
int c;
int d;
c = 10;
d = 20;
System.out.println(c);
System.out.println(d);
//-----------------
int e,f;
e = f = 10;
System.out.println(e);
System.out.println(f);
//错误的
int e1,f1;//正确的
//int e2,int f2;//错误的
}
}
不同数据类型变量之间的转换
自动类型提升(隐式转换，默认转换)
小的数据类型 向 大的数据类型 转换时
class VarableDemo
{
public static void main(String[] args)
{
int a = 3;
int b = 5;
int c = a+b;//加法运算
System.out.println(c);
byte b1 = 10;
int b2 = 20;
int b3 = b1 + b2;//正确, 自动类型提升(隐式转换，默认转换)
System.out.println(b3);
//byte b4 = b1 + b2;//错误，可能损失精度
//System.out.println(b4);
}
}
类型转换之 强制类型转换
大的数据类型 向 小的数据类型转换时
目标类型 变量名=(目标类型)(被转换的数据);
注意： 在使用转换类型转换的时候，可能出现损失精度
class VarableDemo2
{
public static void main(String[] args)
{
byte b1 = 3;//-128 ---127
int b2 = 7;
//byte b3 = b1 + b2;//错误，可能损失精度
//可以通过强制类型转换来解决问题
byte b3 = (byte)(b1+b2);
System.out.println(b3);
}
}
类型转换之 强制类型转换
大的数据类型 向 小的数据类型转换时
目标类型 变量名=(目标类型)(被转换的数据);
注意： 在使用转换类型转换的时候，可能出现损失精度
class VarableDemo2
{
public static void main(String[] args)
{
byte b1 = 3;//-128 ---127
int b2 = 7;
//byte b3 = b1 + b2;//错误，可能损失精度
//可以通过强制类型转换来解决问题
byte b3 = (byte)(b1+b2);
System.out.println(b3);
}
}
+的几种作用：
加法
正数
字符串连接符
class OperatorDemo2
{
public static void main(String[] args)
{
//正数
System.out.println(+20);
//加法运算
System.out.println(10+20);
int a = 5;
int b = 3;
System.out.println(a+b);
char ch = 'a';//97
System.out.println( ch + 1 );//98
System.out.println( (char)(ch+1) );//b ASCII
//字符串连接符
System.out.println( 'a' + "java" );
System.out.println(12345+"java"+67890);
}
}
算术运算符
++ --
++、--运算符号：
单独使用的时候： 自增1或者自减1
参与运算的时候：
如果++、--运算符在操作数的后面,先把x的值 赋值给 b， 然后再x自增1
例如： b = x++;
如果++、--运算符在操作数的前面，先x自增1， 然后再把增1后的结果 赋值给 b
例如： b = ++x;
class OperatorDemo3
{
public static void main(String[] args)
{
int a = 3;
int b = 4;
//a++;
//b++;
//a--;
//b--;
++a;
--b;
System.out.println(a);
System.out.println(b);
System.out.println("-----------");
int x = 3;
int y = 4;
//int z = x++; //z的结果是3
int z = ++x; //z的结果是4
System.out.println(x);
System.out.println(y);
System.out.println(z);
}
}
赋值运算符：
= , +=, -=, *=, /=, %=
+=: 把运算符左右两边的操作数相加，然后将相加后的结果赋值给左边的变量
注意：在使用赋值运算符的时候，要求运算符的左边必须是变量
int x;
x = 5;//正确
3 = 5;// 错误
class OperatorDemo5
{
public static void main(String[] args)
{
int a = 5;
int b = a + 3;
System.out.println(b);
int c = 10;
c = c + 5;
System.out.println(c);
int d = 10;
d += 5;
System.out.println(d);
}
}
顺序结构概述
是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
总的来说：写在前面的先执行，写在后面的后执行
顺序结构：
代码按照从上到下，依次执行
开始
↓
语言1
↓
语言2
↓
...
↓
结束
class OrderDemo
{
public static void main(String[] args)
{
System.out.println("我们早上9点上课");
System.out.println("我们12点下课");
System.out.println("我们下午5:30点下课吃饭");
System.out.println("over");
}
}
选择结构：
if结构
if语句第一种格式：
if(条件表达式) {
语句体
}
执行流程
首先判断关系表达式看其结果是true还是false。
如果是true就执行语句体。
如果是false就不执行语句体。
if语句的使用注意事项：
1: 条件表达式，无论是否复杂，要求最终结果必须是boolean类型结果。
2：if语句控制的语句体如果是一条语句，大括号可以省略；
如果是多条语句，就不能省略。建议永远不要省略。
3: if语句格式中， 不要写分号。
class IfDemo
{
public static void main(String[] args)
{
int a = 5;
if (a == 5)
{
System.out.println("a等于5");
}
if (a == 10)
{
System.out.println("a等于10");
}
System.out.println("over")；
}
}
if语句第二种格式：
if(条件表达式) {
语句体1;
}else {
语句体2;
}
执行流程
首先判断关系表达式看其结果是true还是false
如果是true就执行语句体1
如果是false就执行语句体2
需求：
获取两个数中的最大值？
分析：
1：键盘录入两个数。
2：比较大小,获取到最大的数。
import java.util.Scanner;
class IfDemo
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
//1:键盘录入两个数
System.out.println("请输入第一个数字");
int a = sc.nextInt();
System.out.println("请输入第二个数字");
int b = sc.nextInt();
//2：比较大小,获取到最大的数
int max;
if (a > b)
{
max = a;
} else {
max = b;
}
System.out.println("max="+max);
}
}
if语句第三种格式：
if(关系表达式1) {
语句体1;
}else if (关系表达式2) {
语句体2;
}
…
else {
语句体n+1;
}
执行流程
首先判断关系表达式1看其结果是true还是false
如果是true就执行语句体1
如果是false就继续判断关系表达式2看其结果是true还是false
如果是true就执行语句体2
如果是false就继续判断关系表达式…看其结果是true还是false
…
如果没有任何关系表达式为true，就执行语句体n+1。
需求：通过把学生考试成绩分等级来引出if语句的第三种格式
90-100 优秀
80-90 好
70-80 良
60-70 及格
60以下 不及格
分析：
1：键盘录入学生的成绩。
2： 根据分数进行判断，打印出对应的等级。
import java.util.Scanner;
class IfDemo
{
public static void main(String[] args)
{
//创建对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入学生成绩【1--100】");
int score = sc.nextInt();
if (score<0 || score > 100) {
System.out.println("成绩输入有误");
} else if (score>=90 && score<=100) {
System.out.println("优秀");
} else if (score>=80 && score<90){
System.out.println("好");
} else if (score>=70 && score<80){
System.out.println("良");
} else if (score>=60 && score<70){
System.out.println("及格");
} else {
System.out.println("不及格");
}
}
}
switch语句格式：
switch(表达式) {
case 值1：
语句体1;
break;
case 值2：
语句体2;
break;
…
default：
语句体n+1;
break;
}
格式解释：
switch表示这是switch语句。
表达式的取值：byte,short,int,char 小于等于4个字节的整数
JDK5以后可以是枚举
JDK7以后可以是String
case后面跟的是要和表达式进行比较的值
语句体部分可以是一条或多条语句。
break表示中断，结束的意思，可以结束switch语句
default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。
执行流程
首先计算出表达式的值：
其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
注意事项:
case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
default可以省略吗?
可以省略。一般不建议。除非判断的值是固定的。
break可以省略吗?
可以省略，一般不建议。否则结果可能不是你想要的。
default的位置一定要在最后吗?
可以出现在switch语句任意位置。建议放在最后。
switch语句的结束条件
遇到break
执行到程序的末尾
Switch 语法案例:
案例： 请输入数字1-7，打印出对应星期几
例如： 输入 3， 打印出星期三
分析：
1： 键盘录入一个数字 1-7 之间
2： 使用输入的值 与 所有的case 对比
a: 与哪一个case的值相等，执行对应的case中的语句体,遇到break,结束switch语句，执行后面的其他语句
b: 如果与所有的case的值都不相等，执行default语句中的语句体,遇到break,结束switch语句，执行后面的其他语句
import java.util.Scanner;
class SwitchDemo2
{
public static void main(String[] args)
{
//创建对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个数字【1-7】");
//接收键盘录入的数据
int week = sc.nextInt();
switch (week)
{
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("日期输入有误");
break;
}
System.out.println("over");
}
}
循环结构的分类：
for循环
while循环
do..while 循环
for循环语句格式：
for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
执行流程
A:执行初始化语句
B:执行判断条件语句，看其结果是true还是false
如果是false，循环结束。
如果是true，继续执行。
C:执行循环体语句
D:执行控制条件语句
E:回到B继续
For循环案例:
统计”水仙花数”共有多少个
水仙花: 指100-999之间的一个三位数
特点：各位上数的立方和相加 等于 该数本身
例如：153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27
分析：
a: 定义一个变量，用来记录共有多少个”水仙花数”
b: 获取到100-999之间的每一个数
c: 判断这个数是否为水仙花数
个位 = 153 % 10 = 3
十位 = 153 / 10 % 10 = 5
百位 = 153 / 10 / 10 % 10 = 1
千位 = ....
class ForDemo {
public static void main(String[] args) {
//a: 定义一个变量，用来记录共有多少个”水仙花数”
int count = 0;
//b: 获取到100-999之间的每一个数
for (int n=100; n<1000; n++) {
int ge = n%10;
int shi = n/10%10;
int bai = n/10/10%10;
//c: 判断这个数是否为水仙花数
if (n == ge*ge*ge + shi*shi*shi + bai*bai*bai) {
//”水仙花数” 数量加1
//count = count + 1;
count++;
}
}
System.out.println("水仙花数共有"+ count +"个");
}
}
while循环语句格式：
基本格式
while(判断条件语句) {
循环体语句;
}
扩展格式：
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
案例：
1: 水仙花数打印出来，同时打印共有多少个
第1个水仙花数是：153
第2个水仙花数是：370
第3个水仙花数是：371
第4个水仙花数是：407
class WhileDemo2 {
public static void main(String[] args) {
//1: 创建一个变量，用来记录共有多少个水仙花数
int count2 = 0;
int i = 100; //初始化表达式
while (i<1000) {
int ge = i%10;
int shi = i/10%10;
int bai = i/10/10%10;
//判断当前这个数是否为水仙花数
if (i == ge*ge*ge + shi*shi*shi + bai*bai*bai) {
//数量加1
count2++;
System.out.println("第"+count2+"个水仙花数是：" + i);
}
i++;
}
}
}
do…while循环语句格式：
基本格式:
do {
循环体语句;
}while((判断条件语句);
扩展格式
初始化语句;
do {
循环体语句;
控制条件语句;
} while((判断条件语句);
class DoWhileDemo {
public static void main(String[] args) {
int n = 0;//初始化语句;
do {
System.out.println("HelloWorld");//循环体语句;
n++;//控制条件语句;
}
while (n < 10);//判断条件语句
}
}
三种循环的区别及注意事项:
区别：
do…while循环至少会执行一次循环体。
for循环和while循环只有在条件成立的时候才会去执行循环体
注意事项：
写程序优先考虑for循环，再考虑while循环，最后考虑do…while循环。
1: 如果循环中的初始化变量，需要在循环结构后继续使用，请使用while循环，否则，使用for循环(推荐使用for循环)。
2: 如果明确需要循环次数，推荐使用for循环，否则使用while循环。
For循环嵌套案例：
打印如下图形：
*
**
***
****
*****
第一行 j=1; j<=1; j++
第二行 j=1; j<=2; j++
第三行 j=1; j<=3; j++
第四行 j=1; j<=4; j++
第五行 j=1; j<=5; j++
class ForForDemo {
public static void main(String[] args) {
for (int i=1; i<=5; i++) {//控制行数
for (int j=1; j<=i; j++) {//控制列数
System.out.print("*");
}
System.out.println();//换行
}
}
}
跳转语句：
break的使用场景：
在选择结构switch语句中
在循环语句中
离开使用场景的存在是没有意义的
break的作用：
跳出单层循环
跳出多层循环
带标签的跳出
格式：标签名: 循环语句
标签名要符合Java的命名规则
class BreakDemo {
public static void main(String[] args) {
//break;//在switch语句或 循环结果外使用就报错
for (int x=0; x<10; x++) {
if (x==2) {
break;
}
System.out.println(x);
}
System.out.println("over");
System.out.println("------------------");
for (int i=0; i<5; i++) {//控制行数
for (int j=0; j<4; j++) {//控制列数
if (j==2) {
break;
}
System.out.print("*");
}
System.out.println();
}
System.out.println("------------------");
wc:for (int i=0; i<5; i++) {//控制行数
nc:for (int j=0; j<4; j++) {//控制列数
if (j==2) {
//break nc;
break wc;
}
System.out.print("*");
}
System.out.println();
}
}
}
continue的使用场景：
在循环语句中
离开使用场景的存在是没有意义的
continue的作用：
单层循环对比break，然后总结两个的区别
break 退出当前循环
continue 退出本次循环
也可以带标签的使用(不演示了)
做一个练习
class ContinueDemo {
public static void main(String[] args) {
//continue;//不能在循环语句的外面使用
for (int i=0; i<5; i++) {
if (i==2) {
break;
//continue;
}
System.out.println(i);
}
System.out.println("---------------");
for (int i=0; i<5; i++) {
if (i==2) {
//break;
continue;
}
System.out.println(i);
}
}
}
Return跳转语句：
关键字不是为了跳转出循环体，更常用的功能是结束一个方法，也就是退出一个方法。
跳转到上层调用的方法。这个在方法的使用那里会在详细的讲解。
演示案例：
结束循环其实是结束了main方法
class ReturnDemo {
public static void main(String[] args) {
for (int i=0; i<5; i++) {
if (i==2) {
//break;
//continue;
return;
}
System.out.println(i);
}
System.out.println("over");
}
}
break: 结束当前循环，执行循环后面的代码
结果：
0
1
over
continue: 结束本次循环，继续下一次的循环
结果
0
1
3
4
over
return: 结束当前循环,其实上它是把包含循环的 方法结束了，导致了程序的结果
return执行后，后面的语句不执行了
结果
0
1
方法：
简单的说：方法就是完成特定功能的代码块
在很多语言里面都有函数的定义
函数在Java中被称为方法
格式：
//public static/ int/ sum(a,b)/{ / 修饰符 /返回值类型/ 参数类型/{
// int sum = a + b; 方法体
//return 返回值
}
修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
方法体;
return 返回值;
}
方法格式解释：
修饰符 比较多，后面会详细介绍。目前public static
返回值类型 用于限定返回值的数据类型
方法名 :一个名称，为了方便我们调用方法
参数类型: 限定调用方法时传入参数的数据类型
参数名 :是一个变量，接收调用方法时传入的参数
方法体 :完成功能的代码
return :结束方法以及返回方法指定类型的值
返回值: 程序被return带回的结果，返回给调用者
方法的注意事项：
1: 方法不调用不执行
2: 方法与方法是平级关系，不能嵌套定义
3: 方法定义的时候参数之间用逗号隔开
4: 方法调用的时候不用在传递数据类型
5: 如果方法有明确的返回值，一定要有return带回一个值
如何写一个方法呢?两个明确
返回值类型 明确功能结果的数据类型
参数列表 明确有几个参数，以及参数的类型
按照格式和两个明确来完成如下功能
需求：两个数据之和的案例
返回值类型： int
参数列表： int a, int b
有返回值的方法调用的方式
直接调用方法(通常不这么使用)
赋值调用方法
输出调用方法
class MethodDemo {
public static void main(String[] args) {
//直接调用方法
getSum(3, 4);
//赋值调用方法
int sum = getSum(4,5);
System.out.println(sum);
//输出调用方法
System.out.println( getSum(4,10) );
//-------------------------
int i = 10;
int j = 20;
int sum2 = getSum( i, j);
System.out.println("sum2="+sum2);
}
//完成两个int数据相加，返回相加的结果
public static int getSum(int a, int b){
//int sum = a + b;
//return sum;
return a+b;
}
}
方法重载概述：
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
方法重载特点
与返回值类型无关，只看方法名和参数列表
在调用时，虚拟机通过参数列表的不同来区分同名方法
注意：方法的重载
1：与返回值无关
2: 与参数名称无关
需求：
方法：返回int数据类型两个数相加的结果
方法：返回int数据类型三个数相加的结果
方法：返回int数据类型四个数相加的结果
class MethodDemo7 {
public static void main(String[] args) {
System.out.println( add(2,3) );
System.out.println( add(2,3,5) );
System.out.println( add(2,3,5,10) );
}
//两个数相加
public static int add(int a, int b){
return a+b;
}
//三个数相加
//public static int add2(int a, int b, int c){
public static int add(int a, int b, int c){
return a+b+c;
}
//四个数相加
//public static int add3(int a, int b, int c, int d){
public static int add(int a, int b, int c, int d){
return a+b+c+d;
}
}
数组的定义格式
格式1：数据类型[] 数组名;
格式2：数据类型 数组名[];
例如：
int[] arr;
int arr[];
代表着定义一个数组
数组初始化概述：
Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
数组的初始化方式
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
格式：
数据类型[] 数组名 = new 数据类型[数组长度];
数组长度：其实就是数组中元素的个数。
arr: 代表的是数组的名字，同时arr也相当于是一个变量，
这个变量记录着数组在内存中的位置
如何获取数组中元素的值？
通过数组名和编号可以获取到数组中元素的值， 这里的编号用专业的词语叫 索引(下标、角标)
格式：数组名[索引]
索引： 从0开始，到数组长度-1
class ArrayDemo {
public static void main(String[] args) {
int[] arr = new int[3];
System.out.println(arr);//[I@da6bf4
//获取数组中第一个元素的值
System.out.println(arr[0]);//0
//获取数组中第二个元素的值
System.out.println(arr[1]);//0
//获取数组中第三个元素的值
System.out.println(arr[2]);//0
}
}
数组案例：
数组获取最值(获取数组中的最大值最小值)
分析：
1：指定一个参照者，数组中的其中一个元素，推荐使用0元素
2: 从第二个元素起，与参照者进行比较，大的留下来继续比较
3：依次比较完毕后，剩下来这个大的就是最大值了
class ArrayTest{
public static void main(String[] args) {
//定义一个数组
int[] arr = {10,35,76,12,55};
int max = getArrayMax(arr);
System.out.println("max="+max);
int min = getArrayMin(arr);
System.out.println("min="+min);
}
//最小值
public static int getArrayMin(int[] array){
//指定参照者
int min = array[0];
//依次和min比较
for (int i=1; i<array.length; i++) {
//比较大小
if (array[i] < min) {
//更新最小值
min = array[i];
}
}
return min;
}
//最大值
public static int getArrayMax(int[] array){
//指定参照者
int max = array[0];
//依次和max比较
for (int i=1; i<array.length; i++) {
//比较大小
if (array[i] > max) {
//更新最大值
max = array[i];
}
}
return max;
}
}
二维数组：
/*
二维数组： 其实二维数组其实就是一个元素为一维数组的数组。
格式1
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组
n表示每一个一维数组的元素个数
格式2
数据类型[][] 变量名 = new 数据类型[m][];
m表示这个二维数组有多少个一维数组
这一次没有直接给出一维数组的元素个数，可以动态的给出。
举例：
int[][] arr = new int[3][2];
格式3
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化版格式：
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
举例：
int[][] arr = {{1,2,3},{4,6},{6}};
定义了一个二维数组arr
这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
每个一维数组有2个元素，可以通过arr[m][n]来获取
表示获取第m+1个一维数组的第n+1个元素
class Array2Demo {
public static void main(String[] args) {
//定义了二维数组
int[][] arr = new int[3][2];
System.out.println(arr);//[[I@19bb25a
//看一下里面的3个一维数组
System.out.println(arr[0]);//[I@da6bf4
System.out.println(arr[1]);//[I@1e58cb8
System.out.println(arr[2]);//[I@179935d
//获取第一个一维数组中的元素值
System.out.println(arr[0][0]);//第一个元素 0
System.out.println(arr[0][1]);//第二个元素 0
//把第一个一维数组中的第一个元素赋值
arr[0][0] = 100;
System.out.println(arr[0][0]);//第一个元素 0
}
}
二维数组案例：
打印杨辉三角形(行数可以键盘录入)
1
11
121
1331
14641
.......
规律：
两边赋值规律：
1
11
1*1
1**1
1***1
arr[i][0] = 1;
arr[i][i] = 1;
中间赋值规律：
arr[i][j] = arr[i-1][j-1] + arr[i-1][j]
打印规律：
*
**
***
****
for (int i=0; i<=n; i++) {
for (int j=0; j<=i; j++) {
SOP("*");
}
System.out.println();
}
import java.util.Scanner;
class Array2Test{
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入杨辉三角形的行数：");
int row = sc.nextInt();
//创建二维数组，用来存储图形
int[][] arr = new int[row][row];
//两边赋值规律：
for (int i=0; i<row; i++) {
arr[i][0] = 1;
arr[i][i] = 1;
}
//中间赋值规律:
for (int i=2; i<arr.length; i++) {
//arr[0],arr[1] 一维数组
for (int j=1; j<i; j++) {
//arr[i][j] 具体一维数组的元素
arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
}
}
//打印图形
printArray( arr );
}
//打印图形
public static void printArray(int[][] arr){
for (int i=0; i<arr.length; i++) {
//arr[0]...
//for (int j=0; j<arr[i].length; j++) {
for (int j=0; j<=i; j++) {
//arr[i][j] 元素值
System.out.print(arr[i][j] + "\t");
}
System.out.println();//换行
}
}
}