Java语言基础

点击上方"Java软件编程之家"可以关注我哦，文末也有公众号二维码可以直接扫码关注！

关注后回复"Java"关键字可以获取正在更新中的Java系统性学习教程，回复"资源"可以免费获取电子书！

八大基本类型

Java语言开发规范中内置了8种基本类型，如下表：

数据类型	位数	默认值	取值范围	例子
short(短整数)	16	0	-2^15 至 2^15-1	short x = 6;
int(整数)	32	0	-2^31 至 2^31-1	int x = 6;
long(长整数)	64	0	-2^63 至 2^63-1	long x = 6;
float(单精度)	32	0.0	-2^31 至 2^31-1	float x = 6.0f;
double(双精度)	64	0.0	-2^63 至 2^63-1	double x = 6.0d;
char(字符)	16	空(‘’)	0 至2^16-1	char x = ‘c’;
boolean(布尔值)	8	false	true, false	boolean x = true;
byte(位)	8	0	-2^7 至 2^7-1	byte x = 6;

 

这个表只需要简单过一遍即可，能记住是最好，记不了就这暂时过一遍。

注释

Java语言开发规范中注释是一种代码说明、解释、备注，注释不会被javac编译器编译到class文件中，注释的作用是对某行或模块代码逻辑的一些说明。我们一般可以通过两种方式进行代码注释：单行注释（// 这是单行注释），多行注释（/** 这是多行注释 */）。下面是注释的代码例子：

package com.soft.hello;


public class NotesExample {


  /**
   * 
   * 这是一个main方法 
   * 它可以作为程序入口方法 
   * 
   * @param args 这是方法参数
   */
  public static void main(String[] args) {


    // 这是一行打印语句
    System.out.println("hello, world");
  }
}

块

Java语言开发规范中通过一对花括号定义不同的代码块，例如某个类、某个方法、某个循环、某个分支判断等，不同的块通常有不用的作用域，作用域知识到后面讲解控制语句时会再次提到。下面是块代码例子：

package com.soft.hello;


public class BlockExample {
  
  //这是类BlockExample块
  
  
  public static void main(String[] args) {
    
    
    //这是main方法块
    
  }


}

关键字

Java语言开发规范中默认定义了一系列关键字，例如class、static、package、import、final、main、void等等还有很多就不一一列举，每一个关键字对Java来说都是某种约定的规范，例如用class关键字定义一个类，用package关键字定义包，用final关键字定义某个类、方法、变量不可变等等。可以毫不夸张说java语言规范就是由不同的关键字组出来的，关键字是我们学习java最基础的知识。下面是关键字代码例子：

//通过关键字package定义包
package com.soft.hello;


//通过public 关键字修饰类是公共的
//通过class 关键字定义一个类
public class KeywordExample {


}

权限修饰符

Java语言开发规范中通过不同关键字的方式定义了4种类型权限修饰符：

• public：公共的，外部可以访问。

• protected：父子类继承范围可访问。

• private：类私有的，同一个类可访问。

• 缺省：同一个包范围可访问。

下面是权限修饰符的代码例子：

package com.soft.hello;


public class PermissionExample {


  //公共的,外部可访问
  public void method1() {


  }


  //父子继承范围可访问
  protected void method2() {


  }


  //私有的,同一个类范围访问
  private void method3() {


  }
  
  //缺省的, 同一个包范围可访问
  void method4() {
    
  }
  
}

其中public权限修饰符可以修饰类、方法、属性、内部类的定义，而其他的修饰符只能修饰方法、属性、内部类而不能修饰类。关于类、方法、属性等知识后面会详细讲解，这里大致了解即可。

标识符

Java语言开发规范中，除了关键字和花括号外，其他的都是我们自定义的，这类称为标识符，标识符命名规则如下：

• 只能由字母（a-z，A-Z），数字（0-9），下划线（_）和美元符号（$）组成

• 不能以数字开头

•  不能与关键字重名

•  大小写敏感

下面是标识符代码例子：

//IdentifierExample便是标识符，由我们自定义
public class IdentifierExample {
  


}

变量

Java语言开发规范中，使用最多的就是变量，变量需要先定义才能使用，定义变量一般代码格式：变量类型 变量名称 = 变量值。下面是变量的代码例子：

package com.soft.hello;


public class VarExample {
    
  public static void main(String[] args) {
    
    // 定义int 类型变量 i 值为 10
    int i = 10;
  
    // 定义boolean 类型变量 b 值为 false
    boolean b = false;
    
    // 定义long 类型变量l 值为 10
    long l = 10;
    
    
    System.out.println("i 的值 为 " + i);
    System.out.println("b 的值 为 " + b);
    System.out.println("l 的值 为 " + l);
    
  }
  
}

控制台输出：

 

i 的值 为 10

b 的值 为 false

l 的值 为 10

 

运算符

Java语言开发规范中运算符从不同的角度有不同的分类，其中按功能可分为如下几类：

• 算术运算符

• 赋值运算符

• 关系运算符

• 逻辑运算符

• 位运算符

从操作数角度又可以分为：

• 单目运算符

• 双目运算符

• 三目运算符

下面是各种运算符代码例子：

public class OperatorExample {


  public static void main(String[] args) {


    // 算术运算符 ===================== 这是分割线 ==========================
    //  + - * / %
    int a = 10 + 2; // 输出 12
    int b = 10 - 2; // 输出 8
    int c = 10 * 2; // 输出 20
    int d = 10 / 2; // 输出 5
    int e = 10 % 3;// 输出 1,求余数


    // 赋值运算符 ===================== 这是分割线 ==========================
    // = += -= *= /= %= &= ^= |= <<= >>=，操作结果返回左边定义的类型，不同类型会发生部分类型转换，
    // 对于字面量数值编译器会做上下界判断,例如 int a = 100000000000000000000000,明显值超出int类型取值范围，编译器会报错
    int a1 = 10;
    a1 += 5; // 输出 15 类似：a1 = a1 + 5; 后面以此类推
    a1 -= 5; // 输出 10
    a1 *= 5; // 输出 50
    a1 /= 5; // 输出 10
    a1 <<= 10; // 输出 10240，左移
    a1 >>= 10; // 输出 10，右移
    a1 %= 3; // 输出 1，求余数


    // 关系运算符 ===================== 这是分割线 ==========================
    // == < > != >= <= ,操作结果返回boolean类型
    int a5 = 10;
    int a6 = 12;
    boolean b1 = a5 > a6; // 输出 false
    boolean b2 = a5 != a6; // 输出 true


    // 逻辑运算符 ===================== 这是分割线 ==========================
    // 与（&&）、非（!）、或（||）,操作结果返回boolean类型
    int a7 = 10;
    int a8 = 11;
    int a9 = 12;
    boolean b3 = (a7 < a8); // 输出 true
    // !: 取反, true取反后为false, false取反后为true
    boolean b4 = !(a7 < a8); // 输出 false
    boolean b5 = (a7 < a8) && (a9 > a8); // 输出 true
    // &&:
    // 当两边都为true,结果才为true,否则为false,它是短路的，如果第一个操作结果为false,则马上返回false,不会继续判断后面的操作结果
    boolean b6 = (a7 > a8) && (a9 < a8); // 输出 false
    // ||:
    // 当两边其中一边为true,则结果为true,否则为false,它是短路的，如果第一个操作结果为true,则马上返回true,不会继续判断后面的操作结果
    boolean b7 = (a7 < a8) || (a9 > a8); // 输出 true


    // 位运算符 ===================== 这是分割线 ==========================
    // << 带符号左移 >>带符号右移 >>> 无符号右移
    int a10 = 10 << 3; // 输出 80 ,左移n位表示 乘以 2n次方
    int a11 = 80 >> 3; // 输出 10 ,右移n位表示 除以 2n次方


    // 单目运算符 ===================== 这是分割线 ==========================
    // ~（按位取反）、! (取非)、-（负号运算符）、 ++（自增）、 - -（自减）
    int a12 = 10;
    // 后置自增, 类似 a12 = a12 + 1;
    a12++; // 直接System.out.println(a12++); 输出10, 如果先a++;再System.out.println(a12);则输出11


    a12 = 10;
    // 后置自减, 类似 a12 = a12 - 1;
    a12--; // 直接System.out.println(a12--); 输出10, 如果先a--;再System.out.println(a12);则输出9


    a12 = 10;
    // 前置自增 , 类似 a12 = a12 + 1;
    ++a12; // 直接System.out.println(++a12); 输出11, 如果先++a;再System.out.println(a12);也是输出11


    a12 = 10;
    // 前置自减, 类似 a12 = a12 - 1;
    --a12; // 直接System.out.println(--a12); 输出9, 如果先--a;再System.out.println(a12);也是输出9


    // 双目运算符 ===================== 这是分割线 ==========================
    // &: 运算时均把运算数转换为二进制再做比较，规则：当相同的位上均为1时结果为1，否则结 果为0
    int a13 = 12 & 10; // 12 & 10，转为二进制：1100&1010，比较结果为：1000转为十进制：8。所以输出8；
    // |:运算时均把运算数转换为二进制再做比较,规则：当两边操作数的位有一边为1时，结果为1，否则为0
    int a14 = 12 | 16; // 12 | 16转为二进制：1100|10000,比较结果为：11100转为十进制：28,,所以输出28
    // ^: 运算时均把运算数转换为二进制再做比较,规则：两边的位不同时，结果为1，否则为0
    int a15 = 12 ^ 2; // 12 ^ 2转为二进制：1100|10,比较结果为：1110转为十进制：14,,所以输出14


    // 三目运算符 ===================== 这是分割线 ==========================
    int a16 = 1;
    int a17 = 2;
    // 三目运算符首先第一个是关系运算符,如果关系运算符返回true则返回冒号前的值，如果为false则返回冒号后面的值。
    boolean b8 = a16 < a17 ? true : false; // 输出true


  }


}

关于算数运算符有几点需要注意：

• a++和++a的区别：a++属于后置自增，后置的意思是如果存在表达式的话会先计算表达式，再计算a+1, a--和--a也是类似的。下面看个代码例子：

package com.soft.hello;


public class Operator2Example {


  public static void main(String[] args) {


    int a = 10;


    // 先计算 a = a, 注意：基本类型是值类型而不是引用类型，所以a=a是将前面的变量a的值复制一份给新的a变量
    // 也就是说这里左边的a变量和前面定义的a变量在栈帧的局部变量表中是两个的变量
    // 然后再计算前面老的a变量a = a+1;
    a = a++;


    System.out.println(a); // 输出 10


    int b = 10;


    // 先计算 b = b+1,再计算 b = b;
    b = ++b;


    System.out.println(b); // 输出 11
  }


}

• a+=10和a=a+10的区别：当所有操作数类型相同时它们没什么区别，但如果操作数不相同则a+=10的方式会进行隐士类型转换而a=a+10的方式会报错，a-=10和a=a-10也是类似的。下面看个代码例子：
  

package com.soft.hello;


public class Operator3Example {


  public static void main(String[] args) {


    short s1 = 10;
    s1 += 10;
    System.out.println(s1); // 正常输出20;


    short s2 = 10;
    /**
     * 这里因为s2是short类型，而数字10默认是int类型。在java中，在s2+4时，会进行 自动类型转换 ，所以s2+4 会转换成int类型。
     * 而变量s2定义是short类型，将int 类型的s2+4赋值给short类型的s2 ,自然编译器就报错了。
     * 要手动进行类型转换才能避免编译期间的报错，例如改成：s2 = (short) (s2 + 10);但这种情况要人为确保不能超出short类型长度
     */
    s2 = s2 + 10; // 这一行会报错，


    System.out.println(s2);
  }


}

 

基本类型转换

在本章一开始就给出了Java内置的八大基本类型，这些基本类型可以互相转换，转换的原则是：取值范围向上转换是自动且安全的，向下转换需要强制且不安全。下面看几个代码例子：

package com.soft.hello;


public class TypeConvert {


  public static void main(String[] args) {


    // 原则：取值范围向上转换是自动且安全的，向下转换需要强制且不安全


    byte b = 100;


    int a = b; // 这行代码符合原则，可以直接转换


    byte b2 = a; // 这行代码不符合原则，int类型取值范围比byte类型要大（int转byte属于向下转换），编译器会报错，需要通过强制方式（byte b2 = （byte）a）进行转换，但强制转换需要注意溢出安全问题


    long l = a; // 这行代码符合原则，可以转换
    int a2 = l; // 这行代码不符合原则，long类型取值范围比int类型要大，编译器会报错,需要通过强制方式（int a2 = （long）l进行转换，但强制转换需要注意溢出安全问题）


    float f = 100;
    double d = f;// 这行代码符合原则，可以转换
    float f = d; // 这行代码不符合原则，double类型取值范围比float类型要大，编译器会报错,需要通过强制方式（float f = （float）d进行转换，但强制转换需要注意溢出安全问题）


  }


}

命名规范

这里主要介绍编写代码的命名规范，市面上主流的命名规范有两种，分别是：驼峰式和下划线式，它们的区别是多个单词的连接方式，驼峰式采用是将需要连接的单词首字母大写拼接起来，而下划线式采用下划线连接不同单词，全部单词均小写。在Java语言编程中，大部分程序员更喜欢使用驼峰式方式命名各种标识符（类、变量标识符、方法名等），对于Java来说驼峰式其实又被分为首字母是否大写，比如Java的class类命名官方强烈建议是采用首字母大写的驼峰式，而方法和变量的命名一般建议是首字母小写驼峰式（标准驼峰式）。下面看个代码例子：

package com.soft.hello;


//NameExample是类名标识符，采用的是首字母大写驼峰式
public class NameExample {


  // main是方法名，采用的是首字母小写驼峰式
  public static void main(String[] args) {


    // 定义男生数量整型变量（驼峰式，将需要连接的单词首字母大写拼接起来）
    int boysNumber = 20;


    // 定义女生数量整型变量（驼峰式，将需要连接的单词首字母大写拼接起来）
    int girlsNumber = 16;


    // 定义男生数量整型变量（下划线式,通过下划线连接不同单词，全部单词小写）
    int boys_number = 20;


    // 定义女生数量整型变量（下划线式,通过下划线连接不同单词，全部单词小写）
    int girls_number = 16;


  }


}

小结

本章我们主要学习Java语言开发规范基础相关的知识，具体包括：

1、介绍Java内置八大类型

2、介绍Java两种注释方式以及注释的作用

3、介绍Java块的定义和作用

4、介绍Java关键字概念

5、介绍Java四种不同的权限修饰符

6、介绍Java标识符定义规则

7、介绍Java变量定义和使用

8、介绍Java各种运算符

9、介绍Java基本类型互相装换规则

10、介绍Java命名规范

---------------------- 正文结束 ------------------------

长按扫码关注微信公众号

Java软件编程之家