目录

• Java基础语法
  • 算术运算符
  • 关系运算符
  • 逻辑运算符
  • 位运算符
  • 条件运算符
  • 扩展赋值运算符
  • Java中的注释有三种：
  • 注释
  • 标识符
  • 标识符注意点
  • 数据类型
  • 额外拓展(什么是字节)
  • 数据类型拓展
  • 类型转换
  • 变量
  • 变量作用域
  • 常量
  • 变量的命名规范
  • 运算符

Java基础语法

注释

• 当项目结构复杂时，就需要用到注释
• 注释并不会被执行，是给我们写代码的人看的
• 书写注释是一个非常好的习惯

Java中的注释有三种：

• 单行注释
• 多行注释
• 文档注释

public class HelloWorld {
    public static void main(String[] args) {
        // 单行注释
        // 输出一个Hello,World!
        System.out.println("Hello,World!");
        /*
        * 多行注释
        * 可以注释一段文字
        * */
        // JavaDoc：文档注释  /** */
        /**
         * @Description HelloWorld
         * @Author  Slimety
         */
    }
}

标识符

• 关键字

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

标识符注意点

• 所有的标识符都应该以字母(A-Z或者a-z)美元符($)、或者下划线(_)开始
• 首字符之后可以是字母(A-Z或者a-z),美元符($)、下划线()或数字的任何字符组合
• 不能使用关键字作为变量名或方法名。
• 标识符是大小写敏感的
• 合法标识符举例:age、$salary、_value、__1_value
• 非法标识符举例:123abc、- salary、#abc
• 可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音

数据类型

• 强类型语言

  • 要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用

• 弱类型语言

  • 类似JavaScript，没有要求变量的使用要严格符合规定

• Java的数据类型分为两大类

  • 基本类型(primitive type)
  • 引用类型(reference type)

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

        // 整数
        int num1 = 10;// 最常用
        byte num2 = 20;
        short num3 = 30;
        long num4 = 40L;// Long 类型要在数字后面加个L

        // 小数：浮点数
        float num5 = 50.1F;// float 类型要在数字后面加个F
        double num6 = 3.141592653589793238462643;

        // 字符
        char name = 'A';
        // 字符串,String不是关键字，而是类
        String namea = "Slimety";

        // 布尔值：是非
        boolean flag = true;
        // boolean flag = false;
    }
}

额外拓展(什么是字节)

• 位(bit):是计算机內部数据储存的最小单位,11001100是一个八位二进制数。
• 字节(byte):是计算机中数据处理的基本单位,习惯上用大写B来表示,
• 1B(byte,字节)=8bit(位)
• 字符:是指计算机中使用的字母、数字、字和符号

数据类型拓展

public class Demo03 {
    public static void main(String[] args) {
        // 整数拓展： 进制   二进制0b  十进制   八进制0   十六进制0x

        int i = 10;
        int i1 = 010;// 八进制0
        int i2 = 0x10;// 十六进制0x  0~9  A~F  16

        System.out.println(i);
        System.out.println(i1);
        System.out.println(i2);
        System.out.println("=========================");
        // ===============================================
        // 浮点数拓展？  银行业务怎么表示？  钱
        // BigDecimal  数学工具类
        // ===============================================
        // float   有限  离散  舍入误差  大约   接近但不等于
        // double
        // 最好完全避免使用浮点数进行比较
        // 最好完全避免使用浮点数进行比较
        // 最好完全避免使用浮点数进行比较

        float f = 0.1f;
        double d = 1.0 / 10;

        System.out.println(f == d);//false

        float d1 = 2215451313134f;
        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);// 强制转换
        System.out.println(c2);
        System.out.println((int) c2);// 强制转换

        // 所有的字符本质还是数字
        // 编码 Unicode   2字节  0-65536   Excel  2的16次方 = 65536

        // u0000  uFFFF

        char c3 = '\u0061';
        System.out.println(c3);// a

        // 转义字符
        // \t  制表符
        // \n 换行
        // 。。。。
        System.out.println("Hello\tWorld!");

        System.out.println("=========================");
        String sa = new String("hello world");
        String sb = new String("hello world");
        System.out.println(sa == sb);

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

        // 布尔值扩展
        boolean flag = true;
        if (flag == true) {
        }
        if(flag){}
        // Less is More!  代码要精简易读
    }
}

类型转换

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

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

• 强制类型转换

public class Demo04 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i;// 内存溢出

        // 强制转换   (类型)变量名  高--->低

        System.out.println(i);
        System.out.println(b);
    }
}

• 自动类型转换

public class Demo04 {
    public static void main(String[] args) {
        int i = 128;
        double c = i;

        // 强制转换   (类型)变量名  低--->高

        System.out.println(i);
        System.out.println(c);
    }
}

• 类型转换注意点
  • 1.不能对布尔值进行转换
  • 不能把对象类型转换为不相干的类型
  • 在把高容量转换到低容量的时候，强制转换
  • 转换的时候可能存在内存溢出，或者精度问题！

变量

• 变量是什么：就是可以变化的量！
• Java是一种强类型语言,每个变量都必须声明其类型。
• Java变量是程序中最基本的存储单元,其要素包括变量名,变量类型和作用域。

type varName [=value] [{,varName[=value]}];
// 数据类型  变量名 =  值 ; 可以使用逗号隔开来声明多个同类型变量

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

变量作用域

• 类变量
• 实例变量
• 局部变量

public class Demo07 {

    // 类变量  static
    static double salary = 2500;

    // 属性：变量

    // 实例变量：从属于对象;如果不自行初始化，这个类型的默认值 0 0.0
    // 布尔值：默认是false
    // 除了基本类型，其余的默认值都是null；
    String name;
    int age;

    // main方法
    public static void main(String[] args) {


        // 局部变量
        int i = 10;
        System.out.println(i);

        // 变量类型  变量名字  = new  Demo07();
        Demo07 demo07 = new Demo07();
        System.out.println(demo07.age);

        // 类变量  static
        System.out.println(salary);
    }
}

常量

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

final 常量名 = 值;
final double PI = 3.14;

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

变量的命名规范

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

运算符

• Java语言支持如下运算符：

算术运算符

public static void main(String[] args) {
        // 二元运算符
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;

        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);
    }

public static void main(String[] args) {
        // ++   --  自增，自减   一元运算符
        int a = 3;

        int b = a++;// 先赋值再加加
        // a = a + 1;
        System.out.println(a);
        int c = ++a;// 先加加再赋值

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }

关系运算符

public static void main(String[] args) {
        // 关系运算符返回的结果： 正确，错误   布尔值

        int a = 10;
        int b = 20;
        int c = 21;

        System.out.println(c%a);// 21/10=2...1

        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);
    }

逻辑运算符

public static void main(String[] args) {
        // 与   或   非
        boolean a = true;
        boolean b = false;

        System.out.println("a && b:"+(a&&b));// 逻辑与运算：两个变量都为真，结果才为true
        System.out.println("a || b:"+(a||b));// 逻辑或运算：两个变量有一个为真，结果为true
        System.out.println("!(a && b):"+!(a&&b));// 如果是真，则变为假，如果为假，则变为真

        // 短路运算
        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 = 0011 1101
        A^B = 0011 0001  相同为零，不同为一
        ~B = 1111 0010

        2*8 = 16 2*2*2*2   面试
        效率极高！！！
        <<  *2
        >>  /2
         */
        System.out.println(2<<3);
    }

条件运算符

public static void main(String[] args) {
        // x ? y : z
        // 如果x==true,则结果为y,否则结果为z

        int score = 50;
        String type = score < 60 ? "不及格":"及格";
        // if
        System.out.println(type);
    }

扩展赋值运算符

public static void main(String[] args) {
        int a = 10;
        int b = 20;

        a+=b;// a = a+b
        a-=b;// a = a-b

        System.out.println(a);

        // 字符串连接符  +  , String  面试
        System.out.println(""+a+b);
        System.out.println(a+b+"");
    }

感谢B站狂神说，让我学到这些
希望能帮助到你，如有不足之处，希望大佬指出