Java学习笔记（1）

注释

  • 平时编写代码，在代码量比较少的时候，我们还可以自己看懂自己写的，但是但项目结构一旦复杂起来，我们就需要用到注释了

  • 注释不会被执行，是给我们写代码的人看的

  • 书写注释是一个非常好的习惯

Java中的注释有三种

  1. 单行注释

    //此处书写单行注释

  2. 多行注释

    /*此处
  书写
  多行
  注释*/

  3. 文档注释

    /**此处书写文档注释*/

标识符

  • Java中的所有组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

  • 所有的标识符都应该以字母（A-Z或者a-z)、美元符（$）、下划线（_）开始

  • 首字符之后可以是字母（A-Z或者a-z)、美元符（$）、下划线（_）或数字的任何字符组合

  • 不能使用关键字作为变量名或方法名

  • 标识符是大小写敏感的

  • 合法标识符举例：age、$salary、_value、__1_value等

  • 非法标识符举例：123abc、-salary、#abc等

  • 可以使用中文命名，但是一般不建议去使用中文，也不建议使用拼音，很Low

关键字

abstract assert boolean break byte
case catch char class const
continue default do double else
enum extends final finally float
for goto if implements import
instanceof int interface long native
new package private protected public
return strictfp short static super
switch synchronized this throw throws
transient try void volatile while

数据类型

内置数据类型（基本类型）

Java有8种基本类型：6种数字类型（4个整数型，2个浮点型），1种字符类型，还有1种布尔型

Java数据类型

  1. byte

    • 占1个字节（8位）
    • 有符号的以二进制补码表示的整数
    • 最小值是-128(-2^7)
    • 最大值是127(2^7-1)
    • 默认值是0
    • byte类型用在大型数组中节省空间，主要代替整数，因为byte类型占用的空间是int类型的1/4

  2. short

    • 占2个字节（16位）
    • 有符号的以二进制补码表示的整数
    • 最小值是-32768(-2^15)
    • 最大值是32767(2^15-1)
    • 默认值是0
    • short类型也可以节省空间（类似于byte类型），short类型占用的空间是int类型的1/2

  3. int

    • 占4个字节（32位）
    • 有符号的以二进制补码表示的整数
    • 最小值是-2 147 483 648(-2^31)
    • 最大值是2 147 483 647(2^31-1)
    • 一般整数型变量默认位int类型
    • 默认值是0

  4. long

    • 占8个字节（64位）

    • 有符号的以二进制补码表示的整数

    • 最小值是-9 223 372 036 854 775 808(-2^63)

    • 最大值是9 223 372 036 854 775 807(2^63-1)

    • 主要使用在需要较大整数的系统中

    • 默认值是0L

    • 注意要在整数后面添加L，表示此整数是long类型

      例: long a = 100000L,long b = -200000L

    • L不区分大小写，但是小写字母l容易与数字1混淆，所以一般写作大写字母L

  5. float

    • 占4个字节（32位）

    • 单精度的符合IEEE 754标准的浮点数

    • 默认值是0.0f

    • float在储存大型浮点数组的时候可以节省内存空间

    • float类型的浮点数不能表示精确的值（例如货币）

    • 注意在浮点数的后面添加f或F，表示此浮点数是float类型

      例如：float f = 123.4f

  6. double

    • 占8个字节（64位）

    • 双精度的符合IEEE 754标准的浮点数

    • 浮点数的默认类型是double类型

    • 默认值是0.0d

    • double类型的浮点数也不能表示精确的值（例如货币）

    • double类型的浮点数后面可以不添加d或D

      例如：double d = 123.4

  7. char

    • char类型是一个单一的16位Unicode字符

    • 最小值是\u0000（即0）

    • 最大值是\uffff（即65535）

    • char数据类型可以存储任何字符

      例如：char letter = A

  8. boolean

    • boolean类型表示一位的信息

    • 只有两个取值：false和true

    • boolean类型只是记录false/true情况的一种标志

      例如：boolean one = ture

    • 默认值是false

基本数据类型的取值范围已经以常量的形式定义在对应的包装类中了

public class PrimitiveValueType {
    public static void main(String[] args) {
        //byte
        System.out.println("基本类型:byte 二进制位数" + Byte.SIZE);
        System.out.println("包装类:java.lang.Byte");
        System.out.println("最小值:Byte.MIN_VALUE=" + Byte.MIN_VALUE);
        System.out.println("最大值:Byte.MAX_VALUE=" + Byte.MAX_VALUE);
        System.out.println();

        //short
        System.out.println("基本类型:short 二进制位数" + Short.SIZE);
        System.out.println("包装类:java.lang.Short");
        System.out.println("最小值:Short.MIN_VALUE=" + Short.MIN_VALUE);
        System.out.println("最大值:Short.MAX_VALUE=" + Short.MAX_VALUE);
        System.out.println();

        //int
        System.out.println("基本类型:int 二进制位数" + Integer.SIZE);
        System.out.println("包装类:java.lang.Integer");
        System.out.println("最小值:Integer.MIN_VALUE=" + Integer.MIN_VALUE);
        System.out.println("最大值:Integer.MAX_VALUE=" + Integer.MAX_VALUE);
        System.out.println();

        //long
        System.out.println("基本类型:long 二进制位数" + Long.SIZE);
        System.out.println("包装类:java.lang.Long");
        System.out.println("最小值:Long.MIN_VALUE=" + Long.MIN_VALUE);
        System.out.println("最大值:Long.MAX_VALUE=" + Long.MAX_VALUE);
        System.out.println();

        //float
        System.out.println("基本类型:float 二进制位数" + Float.SIZE);
        System.out.println("包装类:java.lang.Float");
        System.out.println("最小值:Float.MIN_VALUE=" + Float.MIN_VALUE);
        System.out.println("最大值:Float.MAX_VALUE=" + Float.MAX_VALUE);
        System.out.println();

        //double
        System.out.println("基本类型:double 二进制位数" + Double.SIZE);
        System.out.println("包装类:java.lang.Double");
        System.out.println("最小值:Double.MIN_VALUE=" + Double.MIN_VALUE);
        System.out.println("最大值:Double.MAX_VALUE=" + Double.MAX_VALUE);
        System.out.println();

        //char
        System.out.println("基本类型:char 二进制位数" + Character.SIZE);
        System.out.println("包装类:java.lang.Character");
        System.out.println("最小值:Character.MIN_VALUE=" + (int)Character.MIN_VALUE);
        //将Character.MIN_VALUE由字符形式转换为数值形式并输出
        System.out.println("最大值:Character.MAX_VALUE=" + (int)Character.MAX_VALUE);
        //将Character.MAX_VALUE由字符形式转换为数值形式并输出
    }
}

运行结果如下

基本类型:byte 二进制位数8
包装类:java.lang.Byte
最小值:Byte.MIN_VALUE=-128
最大值:Byte.MAX_VALUE=127

基本类型:short 二进制位数16
包装类:java.lang.Short
最小值:Short.MIN_VALUE=-32768
最大值:Short.MAX_VALUE=32767

基本类型:int 二进制位数32
包装类:java.lang.Integer
最小值:Integer.MIN_VALUE=-2147483648
最大值:Integer.MAX_VALUE=2147483647

基本类型:long 二进制位数64
包装类:java.lang.Long
最小值:Long.MIN_VALUE=-9223372036854775808
最大值:Long.MAX_VALUE=9223372036854775807

基本类型:float 二进制位数32
包装类:java.lang.Float
最小值:Float.MIN_VALUE=1.4E-45
最大值:Float.MAX_VALUE=3.4028235E38

基本类型:double 二进制位数64
包装类:java.lang.Double
最小值:Double.MIN_VALUE=4.9E-324
最大值:Double.MAX_VALUE=1.7976931348623157E308

基本类型:char 二进制位数16
包装类:java.lang.Character
最小值:Character.MIN_VALUE=0
最大值:Character.MAX_VALUE=65535

Float和Double的最小值和最大值都是以科学记数法的形式输出的，结尾的"E+数字"表示E之前的数字要乘以10的多少次方

例如：3.141E3是3.141× 10^3 =3141，3.141E-3 是 3.141 x 10^-3 =0.003141

引用类型

  • Java的引用类型有三种，分别是类(class)、接口(interface)、数组（array）
  • 所有引用数据类型的默认值都是null
  • 一个引用变量可以用来引用任何与之兼容的类型
  • 引用类型的变量类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，例如 String、User、Employee、Puppy等。变量一旦声明后，类型就不能被改变了。
  • 除了内置数据类型（基本类型），都是引用类型

类型转换

不同类型的数据可以混合运算，但在运算中，不同类型的数据先转化为同一类型，然后进行运算

  • 不能对boolean类型进行类型转换
  • 不能把对象类型转换成不相关类的对象
  • 在把容量大的类型转换为容量小的类型时必须使用强制类型转换
  • 转换过程中可能导致溢出或精度损失
  • 浮点数到整数的转换是通过舍弃小数部分，而不是四舍五入
  • char类型进行了数学运算，那么字符就会按照一定的规则翻译成为一个数字

自动数型转换

  • 转换从低级到高级

    低-------->-------->-------->-------->高
byte,short,char,-->int-->long-->float-->double

  • 必须满足转换前的数据类型的位数要低于转换后的数据类型

  • byte/short/char这三种类型都可以发生数学运算

  • byte/short/char这三种类型在运算的时候，都会被自动转换为int类型，然后再计算

    例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型；同样float数据类型的位数为32，可以自动转换为64位的double类型

public class AutomaticNumberTypeConversion {
    public static void main(String[] args) {
        char c1 ='a';//定义一个char类型
        int i1 = c1;//char类型自动转换为int类型
        System.out.println("char类型a自动转换为int类型后的值为" +i1);
        char c2 ='A';//定义一个char类型
        int i2 = c2+1;//char类型自动转换为int类型后，与int类型相加
        System.out.println("char类型A与int类型1相加后的值等于" +i2);
    }
}

运行结果如下

char类型a自动转换为int类型后的值为97
char类型A与int类型1相加后的值等于66

c1的值为字符 a ,查 ASCII 码表可知对应的 int类型值为 97，A对应值为 65，所以 i2=65+1=66

强制数型转换

  • 转换的数据类型必须是兼容的

  • 格式：(type)value

    type是转换后的数据类型

  • 强制类型转换一般不推荐使用,因为有可能发生精度损失、数据溢出

    例如：int类型强制转换为short类型，必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据溢出；浮点数转换为整数时，会舍弃小数部分，可能造成精度损失

public class ForcedNumberTypeConversion {
    public static void main(String[] args) {
        int i1 = 111;
        byte b1 = (byte)i1;
        System.out.println("int类型i1强制转换为byte类型后的值为" +b1);

        //数据溢出
        int i2 = 128;
        byte b2 = (byte)i2;
        System.out.println("int类型i2强制转换为byte类型后的值为" +b2);

        //精度损失
        float f = 33.77f;
        int i3 = (int)f;
        System.out.println("float类型f强制转化为int类型后的值为" +i3);

        double d = 333.777;
        int i4 = (int)d;
        System.out.println("double类型d强制转换为int类型后的值为" +i4);
    }
}

运行结果如下

int类型i1强制转换为byte类型后的值为111
int类型i2强制转换为byte类型后的值为-128
float类型f强制转化为int类型后的值为33
double类型d强制转换为int类型后的值为333

  • 因为 byte 类型是 8 位，最大值为127，所以当int类型强制转换为 byte类型时，值 128 超过byte类型的最大值，导致数据溢出，从而输出结果为-128

  • 可以看到浮点数到整数的转换是通过舍弃小数部分，而不是四舍五入

变量

在Java语言中，所有的变量在使用前必须声明

Java语言支持的变量类型有：

  • 类变量（静态变量）：独立于方法之外的变量，用 static 修饰
  • 实例变量：独立于方法之外的变量，不过没有 static 修饰
  • 局部变量：类的方法中的变量

类变量（静态变量）

  • 类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外
  • 无论一个类创建了多少个对象，类只拥有类变量的一份拷贝
  • 静态变量除了被声明为常量外很少使用，静态变量是指声明为 public/private，final 和 static 类型的变量。静态变量初始化后不可改变
  • 储存在静态存储区。经常被声明为常量，很少单独使用 static 声明变量
  • 在第一次被访问时创建，在程序结束时销毁
  • 与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为 public 类型
  • 默认值和实例变量相似。数值型变量默认值是 0，布尔型默认值是 false，引用类型默认值是 null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化
  • 可以通过：ClassName.VariableName的方式访问
  • 类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。如果静态变量不是 public 和 final 类型，其命名方式与实例变量以及局部变量的命名方式一致

实例变量

  • 实例变量声明在一个类中，但在方法、构造方法和语句块之外；
  • 当一个对象被实例化之后，每个实例变量的值就跟着确定；
  • 在对象创建的时候创建，在对象被销毁的时候销毁；
  • 实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
  • 可以声明在使用前或者使用后；
  • 访问修饰符可以修饰实例变量；
  • 实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
  • 实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
  • 可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName

局部变量

  • 局部变量声明在方法、构造方法或者语句块中
  • 在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁
  • 访问修饰符不能用于局部变量
  • 只在声明它的方法、构造方法或者语句块中可见
  • 是在栈上分配的
  • 没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用
posted @ 2021-03-18 23:28  Reflily  阅读(49)  评论(0)    收藏  举报