狂神说Java课堂随记——基础

最新推荐文章于 2024-06-19 19:40:06 发布

Harold_ZNYH

最新推荐文章于 2024-06-19 19:40:06 发布

阅读量235

点赞数

分类专栏： Java 学习文章标签：学习 java

本文链接：https://blog.csdn.net/Ian_ZNYH/article/details/122989775

版权

Java 学习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

注释、标识符、关键字

注释Comment

注意：为了方便项目的管理，我们建一个Empty Project，之后我面便要关心Project Structure，配置好环境变量，然后再External Libraries（外部库）新建module（模块）来创建一个个java modules

		 //single-line comment
        /*
        multiline comment
         */
          /**Javadoc：文档注释
         * @Description HelloWorld
         * @Author QJJ
         */

标识符Identifier和关键字Keyword

类名、变量名和方法名都被称为标识符
合法的标识符：age、$salary、_monthly
关键字大全，不能使用关键字作为变量名或者方法名

标识符命名规则：首字符：英文字幕大小写，$，_开始，
首字符之后可以是前三者+数字

（其实中文可以放在标识符任意位置的，只是这样不规范，我们一般都不这样做)

数据类型讲解

Java、C++都属于强类型语言（安全性比较高，但工程速度可能要慢一点），所有变量都必须先定义后才能使用
bit（位）：是子算计内部数据储存的最小单位；byte（字节）：是计算机中数据处理的基本单位，用B表示；1B = 8bit
bit<B<KB<MB<GB<TB
Java的数据分为两大类型**（待补充）*
Primitive Type（基本数据类型）

//八大基本数据类型
      System.out.println("======整数类型======");
      int num1 = 10;
      byte num2 = 30;
      //byte num = 129;  太大了，1byte有效bit只有7个，承受不了那么大
      short num3 = 30;
      long num4 = 30L;   //long类型要在数字后加一个L

      System.out.println("======浮点类型======");
      float num5 = 50.1F;  //float类型要在数字后加一个F
      double num6 = 3.1415926535;

      System.out.println("======字符类型======");
      char name1 = '邱';    //character字符——一个字
      String name2 = "邱俊杰";  //character string字符串——一堆字 **String不同于其它基本数据类型，它是类，不是关键字**

      //布尔值:true or false
      boolean flag = true;
      System.out.println("非常重要：虽然七个数据类型都是用关键字来定义变量的，但其实它们都对应了一个类，可以通过**大写首字母来打出**");
      Integer num10 = 8;

  1. Reference Type（引用数据类型）

2. 关于数据类型的一些补充：

//整数拓展——进制问题：二进制0b 八进制0 十进制 十六进制0x
        int i = 0b10;
        int i2 = 010;
        int i3 = 10;
        int i4 = 0x10; //十六进制的表示：0-9 A-F
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);

        System.out.println("=====================================================================");
        //浮点数拓展——银行业务怎么表示？  浮点数是离散的，会有精度损失，所以最好完全避免使用浮点数进行比较，一般用BigDecimal这样的数学工具类来进行比较
        float f = 0.1f;
        double d = 1.0/10;
        double e = 1/10;
        System.out.println(f);    //0.1
        System.out.println(d);    //0.1
        System.out.println(e);    //0
        System.out.println(f==d); //false f:0.1 d:0.1

        float d1 = 2313131111111111f;
        float d2 = d1+1;
        System.out.println(d1==d2);  //true

        System.out.println("======================================");
        //字符拓展？
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int)c1);     //强制转型
        System.out.println(c2);
        System.out.println((int)c2);     //强制转型
        //所有字符的本质还是数字
        //Unicode编码表查询对应关系
        char c3 = '\u0061';
        System.out.println(c3);  //a

        //转义字符
        System.out.println("Hello\tWorld"); //制表符tab
        System.out.println("Hello\bWorld"); //退格
        System.out.println("Hello\nWorld"); //换行:换到当前位置的下一行，而不会回到行首
        System.out.println("Hello\rWorld"); //回车:回到当前行的行首，而不会换到下一行，如果接着输出的话，本行以前的内容会被逐一覆盖
        System.out.println("Hello\"W\'o\\rld"); //双引号&单引号&反斜杠

        //布尔值扩展
        boolean flag = true;
        if (flag==true) {}          //新手
        if (flag) {}                //老手：和flag==true意思一样
        
        //小彩蛋：对象 从内存分析
        System.out.println("==================================");
        String sa = new String("Hello You");
        String sb = new String("Hello You");
        System.out.println(sa==sb);

        String sc = "Hello hey";
        String sd = "Hello hey";
        System.out.println(sc==sd);          //false

类型转换

由于Java是强类型语言，所以近些某些运算的时候，需要用到类型转换
运算中，不同类型的数据先转化为同一类型，再进行运算
1. 类型从低到高：byte<short, char<int<long<float<double

 int i = 128;
        Byte b = (byte)i;          //强制转型:(类型）变量名  高——低
        System.out.println(i);
        System.out.println(b);     //-128；内存溢出
        double d = i;              //自动转型             低——高
        System.out.println(d);     //128.0
        /*注意点：
        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 c = 'a';
        int i2 = c+1;
        System.out.println(i2);         //98
        System.out.println((char)i2);   //b        //类型转换时对应的unicode编码不变

        System.out.println("==========================");
        int money = 10_0000_0000;                  //JDK7的新特性，数字之间可以用下划线分割
        int years = 20;
        int total = money*years;                   //计算的时候发生了溢出
        long total2 = money*years;                  //默认是int，所以money*year计算好后的结果首先变成int类型，此时已经发生溢出了
        long total3 = money*((long)years);          //先把一个数转换成long，则计算好的结果直接就是long类型了
        long total4 = ((long)money)*years;          //先把一个数转换成long，则计算好的结果直接就是long类型了
        System.out.println(total);                  //-1474836480
        System.out.println(total2);                 //-1474836480
        System.out.println(total3);                 //20000000000
        System.out.println(total4);                 //20000000000

变量、常量和作用域

变量

定义：可以变化的两
Java时一种强类型语言，每个变量都必须申明其类型
Java变量是程序中最基本的储存单元，其要素包括变量类型、变量名和作用域

type varName [=value] [{,varName[=value]}];
//数据类型 变量名 = 值；可以实用都好隔开来声明多个同类型变量
	int a = 1, b = 2, c = 3; //程序可读性较差
	System.out.println(a); //1
	System.out.println(b); //2
	System.out.println(c); //3
/*注意事项
1.每个变量都有类型，可以是基本类型或引用类型（如String）
2.变量名必须是合法的标识符
3.变量声明是一个完整的语句，因此每一个声明必须以分号结束

变量按作用域分类有一下三种：

类变量
实例变量
局部变量

public class VariateConstantActionScope {           //class的属性：变量
    String name;
    int age;                                        //实例变量：类里面，方法外面，作用域为整个类；从属于对象（本例：该class）；如果不自行初始化，就会输出该类型的默认值(0 0.0 null 布尔值：false)，除了基本数据类型，其余类型的默认值都是null
    static double salary = 50000;                   //类变量：实例变量前加一个static，作用域为整个类，暂时都用它而不用实例变量，学习面向对象时会进一步解释
    public static void main(String[] args) {
        int i;                   //局部变量：在方法两个大括号之间的变量，作用域限制在括号代码块之中，在输出前必须声明初始化值（初始化变量）
        System.out.println(i);   //未初始化，报错：java: 可能尚未初始化变量i

        System.out.println("=====================");
        VariateConstantActionScope variateConstantActionScope = new VariateConstantActionScope();  //new+类名，然后alt+回车来插入实例变量，variateConstantActionScope就为这里的对象
        //变量类型                    变量名字                   = new VariateConstantActionScope
        System.out.println(variateConstantActionScope.age);          //默认值：0
        System.out.println(variateConstantActionScope.name);         //默认值：null
        System.out.println(salary);                                  //50000.0
    }
    public void add(i) {                                 //其它方法，在局部变量i的作用域之外，无法调用，报错：需要标识符

    }
}

常量

定义：可以理解为一种特殊的变量，它的值背设定后，在程序运行的过程中不允许被改变

final 常量名 = value；
final double = 9.1;
=================================================
public class Constant {
    static final double PAI = 3.14;     //在程序里面设置常量有很好的便利性（就像casio一样），调用就行
    final static double PAI2 = 3.14;    //static和final为修饰符，不存在先后顺序
    public static void main(String[] args) {
        System.out.println(PAI);
        System.out.println(PAI2);
    }
}

变量的命名规范

所有的变量、方法和类名：见名知意
类变量：驼峰原则monthlySalary
局部变量：驼峰原则
常量：大写字母和下划线MAX_VALUE
类名：首字母大写的驼峰原则GoodMan
方法名：驼峰原则runRun()

运算符

算数运算符

System.out.println("======二元运算符======");
        int a = 10;
        int b = 20;
        int c = 30;
        int d = 40;

        System.out.println(a+b);                //30
        System.out.println(a-b);                //-10
        System.out.println(a*b);                //200
        System.out.println(a/c);                //0
        System.out.println(a/(double)c);        //0.3333333333333333
System.out.println("======一元运算符");
		//++ -- 自增，自减 一元运算符
        int a = 3;
        int b = a++;            //先赋值，后自增
        System.out.println(a);  //4
        System.out.println(b);  //3
        int c = ++a;            //先自增，后赋值
        System.out.println(a);  //5
        System.out.println(c);  //5

        //补充数学运算,使用工具类来操作：Math.xx
        double pow = Math.pow(2,4);
        System.out.println(pow);   //2^4=16
//优先级()>一元运算符>二元运算符>···位运算符等，用括号把优先级表明，是一个良好的编码规范

拓展运算符

在这里插入图片描述

关系运算符

在这里插入图片描述

逻辑运算符

在这里插入图片描述

boolean a = true;
        boolean b = false;
        System.out.println("a&&b: "+(a&&b));  //false
        System.out.println("a||b: "+(a||b));  //true
        System.out.println("!(a&&b): "+!(a&&b));//true

        //短路运算可能出现的问题：
        int c = 5;
        boolean d = c<5&&(c++<5);	//如果改为boolean d = c<6&&(c++<6); d为ture
        System.out.println(d);      //false
        System.out.println(c);      //5，因为c<5已经错了，短路从而不执行c++

位运算符

在这里插入图片描述

“~”：

eg: 3转为2进制（此时Boolean占用4字节）

00000000 00000000 00000000 00000011

取反~（直接作用在计算机保存的二进制位上）：11111111 11111111 11111111 11111100

‘’& | ^’’:

这里的"1"相当于true，"0"相当于false

“<<”/">>":

运算元<<3：运算元二进制左移3位，相当于乘以2的3次方

字符连接符:

int score = 95;
        String type = score < 60 ? "不及格":"及格";          //及格
        System.out.println(type);
        System.out.println(score > 60 ? "不及格":"及格");    //不及格
//虽然用if语句也可以完成这样的操作，但这样的操作更加精简，是一个好习惯

字符串连接符

 int a = 1;
        int b = 3;
        System.out.println("Output: "+a+b);         //13
        System.out.println("Output2: "+(a+b));      //4
        System.out.println(a+b+" Output3");         //4
//注意不同的写法机器读出来的结果不同

包机制

包的本质：文件夹
在Project栏设置中将“Compact Middle Package”给取消勾选，就可以在建包时自动分层
Package的语法：

package com.harold.base;                //和包相关的代码，去掉后会报错
package com.harold.Package;         //定义包中的类
import com.harold.base.Constant;    //导入包中的类，尽量不要让类名和导入的包名重名，防止命名空间重复
import com.harold.base.*; 			//*通配符，导入该包下所有的类

JavaDoc

Javadoc命令的作用：生成自己的API文档
Java帮助文档本质上就是一个JavaDoc生成的文档

package com.harold;

/**
 * @author Harold
 * @version 1.1
 * @since 1.1                      //@since标签标明一个类，方法，或其它标识符是在哪个特定版本开始添加进来的。
 */
public class Doc {
    String name;

    /**
     * @author Harold
     * @param name
     * @return
     * @throws Exception           //在写好方法后，IDE可以自动生成JavaDoc，然后可再根据自己的需求进行修改
     */
    public String test(String name) throws Exception {
        return name;
    }
}
//加在类上面就是类的注释，加在方法上面就是方法的注释