硅基计划2.0 学习总结 壹 Java初阶

---

一、初见Java

（1）Java简介

首先不得不承认Java是一门优秀的程序设计语言

其系列的计算机软件和跨平台体系包括国内的生态链完善是C/C++语言难以弥补的

（2）Java SE

全称Java Standard Edition，是Java体系的基础

（3）Java EE

全称Java Platform Enterprise Edition，是Java体系的进阶

##它们的区别：SE可在JVM标准下运行，而EE需要特定的服务器

二、Java语言特点

简洁安全

去除了C++中指针、多重继承等复杂特性，自带垃圾回收，杜绝内存泄漏风险

纯面向对象

万物皆对象，通过接口实现灵活扩展，反射机制支持运行时动态解析

跨平台能力

基于字节码和JVM实现"一次编写，到处运行"，严格规范数据类型保证移植一致性

健壮高效

异常处理机制+强类型验证，JIT编译器优化使性能接近C++水平

并发网络

原生支持多线程编程，完善网络库为分布式开发提供基础设施

三、Hello World

给出Java中的Hello World代码。你会发现为什么在Java中是这么大一坨，跟C/C++区别很大

public class Try {
    public static void main(String[] args) {
        System.out.println("hello world");
    }
}

如果你学过C++，就知道上面的Try是一个类名，下面的好像是一个"函数"，里面跟着打印结果

但是在Java中并不存在函数一说，在Java中

最外层的是类，中间层是方法（你可以理解为函数）里层是语句三个部分组成

我们画个图来解释下

因此这段代码就可以理解为在一个名字叫Try的类中，通过main方法，执行了一条打印语句

四、文档注释

这个是来声明文档信息的，网上有很多对应教程，建议声明关键必要的信息

五、上手实操写代码

---

本次使用的IDE是Idea2025.1.1社区版

---

在ieda我们创建一个新项目，注意你的项目名是和代码的类名是一致的

我们正好来讲标识符的常用命名规则（驼峰命名法）

类名：大驼峰，一般类名由多个单次组成，则每个单次首字母都要大写，比如：

方法名，变量名：小驼峰，多个单词中从第二个单次开始的首字母都要大写，比如：

int simpleNum = 10;

Java中写代码与C语言不同，不需要一个个代码手搓

回车就可以完成各条语句的撰写，比如sout表示输出打印，main表示main方法等

而且我们发现，在Java中printlen可以打印任何类型字符，无论是整形还是字符

printlrn表示打印后换行，print直接打印不换行，而printf表规范打印（不常用）

public static void main(String[] args) {
        System.out.println("hello world");
        System.out.println("666");
        System.out.println("12.56");
        System.out.println("你好世界");
        System.out.print("simple");
        System.out.printf("%d",15);    }

六、Java中八种基本类型

有字节型（Byte），整型，短整型，长整型，单精浮点型，双精浮点型

字符型（Java中占两个字节，其存储字符范围也比C/C++中广很多）

布尔型（boolean，只有true和falsel，没有表示0和1）

七、变量（基本类型八大类）

在Java中变量如果没有初始化，会直接报错，而不是像C/C++为随机值

接下来我们每个基本类型挨个举例

（1）整型（int）------4字节

public static void main1(String[] args) {//这样可以把其他的main方法注释掉
        int a = 10;
        System.out.println(a);
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
    }

我们要打印整型的最大值需要使用Integer方法中的MAX_VALUE和MIN_VALUE这两个功能

（2）长整型（long）------8字节

 public static void main(String[] args) {//这里也是一样，可以通过这种方式注释掉
        long num1 = 10L;
        System.out.println(num1);
        System.out.println(Long.MAX_VALUE);//wow，打印长整型的最大值和最小值直接用首字符大写的Long呀
        System.out.println(Long.MIN_VALUE);
    }

推荐大写的L啦，小写的也可以，但是小写的经常被误认为数字1啦

同理我们打印最值，使用Long方法中的MAX_VALUE和MIN_VALUE这两个功能

（3）短整型（short）------2字节

 public static void main(String[] args) {
        short num2 = 32767;
        System.out.println(num2);
        System.out.println(Short.MAX_VALUE);//原来短整型也是这么个包装名
        System.out.println(Short.MIN_VALUE);
    }

打印最值，使用Short方法中的MAX_VALUE和MIN_VALUE这两个功能

（4）字节类型）byte------1字节

 public static void main(String[] args) {
        byte num3 = 127;//哇塞，byte类型表示的范围真的很小呢
        System.out.println(num3);
        System.out.println(Byte.MAX_VALUE);//这个也是一样的包装名呢
        System.out.println(Byte.MIN_VALUE);
    }

打印最值，使用Byte方法中的MAX_VALUE和MIN_VALUE这两个功能

为什么我们给四种变量？

这是为了合理运用空间，分配空间

（5）双精度浮点型（double）------8字节

  public static void main(String[] args) {
        int simple1 = 1;
        int simple2 = 2;
        System.out.println(simple1 / simple2);//输出0
        double num4 = 1.0;//小数默认是double型
        double num5 = 2.0;//当然这里的两个num数据写1和2也可以，相除后仍是0.5
        System.out.println(num4 / num5);
        System.out.println(Double.MAX_VALUE);//可以看到是一个科学计数法
        System.out.println(Double.MIN_VALUE);
    }

为什么两个整型相除是0呢？这是因为执行整数除法的时候，舍弃小数部分

如果你想得到小数，可以使用double类型进行计算，算出的结果就是你想要的小数啦

打印最值，使用Double方法中的MAX_VALUE和MIN_VALUE这两个功能，数字比较大

（6） 单精度浮点型（float）------4字节

 public static void main(String[] args) {
        float num6 = 12.5f;
        float simple3 = 1.0f / 3.0f;
        double simple4 = 1.0 / 3.0;
        System.out.println(simple3);//结果是0.33333334
        System.out.println(simple4);//结果是0.3333333333333333
        System.out.println(Float.MAX_VALUE);
        System.out.println(Float.MIN_VALUE);
    }

对于float类型数据，我们结尾要加上f来强调

如果不写，默认是double类型，大空间类型存入小空间类型，有数据丢失风险

那么float和double都可以表示小数，那它们有什么区别呢

double类型更大，说明它精度更高，能够存储更精确小数

打印最值，使用Float方法中的MAX_VALUE和MIN_VALUE这两个功能

（7）字符型（char）------2字节

  public static void main(String[] args) {
        char ch = 'A';
        char ch2 = '早';
        char ch3 = 97;
        System.out.println(ch);
        System.out.println(ch2);
        //注意char类型的包装名是Character
        System.out.println(Character.MAX_VALUE);
        System.out.println(Character.MAX_VALUE);
        System.out.println(ch3);//打印的就是Unicode编码里的97对应的字符
    }

Java中的char类型与C/C++不同，它是有两个字节大小，那就说明它可以存入更多字符，包括中文汉字哦，而且它没有符号位，说明都是正数

它采用Unicode编码，具体可以去这个网站看看→youyoy第三方网站对于Unicode编码汇总

它表示的范围比ASCII编码范围更大，而且它包含ASCII编码

打印最值，注意这里的方法名是Character中的MAX_VALUE和MIN_VALUE这两个功能

但是你会发现打印不出来，这是因为有些字符是不可打印字符

（8）布尔类型（boolean）------未明确大小

public static void main(String[] args) {
        boolean sign1 = true;
        boolean sign2 = false;
        //boolean simple5 = sign1+sign2;//这行代码直接报错
        System.out.println(sign1);
        System.out.println(sign2);
    }

注意在Java中不存在true表示1，false表示0的用法

打印输出也只是打印输出true和false，并且还不能进行加减

如果运行我注释那一行的代码，会直接报错的

一般布尔类型都是未明确大小的，但是在oracle虚拟机中默认定义为1字节

---

---

八、类型转换

分为自动类型转换（隐式）和强制类型转换（显示），分别是编译器自动和人为主动

（1）自动类型转换

  public static void main(String[] args) {
        int num7 = 5;
        long num8 = num7;//这里就把5从整型转换成长整型
        float f = 12.5f;
        double fPro = f;//这里就把12.5从float类型转换成double类型
        System.out.println(num8);
        System.out.println(fPro);
    }

针对的是小的类型转成大的类型，比如示例中的int转double，float转double

（2）强制类型转换

  public static void main(String[] args) {
        double num9 = 12.12345678;
        float num10 = (float) num9;
        System.out.println(num10);
        byte num11 = (byte) 128;
        System.out.println(num11);
}

针对的是大的类型转小的类型，比如示例中的double转float

但是会存在一个问题，由于float只能精确到小数点6位，当发生强制类型转换的时候，会产生数据丢失的风险

还有一个问题，如果你强制转换的数在转换后的类型中超出范围了会发生什么？

就比如我上面示例代码中的byte类型，结果我们看到是-128，为什么呢？

这里就涉及到了数据溢出的原理

你把它想象成一个钟表，当你超过范围了溢出的数据指向溢出的方向，进入溢出区域的范围

九、整型提升

    public static void main(String[] args) {
        int num12 = 20;
        long num13 = 40;
        long ret = num12 + num13;
        System.out.println(ret);
        byte num14 = 10;
        byte num15 = 30;
        int ret2 = num14 + num15;
        System.out.println(ret2);
        //但是你想强行转换也可以，但可能产生数据丢失问题（数据超出类型范围的时候）
        byte ret3 = (byte) (num14 + num15);
        System.out.println(ret3);
    }

什么时候发生整型提升呢，当一个小的类型和一个大的类型进行加减运算时，由于小的类型数据范围比较小，不方便统一运算，因此就提升为数据类型较大的那一个，对应的就用数据较大的那个类型来接收

如果同类型相加，假如数据类型小于int类型，则相加的时候先提升为int类型再进行计算

因为在进行加减运算时，CPU运算逻辑要求这样

十、字符串类型

public static void main(String[] args) {
        String str1 = "hello world ";
        System.out.println(str1);
        String str2 = "hello everyone";
        String ret4 = str1 + str2;
        System.out.println(ret4);//hello world hello everyone
        int num16 = 10;
        int num17 = 40;
        System.out.println(str2 + num16 + num17);//hello everyone1040
        System.out.println(num16 + num17 + str2);//50hello everyone
        System.out.println(str2 + (num16 + num17));//hello everyone50
    }

大部分跟C/C++逻辑类型，但是有一点比较特殊

在Java中，字符串之间使用加号，表示拼接的意思

但是有个细节需要我们注意，+确实是在字符串中表示拼接作用

但是如果你+号两侧中字符串类型的位置不一样，会导致结果不同

为什么两者的情况不同呢？

原来是字符串变量在前面，执行拼接指令，在后面则等前面的变量值执行完了，再执行后面

但如果你就是向字符串在前的时候拼接上比如变量相加的结果呢？很简单，加个括号就可以了

##与其他类型的转换

 public static void main(String[] args) {
        int num18 = 10;
        String str3 = num18 + "";
        System.out.println(str3);
        System.out.println(String.valueOf(num18));//这样也可以强制转换
        //String转int
        String strOther = "hello world";
        int otherInt = Integer.parseInt(strOther);
    }

int转string，我们可以给字符的结果加上""或者是使用Srring方法中的valueof功能

反之string转int，目前我认知的只能使用Integer方法中的parseInt功能

而且这种转换编译器也会报出警告

十一、运算符简略介绍

（1）Java特殊介绍

例子一：

public static void main(String[] args) {
        int num19 = 50;
        int num20 = 0;
        //System.out.println(num19/num20);
        System.out.println(11.0 % 2.0);//结果是1.0
    }

上面的num19/num20这段代码会报错

因为num20是一个0的值，计算异常，也就是0不能作为除数

Java中有一种特殊求余的方式，小数点求余，这是在C/C++中所没有的

例子二：

在C语言中，这段代码：3<num22<5的最终结果是true为真，但是在Java中无法通过编译

这是因为第3<5判断后，返回的类型是true

而true和5不是同一个类型，无法比较，Java中对类型的检查非常严格

（2）增量运算符问题

 public static void main(String[] args) {
        int num21 = 10;
        num21 += 1.5;
        System.out.println(num21);//为何打印的结果是11呢？
    }

因为你num21是一个整型类型，你加上一个1.5相当于是double类型，10会发生整型提升

计算后的结果本应该是11.5，但是你的num21是int类型

会进行强制转化，舍弃小数部分，不会四舍五入，因此上述计算式子等同于

num21 = (int) (num21 + 1.5);
        System.out.println(num21);//这里的打印结果就是12了

（3） 短路求值

public static void main(String[] args) {
        int num22 = 4;
        int num23 = 2;
        boolean ret5 = num22 > num23 && 1 > 2;
        System.out.println(ret5);//打印结果是false，因为两边同时为真整个式子才为真
        boolean ret6 = num22 > num23 || 1 > 2;
        System.out.println(ret6);//打印结果为true，只要两边有一边为真整个式子就是真
        //针对程序抛出异常，我们使用短路来确保安全
        boolean retError3 = num22 > num23 || (1 / erroSimple) > 2;
        System.out.println(retError3);
        //输出为true，右边式子不会计算，不会执行右边的抛出异常

但是在Java中，如果是按位与和按位或，则不会短路，会产生程序抛出异常

为了避免这种情况，我们善于利用短路来确保我们代码安全

int erroSimple = 0;
boolean retError = num22>num23&(1/erroSimple)>2;//如果你不使用短路，会发生程序抛出异常
        //报错信息→→Exception in thread "main" java.lang.ArithmeticException: / by zero
boolean retError2 = num22>num23|(1/erroSimple)>2;
        //同理会发生程序抛出异常，Exception in thread "main" java.lang.ArithmeticException: / by zero
System.out.println(retError);
System.out.println(retError2);

十二、位运算符

位运算符之前在C语言中已经计算过了，这里不做过多介绍，这里举一个例子来看看

但是在Java中有一种特殊的右移，无符号右移，就是右移后甭管你是正数还是负数，一律添上0

public static void main(String[] args) {
        int num24 = 0xf;//这是十六进制数字，f代表15
        int ret7 = ~0xf;
        System.out.println(ret7);//诶，打印结果是-16，为什么呢？取反是按原码取反
        //同样移位操作符也讲过，这里我举一个特殊例子
        int num25 = -1;
        int ret8 = num25 >> 1;
        System.out.println(ret8);//结果还是-1
        //以下是Java独有的无符号右移
        int ret9 = num25 >>> 1;
        System.out.println(ret9);//结果是2147483647，一个非常大的数
    }

以下是利用deepseek进行解读为什么打印结果是-16，注意红框框里的字"绝对值"

以下是利用deepseek进行解读为什么ret9是一个非常大的数

十三、条件操作符&&运算符优先级

 public static void main(String[] args) {
        int ret10 = 1 > 0 ? 2 : 4;//问号左边式子必须是布尔类型的判断
        System.out.println(ret10);
    }

跟C语言有些类似，但是这个操作符的值必须是有其他值去接收结果值来接收

至于优先级，与其记那么多规则，

还不如直接添加括号，想让哪个部分先算就把哪个部分加括号即可

---

本文章所用代码：Git码云仓库链接

---

作者水平有限，文章难免有些疏漏错误，欢迎指正，我们友好交流

---

END