Java语言基础（环境搭建、语法、变量、类型转换、运算符、控制语句、数组）

已于 2022-06-30 20:50:24 修改
阅读量1.2w 收藏 86
点赞数 24
文章标签： java javase
于 2021-06-09 21:19:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuan2019035055/article/details/117555533
版权
Java 同时被 2 个专栏收录
33 篇文章 52 订阅
订阅专栏
Java基础
11 篇文章 36 订阅
订阅专栏

目录

1 Java环境搭建

1.1 JDK下载

  • 官网：https://www.oracle.com/
  • 或浏览器搜索java8download

1.2 JDK安装

  • 傻瓜式点击下一步就行
  • 改路径安装更改JDK路径和JRE路径
  • 注意点：安装路径不要包含中文和空格，所有开发工具最好安装路径统一

1.3 JDK的安装目录

在这里插入图片描述

1.4 常用DOS命令

在这里插入图片描述

1.5 Path环境变量配置

  • 1.右键电脑>属性>高级系统设置>高级>环境变量
  • 2.系统变量配置：点击新建，名称为JAVA_HOME，变量值为jJava安装路径，如：F:\Java
  • 3.编写Path变量：系统变量>path>编辑>新建>添加 %JAVA_HOME%\bin
  • 4.验证：cmd窗口输入javac

1.6 IDEA编辑器

  • 快速生成语句
    • 快速生成main()方法：psvm，回车
    • 快速生成输出语句：sout，回车
  • 内容辅助键
    • Ctrl+Alt+space（内容提示，代码补全等）
  • 快捷键
    • 注释：
      1.单行：选中代码Ctrl+/，再来一次，就是取消
      2.多行：选中代码Ctrl+Shift+/，再来一次，就是取消
    • 格式化：Ctrl+Alt+L

2 基本语法

2.1 注释

  • 1.单行注释

    格式：//注释信息

  • 2.多行注释

    格式：/*注释信息*/

  • 3.文档注释

    格式：/**注释信息*/

2.2 关键字

  • 关键字的字母全部小写
  • 常用的代码编辑器，针对关键字有特殊的颜色标记，非常直观。

2.3 常量

在这里插入图片描述

2.4 数据类型

2.4.1 数据类型
  • 基本数据类型
    • 整数（byte、short、int、long）
    • 浮点数（float、double）
    • 字符（char）
    • 布尔（boolean）
  • 引用数据类型
    • 类（class）
    • 接口（interface）
    • 数组（[ ]）
2.4.2 内存占用和取值范围

在这里插入图片描述

2.5 变量

2.5.1 定义变量
  • 数据类型+变量名=值
2.5.2 变量的注意事项
  • 变量名不能重复
  • 变量未赋值不能使用
  • long类型的变量定义时，为防止整数过大，值后面加L
  • float类型的变量定义时，为防止类型不兼容，值后面加F
  • 一条语句可以定义多个变量，但需要使用逗号进行分割
  • 数值不能超过变量取值范围

2.6 标识符

2.6.1 标识符定义规则
  • 由字母、数字、下划线（_）和美元符（$）组成
  • 不能以数字开口
  • 不能是关键字
  • 区分大小写
  • 不能有空格
2.6.2 常用命名约定（驼峰法）
  • 小驼峰命名法：方法、变量
    • 标识符是一个单词时，首字母小写
    • 范例：name
    • 标识符由多个单词组成时，第一个单词首字母小写，其他单词首字母大写
    • 范例：firstName
  • 大驼峰命名法：类
    • 标识符是一个单词时，首字母大写
    • 范例：Student
    • 标识符由多个单词组成时，全部首字母大写
    • 范例：GoodStudent

2.7 类型转换

2.7.1 自动类型转换
  • 把一个表示数据范围小的数值或变量赋值给另一个表示数据范围大的变量
  • 范例：doubled = 10;
    在这里插入图片描述
2.7.2 强制类型转换
  • 把一个表示数据范围大的数值或变量赋值给另一个表示数据范围小的变量
  • 格式：目标数据类型+变量名 = (目标数据类型)值或变量
  • 范例：int k = (int)88.88

2.8 打印输出

  • System.out.print(打印内容) //打印后不换行

  • System.out.println(打印内容) //打印后换行

  • System.out.println() //没内容时起到换行效果

3 运算符

3.1 算术运算符

在这里插入图片描述

 public static void main(String[] args) {
        int a = 6;
        int b = 4;
        System.out.println(a + b); //10
        System.out.println(a - b); //2
        System.out.println(a * b); //24
        System.out.println(a / b); //1
        System.out.println(a % b); //2
        //除法得到商，取余得到余数
        
		//整数相除只能得到整数，要想得到小数要有浮点数参与
        System.out.println(6.0 / 4); //1.5
    }
3.1.1 字符的“+”操作
  • 字符进行“+”操作时，拿的是字符在计算机底层对应的数值进行操作
    • ‘A’ > 65
    • ‘a’ > 97
    • ‘o’ > 48
  • 算术运算符表达式中多个基本数据类型的值的时候，整个算术运算符的类型会自动提升
  • 提升规则：
    • 1.byte类型、short类型和char类型都会提升到int类型
    • 2.整个表达式的类型自动提升到表达式中最高等级操作数同样类型
      等级顺序：byte、short、char -> int -> long -> float -> double
  • 范例：
public class Demo {
    public static void main(String[] args) {
        int i = 10;
        char c = '0';
        System.out.println(i + c); //75

        //char cj = i + c;
        //char类型会自动提升到int类型
        int j = i + c;
        System.out.println(j); //75

		//10.1是double类型高于int类型
		//int k = 10 + 10.1; 
		double k = 10 + 10.1;
    }
}
3.1.2 字符串的“+”操作
  • 当 “+” 操作出现字符串时，这个 “+” 是字符串连接符，而不是算术运算符
  • 范例：
    System.out.println('it'+6+66) //it666
  • 在 “+” 操作中，如果出现字符串就是连接符，否则就是算术运算。当连续 “+” 操作时，从左到右依次执行。
  • 范例：
    System.out.println(1+99+'it') //100it

3.2 赋值运算符

在这里插入图片描述

  • 注意事项：扩张的赋值运算符隐含强制类型转换。

3.3 自增自减运算符

在这里插入图片描述

  • ++ 和 - - 可以放变量前面也可以放变量后面
  • 单独使用时， ++ 和 - - 放变量前后结果都是一样的
  • 参与操作使用时，如果放变量后面，先拿变量参与操作，后拿变量做++或- -；
    参与操作使用时，如果放变量前面，先拿变量做++或- -，后拿变量参与操作。
  • 范例：
public class Demo {
    public static void main(String[] args) {
        //单独使用
        int i = 10;
        //i++;
        ++i;
        System.out.println(i); //11
        //参与操作使用++在后面
        int b = 10;
        int j = b++;
        System.out.println(b); //11
        System.out.println(j); //10
        //参与操作使用++在前面
        int c = 10;
        int k = ++c;
        System.out.println(c); //11
        System.out.println(k); //11
    }
}

3.4 关系运算符

在这里插入图片描述

  • 关系运算符的结果都是boolean类型，要么true，要么false

3.5 逻辑运算符

符号作用说明
&逻辑与同真为真，其余为假（满足两个为真）
``逻辑或
^逻辑异或相同为false，不同为true
！逻辑非取反

3.6 短路逻辑运算符

符号作用说明
&&短路与作用与&相同，但是有短路效果
``
  • 范例：
public class Demo {
    public static void main(String[] args) {
        int i = 10;
        int j = 20;

        //&& :具有短路效果，符号左边为false的时候，右边就不执行
        //如果符号左边为true，右边要继续执行
        System.out.println((i++>100) && (j++>100)); //false & false,
        System.out.println("i="+i); //11
        System.out.println("j="+j); //20
    }
}

  • 注意事项：

    1、逻辑与 &：无论左边真假，右边都要执行

    2、短路与 &&：如果左边为真，右边执行；如果左边为假，右边不执行

    3、逻辑或 | ： 无论左边真假，右边都要执行

    4、短语或 ||：如果左边为假，右边执行；如果左边为真，右边不执行

3.7 三元运算符

  • 格式：关系表达式 ? 表达式1 ：表达式2；
  • 范例：a > b ? a : b;
  • 计算规则：
    首先计算关系表达式的值
    如果值为true，表达式1的值就是运算结果；
    如果值为false，表达式2的值就是运算结果。
  • 范例：
public class Demo {
    public static void main(String[] args) {
        int i = 10;
        int j = 20;

        //输出两个数据中的较大值
        int max = i > j ? i : j;
        System.out.println("max=" + max); //20
    }
}

3.8 Scanner使用的基本步骤

  • 导包的三种方式：

    • 1、手动导包：import java.util.Scanner;
    • 2、快捷键导包：创建好Scanner对象后，鼠标放在Scanner上按Alt+Enter
    • 3、自动导包：写Scanner单词创对象时，按tab补全导包

  • 导包的步骤：

    • 1.导包
    import java.util.Scanner; //导包必须在定义类上面
    • 2.创建对象
    Scanner sc = new Scanner(System.in); //只有sc是变量名可以变，其他都不可以变
    • 3.接收数据
    int i = sc.nextInt(); //i是变量名可以变，其他都不能变
sc.nextInt(); //Ctrl+alt+v：补全生成左边的内容

3.9 案例：三个和尚

import java.util.Scanner;
public class Demo {
    public static void main(String[] args) {
        //从键盘输出三个身高求出最高值
        Scanner sc = new Scanner(System.in);

        //键盘输入三个数值
        int height1 = sc.nextInt();
        int height2 = sc.nextInt();
        int height3 = sc.nextInt();

        int temp = (height1>height2) ? height1:height2;
        int max = (temp>height3) ? temp:height3;
        System.out.println(max);
    }
}

4 流程控制语句

4.1 流程控制语句分类

  • 顺序结构
  • 分支结构（if、switch）
  • 循环结构（for、while、do…while）

4.2 if语句

4.2.1 if语句格式1
  • 格式：
if(关系表达式) {
	语句体;
}
  • 执行流程：
    1、首先计算关系表达式的值
    2、如果关系表达式的值为true就执行语句体
    3、如果关系表达式的值为false就不执行语句体
    4、继续执行后面的语句内容
4.2.2 if语句格式2
  • 格式：
if(关系表达式) {
	语句体1;
}else {
	语句体2;
}
  • 执行流程：
    1、首先计算关系表达式的值
    2、如果关系表达式的值为true就执行语句体1
    3、如果关系表达式的值为false就执行语句体2
    4、继续执行后面的语句内容
4.2.3 if语句格式3
  • 格式：
if(关系表达式1) {
	语句体1;
}else if(关系表达式2){
	语句体2;
}
...
else {
	语句体n+1;
}
  • 执行流程：
    1、首先计算关系表达式1的值
    2、如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
    3、如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
    …
    4、如果没有任何关系表达式值为true就执行语句体n+1
  • 范例：
import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的成绩");
        int score = sc.nextInt();
        
        if(score == 100){
            System.out.println("满分");
        }else if(score >= 90) {
            System.out.println("优秀");
        }else if(score >= 80) {
            System.out.println("良好");
        }else if(score >= 70) {
            System.out.println("中等");
        }else if(score >= 60) {
            System.out.println("及格");
        }else {
            System.out.println("不及格");
        }
    }
}

4.3 switch语句

  • 格式：
switch(表达式) {
	case 值1:
		语句体1;
		break;
	case 值2:
		语句体2;
		break;
	...
	default:
		语句体n+1;
		break; //最后一个可以省略
  • 格式说明
    • 表达式：取值为byte、short、int、char，JDK5以后可以是枚举，JDK7以后可以是String
    • case：后面跟的是要跟表达式比较的值
    • break：表示中断结束的意思，用来结束switch语句
    • default：表示所有情况都不匹配的时候，就执行该处内容，和if语句中的else相似
  • 执行流程：
    1、首先计算表达式的值
    2、以此和case后面的值进行比较，如果有对应值，就会执行相应语句，在执行过程中，遇到break就会结束
    3、如果所有的case的值和表达式的值都不匹配，就会执行default里面的语句体，然后程序结束
  • 注意事项：在switch语句中，如果case控制的语句后面不写break，将会出现穿透现象，在不判断下一个case的情况下，向下运行，直到遇到break，或者整体程序结束
  • 案例：初夏秋冬（case穿透）
import java.util.Scanner;
public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个月份");

        int month = sc.nextInt();
        switch(month) {
            //case穿透
            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;
            default:
                System.out.println("你输入的月份有误");
        }
    }
}

4.4 for循环语句

  • 格式：
for(初始化语句;条件判断语句;条件控制语句){
    循环体语句;
}
  • 流程图
    在这里插入图片描述
  • 执行流程
    1、执行初始化语句
    2、执行条件判断语句，且看结果是true还是false
    如果是false，循环结束；如果是true，继续执行
    3、执行循环体语句
    4、执行条件控制语句
    5、返回到2继续
4.4.1 案例1: 输出数据
public class Demo {
    public static void main(String[] args) {
        // 输出1-5
        for(int i=1;i<=5;i++) {
            System.out.print(i+" "); //1 2 3 4 5
        }

        // 输出5-1
        for(int i=5;i>0;i--) {
            System.out.print(i + " "); //5 4 3 2 1
        }
    }
}
4.4.2 案例2: 求1-5数据和
public class Demo {
    public static void main(String[] args) {
        int sum = 0;
        for(int i=1;i<=5;i++) {
            sum += i;
        }
        System.out.println(sum); //15
    }
}
4.4.3 案例3: 求1-100偶数数据和
public class Demo {
    public static void main(String[] args) {
        int sum = 0;
        for(int i=1;i<=100;i++) {
            //判断i是否为偶数
            if(i%2==0){
                sum += i;
            }
        }
        System.out.println(sum);
    }
}
4.4.4 案例4: 打印1-100的数每行10个
public class Demo {
    public static void main(String[] args) {
        //打印1-100，每行10个
        int a = 0;
        for(int i=0;i<100;i++){
            a++;
            System.out.print(i+" ");
            if(a % 10 == 0){ //10代表每行10个，可以换为所需个数
                System.out.println(); //10个后换行
            }
        }
    }
}
4.4.5 案例5: 水仙花数
  • 什么是水仙花数？
    1、水仙花数是一个三位数
    111 333 456 999 530
    2、水仙花数的个位、十位、百位的数字立方和等于原数
    在这里插入图片描述
  • 怎么获取个位、十位、百位上的数
    1、个位数
    371 ；1就是原始数字对10进行取余的运算结果；371 % 10 = 1
    2、十位数
    371；371通过除以10，可以将7移动到个位上去（整数）；371 / 10 = 37
    37 ；37对10进行取余可以得到最后一位的值7 ； 37 % 10 = 7
    3、百位数
    371 ； 3就是原始数字除以100的结果（整除）；371 /100 = 3
    4、思考：任意数字的指定位置上的数值如何求？
    123456789 ； 先10000得到12345；再对10取余得到5
public class Demo {
    public static void main(String[] args) {
        for(int i=100;i<=999;i++) {
            int a = i % 10; //个位
            int b = i / 10 % 10; //十位
            int c = i / 100 ; //百位
            if(a*a*a + b*b*b + c*c*c == i) {
                System.out.println("水仙花数："+i); //有153、370、371、407
            }
        }
    }
}
4.4.6 案例6: 统计水仙花个数
public class Demo {
    public static void main(String[] args) {
        int count = 0; //存放判断水仙花的次数
        for(int i=100;i<=999;i++) {
            int a = i % 10; //个位
            int b = i / 10 % 10; //十位
            int c = i / 100 ; //百位

            if(a*a*a + b*b*b + c*c*c == i) {
                count++;
            }
        }
        System.out.print("水仙花共有"+count+"个"); //4个
    }
}

4.5 while循环语句

  • 用法：用来描述未知次数循环
  • 格式：
初始化语句；
while(条件判断语句) {
	循环体语句;//比如：输出内容
	条件控制语句;
}
  • 执行流程：
    1、执行初始化语句；
    2、执行条件判断语句，看其结果为true还是false
    如果是false，循环结束；如果是true，继续执行
    3、执行循环体语句
    4、执行条件控制语句
    5、回到2继续
  • 案例：珠穆朗玛峰
public class Demo {
    public static void main(String[] args) {
    //需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)
    //假如我有一张足够大的纸，它的厚度是0.1毫米。
	//请问，我折叠多少次，可以折成珠穆朗玛峰的高度?

        //1.定义计数器变量，用于统计折叠的次数
        int count = 0;
        //2.定义纸张厚度变量
        double paper = 0.1;
        //3.定义珠峰高度变量
        int zf = 8844430;
        //不知道循环次数，更适合使用while
        while(paper<=zf) {
            //循环过程中每次纸张堆叠，厚度加倍
            paper *= 2;
            //在循环中累加次数
            count++;
        }
        //循环结束后打印
        System.out.println(count); //27
    }
}

4.6 do…while循环语句

  • 格式：
初始化语句；
do{
	循环体语句;//比如：输出内容
	条件控制语句;
}while(条件判断语句);
  • 执行流程：
    1、执行初始化语句
    2、执行循环体语句
    3、执行条件控制语句
    4、执行条件判断语句，看其结果为true还是false
    如果是false，循环结束；如果是true，继续执行
    5、回到2继续

4.7 三个循环的区别

4.7.1 第一
  • do…while：先输出一次再进行判断（最少输出一次）
  • for、while：先判断再输出
4.7.2第二
  • for循环结束后变量不能使用
  • while循环结束后还可以使用（打印变量次数）
4.7.3死循环
  • for语句
for(;;){
    System.out.println("死循环");
}
  • while语句
while(true){
    System.out.println("死循环了");
}
  • do…while语句
 do{
    System.out.println("死循环");
}while(true);

4.8 跳转控制语句

  • continue：用于循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次执行
  • break：用于循环中，基于条件控制，终止循环体内容执行，结束当前整个循环
  • 范例：
public class Demo {
    public static void main(String[] args) {
        for(int i=1;i<=5;i++) {
            if(i%2==0) {
                //continue; //为偶数时跳过输出，1 3 5
                break; //当遇到偶数终止循环，只输出1
            }
            System.out.println(i);
        }
    }
}

4.9 循环嵌套

public class Demo {
    public static void main(String[] args) {
    	//九九乘法表
        for(int i=1;i<=9;i++) {
            for(int j=1;j<=i;j++) { //j<=i,当i=1时，j=1，输入一次后循环结束；i的值加1，i=2，j=1，输出两次后跳出...
                System.out.print(i +"*"+j + "=" + i*j +" ");
            }
            System.out.println();
        }
    }
}

4.10 Random使用步骤

  • 作用：用于产生一个随机数

  • 步骤：

    • 1.导包：
    import java.util.Random
    • 2.创建对象：
    Random r = new Random(); //r是变量名可变
    • 3.获取随机数：
    int number = r.nextInt(10); 
//获取数据的范围是：[0,10),包括0，不包括10
//number是变量名可变，数字10可变

  • 案例：猜数字游戏

import java.util.Scanner;
import java.util.Random;

public class Demo {
    public static void main(String[] args) {
        //1.生成随机数1-100
        Random r = new Random();
        int number = r.nextInt(100)+1; //

        //4.不确定次数用while，死循环
        while(true) {
            //2.键盘输出数字
            Scanner b = new Scanner(System.in);
            System.out.println("请输入要猜的数字:");
            int guessnumber = b.nextInt();
			//3.比较
            if(guessnumber>number) {
                System.out.println("你猜的数字"+guessnumber+"大了");
            }else if(guessnumber<number) {
                System.out.println("你猜的数字"+guessnumber+"小了");
            }else {
                System.out.println("猜对了");
                break;
            }
        }
    }
}

5 数组

  • 数组（array [əˈreɪ] ）是一种用来存储多个相同类型数据的存储模型

5.1 数组定义格式

  • 格式1（常用）
//数据类型[] 变量名；
int[] arr; //定义了一个int类型的数组，数组名是arr
  • 格式2
//数据类型 变量名[];
int arr[]; //定义了一个int类型的变量，变量名是arr数组

5.2 数组初始化

5.2.1 动态初始化
  • 初始化时只指定初始化长度，由系统为数组分配默认初始化值
  • 默认值：
    • int：默认值0
    • float：默认值0.0
    • boolean：默认值false
    • char：默认值是空字符
    • 引用数据类型：默认值null
  • 格式：
数据类型[] 变量名 = new 数据类型[数组长度];
  • 范例：
//new：为数组申请内存空间 3：数组长度/数组中元素个数
int[] arr = new int[3]; 
System.out.print(arr[0]) //0 系统分配的默认初始化值
5.2.2 静态初始化
  • 初始化指定数组元素，系统会根据元素个数，计算出数组的长度
  • 格式：
数据类型[] 变量名 = new 数据类型[]{数据1，数据2，数据3,.....}

数据类型[] 变量名 = {数据1，数据2，数据3，....} //简化格式
  • 范例：
int[] arr = new int[]{1,2,3};
System.out.println(arr[0]);

int[] arr1 = {1,2,3};
System.out.println(arr1[0]); //1

5.3 数组元素访问

  • 数组变量访问方式
  • 格式：变量名
  • 数组内部保存数据访问方式
  • 格式：数组名[索引] //0、1、2、3…
int[] arr1 = {1,2,3};
System.out.println(arr1); //[I@1b6d3586:内存空间地址值
System.out.println(arr1[0]); //1
System.out.println(arr1[1]); //2
System.out.println(arr1[2]); //3

5.4 内存分配

  • 栈内存：存储局部变量（定义在方法中的变量，如：arr，使用完毕立刻消失）
  • 堆内存：存储new出来的内容（实体、对象）（垃圾回收器空闲时回收）
    在这里插入图片描述

5.5 遍历数组

  • 获取数组元素个数，格式：数组名.length
public class Demo {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        for(int i=0;i<arr.length;i++) {
            System.out.println(arr[i]); // 1 2 3 4 5
        }
    }
}

5.6 获取数组最值

  • 执行流程：
    1、假设数组中的第一个元素为最大值
    2、遍历数组，获取每一个元素，准备进行比较
    3、如果比较的过程，出现了比max更大的，让max记录更大的值
    4、循环结束后，打印最大值
public class Demo {
    public static void main(String[] args) {
        int[] arr = {2,6,7,8,1,3,5,4,9};
        int max = arr[0];
        for(int i=1;i<arr.length;i++) {
            if(arr[i] > max) {
                max = arr[i];
            }
        }
        System.out.println(max); //循环结束后打印
    }
}

6 二维数组

6.1 二维数组格式

  • 格式一 ：数据类型[ ][ ] 变量名;
int[][] arr;
  • 格式二 ：数据类型 变量名[][];
int arr[][];
  • 格式三 ：数据类型[] 变量名[];
int[] arr[];

6.2 动态初始化

  • 格式：数据类型[ ][ ] 变量名 = new 数据类型[m][n];
    • m：行
    • n：列（每行可以存放多少数据）
  • 范例：
public class Demo {
    public static void main(String[] args) {
        int[][] arr = new int[2][3];
        for(int[] row : arr) {
            for(int data : row) {
                System.out.printf("%d\t",data); // 0 0 0
            }                                   // 0 0 0 
            System.out.println();
        }

    }

}

6.3 访问元素

public class Demo{
    public static void main(String[] args){
        /*
        问题:二维数组中存储的是一维数组，那能不能存入[提前创建好的一维数组]呢？
        */
        int[] arr1 = {11,22,33};
        int[] arr2 = {44,55,66};
        int[] arr3 = {77,88,99,100};

        int[][] arr = new int[3][3];

        arr[0] = arr1;
        arr[1] = arr2;
        arr[2] = arr3;
        //输出二维数组
        for(int[] row : arr) {
            for(int data : row) {
                System.out.printf("%d\t",data); //11 22	33
            }                                   //44 55	66
            System.out.println();               //77 88	99 100
        }
        
        System.out.println(arr[1][2]); //66
        System.out.println(arr[2][3]); //100
    }
}

6.4 静态初始化

  • 格式1：格式: 数据类型[ ][ ] 变量名 = new 数据类型[ ][ ] {{元素1，元素2…},{元素1,元素2…}};
int[][] arr = new int[][]{{11,22},{33,44}};
  • 格式2（简化格式）：数据类型[][] 变量名 ={{元素1,元素2},{元素1,元素2…}};
int[][] arr = {{11,22},{33,44}};

6.5 遍历二维数组

public class Demo{
    /*
      需求:已知一个二维数组 arr = {{11,22,33},{44,55,66}}
      遍历该数组，取出所有元素并打印
      */
    public static void main(String[] args){

        int[][] arr = {{11,22,33},{44,55,66}};
        // 遍历二维数组，取出里面每一个一维数组
        for(int i = 0;i < arr.length;i++){
            // 遍历一维数组,arr[i]就是每一个一维数组
            for(int j = 0;j < arr[i].length;j++){
                System.out.print(arr[i][j]+" "); //11 22 33 44 55 66
            }
        }
    }
}

前七章知识点案例总结

1.缝七过

在这里插入图片描述

public class Demo {
    public static void main(String[] args) {
        //个位是7，十位是7,7的倍数过
        //i%10==7 i/10%10==7 i%7==0    
        for (int i = 1; i <= 100; i++) {
            if (i % 10 == 7 || i / 10 % 10 == 7 || i % 7 == 0) {
                System.out.print(i + " ");
            }
        }
    }
}

2.不死神兔

在这里插入图片描述
在这里插入图片描述

public class Demo {
    public static void main(String[] args) {
        //1
        int[] arr = new int[20];

        //2
        arr[0] = 1;
        arr[1] = 1;

        //3
        for(int x=2;x< arr.length;x++) {
            arr[x] = arr[x-2] + arr[x-1];
            //arr[2] = arr[0] +arr[1];
        }
        System.out.println("第二十个月兔子个数为"+arr[19]); //6765
    }
}

3.百钱百鸡

在这里插入图片描述在这里插入图片描述

public class Demo {
    public static void main(String[] args) {
        //1.第1层循环，用来表示鸡公范围，x=0,x<=20
        for(int x=0;x<=20;x++){
            //2.第2层循环，表示母鸡范围
            for(int y=0;y<=33;y++){
                //3.小鸡数量
                int z = 100 -x -y;
                //4.三种鸡的总钱是否等于100
                if(z%3==0 && 5*x+3*y+z/3==100){
                    System.out.println("公鸡个数："+x+","+"母鸡个数"+y+","+"小鸡个数"+z);
//                    公鸡个数：0,母鸡个数25,小鸡个数75
//                    公鸡个数：4,母鸡个数18,小鸡个数78
//                    公鸡个数：8,母鸡个数11,小鸡个数81
//                    公鸡个数：12,母鸡个数4,小鸡个数84
                }
            }
        }
    }
}

4.数组元素求和

在这里插入图片描述

public class Demo {
    public static void main(String[] args) {
        int[] arr = {68,27,95,88,171,996,51,210};
        int sum = 0;
        for(int i=0;i< arr.length;i++) {
            if(arr[i]%10!=7 && arr[i]/10%10!=7 && arr[i]%2==0){
                sum += arr[i];
            }
        }
        System.out.println(sum); //1362
    }
}

5.数组内容相同

在这里插入图片描述

public class Demo {
    public static void main(String[] args) {
        int[] arr = {11, 22, 33, 44, 55, 66};
        //int[] arr2 = {11, 22, 33, 44, 55, 66}; //返回true
        int[] arr2 = {22, 11, 33, 44, 55, 66}; //返回false
        
        boolean a = compare(arr, arr2);
        System.out.println(a); 
    }
    public static boolean compare(int[] arr, int[] arr2) {
        //比较长度
        if (arr.length != arr2.length) {
            return false;
        }
        //比较元素内容
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] != arr2[i]) {
                return false;
            }
        }
        //都相同时
        return true;
    }
}

6.查找

在这里插入图片描述在这里插入图片描述

import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        int[] arr = {19,28,35,42,56};

        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个数");
        int number = sc.nextInt();

        int index = getIndex(arr,number);
        System.out.println("索引下标为："+index);

    }
    public static int getIndex(int[] arr,int number) {
        //索引变量
        int index = -1;
        //遍历数组
        for(int i=0;i< arr.length;i++){
            if(number==arr[i]){
                index = i;
                break;
            }
        }
        return index;
    }
}

7.反转

在这里插入图片描述在这里插入图片描述

public class Demo {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};

        //初始化两个索引变量用逗号隔开
        for(int start=0,end=arr.length-1;start<=end;start++,end--){
        	//反转
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
        for(int i=0;i< arr.length;i++) {
            System.out.print(arr[i]+" "); //55 44 33 22 11
        }
    }
}

8.评委打分

在这里插入图片描述

import java.util.Scanner;
public class Demo {
    public static void main(String[] args) {
        int[] arr = new int[6];
        Scanner sc = new Scanner(System.in);

        //1.键盘输入六个评委的分数
        for(int i=0;i< arr.length;i++) {
            System.out.println("请输入第"+(i+1)+"个评委打分：");
            arr[i] = sc.nextInt();
        }
        //printArray(arr);

        //2.调用getMax
        int max = getMax(arr);

        //3.调用getMin
        int min = getMin(arr);

        //4.调用getSum
        int sum =getSum(arr);

        //5.计算平均分
        int avg = (sum-max-min)/arr.length-2;
        System.out.println("选手最终得分是："+avg);

    }
    //获取所有元素和
    public static int getSum(int[] arr) {
        int sum = 0;
        for(int i=0;i< arr.length;i++) {
            sum += arr[i];
        }
        return sum;
    }

    //获取最小值
    public static int getMin(int[] arr) {
        int min = arr[0];
        for(int i=1;i< arr.length;i++) {
            if(arr[i] < min) {
                min = arr[i];
            }
        }
        return min;
    }
    //获取最大值
    public static int getMax(int[] arr) {
        int max = arr[0];
        for(int i=1;i< arr.length;i++) {
            if(arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }

    //遍历数组
    public static void printArray(int[] arr) {
        System.out.print("[");
        for(int i=0;i< arr.length;i++) {
            if(i==arr.length) {
                System.out.print(arr[i]);
            }else {
                System.out.print(arr[i]+",");
            }
        }
        System.out.print("]");
    }
}

8 import导包

  • 格式：`import 包名;
  • 范例：`Demo类中导入Student类的方法
    在这里插入图片描述
  • Student类
package Student;

public class Student {
    public void study(){
        System.out.println("学习");
    }
}
  • Demo类
package test;
import Student.Student;

public class Demo {
    public static void main(String[] args) {
        Student s = new Student();
        s.study(); //学习
    }
}
袁袁袁袁满
关注
  • 24
    点赞
  • 踩
  • 86
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
JAVA基础-语言
big_bit的博客
10-19 430
标识符 1.在程序中自定义一些名称 2.由26个字母组成；0-9；_ 和$ 3.数字不能开头 4.严格区分大小写，类名首字母大写较好 注释 1. 单行注释 // 2. 多行注释  /* 这是 注释 */ 3.java特有注释 /** 文档注释。  */ 4. 单行注释中可以有单行和多行注释； 5. 多行注释中可以有单行注释，
Java基础语法之变量、运算符、流程控制、数组和方法等基础语法
qq_38326107的博客
10-12 627
变量、运算符、流程控制、数组和方法等基础语法。Java程序的执行流程，符合Java语法规则的程序。 1.1.1.Java初识 对Java进行简单介绍，Java程序如何执行，以及Java程序的结构。 Java简介，JDK（JAVA开发工具包）=开发工具集（javac编译器工具、java命令解释执行等组件）+JRE（JAVA运行时环境）=开发工具集+JRE（JVM+Java标准类库），开发程序必须使用JDK，运行开发完成的程序只需JRE，JVM（JAVA虚拟机）是JAVA平台无关性（LINUX、WINDOWS等
Java基础--知识积累
AspiralMoon
11-30 233
1.注释 单行注释 // 多行注释 /*    */ 文档注释 /**      */ 初学者先写注释再写代码，先有思想后写代码实现 2.关键字 关键字全小写 goto和const为保留字存在，目前并不存在 3.标识符 英文大小写字母 数字字符 $和_ ！！不能以数字开头，不能史Java中的关键字，区分大小写 包（文件夹名）：要求全小写，一
Java基础全方位解析：从入门到精通（零基础学IT）
最新发布
老高的博客
07-03 1711
Java诞生于1995年，原属于SUN公司，2009年4月20日，美国数据软件巨头甲骨文公司（*Oracle*）宣布以74亿美元收购SUN公司。Java是最受欢迎的开发语言，已经火了20年，并将继续引领着IT的编程语言。// 定义一个名为Person的类// 成员变量// 无参构造器// 有参构造器// 方法：设置姓名// 方法：获取姓名// 方法：设置年龄// 方法：获取年龄return age;// 方法：显示个人信息// 主方法，用于测试 Person 类。
Java基础语言
Maketh1man的博客
02-23 210
所了解到的Java语言基础（任重而道远）基本的数据类型有1.数值型。1）整数类型（byte,short,int,long)          2)浮点类型（float，double)2.字符型。3.布尔型。和C中基本上一样，没有太大出入变量与常量标识符：可以理解为一个名字，就是类名，变量名，方法名，数组名，文件名等的有效字符序列。只能由字母，下划线，$,或数字组成，字母下划线或$开头且敏感于大小写...
【Java】<一> 语言环境
不管风吹浪打，胜似闲庭信步
09-06 1284
由于要进行软考了，所以需要提前了解一下Java的语言环境
java语言基本_JAVA基本语言
weixin_29062963的博客
02-18 200
一、基础语言要素1.1 标识符：用来给类、对象、方法、变量、接口和自定义数据类型命名的。组成：由数字，汉字，字母和下划线(_)，美元符号($)或人民币符号(￥)组成。在Java中是区分大小写的，而且还要求首位不能是数字。例如：下面的标识符是合法的：HelloWord，Hello_Word， $HelloWord，_sys_ta，OK，_23b，_3_下面的标识符是非法的：#HelloWord，He...
Java基础语法(HelloWorld、常识、常量、变量和数据类型、数据类型转换、运算符、方法、流程控制语句、数组、开发工具)
jxstudy的博客
06-27 485
HelloWorld、常识、常量、变量和数据类型、数据类型转换、运算符、方法、流程控制语句、数组、开发工具
java基础语言_java语言基础
weixin_35810223的博客
02-12 230
Java语言基础很多人认为学习Java语言之前必须要学习C++语言，其实并非如此，产生这种错误的认识是因为很多人在学习Java语言之前都学过C++语言。事实上，Java语言比C++语言更容易掌握。要掌握并熟练应用Java语言，就需要对Java语言的基础进行充分的了解。本讲对Java语言基础进行了比较详细的介绍，对于初学者来说，应该对本讲的各个小节进行仔细的阅读、思考，这样才能达到事半功倍的效果。通...
Java 语言基础
技术田园犬
07-22 164
Java基本数据类型 name 符号 类型 byte byte 有 字节 8 shout 有 短整型 16 int 有 整型 32 long 有 长整型 64 float 有 单精浮点型 32 double 有 双精浮点型 64 char -...
java基础语言_java基础语言有哪些
weixin_36016360的博客
02-12 695
java基础语言有哪些java基础语言是学习java最重要的环节，接下来，小编为您介绍了java基础语言有哪些，让我们一起看看吧！一、主体结构1、java程序的基本组成单元是类，类体中包括属性与方法；2、类的属性为全局变量，方法中的变量为局部变量；二、基本数据类型1、基本数值类型分为8种；由低到高排列顺序：byte2、整数类型 声明方法byte mybyte = 124 ；(-128~127)sh...
java语言基础介绍
qq_58293159的博客
03-12 1154
Java语言基础的介绍
Java语言的基础知识
m0_57254953的博客
06-19 6970
专升本复习
Java语言入门基础
ice_gang的博客
05-14 2563
Java语言简介0.Sun Microsystems 于1995年推出；1.1991年Sun 公司的James Gosling等人开始开发名称为Oak的语言。希望用于控制嵌入在有线电视交换盒、PDA等的微处理器；2.1994年将Oak 语言更名为Java；3.Java 即安全、可移植，又可以跨平台，而且人们发现它能解决Internet上的大型应用问题。开发Java程序三步走：1.编写源程序 —— ...
Java语言基础详细讲解
weixin_45536242的博客
07-08 2340
就像人与人之间交流使用的语言需要遵循一定的语法规则一样，Java语言也离不开特定语法的支持，如基本语法、数据类型、变量、常量、运算符与表达式、类型转换和输入输出等，只不过这些语法要比日常生活中语言的语法更加严谨。本章我们先来学习这些基本语法，为后续学习打下扎实的根基。2.1 Java基本语法作为一门流行的编程语言，Java有着它自己特定的语法格式，要想使用Java语言开发出一款功能完善的软件产品，就必须熟练掌握这些基本语法。当然，这些基本语法都是简单易懂的，包括基本格式、关键字、标识符、注释、编程风格等。2
java 的基础语句
wuthering_wind的博客
11-05 3243
对java基础语句的处理本次的本次一共要实现若干个独立的功能，我写在了一个程序中。下面是具体的代码：import java.util.Scanner; class ZuoYe{ public static void main(String args[]) { //1. 使用while循环，求1+11+111+1111+11111+111111。 Sys
java学习笔记：关键字、标识符、注释和常量/变量
励志的小胡子
09-15 696
 目标： 关键字 标识符 注释 常量和变量 关键字： 概述：被java语言赋予特定含义的单词 特点：组成关键字的字母全是小写 注意事项： goto和const作为保留字存在，目前不可使用 类似Notepad++这样的高级记事本，针对关键字有特色的颜色标记，非常直 关键字表： 标识符： 概述：就是给类、接口、方法、变量等起名字时使用的字符序列。 组成规则： 英...
java基础语言
崔崇鑫的博客，你linux/云运维工作中的百科全书。
10-08 238
项目取名建议： 域名反写 . 项目名称 . 模块名称 . 类名 cn.tedu. aproject. studentmanager. **** 当程序的运行结果与你所预期的结果不同时: 1.打桩: System.out.println(数据); 2.Debug调试工具:首先要添加断点(双击) 1)掌握四个键: 1....
java语言基础
儒雅随和丶mata坤的博客
10-04 506
【计算机基础知识】    计算机：Computer，俗称电脑。是一种能够按照程序运行，自动、高速的处理海量数据的智能化电子设备  计算机由两部分组成：硬件和软件  硬件：计算机系统中由电子、机械、光电元件组成的各种物理装置的总称（裸机）  软件：软件可以使计算机按照事先预定义好的顺序完成特定的功能，软件分为系统软件和应用软件        就是按照特定顺序组织的计算机数据和指令的集合 ...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

袁袁袁袁满

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值