2021-07-16and2021-07-17

最新推荐文章于 2024-06-15 16:38:52 发布

wulijiabao

最新推荐文章于 2024-06-15 16:38:52 发布

阅读量63

点赞数

分类专栏： JAVA 文章标签： intellij-idea

本文链接：https://blog.csdn.net/wulijiabao/article/details/118784046

版权

JAVA 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

包机制

为了更好的区分类，建立包机制

建立包中包
点击齿轮，取消勾选 compact middle package

导包import

类名不要重复，为了使用某一个包的成员，导包的时候如果导入了一样的类名，会报错

//导入这个包下所有的内容 .*
import com.li.base.*;

JavaDoc

甲骨文官网api ⬅查看请点击此处
参数信息

注解和注释的区别

第一步，打开类所在文件夹
第二步，用命令行执行类文件

如何在idea中生产javadoc文件 ⬅点击此处查看

/**
 1. @author laoli
 2. @version 0.1
 3. @since 1.0
 */
public class Doc {
    String name;//一个属性
    //一个方法

    /**
     *
     * @param name  参数
     * @return      返回值
     * @throws Exception //异常抛出情况
     */
    public String test(String name){
        return  name;
    }
}

JAVA流程控制

1.用户交互Scanner
2.顺序结构
3.选择结构
4.循环结构
5.break&continue

用户交互Scanner

基本语法➡Scanner s = new Scanner(System.in);

通过next与nextline方法获取输入的字符串
用hasNext与hasNextline来判断是否还有输入

next();

一定要读取到有效字符才能结束输入
对输入到有效字符之前的空白，next()方法会自动将其去掉例如
只有输入有效字符之后，才将其后面输入的空白当作分隔符或者结束符
next()不能得到带空格的字符

nextline();

以回车作为结束符，也就是说，获取输入回车前所有字符
可以获得空白

1.通过实例来查看next与nextline的区别

package com.li.scanner;

import java.util.Scanner;

public class Demo1 {
    public static void main(String[] args) {
        //创建一个扫描对象，接受键盘数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方法接收：");
        //判断下一个位置用户有没有输入
        if (scanner.hasNext()){
            String str = scanner.next();//输入hello world
            System.out.println("内容为："+str);//输出为hello
        }
        //属于IO流的不关闭会一直占用资源，所以要养成良好的习惯，用完即关闭
        scanner.close();
    }
}

package com.li.scanner;

import java.util.Scanner;

public class Demo2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用nextline来接收：");
        //使用nextline，判断下一行是否按了回车键
        if (scanner.hasNextLine()){
            String str = scanner.nextLine();//输入hello world
            System.out.println("结果为："+str);//输出hello world
        }
        scanner.close();
    }
}

2.scanner的应用实例

题目：

输入多个数，求一共多少个数，以及总和和平均值，每输入一个数回车确认，通过非数字结束

答案

package com.li.scanner;

import java.util.Scanner;

public class Demo4 {
    //来个实例，输入多个数，求一共多少个数，以及总和和平均值，每输入一个数回车确认，通过非数字结束
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = 0;//数字个数
        double sum = 0;//总和
        while (scanner.hasNextDouble()){
            double num = scanner.nextDouble();
            n = n+1;
            sum = sum + num;
            System.out.println("你当前输出了第"+n+"个数据，当前的sum="+sum);
        }
        System.out.println(n+"个数的总和为"+sum);
        System.out.println(n+"个数的平均值为"+(sum/n));
        scanner.close();
    }
}

顺序结构

java基本机构就是顺序结构，除非有特别指明，否则就按照顺序一句一句执行
没什么好说的，任何算法都离不开，基础但最重要

选择结构

if单选择结构
if双选择结构
if多选择结构
嵌套的if结构
switch结构

1.if单选择结构

if(布尔表达式){
//布尔表达式为真，执行接下来的语句 }

public class IfDemo1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        //equal：判断字符串是否相等
        if(s.equals("Hello")){
            System.out.println(s);//如果输入为Hello，那么执行当前这句话
        }
        System.out.println("end");
        scanner.close();
    }
}

2. if双选择结构

if(布尔表达式){
//布尔表达式为真，执行接下来的语句
}else{
//布尔表达式为假，执行接下来的语句
}

public class IfDemo2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        int score = scanner.nextInt();
        if (score>60){
            System.out.println("及格");
        }else {
            System.out.println("不及格");
        }

        scanner.close();
    }
}

3. if多选择结构

if(布尔表达式1{
//布尔表达式1为真，执行接下来的语句
}elseif(布尔表达式2){
//布尔表达式2为真，执行接下来的语句
}elseif(布尔表达式3){
//布尔表达式3为真，执行接下来的语句
}…
else{
//以上布尔表达式都为假，执行接下来的语句
}

public class IfDemo3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        int score = scanner.nextInt();
        if(score==100){
            System.out.println("S级");
        }else if (score>=90&&score<100){
            System.out.println("A级别");
        }else if (score>=80&&score<90){
            System.out.println("B级别");
        }else if (score>=70&&score<80){
            System.out.println("C级别");
        }else if (score>=60&&score<70){
            System.out.println("D级别");
        }else if (score>=0&&score<60){
            System.out.println("不及格");
        }else {
            System.out.println("成绩不合法");
        }
        scanner.close();
    }
}

4. 嵌套的if结构

**if**(布尔表达式1){
"//布尔表达式1为真，执行接下来的语句"
    **if**(布尔表达式2){
    "//布尔表达式2为真，执行接下来的语句"
    }
}

实例：寻找一个数，是否在m-n之间
类似于二分法的思想，进行嵌套if，快速查找数

public class IfDemo4 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        int m=0;
        int n=100;
        if (num>m&&num<=n/2){
            if (num>m&&m<=n/4){
                
            }
        }


        scanner.close();

    }
}

5. switch结构

只需要考虑case穿透现象和switch具体匹配一个值就可以了
具体看代码

public class SwitchDemo1 {
    public static void main(String[] args) {
        
        char grade = 'C';
        switch (grade){
            case 'A':
                System.out.println("您是A级");
                break;//不加的话会穿透执行
            case 'B':
                System.out.println("您是B级");
                break;
            case 'C':
                System.out.println("您是C级");
                break;
            case 'D':
                System.out.println("您是D级");
                break;
            case 'E':
                System.out.println("您挂科");
                break;
            default:
                System.out.println("未知");
        }
    }
}

这里是jdk7版本以后的新特性

switch可以匹配String类型了

public class SwitchDemo2 {
    public static void main(String[] args) {
        String name = "laoli";
        switch (name){
            //jdk的新特性，表达结果可以是字符串
            //但是字符的本质还是数字

            //反编译 Java--class（字节码文件） ----IDEA反编译
            case "laoli":
                System.out.println("666");
                break;

        }
    }
}

循环结构

1.while 循环

while(布尔表达式){
//布尔表达式为真，则一直循环下去
//通常我们是需要停止循环的
}
千万避免死循环

public class WhileDemo1 {
    public static void main(String[] args) {
        //打印1-100
        int i = 0;
        int i1 = 0;
        int sum = 0;
        while(i<100){
            i++;
            System.out.println(i);
        }
        //除服务器那一类需要一直循环下去，通常我们是需要停止循环的
        //下面永远会执行下去
        /*while(true){
            System.out.println("666");
        }*/
        while(i1<100){
            i1++;
            sum+=i1;
        }
        //输出1+2+3+....+100
        System.out.println(sum);
    }
}

2.do…while循环

while是先判断后执行，dowhile是先执行后判断所以dowhile语句至少会执行一次

public class DoWhileDemo1 {
    public static void main(String[] args) {
        int a = 0;
        while(a<0){
            System.out.println(a);
        }
        System.out.println("=====================");
        do {
            System.out.println(a);
        }while (a<0);
    }
}

3.for循环

最重要

for循环语句是支持迭代的一种通用结构，最有效最灵活 for循环执行的次数是在执行前就确定的格式如下

for("初始化"; "布尔表达式";"迭代"){
//代码块

> }

实例一

public class ForDemo1 {
    public static void main(String[] args) {
        int n = 1;//初始化
        while (n<100){//条件判断
            System.out.println(n);//循环体
            n=n+2;//迭代
        }
        /*
        for(初始化; 条件判断; 迭代){

        }
         */
        for (int i=1; i<=100; i++){
            System.out.println(i);
        }
        //快捷方式  100.for+回车
       /* for (int i = 0; i < 100; i++) {

        }*/
    }
}

实例二分别求1-100中奇数和偶数的和

public class ForDemo2 {
    //实例，分别求1-100奇数和偶数的和
    public static void main(String[] args) {
        //快捷键 100.for
        int oddsum = 0;//奇数的和
        int evensum = 0;//偶数的和
        for (int i = 0; i <= 100; i++) {
            if (i%2==0){
                evensum = evensum + i;
            }else {
                oddsum = oddsum + i;
            }
        }
        System.out.println(evensum);
        System.out.println(oddsum);
    }
}

实例三输出1-1000能被5整除的数，并且每行输出三个这里注意print与println的区别

public class ForDemo3 {
    //实例，输出1-1000能被5整除的数，且每行输出三个
    public static void main(String[] args) {
        int n = 0;
        for (int i = 0; i < 1000; i++) {
            if (i%5==0){
                System.out.print(i+"\t");//print(输出完不换行)而不是println(输出完换行)
                n++;
            }
            if (n==3){
                System.out.println("\n");
                n=0;
            }
        }
    }
}