Java基础语法学习笔记（2021.05.15~16）

Java基础语法

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

1. 注释

为了在项目结构复杂时，看不懂自己的代码，需要一些注释

1. 单行注释
2. 多行注释
3. 文档注释

ps：注释是个好的习惯！

具体语法：

//单行注释：注释单行
	//输出一行helloworld!!!

//多行注释：注释多段文字
	/*
            123132
            13213213
            32321
         */

//文档注释
	/**
         * @Description Helloworld
         * @Author xiaowei99
         *
         */

2. 标识符

Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。标识符不能为关键字，以下是所有关键字：

public class HelloWorld {
    public static void main(String[] args) {
        //单行注释：注释单行
        //输出一行helloworld!!!
        System.out.println("helloworld!!!");

        //多行注释：注释多段文字
        /*
            123132
            13213213
            32321
         */

        //文档注释
        /**
         * @Description Helloworld
         * @Author xiaowei99
         *
         */
    }
}

以上粉紫色高亮的部分都是标识符！

标识符关键点：

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

demo：

public class Demo01 {
    public static void main(String[] args) {
        String Ahello="hello";
        String $hello="hello";
        String _hello="hello";
        String _hel_1$lo="hello";
//        String @hello="hello";
//        String !hello="hello";
//        String 1hello="hello";
//        String ^hello="hello";
//        String &hello="hello";
//        String *hello="hello";
//        String +hello="hello";
//        String hello(!*$&#@%)(="hello";
    }
}

注释起来的都不行

3. 关键字

Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。标识符不能为关键字，以下是所有关键字：

二、数据类型

1. 强类型语言

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

2. 弱类型语言

要求变量的使用要符合规定即可，所有变量都必须先定义后才能使用，例如VB、JS

3. Java数据类型

基本类型
引用类型

基本数据类型报错：

报错二：
1. Demo代码：

public class DemoDataType {
    public static void main(String[] args) {
        String a = "hello";
        int b = 10;
        //String c = 10;
        //int d = "heloo";

        //整数类型
        byte num0 = 127;//范围在127~-127
        short num1 = 32767;//范围在32767~-32767
        int num2 = 2147483647;//范围在2147483647~-2147483647
        long num3 = 0x8000000000000000L;//范围在0x7fffffffffffffff~0x8000000000000000，注意：在最后需要加L来表示范围是long类型

        //浮点类型：也就是小数类型
        float num4 = 1.1F;//范围:1.4E-45~3.4028235E38,注意：在最后需要加F来表示范围是float类型
        double num5 = 3.1415926535D;//范围:4.9E-324~1.7976931348623157E308,注意：在最后需要加D来表示范围是double类型

        //字符型
        char char1 = 'a';//注意只能是一个字符，形如'A','韦',如果多于一个字符，形如'小韦','ab'则是不准使用的
        //String类型
        String str1 = "abcde小韦";//不是基本类型，是Java给我们定义好的一个类，属于引用类型

        //布尔类型
        boolean flag = true;
        boolean flag2 = false;//只能是true 或者 false 两种类型之一，判断是非用的。

    }
}

什么是字节？

位(bit):是计算机内部数据储存的最小单位，11001100是一个八位二进制数。

字节(byte):是计算机中数据处理的基本单位，习惯上用大写B来表示,1B (byte,字节) = 8bit(位)
字符:是指计算机中使用的字母、数字、字和符号

4.拓展Demo

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

        //拓展==============================================================================================
        System.out.println("==========================整数拓展==================================");
        /*
        整数类型拓展：
        进制；
        2进制：0b开头；
        8进制：0开头；
        10进制：正常；
        16进制：0x开头；
         */

        int i2 = 0b10;
        int i8 = 010;
        int i10 = 10;
        int i16 = 0x10;

        System.out.println(i2);
        System.out.println(i8);
        System.out.println(i10);
        System.out.println(i16);


        /*
        浮点类型扩展：
        特点：有限、离散、误差、大约、接近却不等于；
        基于特点，最好不使用浮点数用于比较；
        基于特点，类似银行的大型数字计算系统应该避免使用浮点数；
        BigDecimal 这个系统提供的工具类可以替代浮点类型；
         */
        System.out.println("==============================浮点数拓展=============================");
        float f1 = 0.1f;
        double d1 = 0.1d;
        double d2 = 1.0/10;
        System.out.println("f1==d1");
        System.out.println(f1==d1);//false
        System.out.println("f1==d2");
        System.out.println(f1==d2);//false
        System.out.println("d1==d2");
        System.out.println(d1==d2);//true

        float n1 = 99999999999999999f;
        float n2 = n1+1;
        System.out.println("n1==n2");
        System.out.println(n1==n2);//true


        /*
        字符拓展：
        字符本质：字符本质是数字编码，在输出中可以用转义字符或者数字或者编码表示一个字符，例如：\u0061,也可以把字符转换成int查看本身编码。
        转义字符使用
        字符串底层不同
         */
        System.out.println("================================字符拓展=============================");
        char c1 = 'a';
        char c2 = '韦';
        System.out.println("c1转int");
        System.out.println((int)c1);
        System.out.println("c2转int");
        System.out.println((int)c2);

        System.out.println("unicode编码表示a");
        System.out.println('\u0061');
        System.out.println("ascii编码表示a");
        System.out.println((char)97);

        System.out.println("转义字符使用");
        System.out.println("xiaowei\t99");// \n、\t、...

        String str3 = "hello";
        String str4 = "hello";
        String str5 = new String("hello");
        String str6 = new String("hello");
        System.out.println("str3==str4");
        System.out.println(str3==str4);
        System.out.println("str5==str6");
        System.out.println(str5==str6);

        /*
        布尔值拓展：
        if中布尔值的使用
         */
        System.out.println("================================布尔值拓展=============================");
        boolean flag4 = true;
        if(flag==true){
            System.out.println(flag);
        }
        if (flag){
            System.out.println(flag);
        }
    }
}

三、类型转换

1. 强制类型转换

(类型)变量名高到低需要强制转换。

2. 自动类型转换

低到高没有语法，直接赋值即可。

3. Demo

public class DemoTypeConvert {
    public static void main(String[] args) {
        //强制转换
        System.out.println("=============强制转换==============");
        int n1 = 128;
        byte n2 = (byte)n1;
        System.out.println("128转byte");
        System.out.println(n2);//内存会溢出，结果为-128

        char c1 = 'a';
        int n3 = 98;
        System.out.println("字符转int");
        System.out.println((int)c1);//97
        System.out.println("int转字符");
        System.out.println((char)n3);//b
        System.out.println("字符自动转int再强转字符");
        System.out.println((char)(c1+2));//c

        //自动转换
        System.out.println("=============自动转换==============");
        int n5 = 60;
        long n6 = n5;
        double n7 = n5;
        System.out.println("n5的值");
        System.out.println(n5);
        System.out.println("n5转n6");
        System.out.println(n6);
        System.out.println("n5转n7");
        System.out.println(n7);

        //不能对布尔值转换
        System.out.println("=============布尔值转换==============");
        boolean flag = true;
        int a = 10;
        //int b = (int)flag;语法错误
        //boolean flag1 = (boolean) a;语法错误

        //内存溢出以及精度问题
        System.out.println("=========内存溢出以及精度问题===========");
        int n8 = 10_0000_0000;
        int n9 = 20;
        System.out.println("n8和n9直接相乘结果");
        System.out.println(n8*n9);//内存溢出

        long n10 = n9*n8;
        System.out.println("n8和n9直接相乘赋值到long类型结果");
        System.out.println(n10);//内存溢出

        long n11 = n9*(long)n8;
        System.out.println("n8和n9转换其中之一类型相乘赋值到long类型结果");
        System.out.println(n11);

        double n12 = 23.4;
        int n13 = (int)n12;
        System.out.println("double的n12转换到int的n13结果");
        System.out.println(n13);//精度丢失
    }
}

4. 注意点

1. 不能对布尔值进行转换。
2. 不能把对象类型转换成不相干的类型。
3. 把高容量转换低容量时需要强制转换。
4. 转换时可能存在内存溢出、精度问题。
5. 两个低容量运算赋值到高容量时应该先转换成高容量，不然结果就先变成低容量导致内存溢出问题，导致结果不对。

四、变量、常量、作用域

1. 变量

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

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

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

定义变量语法如下

//数据类型 变量名 = 值;形如 int(变量类型) = 1(值);这里的值某些情况可以没有,以下几个例子里的a、b、c、d就是变量：
int a = 0;
int b;
String c = "hello";
String d;

注意：

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

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

变量声明是一条完整的语句，因此每一个声明都必须以分号结束。

2. 常量

初始化后不会改变的值。

//final 数据类型 常量名 = 常量值，形如：final int a = 10;
final double d = 3.14;

3. 作用域

类变量：前面要有static修饰符，从属于类，随着类诞生而诞生，消亡而消亡(PS:不是从属于对象)。
实例变量：从属于类，未赋值的话会被系统自动赋予初始值。
局部变量：在方法内的变量，只能在方法内使用

demo代码：

public class DemoVariable {
    //类变量：前面要有static修饰符，从属于类，随着类诞生而诞生，消亡而消亡(PS:不是从属于对象)
    static int a = 10;

    //常量 修饰符final、static的顺序不影响
    final static double PI = 3.14;

    //实例变量：从属于类，未赋值的话会被系统自动赋予初始值
    String str;
    int n;
    boolean b;

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

        //局部变量：在方法内的变量，只能在方法内使用
        int c = 11;
        System.out.println("局部变量：在方法内的变，只能在方法内使用");
        System.out.println(c);

        //查看实例变量的初始值
        System.out.println("查看实例变量的初始值");
        DemoVariable demoVariable = new DemoVariable();
        System.out.println(demoVariable.str);
        System.out.println(demoVariable.n);
        System.out.println(demoVariable.b);

        //查看常量使用
        System.out.println("查看常量使用");
        System.out.println(PI);

        //查看看类变量使用
        System.out.println("查看类变量使用");
        System.out.println(a);
    }


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

        //局部变量

    }
}

4. 变量命名规范

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

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

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

常量：大写字母和下划线:MAX_VALUE

类名:首字母大写和驼峰原则：Man, GoodMan方法名:首字母小写和驼峰原则: run(), runRun()

五、运算符

1. 算数及赋值运算符demo

package com.xiaowei9s.operation;

public class ArithmeticOperation {
    public static void main(String[] args) {
        int a = 25;
        int b = 10;
        // +
        System.out.println("a+b = "+(a+b));
        // -
        System.out.println("a-b = "+(a-b));
        // *
        System.out.println("a+b = "+(a*b));
        // /
        System.out.println("a/b = "+(a/(double)b));//注意类型转换成小数，不然就会得到整数
        // %
        System.out.println("a%b = "+(a%b));

        /*
        注意++，--运算符
        在做例如a++,a--,++b,--b的代码时，不管代码在何处，值都会变化，
        而++、--号在变量位置的前或后决定了变量在代码执行前自增自减还是在代码执行后自增自减
        例如：
        int a = 10;
        int c = a++;
        执行后c的值是10，a的值却是11，原因是在c定义的语句结束后，a才自增。不理解的话就多去试试吧！
         */
        // ++
        System.out.println("++a : "+(++a));
        // --
        System.out.println("--a : "+(--a));
        // =赋值 ，比较是否相等用的是==
        int c = 10;
    }
}

2. 关系运算符demo

package com.xiaowei9s.operation;

public class RelationOperation {
    public static void main(String[] args) {
        // > 判断是否大于
        System.out.println("10>11:");//false
        System.out.println(10>11);//false
        // < 判断是否小于
        System.out.println("10<11:");//true
        System.out.println(10<11);//true
        // >= 判断是否大于等于
        System.out.println("10>=1:");//true
        System.out.println(10>=1);//true
        System.out.println("10>=10:");//true
        System.out.println(10>=10);//true
        // <= 判断是否小于等于
        System.out.println("10<=1:");//false
        System.out.println(10<=1);//false
        System.out.println("10<=10:");//true
        System.out.println(10<=10);//true
        // == 判断是否相等
        System.out.println("10==10:");//true
        System.out.println(10==10);//true
        System.out.println("10==11:");//false
        System.out.println(10==11);//false
        // != 判断是否不等
        System.out.println("10!=10:");//false
        System.out.println(10!=10);//false
        System.out.println("10!=11:");//true
        System.out.println(10!=11);//true
    }
}

3. 逻辑运算符demo

package com.xiaowei9s.operation;

public class LogicOperation {
    public static void main(String[] args) {
        // || 或运算
        System.out.println("true||false");
        System.out.println(true||false);
        System.out.println("true||true");
        System.out.println(true||true);
        System.out.println("false||false");
        System.out.println(false||false);
        System.out.println("false||true");
        System.out.println(false||true);
 
        // && 与运算
        System.out.println("true&&false");
        System.out.println(true&&false);
        System.out.println("true&&true");
        System.out.println(true&&true);
        System.out.println("false&&false");
        System.out.println(false&&false);
        System.out.println("false&&true");
        System.out.println(false&&true);

        // ! 非运算

        System.out.println("!false");
        System.out.println(!false);
        System.out.println("!true");
        System.out.println(!true);

    }
}

4. 位运算符demo

package com.xiaowei9s.operation;

public class BitOperation {
    public static void main(String[] args) {
        //Integer.toBinaryString是作为二进制输出

        // & 每个二进制的位做与运算
        System.out.println(Integer.toBinaryString(0b1010&0b1100));
        // | 每个二进制的位做或运算
        System.out.println(Integer.toBinaryString(0b1010|0b1100));
        // ^ 每个二进制的位做异或运算（相同的位置一样就为0，相同的位置不一样就为1）
        System.out.println(Integer.toBinaryString(0b1010^0b1100));
        // ~ 每个二进制的位做取反
        System.out.println(Integer.toBinaryString(~0b1100));
        // >> 每个二进制的位右移一位
        System.out.println(Integer.toBinaryString(0b1100<<2));
        // << 每个二进制的位左移一位
        System.out.println(Integer.toBinaryString(0b1100>>2));
        // >>> 每个二进制的位算术右移一位
        System.out.println(Integer.toBinaryString(0b1100>>>1));
    }
}

5. 条件运算符demo

package com.xiaowei9s.operation;

public class ThreeVariableOperation {
    public static void main(String[] args) {
        // x ? y : z 意思是x真则为y，否则为z
        int a = 1==2?3:4;
        System.out.println("a为："+a);
    }
}

6. 拓展赋值运算符demo

package com.xiaowei9s.operation;

public class MoreOperation {
    public static void main(String[] args) {
        int a = 10;
        // += ,a+=b相当于a = a + b
        System.out.println(a+=3);

        // -= ,a-=b相当于a = a - b
        System.out.println(a-=3);

        // *= ,a*=b相当于a = a * b
        System.out.println(a*=3);

        // /= ,a/=b相当于a = a / b
        System.out.println(a/=(double)3);
    }
}

六、包机制、JavaDoc

1.包机制

为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。包语句的语法格式为: package 包路径，（功能是分类，本质是文件夹）形如：package com.xiaowei9s.operation;

包的命名机制：公司域名的倒置作为结构

导入包的方法：import 包路径，形如：import com.xiaowei9s.operation;

2. JavaDoc

在cmd中进入class文件所在目录，使用指令 javadoc -encoding UTF-8 -charset UTF-8 [xxx.class]。

在目录下生成文件后点击index即可进入JavaDoc文档，里面有自动根据注释和代码生成的API文档。

IDEA生成JavaDoc的方法，提供链接： https://www.jianshu.com/p/0ddb0864e499。

知识来源： https://www.kuangstudy.com

posted @ 2021-05-16 21:06 小阴辨阅读(98) 评论(0) 收藏举报

刷新页面返回顶部

小阴辨

Java基础语法 学习笔记（2021.05.15~16）