Java基础语法(一文让你通学java基础语法!!!)

Java基础语法

1.注 释:

Java的注释有3种，分别是单行注释、多行注释、文档注释，格式如下

//单行注释

/*多行注释*/

/**文档注释*/

2.数据类型

java是一种强类型语言.这就意味着必须为每一个变量声明一种数据类型,在java中一共有8种数据类型,分别如下:

2.1.整型(4种)

类型	存储需求	取值范围
byte	1字节	-128~127
short	2字节	-32 768~32 767
int	4字节	-2 147 483 648~214 748 647
long	8字节	-9 223 372 036 854 775 808~9 223 372 036 854 775 807

在java中,整型的范围与运行java代码的机器无关,这就解决了软件从一个平台移植到另一个 平台或者同一个平台不同操作系统的问题,相反C程序会针对不同的处理器选择最为高效的整型,这样会造成一个在32位处理器上运行很好的C程序在16位操作系统上运行时却发生溢出.由于java程序必须保证在每个机器上的运行结果相同,所以各种数据类型的取值范围必须固定.

2.2.浮点类型(2种)

浮点类型数据用于表示有小数部分的数值,在java中有2种浮点类型,分别如下:

类型	存储需求	取值范围
float	4字节	1.4E-45~3.4028235E38 (E是一个16进制数位)
double	8字节	4.9E-324~1.7976931348623157E308

2.3.char类型(1种)

char类型的值需要用单引号括起来,例如’A’是编码值为65的字符常量,而"A"是一个字符串.

类型	存储需求	取值范围
char	2字节	0~65535

2.4.boolean类型(1种)

boolean类型一般用来判定逻辑条件,注意:整型值与boolean值之间不能进行相互转换.

类型	存储需求	取值范围
boolean	1字节	true / false

java 字符串转换为Boolean值可以通过Boolean.valueof来实现字符串到boolean值的转换：只有字符串为true 且忽略大小写比如：True/TRue/TRUE等返回布尔值true，其他都返回false.

Boolean b1 = Boolean.valueOf("true");
System.out.println(b1);// true
Boolean hh = Boolean.valueOf("hh");
System.out.println(hh);// false
Boolean aFalse = Boolean.valueOf("false");
System.out.println(aFalse);//false
Boolean aTrue = Boolean.valueOf("True");
System.out.println(aTrue);//true
Boolean aBoolean = Boolean.valueOf(null);
System.out.println(aBoolean);// false

3.变量与常量

3.1.常量

在java中,有多种类型常量,例如:

	    //字符串常量： 双引号括起来的内容
        System.out.println("hello");

        //字符常量： 单引号括起来的的一个字符
        System.out.println('a'); //小写字符
        System.out.println('A'); //大写字符
        System.out.println('1'); //数字字符
        System.out.println('中'); //文中字符
        System.out.println('+'); //符号字符

        //整数常量：直接写的数字
        System.out.println(100);

        //浮点常量：只写的小数
        System.out.println(3.14);

        //布尔常量：true或者false
        System.out.println(true);
        System.out.println(false);

        //空常量：null(该常量不能打印输出)
      

  还有一种使用关键字final指示常量,一般希望某个常量可以在一个类的多个方法中使用,通常称这些为类常量,一般使用 static final 设置一个类常量,需要注意:类常量一般要放在main方法外,如果使用public 修饰的话,多个类都可以使用这个类常量.

3.2.变量

变量从字面上理解就是可以发生改变的量。变量的本质其实是内存中的一小片内存空间，用来存储一个数据，而这个空间的的数据可以在一定范围内发生改变（这里所说的一定范围，就是数据类型）

3.2.1.变量声明和使用

格式

//单独定义变量
数据类型 变量名;
//定义变量并赋值
数据类型 变量名=初始值;

声明变量并使用

public static VariableDemo1{
    public static void main(String[] args){
        //单独声明变量
        int a; 
        a=10; //给变量a赋值为10
        System.out.println("a的值："+a);
        a=20; //修改变量a的值为20
        System.out.println("a的值："+a);

        //定义变量并赋值
        int b=10;
        System.out.println("b的值："+b);
        b=20; //修改变量b的值为20
        System.out.println("b的值："+b);
    }
}

3.2.1.变量的细节问题

变量的初始值:

变量没有赋值，不能够直接使用

public class VariableDemo2{
    public static void main(String[] args){
        //指定定义了变量，没有赋值
        int a; 
        //没有赋值的变量，不能直接使用
        System.out.println(a); //编译报错
    }
}

变量的作用域:

作用域指的是变量所在的{}范围内，一个变量定义在哪个{}范围内，就只能在哪个范围内有效。看如下代码

public class VariableDemo3{
    public static void main(String[] args){
        //变量a的作用域为 第3行~13行
        int a=10;
        {
            //变量b的作用域为 第5行~9行
            int b=20;
            System.out.println(b); //正确
        }
        System.out.println(a); //正确
        //这里超过了变量b定义的{}范围
        System.out.println(b); //编译报错
    }
}

同一行定义多个变量:

可以在一行定义多个相同类型的变量，代码如下:

public class VariableDemo4{
    public static void main(String[] args){
        //a和b都是int类型，值分别为3和4
        int a=3,b=4;
        System.out.println(a);
        System.out.println(b);
    }

4.数据类型转换

数据类型转换指的是同一个数据可以用不同的数据类型存储。比如我们需要用一个变量来表示整数10，能用那些数据类型来存储呢？我们发现byte、short、int、long都能存储整数10。

当这个变量先用byte类型存，后来又用int类型存，我们就说这个变量发生了自动类型转换；

当这个变量先用int类型存，后来又用byte类型存，我们就说这个变量发生了强制类型转换

4.1.自动类型转换(小转大)

public class DateTypeCastDemo1{
    public static void main(String[] args){
        //把整数10赋值给byte类型的变量a
        byte a=10;
        //变量a从byte类型转为int类型
        int b=a;
    }
}

以上代码中数据10刚开始用byte类型存储，后来用int类型存储，像这种从小大到的转换叫做自动类型转换，它不会改变数据大小。

4.2.强制类型转换(大转小)

//强制类型转换格式
数据类型 变量名=(数据类型)被转换的数据;
public class DateTypeCastDemo1{
    public static void main(String[] args){
        //把整数127赋值给byte类型
        int a=127;
        //把int类型的变量a强制转换byte类型
        byte b=(byte)a;
    }
}

此处我们可以理解成小桶水倒进大桶里完全可以(自动类型转换),大桶水倒进小桶里,需要大桶舍弃一些水然后倒进小桶(强制类型转换).

5.运算符

运算符就是在程序中参与运算符的符号，下面是我们要学习的一些运算符.

5.1.算数运算符

我们先来学习算数运算符的 +(加) -(减) *(乘) /(除) 以及 %(取模).

运算符	含义
+	加法运算、字符串拼接
-	减法运算
*	乘法运算
/	除法运算，整数相除只能得到整数
%	取模(余数)

用代码演示一下:
public class ArithmeticDemo1{
    public static void main(String[] args){

        System.out.println(5+3); //加法运算：8
        System.out.println(5-3); //减法运算：2
        System.out.println(5*3); //乘法运算：15
        System.out.println(5/3); //除法运算：1
        System.out.println(5%3); //取余运算：2

        //需要注意的是整数相除只能得到整数
        System.out.println(5/2); //2
        //如果想得到小数必须有小数参与运算
        System.out.println(5.0/2); //2.5
    }
}

5.1.1.+ 符号的其他用法

+符号不仅仅能做加法运算，它与字符和字符串参与运算还有其他功能。下面来看代码演示.

public class ArithmeticDemo2{
    public static void main(String[] args){
        //+符号与数值运算： 普通加法运算
        System.out.println(3+4); //7

        //+符号与字符运算： 先把字符转为int，再做加法运算
        System.out.println('a'+1); //98

        //+符号与字符串运算：字符串连接符
        Sytem.out.println("hello"+5+5); //hello55
        System.out.println(5+5+"hello"); //10hello
        System.out.println("5+5="+10); //5+5=10
    }
}

5.1.2.自增与自减

自增、自减两个特殊的运算符，它是自身原有数据上加1或者减1.

运算符	含义
++	自增
–	自减

++和–运算符的使用要两种情况来看，第一种是单独使用，第二种是混合使用。我们先来学习单独使用.

单独使用:

++和–放在操作数前面和后面，结果都是一样的，最终结果都会在原有数据上自增1或者自减1

public class ArithmeticDemo3{
    public static void main(String[] args){
        int a=3;
        int b=4;
        a++; //等价于 ++a
        System.out.println(a); // 4
        b--; //等价于 --bb
        System.out.println(b); // 3
    }
}

混合使用

++或者–可以放在操作数前面，也可以方法操作数后面。不管++或者–放在操作数后面还是前面，该自增1还是会自增1，该自减1还是会自减1，只是运算顺序有所不同
我们以++和赋值运算混合使用为例来做代码演示；–的用法和++类似，自己完成。

public class ArithmeticDemo4{
    public static void main(String[] args){
        int a=3;
        //等价于a++; int b=a;
        int b=++a;
        System.out.println();//4
        System.out.println(a);//4

        int x=3;
        //等价于int y=x; x++
        int y=x++;
        System.out.println(x);
        System.out.println(y);

        //常量不能做自增、自减运算
        System.out.println(5++); //错误写法
    }
}

总结一下：不管++(–)放在操作数的前面还是后面，最终都得+1或者-1，只不过运算顺序不一样

注意：常量不能做自增和自减运算

5.2.赋值运算符

赋值运算符的用途是把右边的结果赋值给左边。分为基本的赋值运算和扩展的赋值运算符。

先来看一下基本的赋值运算符，我们直接用代码演示

运算符	含义
=	把右边的值赋值给左边

public class AssignDemo1{
    public static void main(String[] args){
        //把右边的整数10,赋值给左边的int变量a
        int a=10;
    }
}

接下来学一下扩展的赋值运算符，分别为+=、-=、*=、/=、%=，它们用于把左右两边运算的结果重新赋值给左边。下面看一下代码演示

运算符	含义
+=	左右两边相加的结果赋值给左边
-=	左右两边相减的结果赋值给左边
*=	左右两边相乘的结果赋值给左边
/=	左右两边相除的结果赋值给左边
%=	左右两边取余数的结果赋值给左边

public class AssignDemo2{
    public static void main(String[] args){
        int a=20;
        //把a+10之结果再赋值给a,最终a=30
        a+=10;
        System.out.println(a); //30

        int b=5;
        //把b/2之结果再赋值给b,最终a=2
        b/=2;
        System.out.println(b); //2

        int c=10;
        //把y对4取余数的结果再赋值给y,最终,c=2
        c%=4;
        System.out.println(c); //2

        //注意：扩展的赋值运算符，隐含的有一个强制类型转换
        byte s=3;
        s+=4；//等价于 s=(byte)(s+4);
        System.out.println(s); //7
    }
}

5.3.比较运算符

  用来对两个数据做比较运算，最终结果只能是true或者false

运算符	含义
">‘’	大于
‘’>=‘’	大于等于
<	小于
<=	小于等于
==	判断相等
!=	判断不相等

5.4.逻辑运算符

逻辑运算可以对多个boolean条件进行连接，最终结果也是true或者false

运算符	含义
&(与)	两个条件都满足结果才是true
∣(或)	有一个条件满足结果就是true
!(非)	对结果取反
&&(双与)	两个条件都满足结果才是true，左边为false右边不运算
∣∣(双或)	有一个条件满足结果就是true，左边为true右边不运算

int a=3;
int b=4;
int c=5;
//&(与)： 左右两边都是true,结果才是true
System.println(a>b&b<c); //false
System.println(a<b&b<c); //true

//|(或)： 左右两边有一个是true,结果就是true
System.println(a>b|b<c); //true
System.println(a<b|b<c); //true

//!(非)： 对boolean值取反
System.println(!true); //false
System.println(!!false); //flase
&&和||有短路效果，运算结果与&和|是一样的，但是可以提高运算效率（推荐使用）

//&&(双与)： 左右两边都是true,结果才是true。特点：左边为false,右边不运算
System.println(a>b&&b<c); //false
System.println(a<b&&b<c); //true

//||(双或)： 左右两边有一个是true,结果就是true。特点：左边为true,右边不运算
System.println(a>b||b<c); //true
System.println(a<b||b<c); //true

5.5.三元运算符(条件运算符)

格式：数据类型 变量名 = 关系表达式 ? 表达式1 : 表达式2;

执行流程：
首先判断关系表达式的结果是true还是false,
如果关系表达式是true,三元运算的结果就是表达式1,
如果关系表达式是false,三元运算的结果就是表达式2,
注意:三元运算的结果必须被使用，要么直接打印输出，要么使用变量存起来.

5.6.运算符优先级

优先级	运算符	结合性
1	[]、()(方法调用)	从左向右
2	!、+、-、~、++、–	从右向左
3	*、/、%	从左向右
4	+、-	从左向右
5	<<、>>、>>>	从左向右
6	<、<=、>、>=、instanceof	从左向右
7	==、!=	从左向右
8	&	从左向右
9	^	从左向右
10	I	从左向右
11	&&	从左向右
12	II	从左向右
13	?:	从右向左
14	=、+=、-=、*=、/=、&=、I=、^=、~=、«=、»=、>>>=	从右向左

6.字符串(后续使用比较多,重点学习)

字符串在实际开发中用到的特别多,接下来我们先学习字符串的两种创建方式,分别如下:
第一种:直接赋值

String s1="hello world";
创建的字符串s1对象，只会在常量池中。hello world属于字面量(常量)，创建s1对象的时候，JVM会先去常量池中通过equals(key)方法，判断是否有相同的对象
如果有，则直接返回该对象在常量池中的引用；
如果没有，则会在常量池中创建一个新对象，再返回引用

第二种:使用new String()来创建字符串

String s2 = new String("你好");
此时有两种情况:
1.JVM首先会查找字符串池中是否存在值为"你好"的对象,如果存在,则直接去堆内存中创建一个"你好",并将堆内存中的“你好”对象的引用（内存地址）赋给变量s2.
2.JVM首先会查找字符串池中是否存在值为"你好"的对象，发现不存在，则在字符串池中创建一个“你好”的对象，在堆内存中也创建一个“你好”对象，并将
堆内存中的“你好”对象的引用（内存地址）赋给变量s2;

实例：
String s1 = new String("hello"); ①
String s2 = new String("hello");②
String s3 = "hello";③
String s4 = "hello";④
String s5 = "你好";⑤

程序按顺序执行理解示意图:

6.1.字符串常用操作

6.1.1.截取子串

String类的 subString 方法可以从一个较大的字符串中提取一个子串.例如:

String s1 = "hello";
String s2 = s1.subString(0,3);  // 从hello的0位置开始复制到第3位,但不包含第3位.
System.out.println(s2);  //  结果是hel

6.1.2.拼接

拼接即连接两个字符串,话不多说,直接上示例:

第一种情况:
String s1 = "hello,";
String s2 = "world";
String s3 = s1+s2; 
System.out.println(s3);   // "hello,world"
第二种情况:
如果一个字符串与一个非字符串的值进行拼接,那么后者会转换成字符串进行拼接.
int age = 10;
String s4 = "5+5=";
String s5 = s4+age;
System.out.println(s5);  // "5+5=10"

6.1.3.字符串分割

String类的split（）方法可根据给定的分隔符对字符串进行拆分。

String s1 = "你好,我好,大家好";
String [] split = s1.split(",");
for(int i=0 , i < split.length , i++ ){
System.out.println("索引" + i + "位置的元素为:"+ split[i]);   
// "索引0位置的元素为:你好"
// "索引1位置的元素为:我好"
// "索引2位置的元素为:大家好"
}

6.1.4.字符串分割

String 类中contains( )方法可以判断字符串是否包含指定内容。

String s1 = "Java编程思想";
boolean a = s1.contains("Java");
System.out.println(a);   //   true

6.1.5.比较字符串是否相等

比较字符串对象的内容是否相同，就需要用equals()方法。并且进行比较的字符串不为null，内容相同返回true。
注意:比较时前者不允许为null，否则直接报错，后者可以为null。

String s1 = "abc";
String s2 = "abc";
String s3 = "bcd";
System.out.println(s1.equals(s2)); //true
System.out.println(s1.equals(s3)); //false

7.输入输出

首先我们要学会使用基本的控制台实现输入输出.

7.1.读取输入

- 1.导包，写在class类的上面
  import  java.util.Scanner;
- 2.创建Scanner对象
  Scanner sc=new Scanner(System.in);
- 3.调用方法获取键盘录入数据
  int num=sc.nextInt();  //读取整数
  double num1 = sc.nextDouble(); //读取一个浮点数

7.2.格式化输出

System.out.print();  // 不换行打印
System.out.println();  // 换行打印

7.3.随机数

接下来我们要学习一个知识点叫做随机数，和键盘录入非常类似，我们来看一下。

产生随机数的步骤

//1.导包(可以先不写，由Idea自动导入)
import java.util.Random;
//2.创建随机数对象
Random r=new Random();
//3.获取键盘录入数据
int num=r.nextInt(10); //这里的10，表示随机数的范围是[0,10)

我们来做一个代码的演示

//1.导包
import java.util.Random;
public class Demo1{
  public static void main(String[] args){
    //2.创建Random对象
    Random r=new Random();

    //获取10个随机数
    for(int i=1;i<=10;i++){
      int num=r.nextInt(10);
           System.out.println(num);
    }
  }
}

8.控制流

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的，也就是说程序的流程对运行结果有直接的影响。在清楚每条语句的执行流程的前提下，才能通过控制语句的执行顺序来实现我们要完成的功能。

8.1.if语句

if是如果的意思，用来对条件进行判断，根据条件判断的结果是否成立，选择性的执行不同的语句体。

8.1.1.单if语句

先来看一下单if语句的格式和执行流程

//如果条件成立，执行下面的语句体；否则不执行
if(条件判断){
    语句体;
}

键盘录入一个整数，判断这个整数是否为偶数，如果这个数是偶数，就是输出”xx是偶数“(xx表示你输入的数)

Scanner sc=new Scanner(System.in);
System.out.println("请输入一个整数：");
int num=sc.nextInt();

//判断num是否为偶数
if(num%2==0){
    System.out.println(num+"是偶数");
}

上面代码只能判断输入的数是偶数的情况，输出这个数是偶数；如果输入的数不是偶数，将什么也做不了。所以就有了下面的if…else语句

8.1.2. if…else语句

还是先来看一下，if...else语句的格式和执行流程

//如果条件成立执行，语句体1;否则执行语句体2;
if(条件){
    语句体1;
}else{
    语句体2;
}

键盘录入一个整数，判断这个整数是否为偶数，如果这个数是偶数，就是输出”xx是偶数“；否则输出”xx是奇数“(xx表示你输入的数)

Scanner sc=new Scanner(System.in);
System.out.println("请输入一个整数：");
int num=sc.nextInt();

//判断num是否为偶数
if(num%2==0){
    System.out.println(num+"是偶数");
}else{
    System.out.println(num+"是奇数");
}

8.1.3. if…else if语句

如果我们需要对两种以上的情况进行判断，就可以用if…else if语句.

if(条件1){ //如果条件1成立，执行语句体1
    语句体1;
}else if(条件2){ //如果条件2成立，执行语句体2
    语句体2；
}else{ //如果以上条件都不成立，执行最后的else
    语句体n+1;
}

8.1.4.if语句的注意事项

在使用if语句时，注意下面几个问题:
​1. if后面()中的条件判断语句必须是boolean类型.
2.​ 如果是多个条件的情况，只会执行第一个条件为true的语句体；后面的条件就不再执行.
3.​ 如果{}中的语句体只有1条语句，{}可以省略

8.2.switch语句

switch语句用于在几个固定的值之间进行选择，如一个星期有7天，一年有12个月等等。废话少说，我们直接用一个案例来学习switch语句。根据键盘录入的整数，输出对应的星期。

Scanner sc=new Scanner(System.in);
int week=sc.nextInt();
//假设键盘录入的是5，下面的case 5与之匹配，就执行该处的语句体。
//遇到break就结束，如果没有遇到break会穿透(你可以尝试删掉break试一下)
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;
}

switch语句有下面的几个注意事项

switch小括号中的变量，类型只能是下面几种:

• byte short int char
• JDK7之后可以是字符串 （目前市场上用的最多的版本是JDK8）
• JDK5之后可以是枚举
• case后面的值只能是常量，不能是变量
• case后面的值不能重复
• break可以省略，但是会穿透

8.3.for语句

for这个单词没有特殊含义，它仅仅只表示接下来的代码是循环语句，有自己的执行流程。

/*
执行流程：
    1.先执行初始化语句;
    2.再执行条件判断语句;
        如果条件为true，就执行循环语句体;
        如果条件为false，就跳出循环，执行循环之后的代码
    3.条件控制语句
    4.回到2步骤继续执行
*/
for(初始化语句;条件判断语句;条件控制语句){
  循环语句体;
}

注意: 在开发中可能要遇到两层for循环,但是在条件成立时就要跳出两层for循环,而continue只是跳出本次循环,执行下次循环,还有break是跳出本层循环,并不能满足需求,所以我们需要借助break的标记,从而实现跳出两层for循环

flag:  //借助标记跳出两层for循环
for(初始化语句;条件判断语句;条件控制语句){
  for(初始化语句;条件判断语句;条件控制语句){
      if(条件){
         循环语句体;
         break flag;
     }
   }
}

8.4.while语句

接下来学习另外一种循环语句，叫做while循环，while循环的执行流程其实和for循环是一模一样的，只是格式不一样。在实际开发中根据需求来进行选择.

我们还是先学习一下while循环的格式和执行流程

初始化语句;
while(条件判断语句){
  循环语句体;
  条件控制语句;
}
我们通过一个简单的案例，来学习一下它的执行流程。打印输出5个"helloworld"

int i=1;
while(i<=5){
  System.out.println("helloworld");
  i++;
}

/*
执行流程分析：
    1) 开始i=1;
    2) 判断i<=5是否成立
        如果条件成立，执行大括号中的代码 打印输出一个"helloworld"
        如果不成立，while循环结束。
    3) 执行i++，i变成2
    4) 继续回到2步骤执行
*/

8.5.do while语句

还是通过一个简单得案例来演示，打印输出10个"helloworld".

int i=1;
do{
  System.out.println("helloworld");
  i++;
}while(i<=10);

do...while循环有一个特点，就是不管条件是否成立，循环语句体先执行一次再说。

9.数组

数组是用来存储多个数据的容器，有下面几个特点。

1.元素类型是一致的.
2.长度是不可变的.

9.1.数组的格式

//格式1：数据类型[]  数组名 = new 数据类型[长度];
int[] arrayA=new int[3];

//格式2：数据类型[]  数组名 = new 数据类型[]{元素1,元素2,元素....};
int[] arrayB=new int[]{10,20,30};

//格式3：数据类型[]  数组名 = {元素1,元素2,元素....};
int[] arrayC={10,20,30};

9.2.数组的元素访问

在数组中每一个元素都有一个索引与之对应，这个索引其实就是一个从0开始的整数

int[] array={8,7,4,6,9,10,12};
System.out.pritnln(array);  //地址值
System.out.println(array[0]); //8
System.out.println(array[4]); //9
System.out.println(array[6]); //12

9.3.数组的内存图

Java把内存分为栈、堆、方法区主要的三个区域

栈：存储局部变量(定义在方法中的变量)
堆：存储new出来的数据(数组就是new出来的)
方法区：存储字节码相关信息(编译后生成的class文件)

9.4.数组的常见操作

9.4.1.数组的遍历

遍历就是把数组中的元素一个一个的获取出来

int[] array={10,20,30,40};
//array.length: 数组的长度
for(int i=0;i<array.length;i++){
    System.out.println(array[i]);
}

9.4.2.数组元素求和

/*
1.定义一个求和变量sum
2.遍历所有需要求和的数据
3.把需要求和的数据和sum累加
*/
int[] array={10,20,30,40};

int sum=0;
for(int i=0;i<array.length;i++){
    sum+=array[i];  
}
System.out.println("所有元素的和为："+sum);

9.4.3.数组求最值

/*
打擂台的思路：
    1.把数组中0索引元素假设为最大值max(有一个人擂台)
    2.遍历其他元素和max进行比较(其他人和擂主比武)
        如果其他元素>max，就把其他元素赋值给max(擂主换人)
    3.循环结束之后，最终max就是最大值(最终的擂主)
*/
int[] array={8,20,7,29};
//把数组中0索引元素假设为最大值max(有一个人擂台)
int max=array[0];
//遍历其他元素和max进行比较(其他人和擂主比武)
for(int i=1;j<array.length;i++){
    //如果其他元素>max，就把其他元素赋值给max(擂主换人)
    if(array[i]>max){
        max=array[i];
    }
}
System.out.println("数组中元素的最大值为："+max);

到此,java基础语法已经学习完啦,如有问题评论或者私信博主都可以哦,最后大家一起加油,成为你心中最想成为的那个"猿".