java基础（B站up主遇见狂神说学习笔记）

最新推荐文章于 2022-07-14 15:13:14 发布

浩浩小哥哥

最新推荐文章于 2022-07-14 15:13:14 发布

阅读量1k

点赞数 2

分类专栏： java基础后端文章标签： java

本文链接：https://blog.csdn.net/zero881/article/details/115279720

版权

java基础同时被 2 个专栏收录

17 篇文章

订阅专栏

后端

12 篇文章

订阅专栏

本文介绍了Java编程的基础知识，包括注释的使用、数据类型（如基本类型和引用类型）、变量声明、类型转换、运算符（算术、关系、逻辑等）以及变量的作用域。特别强调了Java是强类型语言，要求在使用变量前必须先定义，并展示了如何处理数据溢出和精度问题。此外，还提到了JavaDoc的使用，用于生成API文档。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

注释、标识符、关键字（BAT）

书写注释是一个非常好的习惯，平时写代码一定要注意规范

单行注释 //
- 可以注释一行文字
多行注释 /**/
- 可以注释一段文字
文档注释（JavaDoc）/** */
- 大公司经常用

标识符

关键字

在这里插入图片描述

Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
所有的标识符都应该以字母，美元符（$）、或者下划线开始
首字母之后可以是字母，美元符，下划线或数字的任何字符组合
不能使用关键字作为变量名或方法名
标识符是大小写敏感的
合法标识符举例：age、$salary，_value、__1_value
非法标识符距离：123abc、-salary、#abc

数据类型（java是一种强类型语言）

强类型语言
- 要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
- 好处：安全性高
- 坏处：速度下降
弱类型语言
- 要求变量的使用不用符合规定
Java的数据类型分为两大类
- 基本类型（primitive type）
  - 整数类型
    - byte -128到127
    - short -32768到32767
    - int -2147483648到2147483647
    - long -9223372036854775808到9223372036854775807
  - 浮点类型
    - float 4个字节
    - double 8个字节
  - 字符类型
    - char 2个字节
  - boolean类型只占一个位（true 或者false）
- 引用类型（reference type）
  - 引用数据类型
    - 类
    - 接口
    - 数组

什么是字节

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

数据类型以及扩展面试题

/**
 * @program: JavaSE
 * @description:
 * @author: HuMingHao
 * @create: 2021-03-24 16:33
 **/
public class Demo03 {
    public static void main(String[] args) {
        // 整数拓展：  进制    二进制0b   十进制   八进制0  十六进制 0X
        int i = 10;
        int i2 = 010;// 八进制0
        int i3 = 0x10;// 十六进制0x 0~9 A~F 15

        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("==============================================");
        //==================================================
        // 浮点数扩展？ 银行业务怎么表示？ 钱
        // BigDecimal 数学工具类
        // float 有限的 离散的  舍入误差 大约 接近但不等于
        // double
        // 最好避免使用浮点数进行比较
        float f = 0.1f;// 0.1
        double d = 1.0/10;// 0.1

        System.out.println(f==d); // false

        float d1 = 23131312312312313f;
        float d2 = d1 + 1;

        System.out.println(d1==d2);// true

        //==================================================
        // 字符拓展？
        //==================================================
        char c1 = 'A'; // 97
        char c2 = '中';// 20013

        System.out.println(c1);
        System.out.println((int)c1);// 强制转换

        System.out.println(c2);
        System.out.println((int)c2);

        // 所有的字符本质还是数字
        // 编码 Unicode 表 97 = a   2字节   65536 字符
        // excel 2 16 == 65536
        // U0000 UFFFF

        char c3 = '\u0061';

        System.out.println(c3);// a

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

        //false
        String sa = new String("hello world");
        String sb = new String("hello world");
        System.out.println(sa==sb);
        // true
        String sc = "hello world";
        String sd = "hello world";
        System.out.println(sc==sd);

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

        }
        if(flag){

        }

    }
}

类型转换

由于Java是强类型语言，所以要进行有些运算的时候的，需要用到类型转换。

运算中，不同类型的数据先转化为同一类型，然后经行运算
强制类型转换
自动类型转换

/**
 * @program: JavaSE
 * @description:
 * @author: HuMingHao
 * @create: 2021-03-25 11:06
 **/
public class Demo05 {
    public static void main(String[] args) {
        int i = 128;
        double b = i;// 内存溢出，强制类型转换

        // 强制转换  （类型）变量名    高--低
        // 自动转换   低--高

        System.out.println(i);
        System.out.println(b);

        /*
        注意点：
        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 c = 'a';
        int d = c + 1;
        System.out.println(d);
        System.out.println((char)d);
    }
}

/**
 * @program: JavaSE
 * @description:
 * @author: HuMingHao
 * @create: 2021-03-25 13:33
 **/
public class Demo06 {
    public static void main(String[] args) {
        // 操作比较大的数的时候，注意溢出问题
        // JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money*years; // -1474836480,计算的时候溢出了
        long total2 = money*years; // 默认是int，转换之前已经存在问题了？

        long total3 = money*((long)years);// 先把一个数转换为long
        System.out.println(total3);



    }
}

注意：当byte，short，char 发生运算时，会自动转换成 int 类型

变量

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

// 数据类型变量名 = 值；

注意事项：

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

变量作用域

类变量：从属于类的，一起出现，一起消失，加了static，能直接输出
实例变量从属于对象的，
局部变量

常量

常量（Constant）：初始化（initialize）后不能再改变值！不会变动值。
所谓常量可以理解成一种特殊的变量，他的值被设定后，在程序运行过程中不允许被改变。，

final 常量名 = 值;
final double PI = 3.14;
常量名一般使用大写字符。

/**
 * @program: JavaSE
 * @description:
 * @author: HuMingHao
 * @create: 2021-03-25 14:58
 **/
public class Demo07 {
    public static void main(String[] args) {
        // int a,b,c;
        // 程序可读性
        int a = 1;
        int b = 2;
        int c = 3;
        String name = "haohao";
        char x = 'X';
        double pi = 3.14;

    }
}

/**
 * @program: JavaSE
 * @description:
 * @author: HuMingHao
 * @create: 2021-03-25 15:16
 **/
public class Demo08 {
    // 属性：变量

    // 类变量 static 从属于类，一起出现，一起小时
    static double salary = 2500;

    // 实例变量: 从属于对象；如果不自行初始化，这个类型的默认类型 0  0.0
    // 布尔值：默认是false
    //除了基本类型，其余的默认值都是null
    String name="浩浩";
    int age=0;



    // 作用域非常高
    static{

    }

    // main方法
    public static void main(String[] args) {
        // 局部变量：必须声明和初始化值
        int i = 10;

        System.out.println(i);

        // 变量类型 变量名字 = new Demo08();
        Demo08 demo08 = new Demo08();

        System.out.println(demo08.name);
        System.out.println(demo08.name);

        System.out.println(salary);



    }

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

    }
}

/**
 * @program: JavaSE
 * @description:
 * @author: HuMingHao
 * @create: 2021-03-25 17:29
 **/
public class Demo09 {
    // static 修饰符，不存在先后顺序
    static final double PI = 3.14;
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

所有变量、方法、类名：见名知意
类成员变量：首字母小写和驼峰原则：monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则，MAN，GoodMan
方法名：首字母小写和驼峰命名：run(),runRun()

运算符

算术运算符：

操作符	描述	例子
+	加法 - 相加运算符两侧的值	A + B 等于 30
-	减法 - 左操作数减去右操作数	A – B 等于 -10
*	乘法 - 相乘操作符两侧的值	A * B等于200
/	除法 - 左操作数除以右操作数	B / A等于2
％	取余 - 左操作数除以右操作数的余数	B%A等于0
++	自增: 操作数的值增加1	B++ 或 ++B 等于 21（区别详见下文）
–	自减: 操作数的值减少1	B-- 或 --B 等于 19（区别详见下文）

赋值运算符：

=
关系运算符：> , < , >= ,<=,==,!=,instanceof
逻辑运算符：&&，||，！
位运算符：&，| , ^ , ~ , >> , << ,>>>(了解！！！！)
条件运算符：？：

扩展赋值运算符：+=，-=，*=，/=

package operator;

/**
 * @program: JavaSE
 * @description:
 * @author: HuMingHao
 * @create: 2021-03-26 14:04
 **/
public class Demo01 {
    public static void main(String[] args) {
        // 二元运算符
        // ctrl+D ： 复制当前行到下一行
        int a = 10;
        int b = 20;
        int c = 30;
        int d = 10;

        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);
    }
}

package operator;

/**
 * @program: JavaSE
 * @description:
 * @author: HuMingHao
 * @create: 2021-03-26 15:26
 **/
public class Demo02 {
    public static void main(String[] args) {
        long a = 123123123123123L;
        int b = 123;
        short c =10;
        byte d = 8;

        // 如果多个操作数有一个为long类型
        System.out.println(a+b+c+d);
        // 其他都为int
        System.out.println(b+c+d);

        System.out.println(c+d);
    }
}

package operator;

/**
 * @program: JavaSE
 * @description:
 * @author: HuMingHao
 * @create: 2021-03-26 15:34
 **/
public class Demo03 {
    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);
        System.out.println(a!=b);

    }
}

自增运算符和初识Math类

package operator;

/**
 * @program: JavaSE
 * @description:
 * @author: HuMingHao
 * @create: 2021-03-26 15:51
 **/
public class Demo04 {
    public static void main(String[] args) {
        // ++ -- 自增 ，自减 二元运算符
        int a = 3;// a = a + 1;
        int b = a++;// 执行完这行代码后，先给b赋值，再自增
        System.out.println(a);// 4
        int c = ++a;// 执行完这行代码前，先自增，再给c赋值

        System.out.println(a);// 5
        System.out.println(b);// 3
        System.out.println(c);// 5

        // 幂运算 2^3 2*2*2 = 8 很多运算，我们会使用一些工具类来操作！
        double pow = Math.pow(2,3);
        System.out.println(pow);


    }
}

逻辑运算符和位运算符

package operator;

/**
 * @program: JavaSE
 * @description:
 * @author: HuMingHao
 * @create: 2021-03-26 16:25
 **/
public class Demo06 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101

        A&B = 0000 1100 // 1 1 为 1
        A/B = 0011 1101  // 有一个为1 则为11
        ~B = 1111 0010
        A^B = 0011 0001 // 异或 一样则为0，不一样则为1

        2*8 怎么运算最快 2*2*2*2
        位运算效率高
        <<  左移 *2
        >>  右移 /2
        0000 0000 0
        0000 0010 2
        0001 0000 16
         */
        System.out.println(2<<3);// 16
    }
}

三元运算符

package operator;

/**
 * @program: JavaSE
 * @description:
 * @author: HuMingHao
 * @create: 2021-03-26 17:19
 **/
public class Demo08 {
    public static void main(String[] args) {
        // x ? y : z
        // 如果x==true，则结果为y，否则结果为z
        int score = 80;
        String type = score < 60 ?  "不及格": "及格";// 必须掌握
        // if
        System.out.println(type);
    }
}

扩充字符串连接 +

package operator;

/**
 * @program: JavaSE
 * @description:
 * @author: HuMingHao
 * @create: 2021-03-26 17:09
 **/
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);

        // 字符串连接符 + ，String
        System.out.println(""+a+b);// 1020
        System.out.println(a+b+"");// 30
    }
}

这里写图片描述

包机制

为了更好的组织类，Java提供了包机制，用于区别类名的命名空间
包语句的语法格式为：
```
package pkg1[.pkg2.[pkg3...]]
```
一般利用公式域名倒置作为报名
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包，使用‘import’ 语句可完成此功能。

import package[.package2...].(classname|*)

import com.hao.*;
- 导入所有包

JavaDoc

JavaDoc是Sun公司提供的一个技术，它从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档。
参数信息：
- @auther 作者号
- @version 版本号
- @since 指明需要最早使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
命令行生成javaDoc文档 javadoc 参数 Java文件
利用idea 生成JavaDoc文档

package com.hao.basic;

/**
 * @program: JavaSE
 * @description:
 * @author: HuMingHao
 * @version 1.0
 * @since 1.8
 * @create: 2021-03-28 12:56
 **/
public class Doc {

    String name;

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