Java基础语法

最新推荐文章于 2024-07-21 22:27:18 发布
最新推荐文章于 2024-07-21 22:27:18 发布
阅读量101 收藏
点赞数
分类专栏： java 文章标签： javase java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44926251/article/details/115679495
版权

Java基础语法

目录

一、注释、标识符、关键字

1.注释
单行注释：//
多行注释：/* */ （快捷键：选中多行按Ctrl+/）
文档注释：/** */ （里面可以加参数等，可以被识别，例如：@author 面具人，后面会有专门的说明。）
2.标识符
  • java中所有的组成部分都需要名字，类名、变量名以及方法名都被称为标识符
  • 所有的标识符都应该以字母(A-Z 或者a-z)，美元符($)、或者下划线()开始
  • 标识符的大小写敏感
  • 合法标识符举例：number、$dictionary、_bob
  • 非法标识符举例：123good、-sorry、#abc
  • 可以使用中文命名，但不建议，很low！
3.关键字

Java52个关键字
52个关键字及其作用（摘录）

二、数据类型

1.强类型语言
  • 要求变量的使用要严格符合规定，所有变量必须先定义后才能使用。（优点：安全性高；缺点：速度会变慢）
2.弱类型语言
  • JavaScript、VBScript等等
3.Java的数据类型分为两大类
  • 基本数据类型（常考，重点）
数据类型关键字占用字节取值范围默认值
字节型byte1-128（-27）~127（-27-1）0
短整型short2-32768（-215）~32767（-215-1）0
整型int4-2147483648（-231）~2147483647（-231-1）0
长整型long8-9223372036854775808（-263）~9223372036854775807（263 -1）0L
单精度浮点型float41.4E-45~3.4028235E380.0F
双精度浮点型double84.9E-324~1.7976931348623157E3080.0D
字符型char20~65535‘\u0000’
布尔型boolean1bit但实有1B只有true和false两个值（计算机中用1和0表示）false

  • 什么是字节：

    位（bit）：计算机内部 数据储存 的最小单位，11001100是一个八位二进制数。
字节：计算机中 数据处理 的基本单位，习惯用大写的B表示。
字符：是指计算机中使用的字母、数字、字、和符号。
1B(Byte)=8b(bit)
1KB=1024B
1MB=1024KB
1GB=1024MB
1TB=1024GB

  • 引用数据类型（除基本类型外都是引用类型）

    类、接口、数组

  • 数据类型拓展

    package com.example.bag2021041301;

public class JavaBase04 {
    public static void main(String[] args) {
        //1.整数类型拓展：进制：二进制0b、十进制、八进制0、十六进制0x
        int i1 = 10;
        int i2 = 010;   //八进制
        int i3 = 0x10;   //十六进制0x 0~9、A~F 16

        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);

        System.out.println("___________________________________________");

        //2.浮点数拓展：
        float f = 0.1f;
        double d = 0.1;
        System.out.println(f == d);   //结果是false

        System.out.println("+++++++++++++++++++++++++++++++++++++++++++");
        float f1 = 121212121212f;
        float f2 = f1 + 1;
        System.out.println(f1 == f2);   //结果是true
        //尽量避免用浮点数进行比较！
        //原因就是：float数字长有限，又是离散，而且存在舍入误差，意思就是大约、接近但不等于！
        //经常用BigDecimal类：数学工具类，进行判断实际问题，例如银行业务。

        System.out.println("-------------------------------------------");

        //3.字符拓展：
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);;
        System.out.println((int)c1);   //强制转换
        System.out.println(c1);
        System.out.println((int)c2);   //强制转换
        //所有的字符本质都是数字！
        //Unicode 2字节 0~65536 Excle:2^16=65536
        //U0000~UFFFF
        char c3 = '\u0061';
        System.out.println(c3);

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

        System.out.println("-------------------------------------------");

        //5.以下运行结果可以用对象和内存进行解释：
        String str1 = new String("Hello World");
        String str2 = new String("Hello World");
        System.out.println(str1 == str2);   //false

        String str3 = "HelloWorld!";
        String str4 = "HelloWorld!";
        System.out.println(str3 == str4);   //true

        System.out.println("--------------------------------------------");

        //6.布尔值拓展：

        Boolean flag = true;
        if (flag == true){};   //菜鸟写法
        if (flag){};   //老司机写法

        //less is more：代码要精简易读！
    }
}

三、类型转换

低→高：

byte,short,char→int→long→float→double

  • 强制类型转换

    (类型) 变量名 ：由高→低
int i = 128;
byte b = (byte)i;   //结果是-127，因为内存会溢出

  • 自动类型转换

    //低→高
int i = 128;
double b = i;

  • 注意点

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

public class JavaBase05 {
    public static void main(String[] args) {

        int mo = 100_00_00;
        System.out.println(mo);    //结果仍然是1000000，所以数字之间可以用下划线分割。

        int money = 100_0000_000;
        System.out.println(money);  //结果仍然是1000000，所以数字之间可以用下划线分割。
        int years = 20;
        int total = money*years;   //结果为负数，计算的时候内存溢出了
        long total1 = money*years;   //结果依旧为负数，默认是int，转换之前已经存在问题。
        long total2 = money*((long)years);   //计算之前先对一个数进项强制类型转换为long，便可解决。

        System.out.println(total);
        System.out.println(total1);
        System.out.println(total2);
    }
}

四、变量、常量、作用域

1.变量

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

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

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

  • 注意事项：

    //每个变量都有类型，类型可以是基本类型，也可以是引用类型。
//变量名必须是合法的标识符。
//变量声明是一条完整的语句，因此每一个声明都必须以分号结束。
//从程序的可读性原则出发，不建议一行声明多个变量！

  • 作用域：

    //类变量：写在类里面，需要加一个关键字static
//实例变量：写在类中间，从属于对象
//局部变量：写在方法里面
    static int allClicks = 0;   //类变量
    String str = "Hello World!";   ///实例变量

    public void method(){
        int i = 0;   //局部变量
    }

    package com.example.bag2021041301;

public class JavaBase06 {
    //属性：变量

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

    //实例变量：从属于对象
    String name;   //如果不进行初始化，会自动赋默认值！String默认值为null！
    int age = 1;

    //main方法

    public static void main(String[] args) {

        //局部变量：必须声明和初始化值
        int i= 10;

        //变量类型 变量名字(↓即对象) = new JavaBase06();
        JavaBase06 JavaBase06 = new JavaBase06();
        System.out.println(JavaBase06.name);
        System.out.println(JavaBase06.age);

        System.out.println(salary);
    }
2.常量

  • 初始化后不能再改变，不会再变动的值。

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

    static final double PI = 3.14;   //static final顺序无所谓，static是修饰符，不存在先后顺序
                                 // 常量定义一般使用final关键字
System.out.println(PI);   //常量输出
3.变量的命名规则
  • 所有变量、方法、类名:见名知意
  • 类成员变量:首字母小写和驼峰原则: monthSalary除了第一个单词以外，后面的单词首字母大写lastName
  • 局部变量:首字母小写和驼峰原则
  • 常量:大写字母和下划线: MAX_ VALUE
  • 类名:首字母大写和驼峰原则: Man, GoodMan
  • 方法名:首字母小写和驼峰原则: run(), runRun()

五、基本运算符

基本运算符

  • 关系运算符返回的结果是Boolean值，一般会跟if结构一起使用。
  • %：取余，也叫模运算
    表达式运算后的自动转换问题

六、自增、自减运算符，幂运算

1.自增自减运算
  • b = a++：先赋值，再自增
  • c = ++a：先自增，再赋值
  • 自减运算同理
2.幂运算
  • double a = Math.pow(3,2);   //幂运算pow
System.out.println(a);

七、逻辑运算符、位运算符

1.逻辑运算符
  • /**
 *逻辑运算符：
 * &&
 * ||
 * !
 */
public class Test05 {
    public static void main(String[] args) {
        //定义布尔类型的变量：

        boolean x = true;
        boolean y = false;

        System.out.println(x && y);   //逻辑与 && : 两边都为true 结果才是true, 只要一边是false 结果就为false
        System.out.println(x || y);   //逻辑或 || : 两边的结果 只要有一个为true, 就为true

        System.out.println(! false);   //取反
        System.out.println(!(x && y));
    }
}

  • /**
 * 逻辑运算符
 *      短路效果演示：
 */
public class Test06 {
    public static void main(String[] args) {

        //定义变量
        int a = 10;
        int b = 10;
        int c = 30;

        //逻辑运算符 连接布尔类型的表达式
        System.out.println(a == b && a >= c);//false
        System.out.println(a >= b || a >= c);//true

        System.out.println("------------------------------------");

        //短路&&的特点: 符号左边是false ,右边就不运算；符号左边是true，右边就会运算
        System.out.println(++a < b && ++b < c);
        System.out.println("a = " + a);
        System.out.println("b = " + b);

        System.out.println("------------------------------------");

        //短路||的特点: 符号左边是 true ,右边不运算；符号左边是false，右边就会运算
        System.out.println(++a < b || ++b < c);
        System.out.println("a = " + a);
        System.out.println("b = " + b);
2.位运算符
  • public class JavaBase09 {
    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
         *  ~B = 1111 0010   //取反运算：对应位相反，0为1,1为0
         *
         *  面试题：
         *  2*8 = 16  2*2*2*2* = 16
         *  << ：左移 *2；右边补0
         *  >> ：右移 /2；左边补1
         */
        System.out.println(2<<3);
        //即把16进制的2左移三次，相当于给2乘了3次2，结果为16；位运算效率极高！
        /**
         * 原理：
         * 0000 0000  0
         * 0000 0001  1
         * 0000 0010  2
         * 0000 0100  4
         * 0000 1000  8
         * 0001 0000  16
         */
    }
}

八、三元运算符、扩展赋值运算符

1.扩展赋值运算符
  • 扩展赋值运算符
 /**
  * 扩展赋值运算符
  * += -= *= /= %=
  */
 public class Test03 {
     public static void main(String[] args) {
 
         int a = 10;   //a = a + 10；以下运算同理
         a += 10;
         System.out.println(a);
 
         int b = 20;
         b -= 10;
         System.out.println(b);
 
         int c = 20;
         c *= 10;
         System.out.println(c);
 
         int d = 30;
         d %= 20;
         System.out.println(d);
 
         int e = 20;
         e /= 20;
         System.out.println(e);
 
         //字符串在前，+ 起连接作用！字符串在后，表达式会进行运算！
         System.out.println("a+b = " +a+b);   //2010
         System.out.println(a+b+ " = a+b");   //30
     }
 }
  • 三元运算符
 /**
  * 三元运算符：
  * 数据类型 变量名 = 布尔类型表达式 ? 结果1 : 结果2;
  */
 public class Test07 {
     public static void main(String[] args) {
         
         //? 前面为真，则输出 ： 前面的值，否则，输出后面的值
 
         int i = (1 == 2 ? 100 : 200);
         System.out.println(i);
 
         int y = (3 <= 4 ? 1000 : 2000);
         System.out.println(y);
     }
 }

九、运算符优先级

运算符优先级（转载）
Java运算符优先级

  • 括号级别最高，逗号级别最低，单目 > 算术 > 位移 > 关系 > 逻辑 > 三目 > 赋值

十、包机制

  • 包的本质就是文件夹
  • 一般利用公司域名倒置作为包名
  • 导入包用import关键字，而且导包操作必须在包之下
  • *是通配符，可以导入全部的包
package com.example.bag2021041301;
/*
@author 作者名
@version 版本号
@since 指明需要最早的JDK版本
@param 参数
@return 返回值情况
@throws 异常抛出情况
*/

//例如：11~17加在了类上面，是对于类的注释，21~25加在了方法上面，是对于方法的注释

/**
 * @author 一叶之秋
 * @version 2020.1.0
 * @since 1.8
 */
public class JavaBase12Doc {
    String name;

//    /**
//     *
//     * @param name
//     * @return
//     */
//    public String test(String name){
//        return name;
//    }

    /**
     * @author 一叶之秋
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
}

十一、Java Doc生成文档

JDK1.8帮助文档

  • 使用命令行生成自己的Java文档
    在这里插入图片描述
  • 使用idea生成JavaDoc文档
    在这里插入图片描述
面具人x
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java数据类型总结
def12356的博客
08-08 227
Java基本类，引用类和包装类 基本类型 存储空间 取值范围 对应包装类 boolean 1 bits true 或者 false Boolean byte 1字节 -128 ~ 127 Byte char 2字节 0 ~ 2^16-1 Character short 2字节 -2^15 ~ 2^15-1 Short int 4字节 -2^31 ~ 2^31-1 Integer long 8字节 -2^63 ~ 2^63-1 Long float 4字节 —— Flo
Java基础之 接口、抽象类、构造方法、setXxx,getXxx、静态变量和成员变量、代码块、this和super的区别、final关键字、重写与重载...
avu43057的博客
09-25 375
接口： 1). 什么是接口? 　　接口是对外暴露的规则. 2). 如何定义接口? 　　使用关键字 interface 接口名{} 3). 接口与类的关系? 　　实现关系, 可以单实现, 也可以多实现, 但是多个接口名之间, 需要用逗号进行分隔. 　　使用关键字: implements 　　　　class 实现类 implements...
Java中[xxx:xxx,aaa:aaa]格式字符串解析
qq_33321351的博客
09-03 7864
Java中[xxx:xxx,aaa:aaa]格式字符串解析 String str = "[name:张三,age:18,phone:15888887777,email:15888887777@qq.com]"; //转换成json数组 package net.sf.json JSONArray input = JSONArray.fromObject(str); input.stream().map(e -> { //将json数组转换成map并返回 Map<
JavaWeb
weixin_47520834的博客
08-25 2567
JavaWeb html 1.html基本规则 1.文件标签：构成html最基本的标签 * html:html文档的根标签 * head：头标签。用于指定html文档的一些属性。引入外部的资源 * title：标题标签。 * body：体标签 * <!DOCTYPE html>：html5中定义该文档是html文档 2.文本标签：和文本有关的标签 <!-- 元标签 对页面的设置信息 书写格式： 双标签 <xxx> </xxx>
Java Json 格式转化 —— 将 A.B.C 转成 {"A":[{"B":[{"C":"XXX"}]}]}
qq_32657967的博客
11-26 1287
public class ResultDemo { /** * 将 第一层.第二层.第三层 变成如下格式 * {&amp;quot;第一层&amp;quot;:[{&amp;quot;第二层&amp;quot;:[{&amp;quot;第三层&amp;quot;:&amp;quot;最后一层&amp;quot;}]}]} */ public static void main(String args[
Java基础语法.docx
05-13
Java基础语法的word版，md版本图片可能加载不出来，这个有全部的效果图，配合视频看效率更快——b站“狂神说Java”
Java基础语法)教案
04-05
Java基础语法)教案Java开发环境搭建，HelloWorld案例，注释、关键字、标识符以及Java中的数据，但是难度都相对较低，大家只需要下去多加练习，掌握肯定没问题。 关于前两大块内容，Java开发环境待见和HelloWorld案例...
java基础语法
12-19
java基本的数据类型，swing窗体的使用，java基本的循环语句
Java-Lambda
最新发布
lizhiwei21的博客
07-21 174
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 494
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1173
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1144
JVM-垃圾回收与内存分配
【Java算法】前缀和 下
2302_79806056的博客
07-18 1066
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 518
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 550
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 485
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
Java基础语法详解与实战
"Java基础知识综合，包括Java开发环境的搭建，基础语法的讲解，如变量、运算符、流程控制语句等，旨在为初学者打下坚实的编程基础。" Java是一种广泛使用的高级编程语言，其跨平台的特性使得它在各种操作系统上都能...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

面具人x

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值