栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

java基础

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

java基础

java基础 java流程控制 用户交互scanner 输入分类

通过Scanner类来获取用户的输入

Scanner scanner = new Scanner(System.in);

通过Scanner类的next()与nextLine()方法获取输入的字符串,在读取前我们一般需要 使用hasNext()与hasNextLine判断是否输入的数据

  • next():

    • 一定要读取到有效字符后才可以结束输入

    • 对输入有效字符之后遇到的空白,next()方法会自动将其去掉

    • 只有输入有效字符后才将其输入的空白作为分隔符或者结束符

    • next()不能得到带有空格的字符串

  • nextLine():

    • 以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符
    • 可以获得空格
//创建一个扫描器用于,接收用户数据
Scanner scanner = new Scanner(System.in);       
System.out.println("输入");
//使用next方法接收
String str = scanner.next();
//程序等待用户输入
System.out.println("输出"+str);
scanner.close();//凡是属于IO流的类如果不关闭会一直占用内存,要习惯性关闭
Scanner scanner = new Scanner(System.in);
int x = 0;
double sum = 0;
while (scanner.hasNextDouble()){
    double m = scanner.nextDouble();
    sum=sum + m;
    x++;
}
System.out.println("sum值为"+ sum);
System.out.println("x次数为"+ x);
System.out.println("平均值为"+ (sum / x));
    }

扩展:

  • next(),读取输入的 String 类型.
  • nextByte(),读取输入的 byte 类型.
  • nextInt(),读取输入的 int 类型.
  • nextFloat(),读取输入的 float 类型.
  • nextDouble(),读取输入的 double 类型.
顺序结构

Java的基础结构

if选择结构 分类 单选择结构
if(布尔表达式){
    //如果布尔表达式为ture将执行的语句
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-87UkrSRO-1653992534131)(C:Users东南枝AppDataRoamingTyporatypora-user-imagesimage-20220429232646723.png)]

双选择结构
if(布尔表达式){
    //如果布尔表达式为ture将执行的语句
}else{
    //如果布尔表达式为false将执行的语句
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lN5fPtRY-1653992534132)(C:Users东南枝AppDataRoamingTyporatypora-user-imagesimage-20220429232943282.png)]

多选择结构
if(布尔表达式1){
    //如果布尔表达式 1的值为ture将执行的语句
}else if(布尔表达式2){
    //如果布尔表达式 2为ture将执行的语句
}else if(布尔表达式3){
    //如果布尔表达式 3为ture将执行的语句
}else if(布尔表达式4){
    //如果布尔表达式 4为ture将执行的语句
}else{
    //如果以上布尔表达式都不为ture执行的语句
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9quG5ARY-1653992534132)(C:Users东南枝AppDataRoamingTyporatypora-user-imagesimage-20220429234126043.png)]

嵌套的if结构
if(布尔表达式 1){
    //如果布尔表达式 1的值为ture执行代码
   if(布尔表达式 2){
       //如果布尔表达式 2的值为ture执行代码
   }
}
Switch选择结构
switch(expression){
    case value :
    	//语句
    	break;//可选
    case value :
    	//语句
    	break;//可选
    //你可以有任意数量的case语句
    default ://可选
    	//语句
}

每一个中文字符都有一个对应的haseCode值

例子

Scanner scanner = new Scanner(System.in);
       System.out.println("请输入成绩:");
        int sre = scanner.nextInt();
       if(sre == 100){
           System.out.println("满分");
       }else if(sre>=80 && sre <=99){
           System.out.println("A");
       }else if(sre>=61 && sre <=79){
           System.out.println("B");
       }else if(sre>= 0 && sre <=60){
           System.out.println("不合格");
       }else{
           System.out.println("成绩不对");
       }
       scanner.close();
循环结构 while循环
  • 只要布尔表达式为ture,循环会一直循环下去

  • 我们大多数情况是会让循环停止下来的,我们需要一个让表达式失效的方式来结束循环

  • 少部分情况需要一直需要一直执行,比如服务器的请求响应监听等

  • 循环条件一直为ture就会造成无限循环【死循环】,我们正常的业务编程中应该尽量避免死循环,会影响程序性能或者造成程序卡死奔溃

while(布尔表达式){
    //循环内容
}
Do While循环

do while与while不同在于,前者至少进行一次

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

for使循环结构更简单,是支持迭代的一种通用结构

for(初始化;布尔表达式;更新){
    //代码语句
}

 //打印九九乘法表
        
         for (int i=1;i<10;i++){
            for(int b=1;b<=i;b++){
                System.out.print(b+"*"+i+"="+(i*b)+" ");
            }
            System.out.println();
        }
增强for循环

Java5才引入的一种主要用于数组或集合的增强for循环

for(声明语句:表达式){
    //代码句子
}
 int[] a ={10,20,30,40};
        //遍历数组中的元素
        for(int x:a){
            System.out.println(x);
        }
break continue break

在任何循环语句的主体部分,均为break控制循环的流程。break用于强行退出循环,不执行循环剩下的语句。(break语句也在switch语句中使用)

continue

用于循环语句中,用于终止某次循环过程,即跳过循环体中尚未执行的语句,接着执行下一个循环

方法 何为方法
System.out.prinln()   //调用系统类里面的标准输出对象out中的方法println()
//类.对象.方法

Java方法是语句的集合,它们在一起执行一个功能。
方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建,在其他地方被引用

设计方法的原则:方法的本意是功能块,就是实现某个功能的语句块的集合。我们设计方法的时候,最好保存方法的原子性,就是一个方法只完成1个功能,这样利于我们后期的扩展。

public class wey {
    //main方法
    public static void main(String[] args) {
       int sum = add(1,2);//实参,传递实际的参数
       System.out.println(sum);

       int max = max(4,5);
       System.out.println(max);
    }
    //加法
    public static  int add(int a,int b){//形式参数,用来定义作用的
        return a+b;
    }
    //比大小
    public static int max(int num1,int num2){
        if(num1>num2){
            return num1;
        }else if(num1==num2){
            System.out.println("num1=num2");
            return 0;//终止方法
        }
        else{
            return num2;
        }
    }

}
方法的定义及调用 定义

java的方法类似于其他语言的函数,是一段用来完成特定功能的代码片段,一般情况下,定义一个方法包含以下语法:

  • 方法包含一个方法头和一个方法体,下面是一个方法的所有部分:
    • 修饰符:修饰符,这是可选的告诉编译器如何调用该方法。定义了该方法的访问类型。
    • 返回值类型:方法可能会返回值。return ValueType 是方法返回值的数据类型。有些方法执行所需的操作,但没有返回值。在这种情况下,return ValueType是关键字void。
    • 方法:是方法的实际名称。方法名和参数表共同构成方法签名。
    • 参数类型:参数像是一个占位符。当方法被调用时,传递给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的,方法可以不包括任何参数。
      • 形式参数:在方法被调用时用于接收外界输入的数据。
      • 实参:调用方法时实际传给方法的数据。
    • 方法体:方法体包含具体的语句,定义该方法的功能。
修饰符  返回值类型 方法名(参数类型 参数名){
    ....
    方法体
    ....
    return 返回值;
}
调用
  • 调用方法:对象名.方法名(实参列表)

  • java支持两种调用方法的方式,根据方法是否返回值来选择。

  • 当方法返回一个值的时候,方法调用通常被当做一个值。例如:

int larger = max(30,40);
  • 如果方法返回值是void,方法调用一定是一条语句。
System.out.println("hello");
重载
  • 重载就是在一个类中,有相同的函数名称,但形参不同的函数。

    int max = max(4,5);
    System.out.println(max);
    
    double x = max(4.0,5.0);
    System.out.println(x);  
    
    public static int max(int num1,int num2){
            if(num1>num2){
                return num1;
            }else if(num1==num2){
                System.out.println("num1=num2");
                return 0;//终止方法
            }
            else{
                return num2;
            }
        }
        //重载
        public static double max(double num1,double num2){
            if(num1>num2){
                return num1;
            }else if(num1==num2){
                System.out.println("num1=num2");
                return 0;//终止方法
            }
            else{
                return num2;
            }
        }
    
  • 方法的重载的规则:

    • 方法名称必须相同。
    • 参数列表必须不同(个数不同、或类型不同、参数排序顺序不同等)
    • 方法的返回类型可以相同也不相同。
    • 仅仅返回类型不同不足以成为方法的重载。
  • 实现理论:

    • 犯法名称相同时,编译器会根据调用方法的参数个数、参数类型等去逐个匹配,以选择对应方法,如果匹配失败,则编译器报错。
命令行传参

有时候你希望运行一个程序时候再给它消息。这要靠传递命令行参数给main()函数实现。

public static void main(String[] args) {
        //args.length 数组长度
        for(int i=0; i
            System.out.println("args[" + i + "]: "+ args[i]);
        }
    }

使用cmd命令行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bZ0yhV5U-1653992534133)(C:Users东南枝AppDataRoamingTyporatypora-user-imagesimage-20220508221558290.png)]

可变参数
  • 在JDK1.5开始,Java支持传递同类型的可变参数给一个方法

  • 在方法声明中,在指定参数类似后加一个省略号(…)

  • 在一个方法只能指定一个可变参数,它必须是方法的最后一个参数。如何普通的参数必须在它之前声明。

    public class wey02 {
        public static void main(String[] args) {
            //调用可变参数的方法
            test(1,2,3,4,5,6.5);
            test(new double[]{1,2,3});
        }
        public static void test(double... x){
            if(x.length == 0){
                System.out.println("NO argument passed");
                return;
            }
    
            double y = x[0];
    
            //排序
            for(int i = 1;i < x.length; i++){
                if(x[i] > y){
                    y = x[i];
                }
            }
            System.out.println("the max value is " + y);
        }
    }
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q0y7GwcX-1653992534133)(C:Users东南枝AppDataRoamingTyporatypora-user-imagesimage-20220508224843221.png)]

※递归

递归就是A方法调用A方法

(学习递归的思想,但是尽量不用,太占用空间和内存)

  • 递归包含两个部分:
    • 递归头:什么时候不调用自身方法,如果没有头,将陷入死循环。
    • 递归体:什么时候需要调用自身方法。
public static void main(String[] args) {
        System.out.println(f(4));
    }
    private static int  f(int n){
        if(n == 1){
            return 1;
        }else {
            return n*f(n-1);
        }
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3iFDk4Ld-1653992534133)(C:Users东南枝AppDataRoamingTyporatypora-user-imagesimage-20220509213659776.png)]、

数组 数组的定义
  • 数组是相同类型数据的有序集合
  • 数据描述的是相同类型的若干个书记,按照一定的先后次序排列组合而成
  • 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问他们

数组的元素是通过索引访问的,数组索引从0开始。

数组的声明和创建

首先必须声明数组变量,才能在程序中使用数组。

dataType[] arrayRefVar;

Java语言使用new操作符来创建数组

dataTye[] arrayRefVar = new dataType [arraySize];

获取数组长度:

arrays.length
int[] nums;//1.定义
nums = new int[10];//2.创建一个数组,开辟看一个空间
nums[9] = 10;//3.给数组赋值

(内存分析)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tIoJwKlT-1653992534135)(C:Users东南枝AppDataRoamingTyporatypora-user-imagesimage-20220512221722691.png)]

三种初始化状态
  • 静态初始化:

    int[] a = {1,2,3};
    Man[] mans = {new Man(1,1),new Man(2,2)};
    
  • 动态:

    int[] a = new int[2];
    a[0]=1;
    a[1]=2;
    
  • 默认初始化:

    • 数组是引用类型,它的元素相当于类的实例变量,因此数组一经分配空间,其中的每个元素也被按照实例变量同样的方式被隐式初始化。
//静态初始化:创建 + 赋值
int[] a= {1,2,3,4,5,6,7,8};

//动态初始化:包括默认初始化
int[] b = new int[2];
b[0] = 10;

System.out.println(b[0]);
System.out.println(b[1]);//默认值是0,在分配空间时已经默认初始化了
数组的四个基本特点
  • 其长度是确定,数组一旦被创建,它的大小就是不可以改变的。
  • 其元素必须是相同类型,不允许出现混合类型
  • 数组中元素可以是任何数据类型,包括基本类型和引用类型
  • 数据变量属于引用类型,数组也可以看成对象,数组中的每一个元素相当于该队像的成员变量。数组本身就是对象,Java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中。
数组边界
  • 下标的合法区间:[0,length-1],如果越界就会报错;

    public static void main(String[] args){
        int[] a=new int[2];
        System.out.println(a[2]);
    }
    
  • ArraylndexOutOfBoundsException: 数组下标越界异常!

  • 小结:

    • 数组是相同数组类型(数组类型可以为任意类型)的有序集合
    • 数组也是对象。数组元素相当于对象的成员变量
    • 数组长度的确定的,不可变的。如果越界,则报:ArraylndexOutofBounds
数组使用
  • for-Each 循环

  • 数组作方法入参

  • 数组作返回值

    public static void main(String[] args) {
            int[] arrays = {1,2,3,4,5};
            //增强性循环,没有下标
            for (int array : arrays) {
                System.out.println(array);
            }
            aaa(arrays);
            bbb(arrays);
            int[] ll = ccc(arrays);
            aaa(ll);
        }
        //打印数组元素
        public static void aaa(int[] arrays){
            for (int i = 0; i < arrays.length; i++) {
                System.out.print(arrays[i]+" ");
            }
        }
        //反转数组
        public static void bbb(int[] arrays) {
            System.out.println();
            for (int i = arrays.length - 1; i >= 0; i--) {
                System.out.print(arrays[i] + " ");
            }
        }
        //反转数组(返回值传参)
        public static int[] ccc(int[] arrays){
            int[] r = new int[arrays.length];
            for (int i = 0,j=r.length-1; i < arrays.length; i++,j--) {
                r[j]=arrays[i];
            }
            return r;
        }
    }
    
多维数组

多维数组可以看成是数组的数组,比如二维数组就是一个特殊数组就是一个特殊的一堆数组,其每一个元素都是一个一堆数组。

二维数组

  • int a[][] = new int[3][2];
    

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xAXSs3nh-1653992534135)(C:Users东南枝AppDataRoamingTyporatypora-user-imagesimage-20220513123452343.png)]

int[][] array = {{1,2},{3,4},{5,6},{7,8}};
for(int i = 0;i < array.length; i++){
     for(int j = 0;j < array[i].length;j++){
          System.out.print(array[i][j]);
     }
}
Arrays类 冒泡排序 稀疏数组
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/939348.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号