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只有值传递)

介绍

  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]);
        }
    }
}

​ ①编译文件

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

​ ③传递参数

​ ④运行结果【打印】

可变参数【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. 处理方式:

    • 记录数组一共有几行几列,有多少个不同值
    • 把具有不同值的元素的行和列以及值记录在一个小规模的数组中,从而缩小程序的规模
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();
        }
        
    }
}

热门相关:斗神战帝   惊世毒妃:轻狂大小姐   最强反套路系统   特工重生:快穿全能女神   法医王妃不好当!