Java基础语法

Java基础语法

  1. 注释、标识符、关键字

    • 注释:用来解释代码,方便他人。注释并不会被执行

      书写注释是一个非常好的习惯

      Java中的注释有三种:

      单行:// 注释文字

      多行:/* 注释文字 */

      文档:/**

      ​ * 注释文字

      ​ */

    • 关键字自定义标识符不能与关键字相同,因为每个关键字都有其表达的意思
      在这里插入图片描述

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

      注意点

      1. 所有的标识符都应该以字母(A-z或者a-z),美元符($)、或者下划线()开始
      2. 首字符之后可以是字母(A-z或者a-z),美元符($)、下划线()或数字的任何字符组合
      3. 不能使用关键字作为变量名或方法名
      4. 标识符是大小写敏感的
      5. 可以中文命名,但不建议使用,也不建议使用拼音
  2. 数据类型

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

      基本类型:
      在这里插入图片描述

      引用类型:类、接口、数组

  3. 类型转换

    在基本类型运算中(除了boolean),不同类型的数据选择转化为同一类型,然后进行运算

    类型转换从低到高依次是:
    在这里插入图片描述

    1. 强制类型转换(高到低)

      public static void main(String[] args) {
          int i = 128;
          byte b = (byte) i;  // 使用强制转换   (类型)变量名
          System.out.println(i);  // 128
          System.out.println(b);  // -128 发生了内存溢出
      }
      
    2. 自动类型转换(低到高)

      public static void main(String[] args) {
          int i = 128;
          double b = i;  // 发生了自动类型转换
          System.out.println(i);  // 128
          System.out.println(b);  // 128.0
      }
      

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

      精度问题:

      public static void main(String[] args) {
          System.out.println((int)23.7);  //23
          System.out.println((int)-45.89f);   //-45
          // 发生了精度丢失问题
      }
      

      JDK7新特性,数字之间可以用下划线分割

      int m = 10_0000_0000;	// 下划线分割
      

      操作比较大的数的时候,注意溢出问题

      public static void main(String[] args) {
          int money = 10_0000_0000;
          int years = 20;
          int total = money * years;
          long total2 = money * years;    //默认为int,转换之前已经存在问题了?
          System.out.println(total);  //-1474836480
          System.out.println(total2); //-1474836480
          long total3 = money * ((long) years);
          // 运算符两边有两个不是类型的变量,那么结果也会自动转换
          System.out.println(total3); //20000000000
      }
      
  4. 变量、常量

    变量

    变量是什么:就是可以变化的量

    由于Java是强类型语言,所以变量必须先定义再使用

    注意事项:

    1. 每个变量都有类型,类型可以是基本类型,/他可以是引用类型。
    2. 变量名必须是合法的标识符。
    3. 变量声明是一条完整的语句,因此每一个声明都必须以分号结束

    变量作用域

    1. 类变量:类变量必须加static关键字,有默认初始值,从属于类
    2. 实例变量:声明在类中的普通变量,有默认初始值,从属于对象
    3. 局部变量:声明在方法中,必须声明和初始化值,作用域只在方法中有效
      在这里插入图片描述
    4. 变量的默认值。除了基本类型,其余的默认值都null
    常量

    常量:初始化后不能再改变的值,不会变动的值

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

    常量名一般使用大写字符

    定义常量:

    final 类型 变量名 =;
    // static final double PI = 3.14;
    // final static double PI = 3.14;
    // 修饰符,不存在先后顺序,final、static都是修饰符
    
    变量命名规范

    所有变量、方法、类名:见名知意

    类成员变量:首字母小写和驼峰原则:monthSalary
    局部变量:首字母小写和驼峰原则常量:
    大写字母和下划线:MAX_VALUE
    类名:首字母大写和驼峰原则:Man,GoodMan
    方法名:首字母小写和驼峰原则:run(),runRun()

  5. 运算符

    Java语言支持如下运算符:
    在这里插入图片描述
    算术运算符:

    public static void main(String[] args) {
        // 二元运算符
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;
    
        System.out.println(a + b);  //30
        System.out.println(a - b);  //-10
        System.out.println(a * b);  //200
        System.out.println(a / b);  //0
        System.out.println(a / (double) b); //0.5
        System.out.println(d % a);  //5 结果是余数
    }
    

    关系运算符:

    public static void main(String[] args) {
        // 关系运算符返回的结果:正确,错误 布尔值
        int a = 10;
        int b = 20;
    
        System.out.println(a > b);
        System.out.println(a < b);
        System.out.println(a == b);
    }
    

    ++ --:

    public static void main(String[] args) {
        // ++ -- 自增、自减  一元运算符
        int a = 3;
    
        int b = a ++;
        int c = ++ a;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        // 在赋值的前提下,++在变量的后面赋的是原值,++在变量的前面是会先自增1再赋值给变量
    }
    

    逻辑运算符:

    public static void main(String[] args) {
        // 与(and) 或(or) 非(取反)
        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(c);  //5 发生短路现象,c ++ 没执行
        System.out.println(d);
    }
    

    位运算:

    public static void main(String[] args) {
        /*
            A = 0011 1100
            B = 0000 1101
            -------------
            A&B 0000 1100   两个位是1才为1
            A|B 0011 1101   两个位中其中有一个为1就为1
            A^B 0011 0001   两个位相同为0,两个位不同为1
            ~B  1111 0010   按位取反,1变0,0变1
             */
        // 面试题:2*8=16怎么运算最快
        // 位运算效率极高
        // << 扩大两倍  *2
        // >> 缩小两倍  /2
        System.out.println(2 << 3);
    }
    

    扩展赋值运算符:

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //        a += b;
        //        System.out.println(a);
        //        a -= b;
        //        System.out.println(a);
        //        a *= b;
        //        System.out.println(a);
        //        a /= b;
        //        System.out.println(a);
    
        // 面试题
        // 字符串连接符 + 在+的两侧,如果出现了String类型,那么结果不会进行数学运算,而是把结果当作字符串处理
        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 = 80;
        System.out.println(score < 60 ? "不及格" : "及格");  // 及格
    }
    
  6. 包机制、JavaDoc

    包机制

    为了更好的组织类,Java提供了包机制,用于区别类名的命名空间

    本质:包就是文件夹

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

    其他包下的类需要导入包名,使用import导入才能使用其他包下的类

    如果使用了包机制,那么包下的每个类的开头都有一个package开始的语句,这是必须的,而且导入的其他类不能在package的前面

    import ...;
    package ...;
    // 错误情况
    package com.fkeuwgqtllb.operator;
    import com.fkeuwgqtllb.base.Demo01; //引入其他包的类
    // 正确情况
    import com.fkeuwgqtllb.base.*;	//.*是导入这个包下的所有类
    
    JavaDoc

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

    参数信息:

    • @author作者名
    • @version 版本号
    • @since 指明需要最早使用的jdk版本
    • @param 参数名
    • @return 返回值情况
    • @throws 异常抛出情况
    package com.fkeuwgqtllb.base;
    
    /**	文档注释
     * @author YAN	作者
     * @version 1.0	版本号
     * @since 1.8	当前jdk版本
     */
    public class Doc {
        String name;
    
        /**
         *
         * @param name	参数
         * @return	返回值
         * @throws Exception	可能参生的异常
         */
        public String test(String name) throws Exception{
            return name;
        }
    }
    

    在当前文件目录进入CMD窗口下输入:

    javadoc -encoding UTF-8 -charset UTF-8 Doc.java	
    #即可生成文档
    

在这里插入图片描述
生成文档示例:
在这里插入图片描述
7. ### 扩展点

  • 整数扩展

    public static void main(String[] args) {
        int i = 10;
        int i2 = 010;   //表示八进制
        int i3 = 0x10;  //表示十六进制
        int i4 = 0b101010;  //表示二进制
    
        System.out.println(i);  //10
        System.out.println(i2); //8
        System.out.println(i3); //16
        System.out.println(i4); //42
    }
    
  • 浮点数扩展

    public static void main(String[] args) {
        float f = 0.1f;
        double d = 1.0/10;
        System.out.println(f == d); //false
        System.out.println(f);  //0.1
        System.out.println(d);  //0.1
    }
    
    public static void main(String[] args) {
        //原因:超出float精度范围,无法精确计算,最多只能保证7位有效数字
        float d1 = 2131324564654f;
        float d2 = d1 + 1;
        System.out.println(d1 == d2);   //true
        System.out.println(d1); //2.13132457E12
        System.out.println(d2); //2.13132457E12
    }
    
    public static void main(String[] args) {
        //原因:超出double精度范围,无法精确计算,最多只能保证15位有效数字
        double d1 = 9999999999999999f;
        double d2 = d1 + 1;
        System.out.println(d1 == d2);   //true
        System.out.println(d1); //1.0000000272564224E16
        System.out.println(d2); //1.0000000272564224E16
    }
    //如果需要使用浮点数精确计算,请使用BigDecimal
    
  • 字符扩展

    public static void main(String[] args) {
        char c1 = 'a';
        char c2 = '中';
    
        System.out.println(c1);
        System.out.println((int) c1);   //强制转换
        System.out.println(c2);
        System.out.println((int) c2);   //强制转换
        // 所有的字符本质还是数字
        char c3 = '\u0061';
        System.out.println(c3);
    }
    
  • 转义字符

    //\t	制表符
    //\n	换行
    //...
    
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值