Java（一）——初识Java

文章目录

• Java
• • 初识Java
  • • 基本知识
    • 注释
    • 标识符
    • 关键字
    • 字面常量
    • 基本数据类型
    • 变量
    • 类型转换
    • 类型提升
    • 初识字符串类型
    • 运算符
    • 语句
    • • 顺序结构
      • 分支结构
      • • if
        • switch
      • 循环语句
      • • while循环
        • for循环
        • do-while循环
      • 输入输出

Java

初识Java

基本知识

Java的源文件后缀名.java，经过Java编译器javac转化为.class的字节码文件（二进制文件），然后将在JVM中（java虚拟机）运行java代码。

安装JDK时就会安装好JVM，JDK中有JRE，JRE中有JVM。

JDK： java的开发者工具

JRE：java运行时环境

JVM：java虚拟机

Java的第一个代码------hello world

public class Test{
    public static void main(String[] args){//注意左括号的位置，这是Java的书写风格
        System.out.println("hello world");
    }
}

• public class的书写较固定。
• Test是类名【采用大驼峰命名方式】，被public修饰的类名必须和文件名相同。
• args就是数组，与C语言常用的格式不同，C语言中int args[10]就是创建了一个数组，元素个数是10，args的类型是int[10]类型，所以C语言的常用写法是不够严谨的，java中对C语言这种不规范的写法进行了修正：String[] args，这是创建了一个字符串数组。
• java的风格规定：左括号在当前行，即便换行后也不会报错。

---

注释

Java的注释主要有以下三种：

• 单行注释： //注释内容（最常用）
• 多行注释 ：/*注释内容*/（不推荐）
• 文档注释 ：/**文档注释*/（常见于方法和类之上，用来描述方法和类的作用），我们可以使用javadoc工具解析，生成一套以网页文件形式体现的程序说明文档）

注意：

• 多行注释不能嵌套使用
• 多行注释不能嵌套单行注释
• 不论是单行注释还是多行注释，都不参与编译，即编译之后生成的.class文件中不包含注释信息。

对于单行注释和多行注释我们在C语言阶段都了解过了，所以我们这里重点说一下文档注释：

如下，我们书写了一段文档注释：

/**
 文档注释：
 @version v1.0.0
 @author will
 作用HelloWorld类，入门第一个程序练习
 */
public class blog {
    public static void main(String[] args) {
        System.out.println("hello world");
    }
}

在代码所在路径，打开cmd控制台，然后输入如下命令：

javadoc -d blog -author -version -encoding UTF-8 -charset UTF-8 blog.java

执行后，回到路径：

我们发现路径中多了一个文件夹，打开箭头所指的文件：

这便是上面提到的以网页文件形式体现的程序说明文档

---

标识符

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

前面提到，在这段代码中，Test称为类名，main称为方法名，其实它们就是标识符 ，即：在程序中由用户给类名、方法名或变量名所取的名字。

• 硬性规则：

  标识符中可以包含字母、数字、下划线(_)、$

  标识符不能以数字开头，也不能是关键字，并且大小写敏感（严格区分大小写）

• 软性建议：

  类名：采用大驼峰命名方式

  方法名：首字母小写，后面的每个单词的首字母大写（小驼峰）

  变量名：与方法名建议相同

---

关键字

具有特殊含义的标识符称为关键字，比如，上面代码中的不同颜色的public、class等，都是关键字。

关键字是由Java语言提前定义好的，有特殊含义的标识符或者保留字。

---

字面常量

常量即程序运行期间，固定不变的量称为常量

我们的写的第一个Java代码中的 "hello world" 就是字面常量。

public class Constant {
    public static void main(String[] args) {
        System.out.println(10);
        System.out.println(12.5);
        System.out.println("hello world");
        System.out.println(true);
        System.out.println('a');
    }
}

上面的代码中打印的都是常量，只是类型不同而已。

---

基本数据类型

Java中数据类型主要分为两类：基本数据类型 和引用数据类型

基本数据类型有四大类：

• 整型：int、long、short、byte
• 浮点型：float、double
• 字符型：char
• 布尔型：boolean

注意：

• 不论是在16位系统还是32位系统，int都占 4 个字节，long都占 8 个字节。

• 整型和浮点型都是带有符号的

• 整型默认是int类型；浮点型默认是double类型。
  

  如果我们期望它是float类型，我们要在数字后面加上一个f或F，这样就不会报错了。

  

其中大部分在C语言学习中见过并且使用过。具体的数据类型知识将在变量部分介绍。

---

变量

前面介绍了常量，它们在程序运行中始终不变。而在程序中有些内容可能会经常改变，比如：商品的价格、人的年龄等，对于这些经常改变的内容，在Java程序中，称为变量。上面简单提到的数据类型就是来定义不同种类的变量的。

定义变量的语法格式

数据类型 变量名 = 初始值;

比如：

int a = 10;
double d = 12.5;

整型变量

我们用int定义变量时，要注意：

• int不论在何种系统下都是4个字节
• 使用变量前，要对其进行赋值，如果没有赋值，编译报错，十分严格
• 给变量赋值时，不能超过int的表示范围，否则会导致溢出，直接报错
• int的包装类型是Integer

长整型变量

我们用long定义变量时，要注意：

• long不论在何种系统下都是8个字节
• 长整型变量的初始值后（或赋值）加l或L，便于区分，不过不是强制的。
• long的包装类型是Long

短整型变量

我们用short定义变量时，要注意：

• short不论在何种系统下都是2个字节
• short的包装类型是Short

字节型变量

这是我们C语言阶段没有见过的，使用时注意：

• byte不论在何种系统下都是1个字节
• byte的范围是：-128~127
• byte的包装类型是Byte

双精度浮点型

我们使用double定义变量时，注意：

• double不论在何种系统下都是8个字节

• double类型的内存布局遵循 IEEE 754 标准（与C语言一样），会存在一定的误差，因此浮点数是一个近似值，并不是精确值

• double的包装类型是Double

单精度浮点型

注意：

• float不论在何种系统下都是4个字节
• 遵守 IEEE 754标准
• 赋值时，值的后面加上f或F，因为Java中的浮点型默认是double类型的

字符型变量

• 使用 单引号 + 单个字符 的形式表示字符字面值

  char ch = 'A';
  char ch1 = '1';
  char ch2 = '我';

• 计算机的字符本质上是一个整数，所以java中的字符可以存放整型。

• C语言中使用ASCII表示字符，而Java中使用Unicode表示字符，因此，一个字符占用2个字节，表示的字符种类更多，包括中文

布尔型变量

• 布尔型变量只有两种可能的取值：false或true，分别表示假和真

• 使用boolean来定义变量：

  boolean ret = false;

• Java的boolean类型不能和int类型相互转换，不存在 1 表示 true，0 表示 false 的用法（一定要和C语言区别开）

• Java虚拟机规范中，并没有明确规定boolean类型占几个字节，也没有专门用来处理boolean的字节码指令，在Oracle公司的虚拟机实现中，占1个字节

---

类型转换

Java作为一个强类型编程语言，当不同类型之间的变量互相赋值的时候，会有严格的校验。

在Java中，当参与运算数据类型不一致时，就会进行类型转换。Java中类型转换主要分为两类：自动类型转换（隐式）和强制类型转换（显式）。

自动类型转换

代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。特点： 数据范围小的转化为数据范围大的时会自动进行。

例如：

int a = 100;
long b = 120L;
b = a;//编译不报错，b是long类型，a是int类型，小转大，编译器将a自动提升至long类型，然后赋值
a = b;//编译报错，大转小

我们知道，整型默认类型是int类型，那么我们给byte类型的变量赋值时，只要数值不超过byte的表示范围，编译器就会将整数转换为byte类型。

byte a = 100;//没有超过byte的范围，编译器将100转换为byte
byte b = 800;//编译失败，800超过了byte的数据范围，有数据丢失

强制类型转换

当进行操作时，代码需要经过一定的格式处理，不能自动完成。特点： 数据范围大的到数据范围小的。

以上面的代码为例：

int a = 100;
long b = 120L;
b = a;//自动转换
a = b;//编译失败
a = (int)b;//long->int,数据范围由大到小，强制类型转换，否则编译失败

• 不同数字类型的变量之间赋值，表示范围小的类型能够隐式转换为范围较大的类型
• 如果需要把范围大的类型赋值给范围小的类型变量，需要强制类型转换，不过可能会出现精度丢失
• 将一个字面值常量进行赋值的时候，Java会自动针对数字范围进行检查
• 强制类型转换不一定能成功，不相干的类型不能相互转换，例如boolean类型就不可以与其他类型转换。

---

类型提升

不同类型数据之间相互运算时，数据类型小的会被提升到数据类型大的。

两种情况：

int与long之间：int会被提升为long类型（小转大）

int a = 10;
long b = 20;
int c = a + b;//编译出错，int与long相加，int会类型提升至long类型，所以其实是两个long类型相加，表达式结果也需要用一个long类型的变量接收。（当然也可以强制类型转换，不过有些情况下会出现精度丢失）
long d = a + b;//编译成功

byte与byte的运算（不足4字节的提升至4字节类型）

byte a = 10;
byte b = 20;
byte c = a + b;//编译出错，原因：
//虽然byte和byte是相同类型，但是计算时a和b会被提升至int类型，所以需要一个int类型的变量接收。
int d = a + b;//编译成功！

byte会被提升至int，原因是：计算机的CPU通常是按照4个字节为单位从内存中读写数据，这样，硬件上实现就会方便。

总结：

1. 不同类型的数据混合运算，范围小的会提升成范围大的
2. 对于short、byte这种比4个字节小的类型，会先提升成4个字节的int，再运算

---

初识字符串类型

与C语言不同，Java中使用String类定义字符串类型，z这里仅作简单介绍，后续会详细讲解。

比如：

    public static void main(String[] args) {
        String str1 = "hello ";
        String str2 = "world!";
        System.out.println(str1);//直接打印字符串str1
        System.out.println(str2);//直接打印字符串str2
        System.out.println(str1 + str2);//字符串拼接
    }

其中字符串的拼接操作相较于C语言是很方便的。

字符串与整型的转化

int转成String

int num = 100;
//方法一
String str1 = num + "";
//方法二
String str2 = String.valueOf(num);

System.out.println(str1);
System.out.println(str2);

String转成int

String str = "100"; 
//方法一
int num = Integer.valueOf(str);  
//方法二
int num1 = Integer.parseInt(str);

System.out.println(num);
System.out.println(num1);

注意：Java字符串中末尾没有\0

字符串类型就简单介绍到这里。

---

运算符

Java中的大部分运算符及规则与C语言相同，我们这里主要介绍特别注意的点：

所以先看一张图：

注意（与C语言不同的，或者是比较容易忘记的，特别注意的）：

• Java中不存在 1 和 0 表示 真 和 假 的规则

• Java的/和%运算符的右操作数不能为0

• Java可以对浮点型执行%运算符，但是没有意义，一般都是对整数取模。（与C语言不同）

      public static void main(String[] args) {
          double d = 11.5;
          System.out.println(d % 2);
      }

  

• 对于<等关系运算符，不能连续使用。（与C语言一致，Python允许）

• Java中的逻辑运算的结果都是boolean类型，左右表达式也必须是boolean类型的结果

• Java中的位运算符&和|能够分别代替逻辑运算符&&和||，不过，用于逻辑判断的&和|不存在短路规则

      public static void main(String[] args) {
          int a = 10;
          int b = 20;
          boolean b1 = a < b || 10 / 0 == 0;// || 存在短路，a>b为true，后面的10/0==0不进行计算，10/0不会报错
          boolean b2 = a < b | 10 / 0 ==0;// | 不存在短路，a>b为true，后面的10/0==0进行计算，由于/的右操作数不能为0，程序报错
      }

  

• 最开始的图片忽视了位运算符。位运算符有^，&，|，~，规则与C语言一致，注意&和|的逻辑用法。

• 移位运算符有：<<、>>、>>>，>>就是右移，最左边补符号位；>>>是无符号右移，最左边补0，注意，相应的，也会有>>>=

---

语句

顺序结构

比较简单，就是按照代码顺序逐条执行。

分支结构

if

if (布尔表达式){
//语句
}

if (布尔表达式){
//语句
}else{
//语句
}

if (布尔表达式){
//语句
} else if{
//语句
} else{
//语句
}

Java的if语句与C语言的差别不大，不过，笔者总结了几点需要注意的问题：

• Java的代码书写风格

• 悬垂else问题：else与离它最近的还未被匹配的if语句匹配，不是看对齐。

• Java中不存在 1 和 0 表示 真 和 假 的规则，所以if括号里的必须是布尔表达式，其计算

  结果为布尔类型。举个例子：

  C语言中if永真的简单写法：

  if(1)
  {
     
  }

  Java不能像C语言那样写，遵循Java的代码风格以及规则，我们这么写:

  if(true){
      
  }

讲了这么多，我们介绍一下Java分支语句的代码风格：

我们随便写一块代码，判断一个整数的正负性：

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int num = scanner.nextInt();
        
        if(num > 0){
            System.out.println("是正数");
        }else if(num < 0){
            System.out.println("是负数");
        }else{
            System.out.println("为0");
        }
        
    }

• 左花括号不换行
• else和else if不换行

if括号里必须是布尔表达式不必多说。

switch

switch (表达式){
  case 常量值1:{
  //语句1
  [break;]
  }
  case 常量值2:{
  //语句2
  [break;]
  }
  ......
  default:{
  //上面情况都不满足执行的语句
  [break;]
  }
}

执行流程

1. 先计算表达式的值
2. 与case依次比较，一旦有对应的匹配就执行该项下的语句，直到break或switch末尾结束。
3. 当表达式的值没有与case项匹配，执行default下面的语句

Java的switch语句与C语言差别也不大。

• switch后面的表达式不能是 ：long、boolean、float、double类型，也不能表达复杂的条件。
• 多个case后面的常量值不可以重复
• 注意Java的代码风格
• switch括号里只能是以下类型的表达式：
  1. 基本类型：int、byte、short、char
  2. 引用类型：String常量值、枚举类型

循环语句

while循环

while (循环条件){
循环语句;
}

循环条件为true，则执行循环语句，否则结束循环。

注意：

• Java中不存在 1 和 0 表示 真 和 假 的规则，所以循环条件必须是布尔表达式，计算结果是boolean类型
• 注意Java的代码风格

for循环

for (表达式1; 布尔表达式2; 表达式3){
表达式4;
}

• 表达式1：用于初始化循环变量初始值设置，在循环最开始时执行，且只执行一次
• 布尔表达式2：循环条件，满足则循环继续，否则循环结束
• 表达式3：循环变量的更新方式
• 表达式4：循环体语句

仍然注意布尔表达式和代码风格的问题，其他的于C语言一致。

do-while循环

do {
循环语句;
}while (循环条件);

先执行循环语句，再判定循环条件，条件成立循环继续，否则循环终止，所以do-while的循环语句至少被执行一次。

• do-while循环后的;不要忘记
• 循环条件是布尔表达式，表达式的结果是boolean类型
• 代码风格

---

Java中的final与C语言的const类似，被final修饰的变量变为常量，最好将变量名大写

Java浮点型在内存中的存储和C一样

Java字符串中末尾没有\0

Java中可以对小数执行%操作，但没意义

long a = 10;
int b = 10;
int c = a + b;//err,因为int会提升至long类型，用int类型的c来接收不行
long c = a + b;//ok
c += 

---

输入输出

输出到控制台

Java中的输出主要有三种：

    public static void main(String[] args) {
        System.out.println("第一种");
        System.out.print("第二种");
        System.out.printf("第三种");
    }

• println最常用，特点是打印后自动换行
• print与println唯一的差别是：print不自动换行
• printf，格式化输出，与C语言的printf用法一致

从键盘输入

看一段代码，从键盘读取一个整数并打印：

import java.util.Scanner;//导入包
public class BlogShow {
    
       public static void main(String[] args) {
           Scanner scanner = new Scanner(System.in);//相对固定的写法
           int num = scanner.nextInt();//定义变量接收
           System.out.println(num);
    }
    
}

我们看到，Java从键盘输入相比于C语言麻烦，需要3行语句

---

初学阶段，很多涉及到的语法，如类、导入包等知识没有详细讲解，后面笔者会陆续发文介绍，由浅入深，慢慢从初学到熟悉再到精通！

​