1. Toy模板网首页
  2. > Toy博客

JAVA-02（语法介绍）

10月前 分类：Toy博客 阅读(11) 违法举报

这篇具有很好参考价值的文章主要介绍了JAVA-02（语法介绍）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

JAVA-02

Java流程控制

用户交互Scanner

Scanner类

属于IO流的类如果不关会一直占用资源

常用方法

​ 【Scanner scanner = new Scanner(System.in);】
​ .next(); 遇到空格就结束接收
​ .nextLine(); 遇到enter就结束接收
​ .hasNext() 判断是否有输入
​ .hasNextInt() 判断是否有整数输入
​ .close(); 关闭

举例【instance】
package com.xy.base;

import java.util.Scanner;

public class Demo11 {
    public static void main(String[] args) {

        //创建一个扫描对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方式接收：");
        //判断用户有没有输入字符串
        if(scanner.hasNext()){
            //使用next接收
            String str = scanner.next();
            System.out.println("输入的内容为："+str);
        }

        System.out.println("使用nextLine方式接收：");
        if(scanner.hasNext()){
            //使用next接收
            String str1 = scanner.nextLine();
            System.out.println("输入的内容为："+str1);
        }

        System.out.println("请输入一个整数:");
        //判断输入的是否为整数【判断是否有整数输入】
        if(scanner.hasNextInt()){
            int i = scanner.nextInt();
            System.out.println("输入的整数为："+i);
        }else{
            System.out.println("输入的不是整数！");
        }

        //凡是属于IO流的类如果不关会一直占用资源
        scanner.close();

    }
}

输入多个数字，并求其总和与平均值，每输入一个数字用回车确认，通过输入非数字来结束并输出执行结果

package com.xy.base;

import java.util.Scanner;

public class Demo11_instance {

    public static void main(String[] args) {
        //输入多个数字，并求其总和与平均值，每输入一个数字用回车确认，通过输入非数字来结束并输出执行结果
        int count = 0;
        double sum = 0;

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数据：");
        //while判断是否是数字输入
        while (scanner.hasNextDouble()){
            count++;
            sum = sum + scanner.nextDouble();
        }
        System.out.println(count + "个数据总和为：" + sum);
        System.out.println(count + "个数据平均数为：" + sum/count);

        //关闭！！！！！！不要忘记
        scanner.close();

    }
}

三种结构（顺序、选择、循环）

顺序结构

  1. Java最基本的结构，最简单的算法结构
  2. 任何算法都离不开的
  3. 一条一条从上到下执行
System.out.println("顺序结构！");
System.out.println("顺序结构！");
System.out.println("顺序结构！");

选择结构

1. if单选择结构
if(条件式){
	//满足表达式执行的语句
}
2. if...else双选择结构
if(条件式){
	//满足表达式执行的语句
}else{
	//不满足表达式执行的语句
}
3. if...else if多选择结构
if(条件式1){
	//满足表达式1执行的语句
}else if(条件式2){
	//满足表达式2执行的语句
}else{
	//都不满足执行的语句
}
4. 嵌套的if结构
if(条件式1){
	if(条件式1){
		//满足表达式1和2执行的语句
	}
}else{
	//不满足表达式1执行的语句
}
5. switch多选择结构

  • 语法：

    switch(expression){	//expression变量
	case value:	//【可选】判断变量的值是否等于value值
		//语句
		break;	//【可选】  若不选，会有case穿透效果
	case value:
		//语句
		break;
	...
	default:	//【可选】 以上case都不满足时执行default
		//语句
}

  • case穿透效果：如果当前case满足且结束没有break语句，那么将会执行下面所有的case，直到遇见break语句。

  • switch中的变量类型 ：byte、short、int或者char

  • 从Java SE7开始支持字符串String类型

    String  x = "注意";
switch (x){
	case "注意":
		System.out.println("注意");
    case  "协议":
        System.out.println("协议");
        break;
    default:
        System.out.println("default");
}

循环结构

1. while循环

  • 语法

    while(布尔表达式){
	//循环内容
}
2. do...while循环

  • 语法

    do{
	//循环内容
}while(布尔表达式);

  • while和do...while的区别

    • while先判断再执行，do...while先执行在判断
    • do...while至少执行一次，while可以一次也不执行
3. for循环

  • 语法

    for(初始化;布尔表达式;更新){
	//循环内容
}

  • 最有效，最灵活的循环结构

  • 循环次数是在执行之前就已经确定的

  • fou循环 ：先初始化，在判断真假，若为真则执行循环体，然后更新；若为假，则跳出循环

    for (int i = 0; i < 5; i++) {
	System.out.println("i:" + i);
    System.out.println("第" + i + "次循环！");
 }

  • 练习：打印九九乘法表

    for(int i = 1 ; i < 10 ; i ++){
    for (int j = 1 ; j <= i ; j ++){
    	//输出乘法并输出一个tab空格
    	System.out.print(j + "*" +i +"=" + j*i + "\t");
    }
    //换行
    System.out.println(); //等价于 System.out.print("\n");
}

  • 增强for循环【遍历数组】Java5引入的

    int[] num = {10,20,30,40,50};
for(int n:num){
	System.out.println(n);
}

break&continue

  1. break 强制退出循环

    int i = 0;
while(i < 100){
    i++;
    if(i == 10){
    	break;
    }
    System.out.println(i);
}

  2. continue 跳出本次循环，执行下一次【怂】

    int j = 0;
while (j < 10){
    j++;
    if (j%2 == 0) {
    	continue;
    }
    System.out.println(j);
}

练习：打印三角形

public class Demo13_instance {
    public static void main(String[] args) {
        //规定5行
        for(int i = 1 ; i <= 5 ; i ++){
            //打印空的倒直角三角形
            for(int j = 5 ; j >= i ; j --){
                System.out.print(" ");
            }
            //打印正直角三角形
            for (int j = 1 ; j <= i ; j ++){
                System.out.print("*");
            }
            //打印关于另一半直角三角形
            for(int j = 1 ; j <= i ; j ++){
                System.out.print("*");
            }
            //换行
            System.out.println();
        }
    }
}

运行输出：

JAVA-02（语法介绍）

方法（Java只有值传递）

介绍

  1. 方法是解决一类问题的步骤的有序集合
  2. 方法包含于类或对象中
  3. 方法在程序中创建，在其他地方被引用
  4. 一个方法最后只做一个功能，方便扩展
修饰符 返回值类型 方法名（参数类型 参数名）{
	方法体
	return 返回值;   //返回返回值；终结方法
}

- 形参【形式参数】：在写方法时，在括号中的参数名，这里其实就是一个**占位符**
- 实参【实际参数】：在使用方法时，给方法传的参数

方法重载

  1. 定义：在一个类中，方法名相同，参数【形参】不同，返回值可同可不同
  2. 只是返回值不同，不构成重载
  3. 在执行时，编译器会根据调用方法的参数个数、参数类型去逐个匹配，如匹配出错，编译器报错
package com.xy.base;

public class Demo21 {

    public static void main(String[] args) {
        System.out.println(max(10,20));
        System.out.println(max(10,20.1));
    }

    public static double max(double x , double y){
        if (x > y){
            return x;
        }else if (x < y){
            return y;
        }else {
            System.out.println("x=y");
            return x;
        }
    }

    public static int max(int x , int y){
        if (x > y){
            return x;
        }else if (x < y){
            return y;
        }else {
            System.out.println("x=y");
            return x;
        }
    }
}

命令行传参

package com.xy.base;

public class Demo22 {
    public static void main(String[] args) {
        for (int i=0 ; i < args.length ; i++){
            System.out.println("arg[" + i + "]" + args[i]);
        }
    }
}

JAVA-02（语法介绍）

​ ①编译文件

​ ②运行文件这里注意找对文件位置

​ ③传递参数

​ ④运行结果【打印】

可变参数【jdk1.5 引入】

  1. 在方法声明中，指定参数类型后加一个省略号（...）

  2. 一个方法只能指定一个可变参数，它必须是方法的最后一个参数

    package com.xy.base;

public class Demo23 {

    public static void main(String[] args) {
        Demo23 demo23 = new Demo23();
        demo23.test(1,2,3,4,5);
    }

    public void test(int... i){
        System.out.println(i[0]);
    }
}

递归

  • 自己调自己

  • 一定要有出口【不可以一直递归，Java是栈机制，容易栈满】

    package com.xy.base;

public class Demo24 {
    //求阶乘
    public static int f(int n){
        if(n == 1){
            return 1;
        }else{
            return n*f(n-1);
        }
    }

    public static void main(String[] args) {
        System.out.println(f(25));
    }
}

数组

定义与使用

//定义数组  int nums2[]; 定义数组[c/c++风格]
int[] nums;
//分配空间
nums = new int[10];
//赋值
nums[0] = 1;

//二维数组
int[][] array = {{1,2},{1,3},{1,4}};
//遍历
for (int i = 0 ; i < array.length ; i ++){
    for(int j = 0 ; j < array[i].length ; j ++){
    	System.out.print(array[i][j]+"  ");
    }
    System.out.println();
}

使用

public class Demo32 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        //打印数组
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum = sum + array[i];
        }
        System.out.println("sum:"+sum);
        //寻找数组中最大的数
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(array[i] > max){
                max = array[i];
            }
        }
        System.out.println("max:"+max);

        //forEach jdk1.5没有下标
        for (int i : array) {
            System.out.println(i);
        }

        //反转数组
        int result[] = new int[array.length];
        for(int i=0,j=array.length-1 ; i<array.length ; i++,j--){
            result[j]=array[i];
        }
        //打印数组
        System.out.println(Arrays.toString(result));

    }
}

内存分析

  1. 堆：存放new的对象和数组；所有线程共享；不存放别的对象引用
  2. 栈：存放基本变量类型（包含这个基本类型的具体值）；引用对象的变量（会存放这个引用在堆里面的具体地址）
  3. 方法区：所有线程共享；包含所有的class和static变量
举例分析：

  • 首先声明一个数组 ——> 栈中就有了这个数组的名字

  • 然后给数组分配空间 ——> 堆中开辟了相应大小的空间

  • 最后赋值 ——> 堆中的数组空间内开始有值

三种初始化状态

静态初始化:创建+赋值
int[] a = {1,2,3,4,5,6,7,8,9};
动态初始化
int[] b = new int[5];
b[0] = 1;
数组默认初始化

数组是引用类型，他的元素相当于类的实例变量，因此数组在一分配空间时就已经被默认初始为相应类型的默认值了。

数组的特点

  1. 数组一经创建就长度确定
  2. 同一数组元素类型相同
  3. 数组中的元素可以是任何数据类型
  4. 数组变量属于引用类型，数组也可以看成对象
  5. 数组对象本身是在堆中的

Arrays类（import java.util.Arrays）

学会使用官方API帮助文档，这里介绍两个

int[] array = {1,5,7,33,2,879};
//打印Arrays.toString()
System.out.println(Arrays.toString(array));
//排序
Arrays.sort(array);
System.out.println(Arrays.toString(array));

冒泡排序

public class Demo35_sort {
    public static void main(String[] args) {
        int[] array = {1,5,7,33,2,879};
        sort(array);
        System.out.println(Arrays.toString(array));
    }

    /**
     * 冒泡排序
     */
    public static int[] sort(int[] array){
        int temp = 0;
        for(int i = 0 ; i < array.length-1 ; i++){
            boolean flag = false; //优化
            for (int j = 0 ; j < array.length-1-i ; j++){   //因为经过i轮排序之后，后面的i个数据已经是有序的了，所以减掉i
                if(array[j+1] < array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            if(flag == false){  //优化
                break;
            }
        }
        return array;
    }

}

稀疏数组

  1. 定义：当一个数组中大部分元素都为0或同一数据时，可以使用稀疏数组来保存。

  2. 处理方式：文章来源地址https://www.toymoban.com/news/detail-455851.html

    • 记录数组一共有几行几列，有多少个不同值
    • 把具有不同值的元素的行和列以及值记录在一个小规模的数组中，从而缩小程序的规模
public class Demo36 {
    public static void main(String[] args) {
        //创建一个二维数组(原数组) 11*11 0:没有棋子 1：黑旗 2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 1;
        System.out.println("输出原始数组:");
        for(int[] ints : array1){
            for(int anInt : ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        //转换为稀疏数组保存
        //获取有效值
        int sum = 0;
        for(int[] ints : array1){
            for(int in : ints){
                if(in != 0){
                    sum ++ ;
                }
            }
        }
        System.out.println("有效数值个数："+sum);
        //创建一个稀疏数组
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        //遍历数组，将非零值存放进稀疏数组
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[1].length; j++) {
                if(array1[i][j] != 0){
                    count ++;
                    array2[count][0]=i;   //二维数组的第count行的第0列存放数据的横坐标
                    array2[count][1]=j;   //二维数组的第count行的第1列存放数据的纵坐标
                    array2[count][2]=array1[i][j];   //二维数组的第count行的第3列存放数据的值
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"
                               +array2[i][1]+"\t"
                               +array2[i][2]+"\t");
        }
        
        //还原
        //创建数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //读取数据并存储
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];  
        }
        //输出还原得到的数组
        System.out.println("还原得到的数组：");
        for (int i = 0; i < array3.length; i++) {
            for (int j = 0; j < array3[i].length; j++) {
                System.out.print(array3[i][j]+"\t");
            }
            System.out.println();
        }
        
    }
}

到了这里，关于JAVA-02（语法介绍）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • Java学习 用户交互 Scanner

    Scanner 是Java5提供的新特性 可以用来获取用户的输入 需要引入import java.util.Scanner;类 基础语法： Scanner scanner = new Scanner(System.in); 可以通过Scanner类的next()和nextLine()来获取输入的字符串一般在输入前使用 hasnext()和 hasNextLine()用来判断是否有输入的数据 next()与nextLine()区别： ①

    2024年03月17日
    浏览(76)

  • 【Dart】=＞ [04] Dart初体验-基础语法(流程控制-if-switch-case-for循环

    学习内容： if 语句 switch – case 语句 for 循环语句 if 语句让代码有选择的执行，可以指定满足条件时才能执行的代码。 语句形式： if … else if … else if … else 案例： 根据学生分数，判断学生成绩是否及格 根据学生分数，划分学生成绩所在等级 优秀：分数大于等于90分 良好

    2024年01月19日
    浏览(43)

  • 深入探索Java GUI编程：构建交互丰富的用户界面

    Java GUI编程是构建交互式用户界面的关键技术之一。本文将深入研究Java GUI编程的基本概念和原理，介绍Swing和JavaFX两种主流的GUI框架，并通过实例演示它们的使用。读者将学习如何创建各种组件、布局管理、事件处理以及美化界面，从而构建出功能丰富、美观而又用户友好的

    2024年02月16日
    浏览(46)
  • 【Java SE语法篇】4.程序逻辑控制

    【Java SE语法篇】4.程序逻辑控制

    📚博客主页：爱敲代码的小杨. ✨专栏：《Java SE语法》 ❤️感谢大家点赞👍🏻收藏⭐评论✍🏻，您的三连就是我持续更新的动力❤️ 顺序结构 比较简单，按照代码书写的顺序一行一行执行。 如果调整代码的书写顺序, 则执行顺序也发生变化。 它的作用是根据判断的条件

    2024年02月01日
    浏览(41)
  • 【Java探索之旅】方法的概念 定义 执行流程 实参与形参的交互

    【Java探索之旅】方法的概念 定义 执行流程 实参与形参的交互

    🎥 屿小夏 ： 个人主页 🔥个人专栏 ： Java编程秘籍 🌄 莫道桑榆晚，为霞尚满天！ 方法是Java编程中非常重要的概念，它能够帮助我们组织代码、实现代码的重复使用，并使代码更加清晰易懂。本文将介绍方法的概念、定义以及调用执行过程，同时解释实参和形参之间的关

    2024年04月14日
    浏览(46)
  • java基础 -02java集合之 List，AbstractList，ArrayList介绍

    java基础 -02java集合之 List，AbstractList，ArrayList介绍

    在正式List之前，我们先了解我们补充上篇Collection接口的拓展实现，也就是说当我我们需要实现一个不可修改的Collection的时候，我们只需要拓展某个类，也就是AbstractCollection这个类，他是Collection接口的骨干实现，并以最大限度的实现了减少此接口所需要的工作; 如上两图进行

    2024年01月20日
    浏览(42)

  • Linux：Linux操作系统流程控制语句-case语句使用介绍

    本博客将介绍Linux操作系统中流程控制语句-case语句的使用方法。我们将通过多个案例来详细说明case语句的执行流程和用法。这些案例包括菜单选项、rsync服务脚本、nginx服务脚本、实现系统工具箱和实现简单的jumpserver跳板机。通过学习这些内容，您将能够更好地掌握Shell脚本

    2024年02月12日
    浏览(47)
  • 用户认证-Kerberos的介绍和使用(Hadoop、Hive、数仓流程、Presto、Kylin集成配置)

    用户认证-Kerberos的介绍和使用(Hadoop、Hive、数仓流程、Presto、Kylin集成配置)

    概述 Kerberos是一种计算机网络认证协议，用来在非安全网络中，对个人通信以安全的手段进行 身份认证 ， 它允许某实体在非安全网络环境下通信，向另一个实体以一种安全的方式证明自己的身份 。这个词又指麻省理工学院为这个协议开发的一套计算机软件。软件设计上采用

    2024年02月02日
    浏览(56)
  • Java流程控制(二)

    Java流程控制(二)

    循环结构分两大类，一类是当型，一类是直到型。 while 循环 语法结构： 🐟 在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。 🐟 语句中应有使循环趋向于结束的语句，否则会出现无

    2024年02月06日
    浏览(39)

  • Java零基础入门-控制流程

    哈喽，各位小伙伴们，你们好呀，我是喵手。   今天我要给大家分享一些自己日常学习到的一些知识点，并以文字的形式跟大家一起交流，互相学习，一个人虽可以走的更快，但一群人可以走的更远。   我是一名后端开发爱好者，工作日常接触到最多的就是Java语言啦，

    2024年02月05日
    浏览(39)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包