Java基础学习笔记

Java基础

01 - 注释

1. 单行注释：

使用 // 双斜杠表示单行注释

public class HelloWord {
	public static void main(String[] args) {
		// 单行注释内容，运行后输出Hello Word！
		System.out.println("Hello Word!");
	}
}

2. 多行注释

使用 /* 注释内容 */表示多行注释

public class HelloWord {
 public static void main(String[] args) {
     /*
     idea中使用/*回车后可以输入多行注释，下面是两个需要记住的快捷键：
     "psvm"可以快速输入public static void main(String[] args) {}
     "sout"可以快速输入System.out.println("");
     */
     System.out.println("Hello Word!");
 }
}

3. 文档注释

使用/** 开头，每行 * 开头 */结尾代表文档注释
与JavaDoc共同使用

/**
 * idea中使用/**回车后可输入文档注释
 * 文档注释可以引入一些参数例如：
 * @Description java基础语法学习Hello Word
 * @Author 大饼
 */
public class HelloWord {
    public static void main(String[] args) {
        System.out.println("Hello Word!");
    }
}

4. 小结

注释并不会被执行，平时写代码一定注意规范
Java只有三种注释
单行注释只能注释一行内容
多行注释可以注释多行或一段内容
文档注释可以引入参数等内容

日期：2021-03-11

笔记：null

02 - 标识符和关键字

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

所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开头
首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
关键字不能用作标识符
标识符大小写敏感

public class HelloWord {
    public static void main(String[] args) {
        // 大小写十分敏感，下面变量'Name'和'name'是完全两个变量。
        String Name = "大饼";
        String name = "小饼";
        System.out.println(Name);
        System.out.println(name);
    }
}

运行结果：

大饼
小饼

日期：2021-03-11

笔记：2021-03-11

Java关键字机器作用详解-CSDN

03 - 数据类型

1. java的数据类型分为2大类：基本类型、引用类型

基本类型

数值类型

整数类型

浮点类型

字符类型

boolean类型：ture false，只占1位

public class demo02 {
    public static void main(String[] args) {
        // 八大基本数据类型

        // 整数,4种表达方式
        int num1 = 10; //最常用
        byte num2 = 20;
        short num3 = 30;
        long num4 =30L; //Long类型要在数字后面加L表示

        // 浮点数（小数）
        float num5 = 50.1F;
        double num6 = 3.1415926;

        // 字符
        char name7 = '我'; //注意使用单引号,只能是1个字符不能是多个
        // 扩展：字符串的表达方法（因字符串不是数据类型，故注掉）
        //String name = "李大饼"; 
        // 注意：String不是关键字，是类，使用双引号

        // 布尔值
        boolean flag8 = true;
        //boolean flag8 = false;
    }
}

引用类型

类

接口

数组

2. 拓展

整数拓展与浮点数拓展

public class demo03 {
    public static void main(String[] args) {
        // 整数拓展：进制   二进制0b   十进制     八进制0     十六进制0x
        System.out.println("========整数拓展========");
        int i1 = 10; // 十进制10
        int i2 = 010; // 八进制8
        int i3 = 0x10; // 十六进制16
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);

        // 浮点数拓展
        System.out.println("========浮点数拓展========");
        // Q1:float与double是否相同？
        float f = 0.1F;
        double d = 1.0/10;
        System.out.println("Q1: "+(f==d)); //false
        // Q2:float自身相加后是否相等？
        float f1 = 2333F;
        float f2 = f1 + 10;
        float f3 = 2333233323332333F;
        float f4 = f3 + 10;
        System.out.println("Q2: "+(f1==f2)); //false 注意输出内容的拼接方法
        System.out.println("Q3: "+(f3==f4)); //ture
        // Q3、Q4结果不同原因打开debug查看f1~F4的值
        // float和double的特点：有限(Q2)、离散、舍入误差（Q2）、接近但不等于(Q3)
        // 最好完全避免使用浮点数进行比较！！！
        // 最好完全避免使用浮点数进行比较！！！
        // 最好完全避免使用浮点数进行比较！！！
        // 浮点数不能用来表示精确的值，如货币
        // 少用浮点数进行比较，需要计算且不能有误差时使用BigDecimal
    }
}

运行结果：

========整数拓展========
10
8
16
========浮点数拓展========
Q1: false
Q2: false
Q3: true

最好完全避免使用浮点数进行比较！！！
float和double的特点：有限、离散、舍入误差、接近但不等于(Q3)
浮点数不能用来表示精确的值，如货币

日期：2021-03-15

笔记：2021-03-15

注意println输出内容的拼接方法
对于基本类型：“==”其实比较的是它的值

对于引用类型：“==”比较的是对象的内存地址 Java 中 == 比较的是什么？

04 - 类型转换

1. 运算中，不同类型的数据需要先转化为同一类型，然后进行计算。转换

低（字节容量小）------------------------------>高（字节容量大）
byte，short，char —> int —> long —> float —> double

2. 注意事项

不能对布尔值进行转换
不能把对象类型转换为不相干的类型
把高容量转换到低容量时，需要强制转换，转换方法：(类型)变量名
把低容量转换到高容量时，自动转换
转换的时候可能存在内存溢出，或精度问题

public class Demo04 {
    public static void main(String[] args) {
        //高--低时需强制转换：(类型)变量名
        //低--高事自动转换：无需操作
        int i = 128;
        byte b = (byte) i;//内存溢出
        double d = i;//自动转换
        System.out.println("i:"+i);
        System.out.println("b:"+b+" ←强制转换时内存溢出");
        System.out.println("d:"+d+" ←自动转换");
        /*
        知识点：
        1. 不能对布尔值进行转换
        2. 不能把对象类型转换为不相干的类型
        3. 把高容量转换到低容量时，需要强制转换
        4. 数据类型容量（低）byte，short，char —> int —> long —> float —> double（高）
        5. 转换的时候可能存在内存溢出，或精度问题
         */
        System.out.println("====精度问题====");
        System.out.println((int)23.7);//double转int精度丢失
        System.out.println((int)-34.56F);//float转int精度丢失
        System.out.println("====字符串转换====");
        char c = 'a';
        int y = c+1;// "int y ="将 c(chart) 先转换为int，低转高，自动转换
        System.out.println(c);
        System.out.println(y);// char转为int时字符串会被解析为：97,所以"int y ="的结果是98
        System.out.println((char) y);// 将y(int)强制转换为char，结果是b
    }
}

运行结果：

i:128
b:-128 ←强制转换时内存溢出
d:128.0 ←自动转换
====精度问题====
23
-34
====字符串转换====
a
98
b

3. 扩展

操作比较大的数的时候注意溢出问题

public class Demo05 {
    public static void main(String[] args) {
        // 操作比较大的数的时候，注意溢出问题，举例计算工资
        int money = 10_0000_0000;
        int years = 20;
        int total1 = money*years;
        System.out.println("total1："+total1);// -1474836480，计算时内存溢出
        // 尝试使用long转换
        long total2 = money*years;
        System.out.println("total2："+total2);// -1474836480，原因：total2转换前就已经溢出
        
        // 如何解决问题？
        long total3 = money*((long)years);// 先把一个数转为long
        System.out.println("total3："+total3);
        long total4 = ((long)money)*years;// 同理
        System.out.println("total4："+total4);
    }
}

运行结果：

total1：-1474836480
total2：-1474836480
total3：20000000000
total4：20000000000

日期：2021-03-18

笔记：2021-03-18

可以使用下划线拼接数字，方便查看同时不影响输出和计算

05 - 变量、常量、作用域

1. 变量：可以变化的量

java是强类型语言：要求变量使用严格符合规定，所有变量需要先定义后使用
每个变量必须声明类型
java变量是程序中最基本的存储单元，其要素包括：变量名、变量类型、作用域

Type varName [=value] [{,varName[=value]}]

//数据类型变量名 = 值；可以使用逗号来个开声明多个同类型变量，但不要这么用。
注意事项：
- 每个变量都要有类型，类型可以是基本类型、引用类型；
- 变量名必须是合法的标识符
- 变量的声明是一条完整的语句，因此必须以分号结束

public class Demo06 {
    public static void main(String[] args) {
        /*
        int a=1,b=2,c=3;// 虽然java支持，但不建议这么做
        // 为提高可读性，建议分开写
        int a=1;
        int b=2;
        int c=3;
         */
        //示例分别对应：数据类型 变量名 = 值
        String name = "bing";
        char x = 'X';
        double pi = 3.14;
    }
}

2. 变量的作用域

变量会有三种作用域
类变量：写在一个类内，需要关键词“static”
实例变量：写在类后，实例化对象时使用的变量
局部变量：写在方法里

public class Demo07 {
    // 类变量：需要增加static关键字，例如
    static double salary = 2500;// 这个' salary '是类变量
    String name;// 实例变量,在方法的外面，类的里面，作用域比局部变量大，从属于对象
    // 实例变量不需要初始化就可以使用，如果不初始化，会变成变量类型的默认值
    // 布尔值：默认是false；除了基本类型，其余类型默认值都是null

    // 以main方法举例
    public static void main(String[] args) {
        // 局部变量：必须声明和初始化值，只作用域一个方法内
        int i = 10;// 这个'i'是局部变量，如果去掉= 10，会报错变量'i'未初始化
        System.out.println(i);

        // 实例变量用法：变量类型 变量名字 = new base.Demo07();？？？
        Demo07 demo07 = new Demo07();// 此处快捷键直接输入new base.Demo07();然后两次option+回车即可补全
        System.out.println(demo07.name);
        
        // 类变量可以直接输出
        System.out.println(salary);
    }
}

3. 常量（Constant）

常量：初始化后不能再改变的值，不会变动的值。
可以理解成一种特殊的变量，他的值被设定后，在程序运行过程中不允许被改变。
需要使用final关键词，且变量名要全大写。
使用常量可以提高程序可读性

public class Demo08 {
    static final double PI = 3.14;
    //final static double PI = 3.14;// 也可以这么写，变量类型前都是修饰符，修饰符不区分前后顺序
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

日期：2021-03-20

笔记：变量的命名规范

所有的变量、方法、类名要：见名知意，不要使用拼音
类成员变量：首字母小写和驼峰原则（如果由多个单词组成，从第2个单词开始的其他单词的首写字母使用大写）
局部变量：首字母小写和驼峰原则（小驼峰）
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则（大驼峰）
方法名：小驼峰

扩展阅读：

类成员变量和实例成员变量分别指什么有什么区别

成员变量、类变量、局部变量的区别

06 - 基本运算符

Java语言支持以下运算符

算数运算符：+ ，- ，* ，/ ，% ，++ ，-- （java里%是指取余运算，称作模运算）
赋值运算符：=
关系运算符：> ，< ，>= ，<= ，== ，!= ，instanceof （java里等于是'=='）
逻辑运算符：&& ，|| ，！（与、或、非）
位运算符：& ，| ，^ ，~ ，>> ，<< ，>>>
条件运算符：?:
扩展赋值运算符：+=，-+，*=，/=

1. 基本运算符

package operator;

public class Demo01 {
    public static void main(String[] args) {
        // 也叫二元运算符
        int a = 10;
        int b = 20;// command+D：复制当前行到下一行
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);// 这里为0的原因是int类型对0.5只取整数部分
        System.out.println(a/(double)b);// 如果希望上面除法执行正确，需要这么做
        // 试验int的舍入规则：只取整数部分
        int t1 = (int) 1.1;
        int t2 = (int) 0.9;
        System.out.println(t1);
        System.out.println(t2);
    }
}

package operator;

public class Demo02 {
    public static void main(String[] args) {
        long a = 1234512345L;
        int b = 123;
        short c = 10;
        byte d = 8;
        // java不同类型混合运算时会先进行转换，运算结果向最高位转换
        System.out.println(a+b+c+d);// long
        System.out.println(b+c+d);// int
        System.out.println(c+d);// int，char、short、byte混合运算时，会各自先转换成int再做运算
        // 扩展关键字：自动类型提升
    }
}

2. 关系运算，模运算

package operator;

public class Demo03 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 21;
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);
        System.out.println(c%a);// 取余，模运算
    }
}

日期：2021-03-21

笔记：2021-03-21

java不同类型混合运算时会先进行转换，运算结果向最高位转换，转换规则参考java基础：04 - 类型转换

char、short、byte混合运算时，会各自先转换成int再做运算

07 - 自增自减运算符、初识Math类

1. 自增自减运算符是算数用算符的一种

++自增，--自减，称作一元运算符

package operator;

public class Demo04 {
    public static void main(String[] args) {
        //++自增，--自减，一元运算符
        int a = 3;
        int b = a++;// 先赋值再自增
        int c = ++a;// 先自增再赋值
        System.out.println(b);// 先赋值，此时a=3，再自增，此时a=4
        System.out.println(c);// 先自增再赋值，所以a=5而不是4
        System.out.println(a);// 代码走到这里a经过两次自增因此是5
    }
}

2. java中没有^幂运算，使用Math类进行科学工程类计算

日期：2021-03-21

笔记：null

08 - 逻辑运算符、位运算符

1. 逻辑运算符：与或非

&&，与运算：两个都为真，结果才为真
||，或运算：一个为真，结果就为真
!，非运算：如果为真则为假，如果为假则为真
短路运算，与运算的第一个条件为假。短路运算的第二个条件部分不会被执行

package operator;
// 逻辑运算符
public class Demo05 {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        System.out.println("a && b："+(a&&b));// 与运算，两个都为真，结果才为真
        System.out.println("a || b："+(a||b));// 或运算，一个为真，结果就为真
        System.out.println("!(a && b：)"+!(a&&b));// 如果为真则为假，如果为假则为真

        //短路运算，后面的内容不会执行
        System.out.println("a && b："+(b&&a));// 与运算的第一个就是假，则后面无需比较，结果肯定为假，即为短路运算
    }
}

2. 位运算

运行速度快
<<左移即*2，>>右移即/2

package operator;

public class Demo06 {
    public static void main(String[] args) {
        /*
        a = 0011 1100
        b = 0000 1101
        --------------------
        a&b = 0000 1100 //同1为1，否则为0
        a/b = 0011 1101 //有1为1，同0为0
        a^b = 0011 0001 //相同为0，不同为1
        ~b  = 1111 0010//相同为1，不同为0
         */
        // 2*8如何计算最快
        /*
        0000 0010       2
        0000 0100       4
        0000 1000       8
        0001 0000       16
         */
        System.out.println(2<<3);// ???
    }
}

日期：2021-03-21

笔记：2021-03-21

问题！！！左右移是怎么移的？具体规则？

菜单

分享

Java基础

01 - 注释

02 - 标识符和关键字

03 - 数据类型

04 - 类型转换

05 - 变量、常量、作用域

06 - 基本运算符

07 - 自增自减运算符、初识Math类

08 - 逻辑运算符、位运算符

评论

什么是RBAC？5分钟讲清楚

最新版IDEA激活方法 idea2024.2

VS Code SFTP插件watcher无法自动上传和删除？

总结：如何提升产品思维

总结：需求分析的方法论

总结：B端产品经理核心能力有哪些

总结：产品方法论

总结：互联网产品经理应具备什么能力

.gitignore使用总结——git忽略列表

SpringBoot中controller、service、dao、model、pojo、vo、dto都是个啥？