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

一、注释

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

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.compackage com.baidu.www

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