Java基础语法

最新推荐文章于 2023-06-25 18:58:57 发布

StartOn2020

最新推荐文章于 2023-06-25 18:58:57 发布

阅读量243

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/StartOn2020/article/details/105778372

版权

java基础专栏收录该内容

16 篇文章 0 订阅

订阅专栏

学习网站：狂神说Java：https://www.bilibili.com/video/BV12J41137hu?p=33

Java基础语法

1、注释、标识符、关键字

注释

不会被执行，写给写代码的人看的
书写注释是一个非常好的习惯

三种

单行注释
多行注释
文档注释

有趣的代码注释

idea设置注释样式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l0u6UxZD-1587909734290)(\pic\QQ截图20200425224849.png)]

标识符

什么是标识符

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Wd38V5KO-1587909734297)(C:\Users\Hpr\Desktop\求职之路\狂神学Java\pic\QQ截图20200425230314.png)]

标识符注意点

所有的标识符都应该以字母(a-z或者A-Z)、下划线（_）或者美元符($) 开头
首字母之后可以是字母(a-z或者A-Z)、下划线（_）、美元符($) 或者数字的任意字符组合
不能使用关键字作为变量名或方法名
标识符是大小写敏感的
可以用中文，但是不建议，不要用拼音

2、数据类型

强类型语言

要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用(安全性高，速度相对慢)

弱类型语言

VB,JS 没有严格意义上的区分例如 ’12‘+3 可以是数字123，也可以是字符串“123”

Java的数据类型分为两大类

基本类型（Primitive Type）

引用类型（Reference Type）类、接口、数组

什么是字节

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

整数拓展

进制

二进制0b
十进制
八进制0
十六进制0x 0~9 A~F

浮点数拓展

	        //=====================================================
        //浮点数拓展？        银行业务怎么表示？ 钱
        // BigDecimal       数学工具类
        //=====================================================
        //float 有限      离散       舍入误差      大约      接近但不等于
        //double
        //最好完全避免使用浮点数进行比较
        float f = 0.1f;
        double d = 1.0/10;

        System.out.println(f==d);//flase
        System.out.println(f);
        System.out.println(d);

        float d1 = 242342342342342342f;
        float d2 = d1 + 1;

        System.out.println(d1==d2);//true

字符类拓展

        //=====================================================
        //字符拓展？
        //=====================================================
        char c1 = 'a';
        char c2 = '中';

        System.out.println(c1);

        System.out.println((int)c1);//强制转换

        System.out.println(c2);

        System.out.println((int)c2);//强制转换


        //所有的字符本质还是数字
        //编码 Unicode表：97 = a   65 = A  2字节  0-65536   早期Excel最长   2^16 = 65536

        //U0000 UFFFF

        char c3 = '\u0061';  //Unicode 转义字符
        System.out.println(c3);
        System.out.println("=====================================================");

转义字符

        // \t 制表符
        // \n 换行符
        // ……

        System.out.println("Hello\tWorld");

        String sa = new String("hello world");
        String sb = new String("hello world");
        System.out.println(sa==sb);

        String sc = "hello world";
        String sd = "hello world";
        System.out.println(sc==sd);
        //对象    从内存分析
        System.out.println("=====================================================");

布尔类型

        //布尔值扩展
        boolean flag = true;
        if (flag==true){}//新手
        if(flag){ }//老手
        //Less is More! 代码要精简易读

3、类型转换

低----------------------------------------------------------->高

byte，short，char-> int -> long ->float ->double

运算中，不同类型的数据先转化为同一类型，然后进行运算
强制类型转换
自动类型转换

注意点：

不能对布尔值进行转换
不能把对象类型转换为不相干的类型
在把高容量转换到低容量的时候，强制转换
转换的时候可能存在内存溢出，或者精度问题！
操作比较大的时候，注意溢出问题

		int i = 128;
        byte b = (byte)i;//内存溢出
        double c = i ;
//        boolean d =i; //不能对布尔值进行转换

        //强制转化 （类型）变量名  高--低
        //自动转化 （类型）变量名  低--高

        System.out.println(i);
        System.out.println(b);
        System.out.println(c);

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

        System.out.println("=========================");
        System.out.println((int)23.7);//23
        System.out.println((int)-45.89f);//-45

        System.out.println("=========================");
        char d ='a';
        int e = d+1;
        System.out.println(e);
        System.out.println((char)e);

        //操作比较大的时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        System.out.println(money);

        int years = 20;
        int total = money*years;    //-1474836480,计算的时候溢出了
        long total2 = money*years;     //-1474836480,默认是int，转换之前已经出问题了
        long total3 = money*(long)years;


        System.out.println(total);
        System.out.println(total2);
        System.out.println(total3);

        // L l 后缀一定要大写的，免得和1混绕

4、变量、常量

变量

变量：可以改变的量(类比方程)
Java是一种强类型语言，每个变量都必须声明其类型
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型作用域（类比柜子，规定存放的东西的类型，取个名字，放不同的东西）

type varName [=value];

注意事项
- 每个变量都有类型，类型可以说基本类型，也可以是引用类型
- 变量名必须是合法的标识符
- 变量声明是一条完整的语句，因此每个声明都必须以分号结束
变量的作用域
- 类变量
- 实例变量
- 局部变量

public class Demo08 {



    //属性：变量

    //实例变量：从属于对象；如果不进行初始化，就会变成这个类型的默认值 0 0.0 u000
    //布尔值：默认是false
    //除了基本类型，其余的默认值都是null
    String name;
    int age;

    //类变量 static
    static double salary = 2500;


    //main方法
    public static void main(String[] args) {



        //局部变量：必须声明和初始化值
        int i = 10;

        System.out.println(i);

        //变量类型  变量名字 = new Demo08();
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.age);
        System.out.println(demo08.name);

        //类变量 static
        System.out.println(salary);

    }

    //其他方法
    public void add(){
//        System.out.println(i);
    }

}

常量

常量（Constant）：初始化后不能再改变值！不会变动的值。
所谓常量可以理解为特殊的变量，它的值被设置之后，在程序运行过程中不允许被改变
常量名一般使用大写字符

public class Demo09 {

    //修饰符，不存在先后顺序
    static final double PI = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);
    }
}

变量的命名规范

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

5、运算符

Java语言支持的运算符: 优先级（）

算术运算符：+、-、*、、、%，++，–
赋值运算符 =
关系运算符：>,<,>=,<=,==,!=,instanceof
逻辑运算符：&&，||，！
位运算符：&，|，^,~,>>,<<,>>>
<<表示左移移，不分正负数，低位补0；
>>表示右移，如果该数为正，则高位补0，若为负数，则高位补1；
表示无符号右移，也叫逻辑右移，即若该数为正，则高位补0，而若该数为负数，则右移后高位同样补0
条件运算符？：
扩展赋值运算符：+=，-=，*=，/=

        //二元运算符
        //Ctrl + D :复制当前行到下一行
        int a = 10;
        int b= 20;
        int c= 25;
        int d= 25;

        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);
        System.out.println(a/(double)d);

        long a =1231231231231L;
        int b = 123;
        short c = 10;
        byte d = 8;

        System.out.println(a+b+c+d);//Long
        System.out.println(b+c+d);//int
        System.out.println((c+d));//int

        //关系运算符返回的结果： 正确，错误 布尔值
        //if

        int a = 10;
        int b = 20;
        int c = 21;

        //取余:模运算
        System.out.println(c%a); // c/a 21 / 10 = 2 ... 1

        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);

++、–

        // ++ -- 自增，自减 一元运算符
        int a = 3;
        int b = a++;  // 执行完这行代码后，先给b赋值，再自增
        //a = a + 1;
        System.out.println(a);

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

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

逻辑运算符

        // 与（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)); //逻辑非运算：如果是真，则为假；如果是假，则为真

        //短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<4);
        System.out.println(d);
        System.out.println(c);

        /*
        A = 0011 1100
        B = 0000 1101
        --------------------
        A&B = 0000 1100
        A|B = 0011 1101
        A^B = 0011 0001
        ~B = 1111 0010

        2*8 = 16 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);

        int a = 10;
        int b = 20;
        
        a+=b;   //a = a+b
        a-=b;   //a = a-b

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

        // x ? y :z
        //如果x==true, 则结果为y,否则结果为z

        int score = 80;
        String type = score <60 ?"不及格":"及格";
        System.out.println(type);

6、包机制、JavaDoc

包机制

为了更好的组织类，提供了包机制，用于区别类名的命名空间
包语句的语法格式为：
- package pkg1[.pkg2[.pkg3…]];
一般利用公司域名倒置作为包名：com.kuangstudy.blog
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用“import"语句可完成此功能
- import pkg1[.pkg2[.pkg3…]];

JavaDoc

javadoc命令是用来生成自己的API文档的
参数信息
- @author 作者名
- @version 版本名
- @since 指明需要最早使用的jdk版本
- @param 参数
- @return 返回
- @throws 异常抛出情况

/**
 * @author PeiroJack
 * @version 1.0
 * @since 1.8
 * @create 2020-04-26 21:38
 */
public class Doc {

    String name;

    /**
     * @author PeiroJack
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
}

命令行生成

javadoc -encoding UTF-8 -charset UTF-8  Doc.java

使用IDEA生成JavaDoc文档！

StartOn2020

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础语法

学习网站：狂神说Java：https://www.bilibili.com/video/BV12J41137hu?p=33Java基础语法1、注释、标识符、关键字注释不会被执行，写给写代码的人看的书写注释是一个非常好的习惯三种单行注释多行注释文档注释有趣的代码注释idea设置注释样式[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l0u...
复制链接

扫一扫