Java基础-CSDN博客

本文链接：https://blog.csdn.net/m0_65678891/article/details/127156748

Java基础

标识注意点

所有的标识符都应该以字母（A-Z或者a-z）,美元（$）,或者下划线（_）开始
首字符之后可以是字母（A-Z或者a-z），美元（$）,下划线（_）或者数字的任何字符组合
不能使用使用关键字作为变量名或方法名
标识符是大小写敏感的
合法标识符举例：age,$salary,_value,__1_value
非法标识符举例：123abc,-salary,#abc
可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，很Low

数据类型

强类型语言

要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用

Java的数据类型分为两大类

基本类型
引用类型

在这里插入图片描述

什么是字节

位(bit):是计算机内部数据存储的的最小单位，11001100是一个八位二进制数
字节(byte):是计算机中数据处理的基本单位，习惯上用大写B来表示
1B(byte,字节) = 8bit（位）
字符：是指计算机中使用的字母，数字，字和符号

1bit表示1位
1Byte表示一个字节 1B=8b
1024B=1kb
1024kb=1M
1024M=1G

类型转换

由于Java是强类型语言，所以要进行有些运算的时候的，需要用到类型转换

在这里插入图片描述

运算中，不同类型的数据先转化为同一类型，然后进行运算
强制类型转换（由高 – 低） (类型)变量名
自动类型转换（由低 – 高）

类型强制转换的注意点：

1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.在把高容量转换到低容量的时候，强制转换
4.转换的时候可能存在内存溢出或者精度问题

       //内存溢出（强制类型转换）
        int i =128;
        byte b = (byte)i; //存在内存溢出 byte = -128 ~ 127
        System.out.println(i);
        System.out.println(b);

        输出结果：128  128

        //精度问题
        System.out.println((int)23.7);
        System.out.println((int)-45.89f);

        输出结果为 23  -45

        //自动类型转换
        char c = 'a';
        int d = c +1;
        System.out.println(c);
        System.out.println(d);

        输出结果：a  98

        //操作比较大的数的时候，注意内存溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money * years; //-1474836480 ,计算的时候溢出了
        long total2 = money * years; //默认是int，转换之前已经存在问题了
        long total3 = money * ((long)years); //先把一个数转换为Long
        System.out.println(total);
        System.out.println(total2);
        System.out.println(total3);

        输出的结果为：-1474836480  -1474836480  20000000000

变量

变量是什么：就是可以变化的量！
Java是一种强类型语言，每个变量都必须声名其类型
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域

在这里插入图片描述

注意事项：

每个变量都有类型，类型可以是基本类型，也可以是引用类型
变量名必须是合法的标识符
变量声明是一条完整的语句，因此每一个声明都必须以分号结束

        //变量的声明
        int a =1, b=2;
        String name = "zhangsan";
        char x = 'x';
        double pi = 3.14;

作用域

类变量
实例变量
局部变量

public class Variable{
    static int allClicks = 0;  //类变量  加了static 而且它会随着Variable这个类消失而消失
    
    String str = "hello world"  //实例变量：从属于对象  
    /*不自行初始化的类型都会使用默认值，
    例如：int类型的默认值为 0  
    double 默认值为：0.0
    布尔值：默认是false
    除了基本类型，其余的默认值都是为：null
    */   
    int age;  //实例变量
    
    public void method(){
        int i = 0;  //局部变量； 必须声明和初始化值
    }
}

常量

常量：初始化后不能再被改变值！不会变动的值
所谓常量可以理解成一种特殊的变量，它的值被设定后，再程序运行过程中不允许被改变

在这里插入图片描述

常量名一般使用大写字符

    //修饰符，不存在先后顺序（变量类型（double）前面都是修饰符）
    static final double PI = 3.14;

变量的命名规范

所有变量，方法，类名：见名知意
类成员变量：首字母小写和驼峰命名原则：monthSalary
局部变量：首字母小写和驼峰命名原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰命名原则：Man,GoodMan
方法名：首字母小写和驼峰命名原则：run(),runRun()

Java语言支持如下运算

优先级最高为括号（）

算术运算符：+ ，- ，*，/，%，++，–
赋值运算符=
关系运算符：> , < , >= , <= , !=
逻辑运算符：&&，||，！
位运算符：&，| ，^ , ~ , >> ，<< , >>>(了解！！！)
条件运算符：? , :
扩展赋值运算符：+= ，-= ，*= ，/=

        long a = 123123123L;
        int b = 123;
        short c = 10;
        byte d = 8;
        double f = 10.25;

        System.out.println(a+b+c+d); //long
        System.out.println(b+c+d);   //int
        System.out.println(c+d);     //int
        System.out.println(b+c+d+f); //double
        System.out.println(b+f);     //double

        输出结果为：123123264  141  18  151.25  133.25

结论：如果数值类型相加，有一个类型为Long的话，那么结果类型为Long类型

如果数值类型相加，没有类型为Long或double的话，那么结果类型为int类型

如果数值类型相加，有一个类型为double的话，那么结果类型为double类型

        //++   --   自增， 自减   一元运算符
        int a = 3;

        int b = a++; //执行完这行代码后，先给b赋值，再自增

        System.out.println(a); // 4

        int c = ++a; //执行完这行代码前，先自增，再给b赋值

        System.out.println(a); //5
        System.out.println(b); //3
        System.out.println(c); //5

        //幂运算 2^3 2*2*2 = 8  很多运算，我们会使用一些工具类来操作
        double pow = Math.pow(2, 3);
        System.out.println(pow);  //结果为：8.0

        // 与（and）  或（or）  非（取反）
        boolean a = true;
        boolean b = false;

        System.out.println("a && b ：" + (a && b)); //逻辑与运算：两个变量都为真，结果才为true
        System.out.println("a || b ：" + (a || b)); //逻辑或运算：两个变量有一个为真，则结果才为true
        System.out.println("! (a && b):" + !(a && b)); //如果是真则变假，如果是假则变为真

        /*
           输出结果为: a && b ：false
                     a || b ：true
                     ! (a && b):true
         */

        //短路运算
        int c = 5;
        boolean d = (c < 4) && (c++ < 4);   //因为c<4输出是false，已经满足了逻辑与运算，所以后面的c++不执行
        System.out.println(d); //false
        System.out.println(c); //5

        位运算符
        /*
        A = 0011 1100
        B = 0000 1101

        A & B = 0000 1100  //位运算，两个都为1则为1
        A | B = 0011 1101  //与运算，两个都为0则为0
        A ^ B = 0011 0001  //异或运算，两个相同则为0，否则为1
        ~B = 1111 0010     //取反

        2*8 = 16  2*2*2*2
        //位运算效率极高！！！
        <<   *2    向左移相当于乘2
        >>   /2    向右移相当于除2

        0000 0000     0
        0000 0001     1
        0000 0010     2
        0000 0011     3
        0000 0100     4
        0000 1000     8
        0001 0000     16
        */

        System.out.println(2<<3);  //16

字符串连接符 + ，string

        int a = 10;
        int b = 20;

        //字符串连接符   +   ，string
        //在运算符加号（+）的一方出现string类型，它都会把它们转换为String进行连接
        //如果字符串在前面的就进行拼接，如果字符串在后面的就进行运算
        System.out.println(""+a+b);  //1020
        System.out.println(a+b+"");  //30

包机制

为了更好地组织类，Java提供了包机制，用于区别类名的命名空间
包语句的语法格式为：

package pkg1[. pkg2[. pkg3..]];

一般利用公司域名倒置作为包名 com.baidu.xx
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包，使用“import”语句可完成此功能

import package[. package2..].(classname|*);

JavaDoc

Javadoc命令是用来生成自己API文档的+
参数信息

@author 作者名

@version 版本号

@since 指明需要最早使用的jdk版本

@param 参数名

@return 返回值情况

@throws 异常抛出情况