Java基础-基础语法

计算机DOS命令

• 硬盘切换：字母+分号
• 查看当前目录下的所有文件：dir
• 切换目录：（change directory ）cd /d 字母+分号
• 进入硬盘某文件夹：cd /d 字母+分号 \ 文件名
• 从硬盘进入文件夹：cd 文件名
• 返回上一级：cd …/
• 清空屏幕：cls (clear screen)
• 退出终端：exit
• 查看本机ip：ipconfig
• 进桌面：cd /d 桌面地址
• 创建文件夹：(make)md 文件夹名
• 进入文件夹：cd 文件夹名
• 文件夹内建文件：cd>文件名.格式
• 删除文件：del 文件名.格式
• 删除文件夹 ：(remove) rd 文件名

• print(); 输出后不换行
• println(); 输出后换行

1.java基础

java三高 ：高可用、高性能、高并发

1.1.JDK JRE JVM

• JDK: Java development kit
• JRE: Java runtime environment
• JVM: Java virtual machine

测试jdk是否安装成功 cmd 输入 java -version

1.2.第一个java程序

1. 随便新建一个文件夹，存放代码
2. 新建一个java
   • 文件后缀名为 .java
     3.编写代码

public class Hello{
  public static void main(String[] args){
      System.out.print("Hello world!");
    }
}

4.编译javac Hello.java文件，会生成一个java文件
5.运行class文件，java class名

1.3.java程序运行机制

• 编译型：执行速度快，对操作系统要求低，用编译器对整个程序编译一次就能用了
• 解释型：边执行边解释，走一步执行一步，性能有损失

java两种都包含，只是时机不同

• 1.预编译：java文件经过java编译器的javac命令变成class文件
• 2.生成一个机器码和java源代码之间的一个程序（字节码文件）
• 3.字节码被执行的时候进入JVM虚拟机 ，把class文件这个类放到虚拟机的类装载器里，类就会加载到JVM里。
• 4.字节码校验器对代码进行检验是否有误
• 5.再通过解释器解释给操作系统

文档注释

// JavaDOC：文档注释  /**  */
/**
 * @description helloworld
 * @Author 作者
 */

标识符注意点

java 是强类型语言 ：要求变量的使用要严格符合规定，所有的变量都必须先定义后才能使用
一旦定义了一个变量指定了某个数据类型，如果不经过转换的话他就永远是这个类型

• 好处：安全性高 缺点： 速度慢

• 八大基本数据类型

//      整数
        int num1 = 10; // 最常用
        byte num2 = 21;
        short num3 = 30;
        long num4 = 30L; // long类型要在数字后面加个L
//        小数：浮点数
        float num5 = 50.1F; // float类型要在数字后面加个F
        double num6 = 3.1415926;
//        字符
             char name = '中';
             // 字符串，String不是关键字，是类
        // String namea = "chaoren"; // 不是基本类型
        // 布尔值：
        boolean flag = true；
        boolean Flag = false;

1.4.数据类型

public class Demo03 {
    public static void main(String[] args){
        int i = 0;
        int i1 = 010;
        int i2 = 0x11; // 十六进制0x   0~9 A~F:10~15
        System.out.println(i);
        System.out.println(i1);
        System.out.println(i2);
        System.out.println("===========");
        // 浮点数拓展  浮点数不能表示精确的数值，不能用于比较和表示货币等
        // 银行业务怎么表示？ 用 BigDecimal 数学工具类
        // float  有限 离散  舍入误差 约等于 接近但不等于
        // double
        // 得出结论：最好完全避免使用浮点数进行比较
        float f = 0.1f; // 0.1
        double d = 1.0/10; // 0.1
        System.out.println(f==d); // false
        float d1 = 23413153515f;
        float d2 = d1 + 1;
        System.out.println(d1==d2);// true

        // 字符拓展
        System.out.println("============");
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int)c1); // (int) 表示强制转换
        System.out.println(c2);
        System.out.println((int)c2); // 强制转换

        // 所有字符本质还是是数字
        // char类型涉及到编码类型问题 里的Unicode编码可以处理各种语言文字
        // 占两个字节  最多可表示65535个字符 0~65535  2^16=65535
        // unicode 表:(97=a 65=A) unicode转义编码表示范围：U0000~UFFF

        char c3 = '\u0061'; // \u 表示转义字符
        System.out.println(c3);
        // 转义字符 \t 水平制表符 \n 换行符
        System.out.println("========");
        String sa = new String(original:"helloworld");
        String sb = new String(original:"helloworld");
        System.out.println(sa==ab); // false

        String sc = "helloworld";
        String sd = "helloworld";
        System.out.println(sc==sd); // true
        // 对象 从内存分析
        
    }
}

• 运算中，不同类型的数据先转化为同一类型，让后进行运算

1.5.类型转换

不同类型混合运算不论是是赋值还是运算都是向定义时的最高位类型转

// 类型转换
public class Demo05 {
    public static void main(String[] args){
        int i = 128;
        byte b = (byte)i; // 内存溢出  byte类型数值范围:-128~127 输出垃圾值
        // 强制转换  (类型)变量名 高---低
        int j = 128;
        double c = j;
        // 自动转换   低---高
        System.out.println(i);
        System.out.println(b);
        System.out.println(j);
        System.out.println(c);
        /*
        注意点：
        1.不能对布尔值进行转换
        2.不能把对象类型转换为不相干的类型
        3.在把高容量转换到低容量的时候 用强制转换
        4.转换的时候可能存在内存溢出或精度问题！
         */
        System.out.println("========");
        System.out.println((int)23.7); // double类型  23
        System.out.println((int)-45.89f); // float类型  -45
        System.out.println("========");
        char e = 'a';
        int f = e+1;
        System.out.println(f);
        System.out.println((char)f);
        System.out.println("=========");
        // 操作比较大的数时 注意溢出问题
        // jdk7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
//        System.out.println(money); // 1000000000
        int years = 20;
        int total = money*years; // 负数，计算时溢出了
        long total2 = money*years; // 赋值前默认是int，转换之前已经存在问题了
        long total3 = money*((long)years);// 先把一个数转换为long
        System.out.println(total3);  
    }
}

1.6.变量

• java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
• 注意事项：
  • 每个变量都有类型，类型可以是基本类型，也可以是引用类型(例如String)
  • 变量名必须是合法的标识符
  • 变量声明是一条完整的语句，因此每一个声明都必须以分号结束

public class Demo08 { // 这是类
    // 类变量前加 static // 他是从属于Demo08这个类 而且会随着该类一起出来一起消失
    static double salary = 2500; // 都先把类变量加个static好去调用
    // 属性：变量
    // 实例变量：从属于对象（类）, 作用域在类里面 不在方法里面 如果不自行初始化 这个类型的默认值 所有数值类型一般都是：0,浮点型：0.0 (char)字符串变量默认值是0 或'\u0000' 而非 '0'，布尔值默认值是false 除了基本类型，其余的默认值都是null
    String name; // 定义的变量直接可以用 但用起来不简单
    int age;

    // 类里面会有个默认方法 main方法
    public static void main(String[] args){
        // 局部变量：必须声明和初始化值
        int i = 10;
        System.out.println(i);
        // 变量类型 除了基本类型 类型也可以是自己（自定义类型）也是引用类型 这个变量名字他有个值叫做new了一个Demo08 相当于把自己（变量）给拿到了
        // 通过这个demo08就可以用他的东西了
        Demo08 demo08 = new Demo08(); // 相当于把Demo08这个类拿到了 他会通过这个类返回一个Demo08
        System.out.println(demo08.age);
        System.out.println(demo08.name);
        // 类变量
        System.out.println(salary);
    }

    // 其他方法
    public void add(){

    }
}

1.7.常量

• 一经初始化 不能再修改
• 常量名一般使用大写字符

public class Demo09 {
    // 常量通过final这关键词来定义 常量名一般用大写表示
    // static final 这俩是修饰符 不存在先后顺序
    static final double PI = 3.14;
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

1.8.变量的命名规范

• 所有变量、方法、类名：见名知意
• 类成员变量：首字母小写和驼峰命名法：monthSalary 除了第一个单词外，后面的单词首字母大写
• 局部变量：同上
• 常量：大写字母和下划线：MAX_VALUE
• 类名：首字母大写和驼峰命名法 Man，GoodMan
• 方法名：首字母小写和驼峰命名法：run() runRun()

1.9.运算符 运算优先级用括号括起来

/ 号是取余数（模） %号是取商数

• 自增自减运算符

public static void main(String[] args) {
        int a = 3;
        int b = a++; // a++ 先给b赋值 再自增
        // a = a + 1;
        System.out.println(a);
        // a = a + 1;
        int c = ++a; // ++a 先自增 再给c赋值
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        // 幂运算 使用工具类来操作
        double pow = Math.pow(2,3); // 2^3
        System.out.println(pow);
        System.out.println("================");
        int i = 1;
        int j;
        System.out.println(i); // 1
        j = i++;
        System.out.println(i); // 2
        j = i++;
        System.out.println(i); // 3
        j = i++;
        System.out.println(i); // 4
        j = i++;
        System.out.println(i); // 5
        j = i++;
        System.out.println("i=" + i); // 6
        System.out.println(j); // 5
        /*System.out.println("=================");
        i = i++;
        i = i++;
        i = i++;
        i = i++;
        i = i++;
        i = i++;
        // 进操作数栈的始终是 1 ，++是在局部变量表里完成的，赋值操作会覆盖++后的结果。
        System.out.println("i=" + i); // i=1*/
       /* System.out.println("==================");
        int d = 2;
        int e = 3;
        int f = d++; // d=3
        int g = ++e; // e=4
        System.out.println(f);
        System.out.println(g);
        System.out.println(d++ + ++e);*/
    }
}

• 逻辑运算符

 public static void main(String[] args) {
        // 与(&&) 或(||) 非(!)
        boolean a = true;
        boolean b = false;
        // 短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<4);
        System.out.println(d);
        System.out.println(c);
    }

• 位运算符

 public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101
        // 位运算 跟底层二进制有关 效率极高！！！
        A&B = 0000 1100 A与B 相与 两对应位都是1 结果为1，否则为0
        A|B = 0011 1101 A或B 如果两个A、B对应位都是0 结果为0，否则为1
        A^B = 0011 0001 取反(异或) 如果对应位相同为0，否则为1
        ~B  = 1111 0010
        2*8怎么运算最快 计算机不知道2*8=16 可拆分成2*2*2*2 乘2每次在变大 在位运算里变得非常快
        << 左移 *2
        >> 右移 /2
        >>> 右移
        0000 0000 0
        0000 0001 1
        0000 0010 2
        0000 0100 4
        0000 1000 8
        0001 0000 16
         */
    }

• 字符串运算符

• 在加号两侧，只要由一方有String(字符串)类型(只要不是放最末尾) 他就会把其他的操作数都转换为String再进行连接
• 但是会有运算顺序问题

public static void main(String[] args) {
        int a = 10;
        int b = 20;
        // 字符运算符 在加号两侧，只要由一方有String(字符串)类型(只要不是放最末尾) 他就会把其他的操作数都转换为String再进行连接
        // 但是会有运算顺序问题
        System.out.println(a + b); // 30
        System.out.println("" + a + b); // 1020 直接拼接
        System.out.println(a + b + ""); // 30 先相加再拼接
    }

• 三元运算符

 public static void main(String[] args) {
        // 三元运算符
        // x ? y : z
        // 如果x==true 结果为y 否则为z
        int score = 50;
        String type = score < 60 ? "不及格" : "及格";
        System.out.println(type);
    }

1.10.包机制 (防止命名空间重复的问题)

• 为了更好地组织类，java提供了包机制，用于区别类名的命名空间。
• 包语句的语法格式：

• package pkg1[. pkg2[. pkg3…]];
• package com.dj.operator;

• 一般利用公司域名倒置作为包名;

• 为了使用某个包的成员，我们需要在java程序中明确导入该包。用 “import” 语句可以完成

• import package1[.package2…].(className | *);
• import com.dj.base.Demo2;
• import com.dj.base.*; // 导入这个包下所有的类

1.11.JavaDoc 加在类上面就是类的注释，加在方法上就是方法的注释

• javadoc命令是用来生成自己API文档的
• 参数信息
  • @author 作者名
  • @version 版本号
  • @since 指明需要最早使用的jdk版本
  • @param 参数名
  • @return 返回值情况
  • throws 异常抛出情况
• 在java所在文件夹下地址栏进入cmd
• 输入命令
  • javadoc -encoding UTF-8 -charset UTF-8 Doc.java
    (（java生成文档 让他的编码为UTF-8编码格式 并且让他的字符集编码 也变成UTF-8） 目的为了多显示一点中文 防止出现乱码)
• 生成的 index.html 即为帮助文档

• 用idea生成Javadoc文档

2.Java流程控制

• 用户交互用Scanner类来获取用户的输入

2.1.Scanner对象

• java提供一个工具类，可以获取用户的输入。java.util.Scanner是Java5的新特征，我们可以通过Scanner类来获取用户的输入。

调用nextInt(), next(), nextLine()等方法是用来做接收作用的,括号里可以填数字,表示要接受数字范围,

• 基本语法：

Scanner scanner = new Scanner(System.in);

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

注意：

• 要根据相应方法，来输入指定类型的值，如果输入的数据类型与要求的类型不匹配时，会报异常，程序会终止。

 public static void main(String[] args) {
        // 创建一个扫描器对象，用于接收键盘数据
        // 创建Scanner对象，通过System.in接收用户的输入并且把它封装成scanner对象 之后用scanner进行用户的扫描测试
        Scanner scanner = new Scanner(System.in); // Scanner实体化
        System.out.println("使用next方式接收：");
        // 判断用户有没有输入字符串
        if (scanner.hasNext()) { // scanner对象是否还有下一个输入数据
            String str = scanner.next(); // 创建一个str对象，调用scanner.next()方法 获取指定类型变量 停下来等待接收用户的输入 输入后自动接收 赋值给str变量 程序会等待用户输入完毕
            System.out.println("输出的内容为：" + str);
            // 凡是属于IO流的类如果不关闭会一直占用资源，用完就关养成好习惯
            scanner.close();
        }
    }

• Random类的用法

1.Random类的作用：用来生成随机数
2.Random类的使用步骤：1.导包 2.创建Random类的对象 3.获取随机数 变量类型 变量 = 对象.nextInt() 获取
3.死循环(while 和 for)的应用

 public static void main(String[] args) {
        // 1.1.创建Random类的对象
        Random r = new Random();
        // 获取(接收)指定范围的随机数(1~100)
        int num = r.nextInt(100) + 1; // nextInt(100)--> 0~99 加一是整个范围[0+1,99+1]
        System.out.println("输入你要猜的数(1~100):");
        // 创建用户从键盘输入Scanner类的对象
        Scanner sc = new Scanner(System.in);
        // 因为不知道多少次能猜对,所以用死循环改进
        // 死循环写法一
        while (true){ // 不确定几次猜中，用死循环一直持续下去直到猜中break出
            // 接收用户输入的数据
            int guessNum = sc.nextInt();
            // 比较两数是否相等,给出提示
            if (guessNum < num){
                System.out.println("猜小了");
            }else if (guessNum > num){
                System.out.println("猜大了");
            }else{
                System.out.println("恭喜猜中");
                break; // 结束循环
            }
        }
        // 死循环写法二
        /*for (; ; ) {
            // 存取猜数的对象
            int guessNum = sc.nextInt();
            if (guessNum < num) {
                System.out.println("猜小了");
            } else if (guessNum > num) {
                System.out.println("猜大了");
            } else {
                System.out.println("恭喜猜中");
                break; // 结束循环
            }
        }*/
    }

2.2.顺序结构

• java的基本结构就是顺序结构，除非特别指明，否则就按照顺序从上而下一句一句执行。
• 他是任何一个算法都离不开的一种基本算法结构。

2.3.选择结构

• if 选择结构

 public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入内容：");
        String s = scanner.nextLine();
        // equals 判断字符串是否一致
        if(s.equals("Hello")){
            System.out.println(s);
        }
        System.out.println("end");
        scanner.close();
    }

public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入成绩");
        double score = scanner.nextDouble();
        if(score == 100){
            System.out.println("满分");
        }else if (score < 100 && score >= 60){
            System.out.println("及格");
        }else if(score < 60 && score >= 0){
            System.out.println("不及格");
        }else{
            System.out.println("成绩就不合法");
        }
        scanner.close();
    }

• switch结构

jdk7的新特性：表达式的结果可以是字符串！
字符的本质还是数字
反编译 java文件 编译之后 -> 变成class文件(字节码文件) 用反编译工具(IDEA)反编译成java程序或一些东西

 char grade = 'C'; // 单个字符
        switch (grade){
            case 'A':
                System.out.println("优秀");
                break;// 可选

 String name = "刘宇";
        // jdk7的新特性：表达式的结果可以是字符串！
        // 字符的本质还是数字
        // 反编译  java文件 编译之后 -> 变成class文件(字节码文件) 用反编译工具(IDEA)反编译成java程序或一些东西
        switch (name){
            case "大刘宇":
                System.out.println("大刘宇");
                break;
default:
                System.out.println("刘宇");

• switch可以识别字符串的原因

2.4.循环结构

• while 和 do while 的区别

• while 先判断后执行
• do…while 先执行后判断； 至少执行一次

 int a = 0;
        while (a < 0){
            System.out.println(a);
        }
        System.out.println("===========");
        do {
            System.out.println(a);
        }while (a < 0);

       while (true){
            // 死循环
        }

• for循环

for ( ; ; ){
            // 死循环
        }


打印九九乘法表

 // 1.先打出第一列
for (int i = 1; i <= 9; i++){
                System.out.print(1 + "*" + i + "=" + (1 * i) + "\t");
            }
        // 2.再用一个循环包起来
        // 3.去掉重复项，i == j
        // 4.调整样式
        for (int j = 1; j <= 9; j++) {
            for (int i = 1; i <= j; i++) {
                System.out.print(j + "*" + i + "=" + (j * i) + "\t");
            }
            System.out.println();
        }

• break 和 continue
  • break 终止循环 不再进行

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

• continue 跳过本次所有循环内余下的操作，回到下一次是否执行循环判断

int i = 0;
        while (i < 100){
            i++;
            if (i % 10 == 0){
                System.out.println();
                continue; // 跳过本次所有循环内余下的操作，回到下一次是否执行循环判断
            }
            System.out.print(i);

• 关于goto 关键字

int count = 0;
        outer:for (int i = 101; i < 150; i++){
            for (int j = 2; j < i/2; j++){
                if (i % j == 0){
                    continue outer;
                }
            }
            System.out.print(i + " ");
        }

• 打印三角形

// 打印三角形 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();
        }