2022-Java基础史上详细笔记（学完可就业）

Windows常用的快捷方式

基础的Dos命令

打开CMD的⽅式
1. 开始+系统+命令提⽰符
2. win键+R+输⼊cmd (推荐使⽤)
3. 在任意的⽂件夹下，按住Shift键+⿏标右击，打开命令⾏窗⼝
4. 在资源管理器地址栏路径前⾯加 “cmd ”
5. 管理员运⾏⽅式：命令提⽰符右键以管理员⾝份运⾏（最⾼权限运⾏）
常⽤的Dos命令
# 盘符切换 E:
# 查看当前⽬录下所有⽂件 dir
# 切换⽬录 cd /d E:\idea
# 返回上⼀级⽬录 cd ..
# 进⼊同级⽬录下的下⼀级⽬录 cd tmp(该⽬录下的⽂件名)
# 清屏 cls (clear screen)
# 退出终端 exit
# 查看电脑当前IP地址 ipconfig
# 打开计算器 calc
# 打开画图 mspaint
# 新建记事本 notepad
# 在当前⽬录新建⽂件夹 md test(⽂件夹名)
# 新建⽂件 cd> a.txt(⽂件名)
# 删除⽂件 del a.txt(⽂件名)
# 删除⽬录 rd test(⽬录名)
# ping命令(复制链接进⼊Dos直接单击⿏标右键粘贴)
 ping www.baidu.com

Java基础

Java的特性与优势

.简单性
.⾯对对象
.可移植性
.⾼性能
.分布式
.多态性
.多线程
.安全性
.健壮性

第一个helloword程序

1.新建hello.java 文本文件 ，使用查看显示java后缀名

2.编译 javac hello.jav 文件 ，会生成一个class文件

3.运行class文件， java hello

4.代码

public class HelloWorld {
   
    public static void main(String[] args) {
   //psvm
        //单行注释
        //输出一个helloWorld
        System.out.println("helloWorld");//sout

        /*
        * @Description:多行注释
        * @Param: [args]
        * @return: void
        * @author: XiaoLin
        * @date: 2022/5/10
        */

        //文档注释:JavaDoc  /** */

        /**
        * @Description:
        * @Param: [args]
        * @return: void
        * @author: XiaoLin
        * @date: 2022/5/10
        */

    }
}

Java的运行机制

Java的基础语法

注释

注释是为了方便他人与自己的阅读，其中文档里面每一个@都有特殊的含义，一般大公司标准化作业是需要写到开头
.单行注释（//）
.多行注释（/* /）
.文档注释（/* /）

标识符

也就是保留字，取名时需要区别开，标识符是大小写敏感的

所有标识符都应该以字母(A-Z 或者 a-z)，美元符( ) ， 或 者 下 划 线 ( ) 开 始 。

首字母之后可以是字母(A-Z 或者 a-z)，美元符( )，或者下划线()开始。

首字母之后可以是字母(A−Z或者a−z)，美元符()，下划线()或者数字的任意字符组合，但不能使用关键字作为变量名或者方法名。

数据类型

Java是一种强类型语言：要求变量的使用要求严格符合规定，所以变量都必须先定义后才能使用（强类型优点安全性高，相对而言速度慢一点）

public class Demo02 {
   
    public static void main(String[] args) {
   
        String a ="hello";
        int num=100;
        System.out.println(a);
        System.out.println(num);
    }
}

.八大数据类型

public class Demo03 {
   
    public static void main(String[] args) {
   
        //八大基本数据类型

        //整数类型
        int num1=1;
        byte num2=2;
        short num3=3;
        long num4=4;

        //小数 浮点类型
        float num5=50.2F;//float类型要在数字后面加上F
        double num6=3.1415926;

        //字符类型
        char name='a';//字符指的是一个字母
        //字符串 String不是一个关键字是一个类
        String name1="林滔";


        //布尔值
        boolean flag=true;
    }
}

数据类型的拓展

public class Demo04 {
   
    public static void main(String[] args) {
   
        //整数拓展 进制 二进制以0b开头 八进制以0开头  十进制 十六进制以0x开头
        int num =10;
        int num1=010;
        int num2=0x10;
        System.out.println(num);//10
        System.out.println(num1);//8
        System.out.println(num2);//16


        //++++++++++++++++++++++++++++++++++++++++
        //浮点数拓展
        float f=0.1f;
        double d=1.0 / 10;
        System.out.println(f==d);//false
        //float 表示的字长是有限的 离散 存在舍入误差 只能提供接近但不等于的值
        //最好拒绝用浮点数来比较

        //  转义字符  \t表示制表符 \n 表示换行符

        System.out.println("hello\tWorld!\t");

        //强制转换
        int i=128;
        byte b=(byte) i;
        //强制转换: 高到低
        //自动转换: 低到高

        /**
         * 注意点：
         * 不能对布尔值进行转换
         * 不能把对象类型转换为不相干的东西
         * 把高容量转换为低容量的时候  强制装换
         * 强制转换可能造成内存溢出 或者精度问题*/


    }
}

类型转换
由于java是强类型语言，所以要进行有些运算是需要用到类型转换

低  ---------------------------------------->  高
byte,short,char -> int -> long -> float -> double

运算中，不同类型的数据先转化为同一类型，然后进行运算（因为容量不同，表示范围不同）

变量

Java变量是一种强类型语言，每个变量都必须声明其类型，Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域，其实质是一个内存地址名

type varName [=value] [{
   , varName[=value]}];
//数据类型 变量名   =	值; 
//可以用逗号隔开来声明多个类型变量，但是不推荐这样做保证程序可读性

注意：变量声明的是一个完整的句子所以需要用分号结束

常量

常量在初始化后不能再改变！不会变动的值。

常量可以理解为一种特殊的变量，它的值被设定后，在程序运行中不允许被改变

public class Demo05 {
   
    //修饰符不区分前后位置，其中static和final都是修饰符，使用两种输出结果相同
    static final double PI = 3.14;
    // final static double PI = 3.14;
    public static void main(String[] args){
   
        System.out.println(PI);
    }
}

变量的命名规范

1.所有的变量，方法，类名：见名知意
2.类成员变量、局部变量、方法名：首字母小写和驼峰原则（除了第一个单词外，后面单词的首字母大写lastName）
3.类名：首字母大写和驼峰原则
4.常量：大写字母和下划线MAX_NUM

运算符

1.算术运算符：+ - * / % ++ –
2.赋值运算符：=
3.关系运算符：>、<、>=、<=、==、!=、instanceof
4.逻辑运算符：&& 、||、！
5.位运算符：&、|、^、~、>>、<<、>>>
6.条件运算符：?:
7.拓展赋值运算符：+=、-=、*=、/=

public class Demo06 {
   
    public static void main(String[] args) {
   
        // 一元运算符：自增 ++ 自减 --
        int a = 3;
        int b = a++; // a++ 是先赋值后自增，所以此时b=3,语句结束后a=4
        System.out.println(a); // 4
        int c = ++a; // 推荐使用++a 是先自增后赋值，所以赋值前a=5, c=5

        System.out.println(a); // 5
        System.out.println(b); // 3
        System.out.println(c); // 5

        // 幂运算，等需要使用 Math 工具类进行运算
        double power = Math.pow(2, 3);
        System.out.println(power);
    }
}

public class Demo07 {
   
    public static void main(String[] args) {
   
        // 逻辑运算：与或非
        boolean a = true;
        boolean b = false;

        System.out.println("a && b: " + (a && b)); // 两个都为真才为真
        System.out.println("a || b: " + (a || b)); // 两个为假才为假
        System.out.println("!(a && b): " + (!(a && b)));
    }
}

/*
a && b: false
a || b: true
!(a && b): true
Process finished with exit code 0
*/

Java流程控制

Scanner对象

java.util.Scanner 是 Java5 的新特征，我们可以通过 Scanner 类来获取用户的输入。

Scanner s = new Scanner(System.in);

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

public class Demo08 {
   
    public static void main(String[] args) {
   
        //创建一个扫描对象 用来接收键盘数据
        Scanner scanner=new Scanner(System.in);
        System.out.println("使用next方式进行接收");

        //判断数据有没有输入字符串
        if(scanner.hasNext()){
   
            //使用next方式进行接收
            final String next = scanner.next();
            System.out.println("输出的内容是:"+next);
        }
        scanner.close();
    }
}
// 输出界面如下
// 由于使用的是 scanner.next() 一次读入一个单词以空格划分，若使用 scanner.nextLine() 则是 hello world

Next（）

next()方法:

1.一定要读取到有效字符才可以结束输入
2.对输入有效字符之前遇到的空白，next()方法会自动将其去掉
3.只有输入有效字符后才将其后面的空白作为分隔符或者结束符
4.next()不能得到带有空格的字符串

NextLine()

1、以 Enter 为结束符，也就是说 nextLine() 方法返回的是输入回车之前的所有字符
2、 可以获得空白

package scanner;

import java.util.Scanner;

public class Demo01 {
   
    public static void main(String[] args) {
   
        // 创建一个扫描对象，用于接受键盘数据
        Scanner scanner = new Scanner(System.in);
        // 计算数值的和
        double sum = 0;
        // 计算有多少个数
        int count = 0;
        System.out.println("使用next方式接受：");

        // 通过循环判断是否还有输入，并在里面对每一次进行求和统计
        while(scanner.hasNextDouble()){
   
            double num = scanner.nextDouble(); // 读取数字赋值给中间变量 num
            count++; // 将计数器加1
            sum += num;
        }

        System.out.println(count + "个数的和为" + sum);
        System.out.println(count + "个数的平均值是" + (sum / count));

        // 关闭 Scanner ，解除 IO 流资源占用
        scanner.close();
    }
}

// 输出界面如下
使用next方式接受：
10
20
30
40
x		// 输入不是 double 类型时才会推出循环
4个数的和为100.0
4个数的平均值是25.0

Process finished with exit code 0

顺序结构

1、Java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。
2、顺序结构时最简单的算法结构，语句与语句之间，是按从上到下的顺序进行的它是由若干个依次执行的处理步骤组成的，他是任何一个算法都离不开的一种基本算法结构。

选择结构

 单选择结构：我们很多时候需要判断一个东西是否可行，然后我们才去执行，这样一个过程在程序中用 if 语句来表示。

if(布尔表达式){
   
    // 如果布尔表达式为 true 将执行的语句
}
// 如果布尔表达式为假则直接跳过 if(){} 语句，执行下一个语句

package structure;

import java.util.Scanner;

public class ifDemo {
   
    public static void main(String[] args) {
   
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入内容：");
        String s = scanner.nextLine(); // 读取一行输入给 s

        // equals：判断字符串是否相等
        if (s.equals("Hello")){
   
            System.out.println(s);
        }

        System.out.println("End");
        scanner.close();
    }
}

// 输出界面如下
请输入内容：
Hello
Hello
End

Process finished with exit code 0

if 双选择结构——二选一

if(布尔表达式){
   
    // 如果布尔表达式为 true 将执行的语句
}
else{
   
    // 如果布尔表达式为 false 将执行的语句
}

package structure;

import java.util.Scanner;

public class ifDemo {
   
    public static void main(String[] args) {
   
        // 考试分数大于60就是及格，小于60就是不及格

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入成绩：");
        int score = scanner.nextInt(); // 读取成绩给 score

        // equals：判断字符串是否相等
        if (score >= 60){
   
            System.out.println("恭喜你及格了，成绩为" + score + "分");
        }
        else{
   
            System.out.println("很抱歉，你挂科了，成绩为" + score + "分");
        }
        System.out.println("End");
        scanner.close();
    }
}

if 多选择结构——只能执行其中一条语句，直接跳过其他语句

if(布尔表达式1){
   
    // 如果布尔表达式1为 true 将执行的语句
}
else if(布尔表达式2){
   
    // 如果布尔表达式2为 true 将执行的语句
}
else if(布尔表达式3){
   
    // 如果布尔表达式3为 true 将执行的语句
}
else if(布尔表达式4){
   
    // 如果布尔表达式4为 true 将执行的语句
}
...

package structure;

import java.util.Scanner;

public class ifDemo {
   
    public static void main(String[] args) {
   
        // 考试分数大于60就是及格，小于60就是不及格

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入成绩：");
        int score = scanner.nextInt(); // 读取成绩给 score

        // equals：判断字符串是否相等
        if (score==100){
   
            System.out.println("恭喜你是满分");
        }
        else if(score < 100 && score >=90){
   
            System.out.println("恭喜你成绩是A");
        }
        else if(score < 90 && score >=80){
   
            System.out.println("恭喜你成绩是B");
        }else if(score < 80 && score >=70){
   
            System.out.println("恭喜你成绩是C");
        }else if(score < 70 && score >=60){
   
            System.out.println("恭喜你成绩是D");
        }else if(score < 60 && score >=0){
   
            System.out.println("很遗憾你不及格");
        }
        else{
   
            System.out.println("输入不合法，请重新输入成绩(整数)：");
        }
        System.out.println("End");
        scanner.close();
    }
}



// 输出界面如下
请输入成绩：
65
恭喜你成绩是D
End

Process finished with exit code 0

注意：
1、 if 语句至多有一个 else 语句，else 语句在所有的 else if 语句之后。
2、 if 语句可以有若干个 else if 语句，它们必须在 else 语句之前。
3、一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 的语句都将跳过执行。

switch多选择结构

多选择语句还有一个实现方式就是 switch case 语句，switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

switch(expression){
   
    case value : // value 的变量类型可以是 byte、short、int 或者 char，现在可以比较字符串 String 了
        // 语句
        break; // 可选
    case value :
        // 语句
        break; // 可选
        // 你可以有任意数量的case语句
    default : // 可选
        // 语句
}
...

注意：养成规范：每一个 case 语句后面加上一个 break 防止穿透现象执行语句过多。

package structure;

public class switchDemo {
   
    public static void main(String[] args) {
   
        // switch 匹配一个具体的值
        char grade = 'C';

        switch (grade){
   
            // case 穿透会从第一个匹配分支依次执行每个 case 直到遇到 break 或者 default
            case 'A':
                System.out.println("优秀");
                break; //可选
            case 'B':
                System.out.println("良好");
            case 'C':
                System.out.println("及格");
            case 'D':
                System.out.println("再接再厉");
            case 'E':
                System.out.println("不及格");
            default:
                System.out.println("重新输入");
        }
    }

}

while循环结构

while是最简单的循环结构如下：

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

1、只要布尔值为 true，循环就会一直执行下去
2、我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环
3、少部分情况需要循环一直执行，比如服务器的请求响应监听等
4、循环条件一直为 true 就会造成死循环

DoWhile循环

1、对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次
2、do while 循环和 while 循环相似，不同的是，do while 循环至少会执行一次
3、while 和 do while 的区别：while 是先判断后执行，do while 是先执行后判断；do while 总是保证循环体会被至少执行一次

For循环

for 循环使得循环结构变得更加简单，for 循环是一种支持迭代的一种通用结构，最有效、最灵活，for 循环执行的次数在执行之前就确定的。格式如下：

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