Java基础

Java基础学习---点击进入学习

Java语言概述

1.Java语言运行机制

Java是先编译，将.java源文件编译为平台中立的.class文件，最后再解释执行。

Java的设计理念：write once run anywhere 写一遍运行在任何地方

2.Java的跨平台核心

Java跨平台的核心原理为JVM虚拟机，JVMJava虚拟机是一个软件，相当于在不同的平台模拟相同的环境，以实现跨平台的效果。

3.名词解释

JVM（Java Virtual Machine）虚拟机：使用软件在不同操作系统中，模拟相同的环境。

JRE（Java Runtime Environment）运行环境：包含JVM和解释器，完整的Java运行环境。

JDK（Java Development Kit）开发环境：包含JRE + 类库 + 开发工具包（编译器+调试工具） 4.代码解释

public 公开

class 类

static 静态的

void 空的无效的

main 主要的

String 字符串

args - arguments 参数复数形式

System 系统

out 出

print 打印

4.类的阐述

同一个源文件中可以定义多个类。

编译后，每个类都会生成独立的 .class文件。

一个类中，只能有一个main方法，每个类都可以有自己的main方法

public修饰的类称为公开类，要求类名必须与文件名称完全相同，包括大小写。

一个源文件中，只能有一个公开类。

public class A{
	public static void main(String [] args){
		System.out.print("A class print");
	}
	
}

class B{
	public static void main(String [] args){
		System.out.print("B class print");
	}
}

class C{
	public static void main(String [] args){
		System.out.print("C class print");
	}
}

注释

// 单行注释

/* 多行注释*/

/** 文档注释 */

变量和运算符

1. 记事本乱码问题

使用记事本编写Java文件，输出中文默认会有乱码的问题

1.乱码产生原因

记事本默认的编码格式和JVM默认文件的编码不一致导致的

记事本默认的编码格式为 UTF-8

JVM默认的文件编码格式为GBK

2.解决方案

将记事本文件的编码格式修改为ANSI即可

3.编码介绍

UTF-8 万国码 Unicode 是一个十六进制的字符编码集收录了世界上绝大多数国家的语言

GBK 国标扩展版收录了绝大多数中文简体以及繁体

GB2312 国标标准版收录了绝大多数中文简体

ANSI 在不同的操作系统表示不同的编码格式在中文操作系统表示 GBK

2.关键字和保留字

关键字：被Java语言赋予了特殊含义，用做专门用途的单词

关键字特点：关键字中所有字母都为小写

注意：定义标识符避免和关键字冲突

保留字：Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字 goto 、const

3.标识符

Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符

总结：凡是自己可以起名字的内容都称之为标识符。

4. 标识符命名规范

类名：由一个或者多个单词组成每个单词首字母大写其余字母小写这种格式为 大写驼峰

举例：Student Person PersonOperation

变量名：由一个或者多个单词组成第一个单词全部小写后续每遇到一个新的单词首字母大写这种格式为 小写驼峰

举例：studentAge studentName carPriceAndType

5.变量和数据类型的概念

举例：比如你的同桌需要大宝剑发现钱不够找你借5毛钱

时间：2023年12月26日09:40:42

地点：教室

人物：你的同桌

事件：借钱

金额：5毛 / 0.5元

………………

生活中我们通常需要记录数据，记录数据的方式多种多样，比如视频、音频、文字、图片等等。

程序中也同样需要记录数据，程序中使用变量来记录数据。

生活中的数据会有不同的数据类型。Java中也使用不同的数据类型来记录不同的数据。

6. Notepad设置

转存失败，建议直接上传图片文件

/**
 *  这个类用于演示第一次使用notepad
 */
public class HelloNotepad{
    /** 
     *  以下为main方法
     */
    public static void main(String [] args){
        // 这一行代码用于输出一句话
        System.out.println("hello notepad 你好");
    }
}

7.变量的定义方式

声明变量的3种方式：先声明，再赋值：【常用】数据类型变量名; 变量名 = 值;

声明并赋值：【常用】数据类型变量名 = 值;

多个同类型变量的声明与赋值：【了解】数据类型变量1 , 变量2 , 变量3 = 值3 , 变量4 , 变量5 = 值5;

/**
 *  变量的三种定义方式
 */
public class TestVariableDefine{
    public static void main(String [] args){
        // 定义方式1 先声明 再赋值
        int a;
        a = 100;
        System.out.println("变量a的取值为：" +  a); // 字符串与任何内容相加 实为拼接 不做数学计算
        
        
        // 定义方式2 连声明带赋值写为一条语句
        int b = 200;
        
        System.out.println("变量b的取值为：" + b);
        
        // 定义方式3 同时声明多个同类型的变量 (了解)
        // 定义在方法体内都属于局部变量 而局部变量未赋值是不能使用的 
        // 如果使用 会编译报错
        int c,d,e = 55,f,g = 66;
        System.out.println("变量e的取值为：" + e);
        System.out.println("变量g的取值为：" + g);
        
        /* 
           System.out.println("变量c的取值为：" + c);
           System.out.println("变量d的取值为：" + d);
           System.out.println("变量f的取值为：" + f); 
        */
        
    }
}

8.单位换算

1TB = 1024GB

1GB = 1024MB

1MB = 1024KB

1KB = 1024Byte(字节)

1Byte = 8bit(位)

1个字节占8位

9.数据类型

9.1 整数类型

转存失败，建议直接上传图片文件

注意：int为整数的默认类型

如需为long类型赋值

如果取值范围超出int 则必须在末尾加上L 否则编译报错

如果取值范围没有超出int 则末尾的L 可加可不加

总结：我们使用long类型保存整数，如果取值范围在int以内，依然使用4个字节的空间帮我们保存数据，以起到节省内存空间的作用，所以当我们赋值取值范围超出int，继续使用4个字节将无法保存，所以报错，所以我们需要显式的在值的末尾加上L，表示通知JVM必须8个字节来存储。

public class TestNumber{
    public static void main(String [] args){
        // 整数数据类型 四种
        // byte 1个字节 取值范围 -128 ~ 127
        
        byte b1 = 20;
        byte b2 = 120;
        // byte b3 = 128;
        // byte b4 = -129;
        
        System.out.println("变量b1的取值为：" + b1);
        System.out.println("变量b2的取值为：" + b2);
        // System.out.println("变量b3的取值为：" + b3);
        // System.out.println("变量b4的取值为：" + b4);
        
        
        // short类型 2个字节 取值范围 -32768 ~ 32767
        short s1 = 5623;
        short s2 = 32456;
        // short s3 = -35000;
        // short s4 = 32768;
        
        System.out.println("s1的取值为：" + s1);
        System.out.println("s2的取值为：" + s2);
        // System.out.println("s3的取值为：" + s3);
        // System.out.println("s4的取值为：" + s4);
        
        
        // int类型 4个字节 取值范围 -2147483648 ~ 2147483647 
        
        int i1 = 89564;
        int i2 = -789456;
        // int i3 = -2147483649;
        // int i4 = 2147483648;
        
        
        System.out.println("变量i1的取值为：" + i1);
        System.out.println("变量i2的取值为：" + i2);
        // System.out.println("变量i3的取值为：" + i3);
        // System.out.println("变量i4的取值为：" + i4);
        
        
        // long类型 8个字节 取值范围  ：-9223372036854775808 ~ 9223372036854775807
        // 如需为long类型赋值
        // 如果取值范围超出int 则必须在末尾加上L 否则编译报错
        // 如果取值范围没有超出int 则末尾的L 可加可不加 
        System.out.println("long类型的最大取值：" + Long.MAX_VALUE); // 打印最大值
        System.out.println("long类型的最小取值：" + Long.MIN_VALUE); // 打印最小值
        
        
        long l1 = 123456;
        long l2 = 445566;
        System.out.println("l1的取值为：" + l1);
        System.out.println("l2的取值为：" + l2);
        
        
        long l3 = 2147483648L;
        System.out.println("l3的取值为：" + l3);
    }
}

9.2 浮点类型

转存失败，建议直接上传图片文件

float和double都是近似值无法表示精确值后续我们使用BigDecimal表示精确值底层遵循IEEE754 浮点数计数规范计数 float是单精度浮点数有效位数为7到8位 double是双精度浮点数有效位数为15到16位 float 取值范围-3.4E38 ~ 3.4E38 double为浮点数的默认类型，如需为float类型赋值，需要在值的后面追加“F”

double 取值范围 -1.7E308 ~ 1.7E308 (了解) 在给double类型赋值如果超出了float的取值范围需要在末尾加上D

public class FloatAndDouble{
    public static void main(String [] args){
        // float和double都是近似值 无法表示精确值   底层遵循IEEE754 浮点数计数规范 计数
        // float是单精度浮点数 有效位数为7到8位
        // double是双精度浮点数 有效位数为15到16位
        // float 取值范围-3.4E38 ~ 3.4E38
        // double为浮点数的默认类型，如需为float类型赋值，需要在值的后面追加“F”
        
        
        
        float min = -340000000000000000000000000000000000000F;
        System.out.println("float最小的取值为：" + min);
        
        float max = 340000000000000000000000000000000000000F;
        System.out.println("float最大的取值为：" + max);
        
        
        // double 取值范围 -1.7E308 ~ 1.7E308
        // (了解) 在给double类型赋值 如果超出了float的取值范围 需要在末尾加上D 
        double d1 = 2.5;
        double d2 = 3.5;
        
        System.out.println("d1的取值为：" + d1);
        System.out.println("d2的取值为：" + d2);

        
        
        

    }
}

9.3 布尔类型

转存失败，建议直接上传图片文件

布尔类型仅可赋值 true 表示为真 false 表示为假

public class TestBoolean{
    public static void main(String [] args){
        // 布尔类型 
        // 仅可赋值 true 表示为真 false 表示为假 
        boolean bl1 = true;
        boolean bl2 = false;
        
        System.out.println(bl1);
        System.out.println(bl2);
        
        int a = 10;
        int b = 20;
        boolean bl3 = a > b; // 先将a 和 b 比较 比较之后的结果赋值给bl3 
        System.out.println(bl3);    
        
    }
}

9.4 字符类型

转存失败，建议直接上传图片文件

字符赋值：char c1 = 'A';（通过''描述为字符赋值）

整数赋值：char c2 = 65;（通过十进制数65在字符集中对应的字符赋值）

进制赋值：char c3 = '\u0041';（通过十六进制数41在字符集中所对应的字符赋值）

public class TestChar{
    public static void main(String [] args){
        // char类型 2个字节 取值范围是无符号数 0 ~ 65535
        
        // 方式1 直接使用英文的单引号包括任意一个字符
        char ch1 = 'a';
        char ch2 = 'b';
        char ch3 = '1';
     // char ch4 = '56';  编译报错 只能保存一个字符
        char ch5 = '中';
        
        System.out.println(ch1);
        System.out.println(ch2);
        System.out.println(ch3);
        System.out.println(ch5);
        
        
        // 方式2 直接赋值在0~65535以内的整数 
        // 当我们直接给char类型赋值 0 ~ 127 以内的整数 将参考ASCII码表来解析为对应的字符  
        char ch11 = 65;
        System.out.println(ch11);
        
        char ch12 = 66;
        System.out.println(ch12);
        
        char ch13 = 67;
        System.out.println(ch13);
        
        // 当我们直接给char类型赋值 超出0~127范围的整数 将参考Unicode编码表 万国码
        // 万国码收录了世界上绝大多数国家的语言 是一个十六进制的字符编码表
        // 中文的取值范围 是 \u4e00(19968) ~ \u9fa5(40869)
        char ch14 = 20013;
        System.out.println("ch14转换为字符的值为：" + ch14);
        
        char ch15 = 20320;
        System.out.println("ch15转换为字符的值为：" + ch15);
        
        
        char ch16 = 19968;
        System.out.println("ch16转换为字符的值为：" + ch16);
        
        char ch17 = 19969;
        System.out.println("ch17转换为字符的值为：" + ch17);
        
        
        char ch18 = 40869;
        System.out.println("ch18转换为字符的值为：" + ch18);
        
        
        
        // 方式3  直接使用英文的单引号包括 十六进制的Unicode字符值  
        
        char cha1 = '\u4f60';
        System.out.println(cha1);       
    }
}

10.转义字符

转存失败，建议直接上传图片文件

转义字符 Java中使用转义字符来保存一些特殊的符号或者实现一些对应的效果

public class ConvertSign{
    public static void main(String [] args){
        // 转义字符  
        // Java中使用转义字符来保存一些特殊的符号 或者 实现一些对应的效果
        char ch1 = ''';
        
        System.out.println(ch1);
        
        // \n 换行 必须使用双引号包括 println()  
        System.out.println("打\n印\n一\n句\n话\n1");
        System.out.println("打印一句话2");
        
        
        // \t 制表位 缩进一个tab键的距离
        System.out.println("春\t风\t得\t意\t马\t蹄\t疾");
        System.out.println("一\t日\t看\t尽\t长\t安\t花");
        
        
        // \ 保存一个反斜杠 
        
        char ch2 = '\';
        System.out.println(ch2);
        
        
        // " 双引号可以转义 也可以不转义
        char ch3 = '"';
        System.out.println(ch3);
        char ch4 = '"';
        System.out.println(ch4);
        
    }
}

11.String类型

转存失败，建议直接上传图片文件

public class TestString{
    public static void main(String [] args){
        // String 引用数据类型
        // 任何英文双引号之间的内容都属于字符串 
        // 字符串与任何内容相加 实为拼接字符串 不做数学计算
        
        String str1 = "abc hello world";
        String str2 = "世界你好 6666";
        String str3 = "rkqjenwe让我去了软件方面vsdmdeweel,wq;';pw;.qwplddm";
        
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
        
        String str4 = """"""";
        System.out.println(str4);
        
    }
}

12.类型转换

12.1 自动类型转换

自动提升手动下降自动类型转换两种类型要相互兼容目标类型(等号左边)取值范围要大于源类型(等号右边)取值范围

byte -> short -> int -> long -> float - > double char -> int -> long -> float - > double byte short 和 char 进行互转不能自动类型转换必须强制类型转换

public class TestAutoConvert{
    public static void main(String [] args){
        // 自动提升 手动下降
        // 自动类型转换
        // 两种类型要相互兼容
        // 目标类型(等号左边)取值范围要大于源类型(等号右边)取值范围
        
        // byte -> short -> int -> long -> float - > double 
        //          char -> int -> long -> float - > double
        // byte short 和 char 进行互转 不能自动类型转换  必须强制类型转换
        
        byte b1 = 20;
        
        short s1 = b1;
        
        System.out.println(s1);
        
        
        System.out.println("---------------------------------------------------------");
        
        short s2 = 200;
        
        int i1 = s2;
        
        System.out.println(i1);
        
        System.out.println("---------------------------------------------------------");
        
        int i2 = 568978;
        
        long l1 = i2;

        System.out.println(l1);
        
        System.out.println("---------------------------------------------------------");
        
        long l2 = 894578;
        
        float f1 = l2; // 将整数存放到浮点数中 会自动在末尾加上 .0 
        
        System.out.println(f1);
        
        System.out.println("---------------------------------------------------------");
        
        float f2 = 3.5F;
        
        double d1 = f2;
        
        System.out.println(d1);
        
        System.out.println("---------------------------------------------------------");
        
        char ch1 = 'A';
        
        int numa = ch1;
        
        System.out.println(numa);
        
        System.out.println("---------------------------------------------------------");
        
        float f3 = ch1;
        
        System.out.println(f3);
    }
}

12.3 强制类型转换

强制类型转换 1.两种类型要兼容 6种数值和 char类型相互兼容 2.目标类型取值范围小于源类型取值范围 double -> float -> long -> int -> short -> byte double -> float -> long -> int -> char

public class TestForceConvert{
    public static void main(String [] args){
        // 强制类型转换
        // 1.两种类型要兼容 6种数值 和 char类型相互兼容
        // 2.目标类型取值范围 小于 源类型 取值范围 
        // double -> float -> long -> int -> short -> byte 
        // double -> float -> long -> int -> char 
        
        double d1 = 55.5;
        float f1 = (float)d1;
        System.out.println(f1);
        
        System.out.println("------------------------------------");
        
        float f2 = 3.6F;
        
        long l1 = (long)f2; // 将浮点数强制转换为整数 小数位将抹去 
        
        System.out.println(l1);
        
        System.out.println("------------------------------------");
        
        long l2 = 894546;
        
        int i1 = (int)l2;
        
        System.out.println(i1);
        
        System.out.println("------------------------------------");
        
        int i2 = 7812;
        
        short s1 = (short)i2;
        
        System.out.println(s1);
        
        System.out.println("------------------------------------");
        
        
        short s2 = 100;
        
        byte b1 = (byte)s2;
        
        System.out.println(b1);
        
        System.out.println("------------------------------------");
        
        double numa = 66.8;
        
        char cha1 = (char)numa;
        
        System.out.println(cha1);
        
        int numb = 20013;
        
        char cha2 = (char)numb;
        
        System.out.println(cha2);
        
        System.out.println("------------------------------------");
        
        // 思考问题
        
        short ss1 = 257;
        byte bb1 = (byte)ss1; // 1
        
        short ss2 = 128;
        byte bb2 = (byte)ss2; // -128
        
        short ss3 = 129;
        byte bb3 = (byte)ss3; // -127
    }
}

13.包的概念

包就是文件夹用于保存java文件

包名命名规范：全部小写域名倒置不能以点开头或者结尾可以包含点每存在一个点表示一个子文件夹

举例：

域名：www.baidu.com

包名：com.baidu.xxx

14.运算符

14.1 算数运算符

算数运算符

ctrl + D 复制当前行

回顾自动类型转换的问题

两个操作数有一个为double，计算结果提升为double。

如果操作数中没有double，有一个为float，计算结果提升为float。

如果操作数中没有float，有一个为long，计算结果提升为long。

如果操作数中没有long，有一个为int，计算结果提升为int。

如果操作数中没有int，均为short或byte或者char，计算结果仍旧提升为int。

/**
 * @author WHD
 * @description TODO
 * @date 2023/12/28 11:24
 *  算数运算符
 *  + - * /
 *  %取余 求余数 模运算
 *  ctrl + D 复制当前行
 *
 *  回顾自动类型转换的问题
 *  两个操作数有一个为double，计算结果提升为double。
 *  如果操作数中没有double，有一个为float，计算结果提升为float。
 *  如果操作数中没有float，有一个为long，计算结果提升为long。
 *  如果操作数中没有long，有一个为int，计算结果提升为int。
 *  如果操作数中没有int，均为short或byte或者char，计算结果仍旧提升为int。
 *
 */
public class TestArithmeticOperator1 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        System.out.println(a + b); // 30
        System.out.println(a - b); // -10
        System.out.println(a * b); // 200
        System.out.println(a / b); // 0
        System.out.println(a % b); // 10

        int c = 3;
        System.out.println(a % c); // 1

        System.out.println("------------------------------------------");

        byte b1 = 5;

        short s1 = 5;

        int num = b1 + s1;

        System.out.println("------------------------------------------");

        short s2 = 100;

        int i1 = 100;

        int result = s2 + i1;

        System.out.println("------------------------------------------");

        int i2 = 100;

        long l1 = 100;

        long l2 = i2 + l1;

        System.out.println("------------------------------------------");

        long l3 = 100;

        float f1 = 3.5F;

        float l4 = l3 + f1;

        System.out.println("l4 = " + l4);

        System.out.println("------------------------------------------");

        float f2 = 3.5F;

        double d1 = 100.5;

        double d2 = f2 + d1;

        System.out.println("d2 = " + d2);

        System.out.println("------------------------------------------");

        char ch1 = 'A'; // 65
        byte numa = 20;
        short numb = 10;
        System.out.println(ch1 + numa + numb);
        int i = ch1 + numa + numb;
        System.out.println("i = " + i);

        System.out.println("------------------------------------------");

        char ch2 = 'A';

        System.out.println(ch2 + 1);

        System.out.println((char)(ch2 + 1));



    }
}

++ 或者 -- 单独作为一条语句使用在前在后没有区别
如果不是单独一条语句书写在前在后有区别
如果++或者--在前先执行++或者-- 再执行其他的
如果++或者--在后先执行其他的再执行++或者--
++ 或者 -- 都不是线程安全的

/**
 * @author WHD
 * @description TODO
 * @date 2023/12/28 11:40
 *  算数运算符2 ++ 和 --
 *  ++ 表示自增1
 *  -- 表示自减1
 */
public class TestArithmeticOperator2 {
    public static void main(String[] args) {
        int a = 10;
        a++; // 结果等同于 a = a + 1
        System.out.println("a = " + a);

        int b = 10;
        b--; // 结果等同于 b = b - 1;
        System.out.println("b = " + b);

        System.out.println("------------------------------------------");

        int c = 10;
        ++c; // 结果等同于 c = c + 1
        System.out.println("c = " + c);

        int d = 10;
        --d;
        System.out.println("d = " + d);


        System.out.println("------------------------------------------------------");

        // ++ 或者 -- 单独作为一条语句使用 在前在后 没有区别
        // 如果不是单独一条语句书写 在前 在后有区别
        //      如果++或者--在前 先执行++或者-- 再执行其他的
        //      如果++或者--在后 先执行其他的 再执行++或者--
        // ++ 或者 -- 都不是线程安全的

        int a1 = 10;
        int b1 = a1++;
        System.out.println("b1 = " + b1); // 10
        System.out.println("a1 = " + a1); // 11

        System.out.println("------------------------------------------------------");

        int c1 = 10;
        int d1 = ++c1;
        System.out.println("d1 = " + d1); // 11
        System.out.println("c1 = " + c1); // 11

        System.out.println("------------------------------------------------------");

        // 先乘除  后加减
        int j = 1;
        int k = j++ + ++j * j++;
        System.out.println("k = " + k); // 10
        System.out.println("j = " + j);


        int j1 = 5;
        int k1 = (j1++) + (--j1) + ++j1;

        System.out.println("k1 = " + k1);

        // 如果左右两边都是同一个变量 并且涉及到 ++或者--的情况
        // JVM会生成临时变量 保存 右边表达式的值
        int m = 1;
        m = m++;
        System.out.println("m = " + m);
    }
}

14.2 关系运算符

关系运算符：关系运算符最终的结果都为布尔类型

/**
 * @author WHD
 * @description TODO
 * @date 2023/12/28 14:34
 *  关系运算符：关系运算符最终的结果都为布尔类型
 */
public class TestRelationOperator {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        System.out.println(a > b); // false
        System.out.println(a < b); // true
        System.out.println(a >= b); // false
        System.out.println(a <= b); // true
        System.out.println(a == b); // false
        System.out.println(a != b); // true
    }
}

14.3 赋值运算符

= 将等号右边的值赋值给等号左边

+= 求和之后赋值

-= 求差之后赋值

*= 求积之后赋值

/= 求商之后赋值

%= 求余之后赋值

/**
 * @author WHD
 * @description TODO
 * @date 2023/12/28 14:25
     *  赋值运算符
     *  =   将等号右边的值赋值给等号左边
     *  +=  求和之后赋值
     *  -=  求差之后赋值
     *  *=  求积之后赋值
     *  /=  求商之后赋值
     *  %=  求余之后赋值
 */
public class TestGetValueOperator {
    public static void main(String[] args) {
        int a = 10;

        a += 10; // a = a + 10;

        System.out.println("a = " + a); // 20


        a -= 10; // a = a - 10;

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

        a *= 3;// a = a * 3;

        System.out.println("a = " + a); // 30

        a /= 7; // a = a / 7

        System.out.println("a = " + a); // 4


        a %= 2; // a = a % 2;

        System.out.println("a = " + a); // 0

        System.out.println("-------------------------------------------");


        short s1 = 10;

        s1 += 10; // 这里实现了隐式的类型转换  即JVM帮我们实现的类型转换

        System.out.println("s1 = " + s1);

        short s2 = 10;

        s2 = (short)(s2 + 10); // 这里需要手写类型转换

        System.out.println("s2 = " + s2);

        // 对比以上两种方法 结果都相同 第一种写法更加简洁
    }
}

逻辑运算符

& 与 要求两个或者多个表达式都成立 则结果为true

没有短路效果 不管前边的表达式结果如何 都将执行完所有的表达式 *

&& 短路与 要求两个或者多个表达式都成立 则结果为true

有短路的效果 如果前边的条件不成立 则后续的表达式不再执行

| 或 要求两个或者多个表达式 至少有一个成立 则结果为true

没有短路的效果 不管前边的表达式结果如何 都将执行完所有的表达式

|| 短路或 要求两个或者多个表达式 至少有一个成立 则结果为true

有短路的效果 如果前边的表达式成立 则后续的表达式不再执行

! 非 取反

/**
 * @author WHD
 * @description TODO
 * @date 2023/12/28 14:40
 *  逻辑运算符
 *  &   与         要求两个或者多个表达式都成立 则结果为true
 *  没有短路效果 不管前边的表达式结果如何 都将执行完所有的表达式
 *
 *  &&  短路与     要求两个或者多个表达式都成立 则结果为true
 *  有短路的效果 如果前边的条件不成立 则后续的表达式不再执行
 *
 *  |   或       要求两个或者多个表达式 至少有一个成立 则结果为true
 *  没有短路的效果 不管前边的表达式结果如何 都将执行完所有的表达式
 *
 *  ||  短路或    要求两个或者多个表达式 至少有一个成立 则结果为true
 *  有短路的效果 如果前边的表达式成立 则后续的表达式不再执行
 *
 *  !   非       取反
 */
public class TestLogicOperator {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;

        System.out.println((a < b) & (b < c) ); // true
        System.out.println((a < b) && (b < c) ); // true

        System.out.println((a < b) & (b > c)); // false
        System.out.println((a < b) && (b > c)); // false


        System.out.println((a > b) & (b > c)); // false
        System.out.println((a > b) && (b > c)); // false


        System.out.println("--------------------------------------------------");

        System.out.println((a < b) | (b < c) ); // true
        System.out.println((a < b) || (b < c) ); //  true

        System.out.println((a < b) | (b > c)); // true
        System.out.println((a < b) || (b > c)); // true


        System.out.println((a > b) | (b > c)); //  false
        System.out.println((a > b) || (b > c)); // false

        System.out.println("--------------------------------------------------");


        boolean bl1 = true;
        System.out.println(!bl1); // false
        System.out.println(bl1); // true
        System.out.println(!false); // true
        System.out.println(!true); // fase

    }
}

14.5 三目运算符

三元运算符

格式：布尔表达式 ? 结果1 : 结果2

如果布尔表达式结果为true 则执行结果1 否则执行结果2

14.6 位运算符

15.运算符优先级

运算符是有优先级别存在的，实际开发中

1.通常不会在一个表达式中书写过多的运算符

2.如果需要某一段表达式优先执行，可以加上小括号，同时还可以提高代码的阅读性

17.字面量和常量

常量是不可改变的数据

字面量属于常量

后续我们会学习final关键字来修饰，使用final修饰的就属于常量

/**
 * @author WHD
 * @description TODO
 * @date 2023/12/28 16:11
 *  常量
 */
public class TestConst {
    public static void main(String[] args) {
        int a = 20;
        a = 10;
        a = 23;
        a = 35;

        // 字面量 也属于常量
        System.out.println(10); 
        System.out.println(false);
        System.out.println(2.5);
        System.out.println(3.6F);
        System.out.println(100L);
        System.out.println("hello world");
        
    }
}

Java基础学习(一)

Java基础

Java语言概述

1.Java语言运行机制

2.Java的跨平台核心

3.名词解释

4.类的阐述

注释

变量和运算符

1. 记事本乱码问题

2.关键字和保留字

3.标识符

4. 标识符命名规范

5.变量和数据类型的概念

6. Notepad设置

7.变量的定义方式

8.单位换算

9.数据类型

9.1 整数类型

9.2 浮点类型

9.3 布尔类型

9.4 字符类型

10.转义字符

11.String类型

12.类型转换

12.1 自动类型转换

12.3 强制类型转换

13.包的概念

14.运算符

14.1 算数运算符

14.2 关系运算符

14.3 赋值运算符

14.3 赋值运算符

14.5 三目运算符

14.6 位运算符

15.运算符优先级

17.字面量和常量