JAVA基础知识

最新推荐文章于 2024-07-18 20:13:39 发布

华之都

最新推荐文章于 2024-07-18 20:13:39 发布

阅读量100

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/wang1444783135/article/details/125352621

版权

JAVA基础知识

1.注释符，标识符，关键词

(1)Java注释有三种

单行注释 //+注释
多行注释 /* 注释*/
文档注释 /** 注释 */

(2)标识符

关键词

(3)标识符的注意点

所有的标识符都应该以字母（A-Z或者a-z)，美元符号($),或者下划线(_)
首字母之后可以是字母(A-Z或者a-z),美元符号($),或者下划线(_),或者数字的任何组成
不能使用关键词作为变量名
标识符是大小写敏感

2.数据类型

强类型语言

要求变量的使用要严格符合规定，所有变量必须先定义才能使用
弱类型语

(1)Java的数据类型分为两大类

基本类型
引用类型

  //八大基本数据类型
        //整数
        int num1=10;
        byte num2=20;
        short num3=30;
        long num4=40L;//Long类型要在数据后面加上一个L

        //小数，浮点数
        float num5=50.8f;//float要在数据后面加上一个f
        double num6=3.14159265358793228462643;

        //字符
        char num7='A';
        //字符串，String不是关键词，是类
        String name="AA";

        //布尔值:是非
        Boolean flag=true;//=flase

(2)什么是字节?

位：是计算机内部数据储存的最小单位

字节：是计算机数据处理的基本单位

1bie表示一位
1Byte表示一个字节1B=8b
1024B=1KB
1024KB=1MB
1024MB=1G

电脑的32位和64位有什么区别？

3.数据类型扩展

public class Demo02 {
    public static void main(String[] args) {
//整数拓展
        int i=10;
        int i2=010;//八进制
        int i3=0x10;//十六进制
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
//=======================================================================================
//浮点数拓展 float有限，离散，舍入误差，大约，接近但不等于 double
        float f=0.1f;//0.1
        double d=1.0/10;//0.1
        System.out.println(f==d);
        System.out.println(f);
        System.out.println(d);
//=======================================================================================
//字符拓展
        char c1='a';
        char c2='中';
        System.out.println(c1);
        System.out.println(c2);
        System.out.println((int)c1);
        System.out.println((int)c2);
//=======================================================================================

4.类型转换

由于java是强类型语言，所有要进行有些运算的时候的，需要用到类型转换。（数据精度由低到高）
运算中，不同类型的数据先转换同一类型，然后进行运算。

public class Demo05 {
    public static void main(String[] args) {
        int i=128;
        byte b=(byte) i;
        System.out.println(i);
        System.out.println(b);//内存溢出

        //强制类型转换（类型）变量名   高到低
        //自动转换   低到高
        /*
        注意点
        1.不能对布尔值进行转换
        2.不能把对象类型转换为不相干类型
        3.把高容量转换到低容量的时候，强制转换
        4.转换的时候可能存在内存溢出，精度问题
         */
        System.out.println((int)23.7);//23
        System.out.println((int)-45.7f);//-45

        char c='a';
        int d=c+1;
        System.out.println(c);
        System.out.println((char)d);
        System.out.println(d);
        System.out.println((int)c);
    }
}

public class Demo06 {
    public static void main(String[] args) {
        int money=1000000000;
        int year =20;
        int total=money*year;
        long total2=money*year;
        long total3=money*((long)year);
        System.out.println(total);//-1474836480,计算溢出了
        System.out.println(total2);//-1474836480,默认是int，转换之前已经存在问题了
        System.out.println(total3);

    }
}

5.变量，常量，作用域

(1)变量

变量是可以变换的量
Java是一种强类型语言。每个变量必须声明其类型
Java变量是程序中最基本的储存单位，其要素包括变量名，变量类型和作用域

注意事项

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

(2)变量作用域

类变量
实例变量
局部变量

(3)常量

常量：初始化后不能再改变值!不会变动的值。

所谓常量可以理解成一种特殊的变量，它的值被设定后，再程序运行过程中不允许改变。

public class Demo09 {
    static final double PI=3.14;//全局变量
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

常量字符一般用大写字母表示就可以

(4)变量的命名规范

所有变量，方法，类名：见名知意
类成员变量：首字母小写和驼峰原则:monthSalary除了第一个单词外，后面单词的首字母大写
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man，GoodMan
方法名：首字母小写和驼峰原则：run(),runRun()

6.基本运算符

(1)算术运算符+，-,*,/,%

public class Demo01 {
    public static void main(String[] args) {
        //二元运算符
        int a=10;
        int b=20;
        int c=30;
        int d=40;
        int e=3;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);//0
        System.out.println((double) a/b);//0.5
        System.out.println((float) a/b);//0.5
        System.out.println(a%e);//1
        System.out.println(b%e);//2
        System.out.println(c%e);//0
        System.out.println(d%e);//1
    }
}

(2)自加++，自减–，幂运算

public class Demo04 {
    public static void main(String[] args) {
        //自增++,自减--   一元运算符
        int a=3;
        int b=a++;//执行这行代码后，先给b赋值，再自增（此时b=3，a=4）
        //a++    a=a+1
        System.out.println(a);//4
        //++a    a=a+1
        int c=++a;//执行这行代码前，先自增，再给c赋值（此时a=5，c=5）
        System.out.println(a);//5
        System.out.println(b);//3
        System.out.println(c);//5

        int d=4;
        int e=d--;//执行这行代码后,先给e赋值，再自减（此时e=4，d=3）
        //d--    d=d-1
        System.out.println(d);//3
        //--d    d=d-1
        int f=--d;//执行这行代码前，先自减，再给f赋值（此时d=2，d=2）
        System.out.println(d);//2
        System.out.println(e);//4
        System.out.println(f);//2

        //幂运算
        double z=Math.pow(2,3);
        System.out.println(z);
        double v=Math.pow(3,3);
        System.out.println(v);

    }
}

赋值运算符=

(3)关系运算符>,<,>=,<=,==,!=,instanceof

//关系运算符
package operator;

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符返回值的结果：正确，错误
        int a=10;
        int b=20;
        System.out.println(a==b);//false
        System.out.println(a>b);//false
        System.out.println(a<b);//true
        System.out.println(a!=b);//true
    }
}

(4)逻辑运算符&&,||,!

//逻辑运算符
public class Demo05 {
    public static void main(String[] args) {
        //与（and），或（or），非（相反）
        boolean a =true;
        boolean b =false;
        System.out.println(a&&b);//false,同真为真，一假则假
        System.out.println(a||b);//true，一真则真，同假则假
        System.out.println(!(a&&b));//true，如果是真，则变为假；如果是假，则变为真

        //短路运算
        int c=5;
        boolean d=(c<4)&&(c++<4);//由于c<4为假，则c++不执行
        System.out.println(c);//5
        boolean e=(c>4)&&(c++>4);//由于c>4为真，执行c++
        System.out.println(c);//6
        System.out.println(d);//false
        System.out.println(e);//true

        int m=5;
        boolean z=(m>4)&&(m-->5);//由于m>4为真，执行m--
        System.out.println(m);//4
        System.out.println(z);//flase
        
    }


}

(5)位运算符&,|,^,>>,<<,>>>

public class Demo06 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101
        A&B 0000 1100     (两者只要有一个0，则就是0)
        A|B 0011 1101     (两者只要有一个1，则就是1)
        A^B 0011 0001     (两者相同为0，两者不同为1)
        ~B  1111 0010     (与本身相反)

        2*8=16  如何计算最快 2*2*2*2
        <<左移
        >>右移
        0000 0000   0     0000 1001   9              
        0000 0001   1     0000 1010   10
        0000 0010   2     0000 1011   11
        0000 0011   3     0000 1100   12
        0000 0100   4     0000 1101   13
        0000 0101   5     0000 1110   14
        0000 0110   6     0000 1111   15
        0000 0111   7     0001 0000   16
        0000 1000   8 
         */
        System.out.println(2<<3);//16
    }
}

(6)扩展赋值运算符+=,-=,*=,/=

public class Demo07 {
    public static void main(String[] args) {
        int a =10;
        int b =20;

        a+=b;//a=a+b
        a-=b;//a=a-b
        System.out.println(a);//10

        //字符串连接符    + ,String
        System.out.println(a+b);//10
        System.out.println(""+a+b);//1020
        System.out.println(a+b+"");//30
    }
}

(7)条件运算符?,;

//三元运算符
public class Demo08 {
    public static void main(String[] args) {
        //x?y:z
        //如果x==true,则结果为y,否则结果为z
        int score=80;
        String type=score>60?"及格":"不及格";
        System.out.println(type);//及格

    }

}

7.包机制

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

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

一般利用公司域名倒置作为包名；
为了能够使用某一个包的成员，我们需要在java程序中明确导入该包，使用"import"语句可以完成此功能。

import package1[.package2...].(classmane|*);

8.JavaDoc生成文档

javadoc命名是用来生成自己的API文档的

参数信息

            1. @author 作者名
            2. @version 版本号
            3. @since 指明最早使用的jdk版本
            4. @param 参数名
            5. @return 返回值情况
            6. @throws 异常抛出情况

华之都

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
JAVA基础知识

强类型语言要求变量的使用要严格符合规定，所有变量必须先定义才能使用弱类型语(2)什么是字节?位：是计算机内部数据储存的最小单位字节：是计算机数据处理的基本单位1bie表示一位1Byte表示一个字节1B=8b1024B=1KB1024KB=1MB1024MB=1G电脑的32位和64位有什么区别？4.类型转换由于java是强类型语言，所有要进行有些运算的时候的，需要用到类型转换。（数据精度由低到高）运算中，不同类型的数据先转换同一类型，然后进行运算。5.变量，常量，作用域(1)变量变量
复制链接

扫一扫