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语言开发规范中默认定义了一系列关键字,例如classstaticpackageimportfinalmainvoid等等还有很多就不一一列举,每一个关键字对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-zA-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+=10a=a+10的区别:当所有操作数类型相同时它们没什么区别,但如果操作数不相同则a+=10的方式会进行隐士类型转换而a=a+10的方式会报错,a-=10a=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来说驼峰式其实又被分为首字母是否大写,比如Javaclass类命名官方强烈建议是采用首字母大写的驼峰式,而方法和变量的命名一般建议是首字母小写驼峰式(标准驼峰式)。下面看个代码例子:

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软件编程之家

发布了106 篇原创文章 · 获赞 8 · 访问量 3万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览