Java语法基础

最新推荐文章于 2024-04-01 16:48:12 发布

置顶 binglengyiran

最新推荐文章于 2024-04-01 16:48:12 发布

阅读量288

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/binglengyiran/article/details/112424116

版权

Java语法基础

1. 注释

平时我们写代码，在代码量比较少的时候，还可以看懂自己写的是什么，但是当项目的结构一旦复杂起来，就需要用到注释了。注释是不会被执行的，是给写代码的人看的，书写注释也是一个非常好的习惯。
JAVA中的注释有三种：单行注释，多行注释和文档注释。单行注释是//，多行注释是/·······/，文档注释是/** * * */。

/***
 * ░░░░░░░░░░░░░░░░░░░░░░░░▄░░
 * ░░░░░░░░░▐█░░░░░░░░░░░▄▀▒▌░
 * ░░░░░░░░▐▀▒█░░░░░░░░▄▀▒▒▒▐
 * ░░░░░░░▐▄▀▒▒▀▀▀▀▄▄▄▀▒▒▒▒▒▐
 * ░░░░░▄▄▀▒░▒▒▒▒▒▒▒▒▒█▒▒▄█▒▐
 * ░░░▄▀▒▒▒░░░▒▒▒░░░▒▒▒▀██▀▒▌
 * ░░▐▒▒▒▄▄▒▒▒▒░░░▒▒▒▒▒▒▒▀▄▒▒
 * ░░▌░░▌█▀▒▒▒▒▒▄▀█▄▒▒▒▒▒▒▒█▒▐
 * ░▐░░░▒▒▒▒▒▒▒▒▌██▀▒▒░░░▒▒▒▀▄
 * ░▌░▒▄██▄▒▒▒▒▒▒▒▒▒░░░░░░▒▒▒▒
 * ▀▒▀▐▄█▄█▌▄░▀▒▒░░░░░░░░░░▒▒▒
 * 单身狗就这样默默地看着你，一句话也不说。
 */

2. 标识符和关键字

Java所有的组成部分都需要名字，类名、变量名以及方法名都被称为标识符。这些都不能再被用作变量名了
Java的标识符

标识符的注意点

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

3. 数据类型

强类型语言：要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用。
弱类型语言：与上相反。
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 = 30L;  //Long类型要在数字后面加个L

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

        //字符
        char name = 'A';
        //字符串，String不是关键字，类
        String name1 = "黄季兵";

        //布尔值，是非
        boolean flag1 = true;
        boolean flag2 = false;

    }
}

什么是字节

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

1bit表示1位
1Byte表示一个字节1B=8b
1024B=1KB
1024KB=1M
1024M=1G
1024G=1T

4. 数据类型拓展及面试

public class Demo03 {
    public static void main(String[] args) {
        //整数拓展： 进制  二进制0b  十进制   八进制0    十六进制0x
        int i1 = 10;
        int i2 = 010; //八进制0
        int i3 = 0x20;  //十六进制0x
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("==============================================");
        //=============================================================================================
        //浮点数拓展   银行业务怎么表示？钱
        //BigDecimal 数学工具类
        //=============================================================================================
        //float    有限    离散   舍入误差    大约     接近但不等于
        //double
        //最好避免使用浮点数据进行比较

        float f = 0.1f;
        double d = 1.0/10;
        System.out.println(f==d);  //false
        System.out.println(f);
        System.out.println(d);

        float d1 = 23131312312122121f;
        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-65535    Excel
        char c3 = '\u0061';
        System.out.println(c3);  //a

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

        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);

        //对象  从内存分析  ==在对比变量是对比值，对比引用类型是对比地址值，new必定是创建一个新的地址，所以第一个不相同
        //string是存在常量池中的，两个标识符指向的同一个地址，所以第二个相同。

        //布尔值拓展
        boolean flag = true;
        if(flag==true){   // if(flag)
        }

    }
}

5. 类型转换

由于Java是强类型的语言，所以在进行有些运算的时候要用到类型的转换。
低------------------------------------------------------------------------------>高
byte，short，char------>int------->long--------->float--------->double
运算中，不同类型的数据先转换成同一类型，然后进行运算。

强制类型转换高到低
自动转换低到高

public class Demo05 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i;  //内存溢出
        double c = i;
        //强制转换    （类型）变量名   高到低
        //自动转换     低到高
        System.out.println(i);
        System.out.println(b);
        System.out.println(c);
        /*
        注意点：
        1.不能对布尔值进行转换
        2.不能把对象类型转换成不相干的类型
        3.在把高容量转换到低容量的时候，强制转换
        4.转换的时候可能存在内存溢出，或者精度问题！
         */
        System.out.println("===================================");
        System.out.println((int)23.7);  //23
        System.out.println((int)-45.89f);  //-45

        System.out.println("===================================");
        char d  =  'a';
        int e = d + 1;
        System.out.println(e);
        System.out.println((char)e);
    }
}

public class Demo06 {
    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        System.out.println(money);
        int years = 20;
        int total = money*years;  //-1474836480，计算的时候溢出了
        long total2 = money*years;  //默认是int，转换之前已经存在问题
        System.out.println(total);
        System.out.println(total2);
        long total3 = money*((long)years);
        System.out.println(total3);

        //一般long类型的后面用L，而不用l
    }
}

6. 变量、常量、作用域

变量

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

注意事项

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

变量作用域包括三部分：类变量，实例变量和局部变量。

public class Demo08 {
    //类变量 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 Demo08();
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.age);
        System.out.println(demo08.name);

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

    }

    //其他方法
    public void add(){

    }
}

常量

常量指的是初始化后不能再改变的值，不会变动。常量可以理解为一种特殊的变量，它的值被设定之后，在程序的运行过程中不允许被改变。
final 常量名=值，如，final double PI=3.14；
常量名一般使用大写的字符。

变量的命名规范

所有的变量、方法、类名都要见名知意
类成员变量（也就是除了常量）：首字母小写和驼峰原则：monthSalary（除了第一个单词外，后面的单词首字母大写lastName）
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man，GoodMan
方法名：首字母小写和驼峰原则：run()，runRun()

package base;
public class Demo09 {
    //修饰符，不存在先后顺序
    static final double PI = 3.14;
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

7.基本运算符

JAVA语言支持的运算符

算术运算符：+，-，*，/，%（取余，JAVA中叫做模运算），++，–
赋值运算符：=
关系运算符：>，<，>=，<=，==（JAVA中的等于），!=instanceof
逻辑运算符：&&（与），||（或），!（非）
位运算符：&，|，^，~，>>，<<，>>>（了解即可！）
条件运算符：?，:
扩展赋值运算符：+=，-=，*=，/=
注意优先级，最高的是（）

如何建包

右击当前的包，选择new，package即可。

package operator;
public class Demo01 {
    public static void main(String[] args) {
        //二元运算符
        //Ctrl +D:复制当前行到下一行
        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);
    }
}

package operator;
public class Demo02 {
    public static void main(String[] args) {
        long a = 123123123123123L;
        int b = 123;
        short c = 10;
        byte d = 8;
        System.out.println(a+b+c+d);  //Long
        System.out.println(b+c+d);  //Int
        System.out.println(c+d);  //Int
    }
}

package operator;

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符返回的结果：正确，错误  布尔值
        //if
        int a = 10;
        int b = 20;
        int c = 22;
        //模运算
        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);
    }
}

8.自增自减运算符，并初识Math

package operator;
public class Demo04 {
    public static void main(String[] args) {
        //++   --  自增，自减   一元运算符
        int a = 3;
        int b = a++; //a++,a=a+1，++在后面，先赋值再自增；++在前面，先自增再赋值
        System.out.println(a);
        int c = ++a;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        //幂运算 2^3，很多的运算会使用工具类来进行操作
        double pow = Math.pow(2,3);
        System.out.println(pow);
    }
}

9.逻辑运算符与位运算符

package operator;
//逻辑运算符
public class Demo05 {
    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);
    }
}

package operator;
public class Demo06 {
    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
        0000 0000      0
        0000 0001      1
        0000 0010      2
        0000 0011      3
        0000 0100      4
        0000 0101      5
        0000 0110      6
        0000 0111      7
        0000 1000      8
        0001 1000      16
         */
        System.out.println(2<<3);
    }
}

package operator;
public class Demo07 {
    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+"");
    }
}

10.三元运算符和小结

package operator;
//三元运算符
public class Demo08 {
    public static void main(String[] args) {
        // x ? y : z
        //如果x==true,则结果是y,否则结果是z
        int score = 50;
        String type = score < 60 ?"不及格":"及格";//必须掌握
        System.out.println(type);
    }
}

11.包机制

包机制

包的本质就是文件夹

可以搜索阿里巴巴开发手册作为规范参照

12.JavaDoc生成文档

javadoc命令是用来生成自己API文档的，百度搜索JDK帮助文档，这是在线的API帮助文档的链接。
参数信息：

@author 作者名
@version 版本号
@since 指明需要最早使用的JDK版本
@param参数名
@return返回值情况
@throws异常抛出情况

package com.hjb.base;
/**
 * @author hjb
 * @version 1.0
 * @since 1.8
 */
public class Doc {
        String name;
    /**
     *
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
            return name;
        }
}

1.用这个去命令行窗口生成Doc文档，E:\JAVA\code\JavaSE\基础语法\src\com\hjb\base>javadoc -encoding UTF-8 -charset UTF-8 Doc.java
2.用IDEA生成JavaDoc文档：
打开 IDEA，点击 Tools-> Generate JavaDoc，这样会打开生成 javadoc 文档的配置页面。
在这里插入图片描述

binglengyiran

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
4
评论
Java语法基础

Java语法基础1. 注释平时我们写代码，在代码量比较少的时候，还可以看懂自己写的是什么，但是当项目的结构一旦复杂起来，就需要用到注释了。注释是不会被执行的，是给写代码的人看的，书写注释也是一个非常好的习惯。JAVA中的注释有三种：单行注释，多行注释和文档注释。单行注释是//，多行注释是/·······/，文档注释是/** * * */。/*** * ░░░░░░░░░░░░░░░░░░░░░░░░▄░░ * ░░░░░░░░░▐█░░░░░░░░░░░▄▀▒▌░ * ░░░░░░░░▐
复制链接

扫一扫