零基础自学Java--第二弹

原创已于 2025-06-24 14:59:11 修改 · 1.6k 阅读

34 ·

CC 4.0 BY-SA版权

文章标签：

#java #python #开发语言

于 2025-06-23 20:36:09 首次发布

前言

日期：2025年6月23日

种一棵树最好的时间是十年前，其次就是现在。现在就开始学习，坚持。

提示：以下内容仅自己的学习记录，学习视频：B站：狂神说Java

一、注释

Java有三种注释：
（1）单行注释：//
（2）多行注释：/* 在这里插入注释内容 /
（3）文档注释（JavaDoc）：/** 在这里插入注释内容 */

二、标识符

1.关键字

在这里插入图片描述
注：Java 所有的组成部分都需要名字，类名，变量名以及方法名都被称为标识符。

2.标识符注意点

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

在这里插入图片描述

三、数据类型

Java是强类型语言，要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用。

Java的数据类型分为两大类：
◆基本类型(primitive type)
◆引用类型(reference type)
在这里插入图片描述

代码如下（示例）：

public class Demo01 {
    public static void main(String[] args) {
        //八大基本数据类型
        //整数（最常用）
        int num1  =10;
        byte num2  =20;
        short num3  =30;
        long num4  =40L;  //long类型需要在数字后面加上L

        //小数：浮点数
        float num5  =50.0f; //float类型需要在数字后面加上F
        double num6  =60.0d;

        //字符
        char num7  ='熊';  //只能写一个字符，不能写两个，如'小熊'，要用单引号！
        //String不是关键字，是类！
        //String name = "小熊"

        //布尔值：是与非
        boolean flag  =true;
        boolean flag2=false;
    }
}

注意：long类型需要在数字后面加上L（大小写都可以，但是小写的l常常被误认为是1，所以建议用L）
float类型需要在数字后面加上F
String不是关键字，是类！

扩展：常见的进制符号，进制转换和常见的快捷键

public class Demo02 {
    public static void main(String[] args) {
        //整数扩展：   进制： 二进制0b  十进制   八进制0     十六进制0x  （进制的符号写在前面）

        int i = 10;
        int i1 =0b10;   //二进制
        int i2 =010;    //八进制
        int i3 =0x10;   //十六进制

        System.out.println(i);
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("=====================================");//分割线
        //=================================================
        //浮点数拓展    银行业务怎么表示？
        //BIGDecimal        数学类工具
        //=================================================
        //float    f     有限，离散，舍入误差，大约，接近但不等于
        //double   d
        //最好完全使用浮点数进行比较！！！
        //最好完全使用浮点数进行比较！！！
        //最好完全使用浮点数进行比较！！！
        //最好完全使用浮点数进行比较！！！
        //最好完全使用浮点数进行比较！！！


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

        float f1 = 2342342353f;
        float f2 = f1+1;
        System.out.println(f1==f2);  //true

        //=================================================
        //字符拓展
        //=================================================

        char c1 = 'a';
        char c2 = '中';

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

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

        char c3 = '\u0034';
        System.out.println(c3);


        // \t 制表符
        // \n 换行
        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);
        //对象 从内存分析

        System.out.println("=====================================");//分割线
        //布尔值扩展
        boolean flag = true;

        if (flag){
            System.out.println("yes!");
        }
    }
}

1.什么是字节

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

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

2.类型转化

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

◆强制类型转换
◆自动类型转换

public class Demo05 {
    public static void main(String[] args) {
        int i = 128;
        //强制转换；从高到低
        //自动转换：从低到高
    }
}

四、变量

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

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

public class Demo07 {
    public static void main(String[] args) {
        int a=1,b=2,c=3,d=4,e=5;   //可读性不好
        String name = "小熊";
        char a1= 'A';
        double pi = 3.14;

    }
}

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

2.变量作用域

public class Demo08 {

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

    String name;//实例变量：从属于对象,如果不手动初始化，会自动赋值这个类型的默认值
    int age;
    //布尔值默认是false
    //除了基本类型其余都是null

    //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.age);

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

    }

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

    }
}
》》》》》》》》》》》》》
输出结果：
10
null
0
2500.0

五、常量

常量(Constant):初始化(initialize)后不能再改变值!
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

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

// 常量
public class Demo09 {
    //static是修饰符，static和final的位置可以交换
    //类变量 常量 基本类型 常量名 = 常量值
    static final double PI = 3.14159265358979323846;//用final定义常量
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

命名规范

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

六、运算符

在这里插入图片描述
注意：括号内的先运算

1.二元运算

public class Demo01 {
    public static void main(String[] args) {
        //二元运算符
        //Ctrl +D ：复制当前行到下一行
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;

        System.out.println(a + b + c + d);
        System.out.println(a - b) ;
        System.out.println(a * b);
        System.out.println(a / b);   //为int，导致结果0.5，输出却为0，自动四舍五入
        System.out.println(a / (double)b);//为double，输出结果0.5
    }
}
》》》》》》》》》》》》》》》》》
输出结果：
10
-1
2
0
0.5

2.位运算

public class Demo06{public static void main(string[] args){
/*
A=0011 1100
B=0000 1101
-------------------------------------
A&B =0000 1100  //按位与，有0则0，全1则1
A/B=0011 1101   //按位或，有1则1，全0则0
A^B =0011 0001  //按位异或，同则0，异则1
~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 1000     //8
0001 0000     //16
System.out.println(2<<3);

二进制中向左移动一位等于十进制乘2

3.逻辑运算符

//逻辑运算符  与（and）    或（or）    非（取反）
public class Demo05 {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        System.out.println("a&&b：" + (a&&b));  //全真则真
        System.out.println("a||b：" + (a||b)); //有真则真
        System.out.println("!(a&&b)：" + !(a&&b)); //取反


        //短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<4);   //在判断（c<4）的时候已经可以得到这个语句的输出是false，不受后面的值影响，就没有执行(c++<4)
        System.out.println("d:" + d);
        System.out.println("c:" + c);  //所以c的值仍然为5
    }
}
》》》》》》》》》》》》》》》》》》》》》》》》》》》
输出结果：
a&&b：false
a||b：true
!(a&&b)：true
d:false
c:5

注意运算优先级和短路运算

4.扩展赋值运算符

public class Demo07 {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;

        a += b;   //a = a+b =3
        System.out.println(a);
        b -= a;   //b = b-a =-1
        System.out.println(b);

        //字符串连接 +，String
        System.out.println(a+b+"啦啦");//字符串在后面会先将a+b进行运算，输出“2啦啦”
        System.out.println("啦啦"+a+b);//字符串在前面会将后面的a和b作为字符串进行拼接，输出“啦啦3-1”
    }
}

5.自增和自减

//++:自增，--：自减    一元运算符

public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);  //a = 1

        int b = a++;  //执行完这行代码之后先给b赋值，a再自增
        // a = a +1 相当于执行了这一行代码
        System.out.println(a);  //a = 2
        System.out.println(b);  //b = 1

        int c = ++a; //a先自增再赋值给c
        System.out.println(c);  //c = 3
        System.out.println(a);  //a = 3
    }
}

注意++a和a++的区别

6.三元运算符

//三元运算符

public class Demo08 {
    public static void main(String[] args) {
        //x ? y :z
        //如果x=true，则输出y，否则输出z
        int score = 70;
        String type = score > 60 ? "及格" : "不及格";   //if
        System.out.println(type);
    }
}

x ? y :z //如果x=true，则输出y，否则输出z

六、包机制

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。
包语句的语法格式为:

package pkg1[. pkg2[. pkg3..]];

一般利用公司域名倒置作为包名;
为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。使用"import"语句可完成此功能：

import packagel[.package2..l.(classname *);`

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

◆ @author 作者名
◆ @version 版本号
◆ @since 指明需要最早使用的jdk版本
◆ @param 参数名
◆ @return 返回值情况
◆ @throws 异常抛出情况
在这里插入图片描述

总结

以上就是今天学习的内容啦~
第二弹学习了java中的注释、数据类型、类型转换、常量、变量、运算符和包机制还有JavaDoc

作业

使用IDEA生成JavaDoc文档

1. 在IDEA中选择工具（Tool）选项卡打开

在这里插入图片描述

2. 选择生成JavaDoc

在这里插入图片描述

第一步：选择生成JavaDoc文档的范围，我只对一个源文件生成Doc，所以选择文件。
第二步：输出目录最好新建一个文件夹，比较有条理和整洁
第三步：区域设置，决定文档的语言，简体中文就是zh_CN、繁体(台湾)zh_tw、繁体(香港)zh-hk、英语(香港)en-hk、英语(美国)en-us、英语(英国)en-gb、英语(全球)en-ww
第四步：其他命令行参数：如果区域设置为中国，参数一般为-encoding UTF-8 -charset UTF-8
第五步：设置完成后点击确定即可生成Doc文档