2021-02-13

最新推荐文章于 2024-09-27 00:45:01 发布

码上心动

最新推荐文章于 2024-09-27 00:45:01 发布

阅读量482

点赞数 5

分类专栏： java基础语法文章标签： java

本文链接：https://blog.csdn.net/qq_42718098/article/details/113804075

版权

java基础语法专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文介绍了Java编程的基础知识，包括不同类型的注释，如单行、多行和文档注释的使用。接着讲解了标识符的规则，强调了关键字和变量命名的注意事项。此外，详细阐述了Java的数据类型，如基本类型的数值、浮点、字符和布尔型，以及引用类型的概念。还讨论了变量的作用域、类型转换以及变量的声明和使用。最后，文章提到了运算符的种类，如算术、关系和逻辑运算符，并通过示例代码进行了演示。

摘要由CSDN通过智能技术生成

一、注释

1.单行注释

//开头

        // 单行注释

注释一行

2.多行注释

/* 注释 */

/*
多行注释
多行注释
多行注释
多行注释
*/

注释多行

3.文档注释

/**开头 */结尾

/**
 * 文档注释
 * 
 */

/***
 *                    _ooOoo_
 *                   o8888888o
 *                   88" . "88
 *                   (| -_- |)
 *                    O\ = /O
 *                ____/`---'\____
 *              .   ' \\| |// `.
 *               / \\||| : |||// \
 *             / _||||| -:- |||||- \
 *               | | \\\ - /// | |
 *             | \_| ''\---/'' | |
 *              \ .-\__ `-` ___/-. /
 *           ___`. .' /--.--\ `. . __
 *        ."" '< `.___\_<|>_/___.' >'"".
 *       | | : `- \`.;`\ _ /`;.`/ - ` : | |
 *         \ \ `-. \_ __\ /__ _/ .-` / /
 * ======`-.____`-.___\_____/___.-`____.-'======
 *                    `=---='
 *
 * .............................................
 *          佛祖保佑             永无BUG
 */

百度：有趣的代码注释

4.JavaDoc

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

参数信息

@author 作者名

@version 版本号

@since 指明需要jak版本

@param 参数名

@return 返回值情况

@throws 异常抛出情况

public class Dome09 {
    /**
     * @author mzq
     * @version 1.0
     * @since 1.1
     */
    String name;

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

生成Javados文档
在这里插入图片描述

进入cmd

输入指令：javadoc -encoding UTF-8 -charset UTF-8 Dome09.java
-encoding UTF-8 -charset UTF-8 防止乱码

会生成一个index.html文件，点开即可

IDEA生成Javadoc

二、标识符

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

1. 关键字

2.标识符注意点

所有标识符都应该以字母（A-Z或者a-z），美元符($)、或者下划线（_）开始
首字符之后可以是字母(A-Z或者a-z)，美元符($)、下划线（_）或数字的任何字符组合
不能使用关键字作为变量名或方法名。
标识符是大小写敏感的
合法标识符举例：age,$salary,_value,__1_value
非法标识符举例：123abc,-salary,#abc

public class HelloWord {
    public static void main(String[] args) {
        String 123abc ="an";//错误写法
        System.out.println("123abc");
    }
}

可以使用中文命名，但是不建议这样去做，也不建议使用拼音，因为很low

三、数据类型

强类型语言

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

弱类型语言

变量不必符合规定

Java的数据类型分为两大类

1.基本类型（primitive type）

数值类型：
整数类型
byte占1个字节，范围：-128~127
short占2个字节，范围：-32768~32767
int占4个字节，范围：-2147483648~2147483647
long占8个字节，范围：-9223372036854775808~9223372036854775807
浮点类型
float占4个字节
double占8个字节
字符类型
char占2个字节

boolean类型：

占1位其值只有true和false两个

 public static void main(String[] args) {
        //整数
        int num1 =20;
        byte num2 =30;
        short num3 =50;
        long num4 =20L;//long类型在后面要加L
        //小数：浮点数
        float num5 = 5.1F;//float类型在后面要加F
        double num6 = 7.45;
        //字符
        char name = 'A';//单引号
        //字符串，String不是关键字，类
        //String namea = "张三"

        //布尔值
        boolean flag = true;
        boolean flag1 = false;
    }

2.引用类型（reference type）

除基本类型外的所有类型

数据类型拓展

重要

public class Dome02 {
    public static void main(String[] args) {
      //整数拓展： 进制 二进制0b 十进制 八进制0 十六进制0x
        int i = 10;
        int i1 = 010; //八进制
        int i2 = 0x10;//十六进制

       //===============================================
       //浮点数扩展 银行业务表示
       // BigDecimal 数学工具类
       // ===============================================
        //float 有限 离散 舍入误差 大约 接近但不等于
        //double
        //最好完全使用浮点数进行比较 少用浮点数进行比较 最好用BigDecimal
        float a = 0.1f; //0.1
        double b = 1.0/10; //0.1
        System.out.println(a==b);//false

        float a1=855598655f;
        float a2=a1+1;
        System.out.println(a1==a2);//true
        System.out.println("===============================================");

        //===============================================
        //字符拓展
        // ===============================================
        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表：（97 = a 65=A） 2字节 0-65532（2的16次方）
        //U0000 UFFF 区间范围
        char c3 = '\u0061';  //  斜杆u表示转换
        System.out.println(c3); //a

        //转义字符
        //\t 制表符
        //\n 换行 还有很多
        System.out.println("hello\tword");

        System.out.println("===============================================");
        //布尔值扩展
        boolean flag = true;
        if (flag==true){} //新手
        if (flag){} //老手
    }
    }

四、类型转换

Java是一种强类型语言，运算时需要一些类型转换

在这里插入图片描述

运算中，不同类型需要转换为同一类型

public class Dome03 {
    public static void main(String[] args) {
        int i =128;
        byte b= (byte) i;//强制转换 （类型）变量名  高---低
                         //自动转换  低---高
        System.out.println(i);//128
        System.out.println(b);//-128  原因：内存溢出

        int i1 =128;
        double b1=  i;
        System.out.println(i1);
        System.out.println(b1);

        /*
        * 1.不能对布尔值进行转换
        * 2.不能把对象类型转换为不相干类型
        * 3.把高容量转换到低容量的时候，强制转换
        * 4.转换的时候存在内存溢出，或存在精度问题
        * */
        System.out.println("==========");
        System.out.println((int)66.7); //66
        System.out.println((int)-66.87f);//-66

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

    }
}

注意问题：

public class Dome04 {
    public static void main(String[] args) {
       //操作比较大的数的时候，注意溢出问题
        //JDK新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int b =money*years;//-1474836480 计算时候溢出了
        System.out.println(b); //-1474836480
        long b1=money*years;//默认是int 转换之前已经存在问题
        System.out.println(b1); //-1474836480
        long b2 = money*((long)years);//先把一个数转化为long类型
        System.out.println(b2);//20000000000
    }
}

五、变量

变量：可以变化的量； java是一种强类型语言，每个变量必须声明其类型。

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

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

注意事项：

（1）每个变量都有类型，类型可以是基本类型，也可以是引用类型。

（2）变量名必须是合法的标识符。

（3）变量声明是一条完整的语句，因此每一个声明都必须以分号结束。
变量作用域：类变量，实例变量，局部变量

public class Dome05 {
    //定义属性：变量

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

    //实例变量：从属于对象，在Dome05这个类里面使用
    //如果不进行初始化，他会变成这个类型默认值
    //布尔值默认是false
    //除了基本类型，其他默认都是null
    String name;
    int age;

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

        //局部变量（在方法里,只在括号里有效）：必须声明初始化值
        int i = 10;
        System.out.println(i);

        //变量类型 变量名字= new Dome05()
        Dome05 dome05 = new Dome05();
        System.out.println(dome05.age);//0
        System.out.println(dome05.name);//null

        System.out.println(salary);//打印类变量
    }
    //其他方法
    public  void sdd() {

    }
}

变量命名规范

（1）所有变量、方法、类名：见名知意

（2）类成员变量：首字母小写和驼峰原则：monthSalary 除第一个单词以外，后面单词首字母大写

（3）局部变量：首字母小写和驼峰原则

（4）常量：大写字母和下划线 MAX_VALUE

（5）类名：首字母大写和驼峰原则 Man GoodMan

（6）方法名：首字母小写和驼峰原则 run(), runRun()

六、常量

常量（Constant）：初始化后不能再改变值！不会变动的值；

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

//final 常量名=值；
//final  double PI=3.14;  
public class Dome06 {
    //修饰符，不存在先后顺序
    static final double PI=3.14;

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

七、基本运算符

算数运算符：+，-，*，%（求余），++，–

赋值运算符：=

关系运算符：>,<,>=,<=,==(等于)，！=instanceof

public class Dome01 {
    public static void main(String[] args) {
        //二元运算符
        //ctrl+D 复制当前行到下一行
        int a=11;
        int b=18;
        int c=20;
        int d=41;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);

    }
}

public class Dome02 {
    public static void main(String[] args) {
        long a=8986874879L;
        int b = 12;
        short c= 11;
        byte d = 8;
    //有一个long类型，结果为long类型，其余为int类型
        System.out.println(a+b+c+d);
        System.out.println(b+c+d);
        System.out.println(c+d);

        System.out.println((double) c+d);//转换为double类型
    }
}

public class Dome03 {
    public static void main(String[] args) {
        //关系运算符返回的结果：正确或错误 布尔值
        int a = 10;
        int b = 15;
        int c = 23;
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);
        System.out.println(c%a);//取余 模运算
    }
}

++ 冥运算

public class Dome04 {
    public static void main(String[] args) {
        //++ -- 自增 自减 一元运算符
        int a = 7;
        int b = a++;//a++=a+1 执行这行代码后加1
        System.out.println(a);
        int c = ++a;//执行这行代码前先自增1
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

        //冥运算 2^3 2*2*2=8 很多运算，我们需要一些工具类来操作
        double pow = Math.pow(2,3);
        System.out.println(pow);
    }
}

逻辑运算符：&&，||，！

//逻辑运算
public class Dome05 {
    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++<6);//(c<4)为假，不会执行(c++<6)
        System.out.println(d);
        System.out.println(c);
    }
}

位运算

public class Dome06 {
    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 与B完全相反
         *
         * 2*8  2*2*2*2
         * 效率极高
         * << 左移 *2
         * >> 又移 /2
         * 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);
    }
}

扩展运算符

public class Dome07 {
    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);

        //字符串连接 +
        System.out.println(""+a+b);//字符串在前，后面是连接符
        System.out.println(a+b+"");//a+b在前，先进行计算
    }
}

三元运算符

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