4.Java基础

为了项目方便管理，创建空项目

一、注释

• 平时编写代码，在代码量比较少的时候，还可以看懂自己写的，但是当项目结构一复杂起来，我们就需要用到注释了
• 注释并不会被执行，是给写代码的人看的
• 书写注释是一个非常好的习惯
• 平时写代码一定要注意规范

1.单行注释

2.多行注释

3.文档注释（JavaDoc）

• JavaDoc命令是用来生成自己的API文档的

• 参数信息

  • @author 作者名
  • @version 版本号
  • @since 指明需要最早使用的JDK版本
  • @param 参数名
  • @return 返回值情况
  • @throws 异常抛出情况

• 查看生成的文档

javadoc -encoding UTF-8 -charset UTF-8 hello.java

/**
 * 3.文档注释：JavaDoc，有功能，可以加一些参数
 *
 * @author lemon
 * @create 2021-06-27 19:06
 */
public class Annotation {
    public static void main(String[] args) {
        //a.单行注释：只能注释一行文字
        /*
        2.多行注释：可以注释一段文字
         */
        System.out.println("a.Annotation");
    }
}

搜索“有趣的代码注释”

搜索“JDK帮助文档”

搜索“使用IDEA生成JavaDoc文档”

二、标识符和关键字

1.标识符注意点

• Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

• 所有的标识符都应该以字母（A-Z或者a-z）、美元符（$）、下划线（_）开始

• 首字符之后可以是字母（A-Z或者a-z）、美元符（$）、下划线（_）或数字的任何字符组合

• 不能使用关键字作为变量名或方法名

• 标识符是大小写敏感的

  String Name = "张三";
  String name = "张三";
  

• 合法标识符举例：

  String Aname = "张三";//大写字母
  String aname = "张三";//小写字母
  String $name = "张三";//$
  String _name = "张三";//_
  String name1 = "张三";//后面接任何字符
  

• 非法标识符举例：

  //    String 1name = "张三";数字
  //    String #name = "张三";符号
  //    String *name = "张三";符号
  //    String class = "张三";关键字
  

• 可以使用中文命名，但一般不建议这样去使用，也不建议使用拼音

2.关键字

三、数据类型

1.强类型语言 和 弱类型语言

• 强类型语言

  • 要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用（好处：安全性高；缺点：速度慢）

• 弱类型语言

public class StronglyTypeLanguageAndWeaklyTypeLanguage {
    public static void main(String[] args) {
        //变量i需要初始化
//        int i;
        int i = 10;
        System.out.println(i);  //10

        //正确使用
        String s = "hello";
        System.out.println(s);  //hello
    }
}

2.Java的数据类型分为两大类

• 基本类型（primitive type）
• 引用类型（reference type）

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

        //整数，可以在包装类里面看到范围
        //Byte、Short、Integer、Long
        byte b = 10;
        short s = 20;
        int i = 30;  //最常用
        long l = 30L;  //long类型要在数字后面加个L

        //小数：浮点数
        //Float、Double
        float f = 40.1F;  //float类型要在数字后面加个F
        double d = 3.141592653589793238462643;

        //字符：一个字
        char c = 'a';

        //布尔值
        //Boolean
        boolean flag = true;
        boolean flag2 = false;

        //字符串，String不是关键字，而是一个类
        String name = "张三";

        //整数拓展：进制  二进制（0b开头）  八进制（0开头）  十进制  十六进制（0x开头）
        int i1 = 0b10;  //二进制（0b开头）：逢2进1
        int i2 = 010;  //八进制（0开头）：逢8进1
        int i3 = 10;  //十进制：逢10进1
        int i4 = 0x10;  //十六进制（0x开头）：逢16进1  0~9  A~F

        System.out.println(i1);  //2
        System.out.println(i2);  //8
        System.out.println(i3);  //10
        System.out.println(i4);  //16
        System.out.println();

        //浮点数拓展：银行业务怎么表示？钱  BigDecimal  数学工具类
        float f1 = 0.1f;
        double d1 = 1.0 / 10;
        System.out.println(f1);  //0.1
        System.out.println(d1);  //0.1
        System.out.println(f == d);  //false

        float f2 = 123456789f;
        float f3 = f2 + 1;
        System.out.println(f2);  //1.23456792E8
        System.out.println(f3);  //1.23456792E8
        System.out.println(f2 == f3);  //true
        System.out.println();
        //浮点数表示的字长是有限的，也是离散的，浮点数一般都会存在舍入误差（四舍五入），由于很多数字无法精确的表示，只能是大约数（接近但不等于）

        //最好完全避免使用浮点数进行比较！！！

        //字符拓展：所有的字符本质还是数字！！！
        char c1 = 'a';
        char c2 = '张';
        System.out.println(c1);  //a
        System.out.println(c2);  //张
        //强制转换：可以把字符变成数字
        System.out.println((int)c1);  //97
        System.out.println((int)c2);  //24352
        //Unicode编码：可以处理各种语言的文字，占2个字节，最多可以表示2^16 = 65536个字符
        //Unicode编码表：（A = 65, a = 97），范围U0000~UFFFF
        char c3 = '\u0061';
        System.out.println(c3);  //a
        System.out.println();

        //转义字符：
        //\t：水平制表符
        //\n：回车

        //字符串扩展：对象  从内存分析
        String s1 = new String("字符串");
        String s2 = new String("字符串");
        System.out.println(s1 == s2);  //false

        String s3 = "字符串";
        String s4 = "字符串";
        System.out.println(s3 == s4);  //true

        //布尔值扩展：判断条件是否为真
        boolean flag1 = true;
        if (flag1 == true){}
        if (flag1){}
        //代码要精简易读
    }
}

3.什么是字节？

• 位（bit）：是计算机内部数据储存的最小单位

• 字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示

• 1B（byte，字节）=8bit（位）

• 字符：是指计算机中使用的字母、数字、字和符号

• 1bit表示1位

• 1Byte表示一个字节，1B=8b

• 思考：电脑的32位和64位的区别是什么？

  • 32位的操作系统只可以用32位的CPU，最多可以支持4G的内存；而64位的操作系统既可以装32位的操作系统的CPU也可以装64位的操作系统，最多可以支持128G的内存（它们之间有一个“寻址”能力）

四、类型转换

• 由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换

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

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

• 强制类型转换

• 自动类型转换

public class TypeConversion {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte) i;  //强制类型转换：高 -> 低  (类型) 变量名
        double d = i;  //自动类型转换：低 -> 高
        System.out.println(i);  //128
        System.out.println(b);  //-128，内存溢出
        System.out.println(d);  //128.0
        System.out.println();

        /*
        注意点：
            1.不能对布尔值进行转换
            2.不能把对象类型转换为不相干的类型
            3.在把高容量转换到低容量的时候，强制转换
            4.转换的时候可能存在内存溢出，或者精度问题！
         */
        System.out.println((int) 23.7);  //23
        System.out.println((int) -23.78f);  //-23

        char c = 'a';
        int i1 = c + 1;
        System.out.println(i1);  //98
        System.out.println((char) i1);  //b
        System.out.println();

        //操作比较大的数的时候，注意溢出问题
        //JDK7新特性,数字之间可以用 _ 分割
        int money = 10_0000_0000;
        System.out.println(money);  //1000000000
        int years = 20;
        int total = money * years;
        System.out.println(total);  //-1474836480，计算的时候溢出了
        long total2 = money * years;
        System.out.println(total);  //-1474836480，默认是int，计算完之后才转换为long类型，转换之前已经存在问题了
        long total3 = money * (long) years;
        System.out.println(total3);  //20000000000，在计算之前就把精度解决掉了
    }
}

五、变量、常量、作用域

1.变量（Variable）

• 变量是什么：就是可以变化的量！变量代表内存中的一块空间，空间里面要放的东西不确定，位置确定，存的东西不确定

• Java是一种强类型语言，每个变量都必须声明其类型。

• Java变量是程序中最基本的存储单元，其要素包括变量名、变量类型和作用域。

  //数据类型 变量名 = 值;
  //可以使用,隔开来声明多个同类型变量
  //不建议在一行里面定义多个值
  

• 注意：

  • 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
  • 变量名必须是合法的标识符。
  • 变量名必须是一条完整的语句，因此每一个声明都必须以;结束

public class Variable {
    public static void main(String[] args) {
        //可以使用,隔开来声明多个同类型变量
        //不建议在一行里面定义多个值
        //程序可读性！！！
        int a, b, c;
        int d = 1, e = 2, f = 3;
        String s = "zhangsan";
    }
}

2.常量（Constant）

• 常量（Constant）：初始化（initialize）后不能再改变的值！不会变动的值。
• 所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

final 常量名 = 值

• 常量名一般使用大写字符

public class Constant {
    //修饰符不存在先后顺序
    static final double PI = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);  //3.14
    }
}

3.变量作用域（Scope）

• 类变量：写在类里面，需要加关键字static
• 实例变量：写在类中间
• 局部变量：写在方法里面

public class Scope {

    //类变量：static,从属于类，随着类一起出现，一起消失
    static double salary = 4510471;

    //属性：变量

    //实例变量：在类里面方法的外面，从属于对象（类），
    //如果不进行初始化，会变成这个类型的默认值，
    // 所有数值类型初始化一般都是 0 或 0.0 ，
    // 字符串变量初始化是十六位的 U0000 ，
    // 布尔值默认是false，
    // 除了基本类型，其余的默认值都是null
    String name;
    int age;

    //main方法
    public static void main(String[] args) {
        //局部变量：写在方法里面，使用之前必须声明和初始化值
        int i = 10;
        System.out.println(i);  //10

        //变量类型 变量名 = 值;
        Scope s = new Scope();
        System.out.println(s.name);  //null
        System.out.println(s.age);  //0

        //类变量：static  可以直接输出
        System.out.println(salary);  //4510471.0
    }

    //main方法
    public void other() {
        //局部变量：写在方法里面，使用之前必须声明和初始化值
    }
}

4.变量的命名规范

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

六、运算符

• Java支持如下运算符：()优先级最高

1.算术运算符：+、-、*、/、%、++、--

public class ArithmeticOperator {
    public static void main(String[] args) {
        //二元运算符：两个数操作
        int i1 = 10;
        int i2 = 20;
        int i3 = 25;
        int i4 = 25;
        int i5 = 21;

        System.out.println(i1 + i2);  //30
        System.out.println(i1 - i2);  //-10
        System.out.println(i1 * i2);  //200
        System.out.println(i1 / i2);  //0
        System.out.println(i1 / (double) i2);  //0.5
        System.out.println();

        //如果两个操作或多个操作中，有一个数为long，那么结果类型也为long，如果没有long的时候，结果都为int，无论是否有int操作
        //运算规则：先将运算级统一成该运算中最高的数据类型后再运算
        long l = 123456789L;
        int i = 123;
        short s = 12;
        byte b = 1;

        //如果有一个数为double，那么它们的结果也为double
        System.out.println(l + i + s + b);  //123456925  long
//        System.out.println((String) (l + i + s + b));  //这样就可以看到long类型不能转换为String类型
        System.out.println(i + s + b);  //136  int
        System.out.println(s + b);  //13  int
        System.out.println();

        //取余，模运算
        System.out.println(i5 % i1);  //1  21 / 10 = 2 ......1
        System.out.println();

        //一元运算符：一个数操作
        //++自增  --自减
        int i6 = 6;
        int i7 = i6++;  //执行完这行代码后，先给i7赋值，再自增
        //a ++  a = a + 1
        System.out.println(i6);  //7
        //a ++  a = a + 1
        int i8 = ++i6;//执行完这行代码前，先自增，再给i8赋值

        System.out.println(i6);  //8
        System.out.println(i7);  //6
        System.out.println(i8);  //8
        System.out.println();

        //幂运算  2^3  借助工具类 Math
        System.out.println(Math.pow(2, 3));
    }
}

2.赋值运算符：=

3.关系运算符：>、<、>=、<=、==、!=、instanceof

public class RelationalOperator {
    public static void main(String[] args) {
        //关系运算符返回的结果：true/false  布尔值
        int i1 = 10;
        int i2 = 20;

        System.out.println(i1 > i2);  //false
        System.out.println(i1 < i2);  //true
        System.out.println(i1 == i2);  //false
        System.out.println(i1 != i2);  //true
    }
}

4.逻辑运算符：&&、||、!

public class LogicalOperator {
    public static void main(String[] args) {
        //与（and）  或（or）  非（not）
        boolean b1 = true;
        boolean b2 = false;

        System.out.println(b1 && b2);  //false  逻辑与：两个变量都为真，结果才为真
        System.out.println(b1 || b2);  //true  逻辑或：两个变量有一个为真，结果为真
        System.out.println(!(b1 && b2));  //true
        System.out.println();

        //短路运算
        int i = 5;
        System.out.println((i < 4) && (i++ < 4));  //false  前面为false，就不执行后面
        System.out.println(i);  //5
    }
}

5.位运算符：&、|、^、~、>>、<<、>>>（了解即可）

public class PositionalOperator {
    public static void main(String[] args) {
        /*
        与（&）、或（|）、异或（^）、非（~）
        A = 0011 1100
        B = 0000 1101

        A&B = 0000 1100  两个数比较，如果都为1，结果为1
        A|B = 0011 1101  两个数比较，如果都为0，结果为0
        A^B = 0011 0001  两个数比较，如果位置相同，结果为0，否则为1
        ~B = 1111 0010  两个数比较，如果为1，结果为0，如果为0，结果为1

        2 * 8怎么运算最快  2 * 2 * 2 * 2
        右移（>>）：数字 / 2
        左移（<<）：数字 * 2

        2进制，逢2进1
        0000 0000  0
        0000 0001  1
        0000 0010  2
        0000 0011  3
        0000 0100  4
        0000 1000  8
        0001 0000  16

        位运算的优点：效率极高，跟计算机底层打交道的
         */
        System.out.println(2 << 3);  //16
    }
}

6.条件运算符： ? :

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

7.扩展赋值运算符：+=、-=、*=、/=

public class AssignmentOperator {
    public static void main(String[] args) {
        int i1 = 10;
        int i2 = 20;

        i1 += i2;  //i1 = i1 + i2
        System.out.println(i1);  //30
        System.out.println();

        //字符串链接符  +，在 + 两侧，只要一方出现了String，就会把另外一个操作数或者其它操作数都转换为String再进行连接
        System.out.println(i1 + i2);  //50
        System.out.println("" + i1 + i2);  //3020  如果字符串在前面会拼接
        System.out.println(i1 + i2 + "");  //50  如果字符串在后面会依旧进行运算
    }
}

七、包机制（本质就是文件夹）

• 为了更好地组织类，Java提供了包机制，用于区分类名的命名空间。

• 包语句的语法格式为：package

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

//www.baidu.com
package com.baidu.www

• 为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用 import语句可完成此功能
• *作为通配符可导入包下所有的类
• 尽量不要让包里面的名字重复

搜索”阿里巴巴开发手册“