Java学习笔记-Day1

数据处理能力 / 大数据 / JavaSE
字数统计: 3.8k   |   阅读时长≈ 15 分钟

学习地址：https://www.kuangstudy.com/course

Part 1：Java入门

什么是计算机？

计算机是能够按照程序运行，自动、高速处理海量数据的现代化智能电子设备，由硬件和软件组成。

  • 计算机硬件：CPU、IO设备、内存……

image-20220216112111310

  • 计算机软件：可以使计算机按照事先预定好的顺序完成特定的功能，按其功能可划分为系统软件与应用软件。
    • 系统软件：DOS（Disk Operating System）、Windows、Linux、Unix、Mac、Android、iOS
    • 应用软件：WPA、QQ、微信、英雄联盟……

windows常用快捷键

1
2
3
4
# 复制	ctrl + C
# 粘贴	ctrl + V
# 剪切	ctrl + X
# 放大镜	win + '+'

基本的Dos命令

1
2
3
4
5
6
7
8
9
10
11
12
13
# 盘符切换 		E:
# 查看当前目录   dir
# 切换目录 		cd /d E:\Java
# 返回到上级目录 cd..
# 清除屏幕  	cls(clear screan)
# 退出终端 		exit
# 查看电脑ip 	ipconfig
# 用于验证与远程计算机的连接 ping www.baidu.com
# 文件操作 
# 创建文件夹    md 目录名
# 删除文件夹    rd 目录名
# 创建文件		cd>文件名
# 删除文件		del>文件名

Java三大版本

  • JavaSE：标准版（桌面程序、控制台开发……）
  • JavaME：嵌入式开发（手机、小家电……）
  • JavaEE：企业级开发（Web端、服务器开发……）

JDK、JRE、JVM

image-20220216115920056

Java环境准备

  • JDK下载安装、添加环境变量（…jdk/bin和…jdk/jre/bin）

https://www.oracle.com/java/technologies/javase/javase8-archive-downloads.html

​ 环境测试：打开cmd，输入：java -version

  • IDEA集成环境安装

https://www.jetbrains.com/idea/

Hello World详解

  • cmd执行java程序
  1. 新建一个文件夹，存放代码
  2. 新建java文件：Hello.java（文件名要与类名保持一致！）
  3. 编写java程序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.zhou.hello;

/* 学习摘要：
1. 基本代码块：类{主方法}
2. 主方法快捷键：psvm
3. 打印快捷键：sout
4. Java运行流程：先将java文件编译生成class文件，再执行class文件
 */

public class Demo01 {  // 类定义
    // 定义主方法，快捷键psvm
    public static void main(String[] args){
        // 打印输出：Hello World！
        System.out.print("Hello World!"); // 不换行打印
        System.out.println("Hello World!"); // 换行打印，快捷键sout
        System.out.print("Hello World!");
    }
}
  1. 编译生成class文件：打开cmd（与java文件路径保持一致），输入：javac Hello.java
  2. 运行class文件：java Hello
  • 执行过程

image-20220216122418415

  • 编译型和解释型语言的区别

编译型：高级语言——>编译器——>翻译成可执行文件——>机器执行

解释型：高级语言——>解释器一句一句“翻译”成机器语言来一句一句执行

参考资料：https://blog.csdn.net/xwx_100/article/details/83212067

Part2：Java基础

注释

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.zhou.base;

// 1. 注释
// 单行注释
/*
这是
多行注释
 */
public class Demo01 {
    public static void main(String[] args) {
        System.out.println("好的代码从学会写注释开始！");
    }
}

标识符和关键字

标识符

  1. 所有的标识符都应该以字母（A-Z或a-z）、美元符（$）、下划线（_）开始；
  2. 首字符之后可以是字母（A-Z或a-z）、美元符（$）、下划线（_）或数字的任何字符组合；
  3. 不能使用关键字作为变量名或方法名；
  4. 标识符是大小写敏感的；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package com.zhou.base;

//2. 标识符和关键字
// 关键字解释
/*
1. public：一种控制方式，表示共用模式
2. class：用于类的声明
3. static：变量修饰符，全局（静态）变量
4. void：声明当前成员没有返回值
 */
public class Demo02 {
    public static void main(String[] args) {  // 翻译：共用的全局的没有返回值的主方法
        System.out.println("Hello World!");
        // 标识符命名规则
        /*
        1. 首字符只能为字母（大小写均可）、下划线"_"、美元符"$"
        2. 首字符外可以为字母（大小写均可）、下划线"_"、美元符"$"、数字
        3. 不能为关键字
        4. 大小写敏感
         */
        String Name = "Guiyi";
        String name = "guiyi";
        System.out.println(Name);
        System.out.println(name);
    }
}

关键字

  • 访问控制
Java关键字 关键字含义
private 一种访问控制方式：私用模式，访问控制修饰符，可以应用于类、方法或字段（在类中声明的变量）
protected 一种访问控制方式：保护模式，可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符
public 一种访问控制方式：共用模式，可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符。
  • 类、方法和变量修饰符
Java关键字 关键字含义
abstract 表明类或者成员方法具有抽象属性，用于修改类或方法
class 声明一个类，用来声明新的Java类
extends 表明一个类型是另一个类型的子类型。对于类，可以是另一个类或者抽象类；对于接口，可以是另一个接口
final 用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量
implements 表明一个类实现了给定的接口
interface 接口
native 用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new 用来创建新实例对象
static 表明具有静态属性
strictfp 用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范
synchronized 表明一段代码需要同步执行
transient 声明不用序列化的成员域
volatile 表明两个或者多个变量必须同步地发生变化
  • 程序控制
Java关键字 关键字含义
break 提前跳出一个块
continue 回到一个块的开始处
return 从成员方法中返回数据
do 用在do-while循环结构中
while 用在循环结构中
if 条件语句的引导词
else 用在条件语句中，表明当条件不成立时的分支
for 一种循环结构的引导词
instanceof 用来测试一个对象是否是指定类型的实例对象
switch 分支语句结构的引导词
case 用在switch语句之中，表示其中的一个分支
default 默认，例如：用在switch语句中，表明一个默认的分支。Java8 中也作用于声明接口函数的默认实现
  • 错误处理
Java关键字 关键字含义
try 尝试一个可能抛出异常的程序块
catch 用在异常处理中，用来捕捉异常
throw 抛出一个异常
throws 声明在当前定义的成员方法中所有需要抛出的异常
  • 包相关
Java关键字 关键字含义
import 表明要访问指定的类或包
package 包
  • 基本类型
Java关键字 关键字含义
boolean 基本数据类型之一，声明布尔类型的关键字
byte 基本数据类型之一，字节类型
char 基本数据类型之一，字符类型
double 基本数据类型之一，双精度浮点数类型
float 基本数据类型之一，单精度浮点数类型
int 基本数据类型之一，整数类型
long 基本数据类型之一，长整数类型
short 基本数据类型之一,短整数类型
null 空，表示无值，不能将null赋给原始类型（byte、short、int、long、char、float、double、boolean）变量
TRUE 真，boolean变量的两个合法值中的一个
FALSE 假，boolean变量的两个合法值之一
  • 变量引用
Java关键字 关键字含义
super 表明当前对象的父类型的引用或者父类型的构造方法
this 指向当前实例对象的引用，用于引用当前实例
void 声明当前成员方法没有返回值，void可以用作方法的返回类型，以指示该方法不返回值
  • 保留字
Java关键字 关键字含义
goto 保留关键字，没有具体含义
const 保留关键字，没有具体含义，是一个类型修饰符，使用const声明的对象不能更新

变量和数据类型

  • 强类型语言

    要求变量的使用严格规定，所有变量都必须先定义后才能使用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    package com.zhou.base;// 3. 变量和数据类型
    /*
    1. Java为强类型语言，所有的变量必须先定义后才能使用；
    2. Java数据类型分两大类：基础类型（整型、浮点型、字符型、布尔型）和引用类型（类、接口、数组）；
     */

    public class Demo03 {
        public static void main(String[] args) {
            // 变量的定义：1）声明和初始化同时进行
            String name1 = "Guiyi";
            // 变量的定义：2）先声明，后初始化
            String name2;
            name2 = "xiaoming";  // 必须初始化变量，否则会报错！
            System.out.println(name1);
            System.out.println(name2);
            System.out.println("--------------------------------------------");
            System.out.println("---------------八大基础类型-----------------------");
            byte num1 = 1;
            int num2 = 10;  //常用
            short num3 = 100;
            long num4 = 10000;
            float num5 = 1.1f;
            double num6 = 1.111111;  //常用
            char c1 = 'a';
            boolean flag = true;
            System.out.println("---------------强制转化（高转低）----------------------");
            int a = (int)1.1 + 2;
            System.out.println("---------------自动转化（低转转）----------------------");
            double b = 2 + 5;
            System.out.println(a);
            System.out.println(b);
            System.out.println("c1="+c1);
            System.out.println("c1="+(int)c1);
        }
    }

  • Java的数据类型分为两大类

    1. 基本类型（primitive type）
      • 整型：byte占1个字节、short占2个字节、int占4个字节、long占8个字节
      • 浮点型：float占4个字节、double占8个字节
      • 字符型：char占2个字节
      • 布尔型：boolean占1位，其值只有true和false两个
    2. 引用类型（reference type）
      • 类
      • 接口
      • 数组

  • 什么是字节？

在计算机数据存储中，存储数据的基本单位是字节B(Byte)，最小单位是位bit。

8个bit组成1个Byte(字节)，能够容纳1个英文字符，不过一个汉字需要2个字节的存储空间。

计算机常用的存储单位和换算如下：

8 bit = 1 Byte 一字节

1024 B = 1 KB （KiloByte） 千字节

1024 KB = 1 MB （MegaByte） 兆字节

1024 MB = 1 GB （GigaByte） 吉字节

1024 GB = 1 TB （TeraByte） 太字节

1024 TB = 1 PB （PetaByte） 拍字节

1024 PB = 1 EB （ExaByte） 艾字节

1024 EB = 1 ZB （ZetaByte） 泽字节

1024 ZB = 1 YB （YottaByte） 尧字节

1024 YB = 1BB（Brontobyte）珀字节

1024 BB = 1 NB （NonaByte） 诺字节

1024 NB = 1 DB （DoggaByte）刀字节

  • 数据类型拓展
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package com.zhou.base;

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

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

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

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

        System.out.println((int)c1); // 强制转换
        System.out.println((int)c2); // 数据类型的转换需注意内存溢出和精度问题！

        // 所有的字符本质还是数字
        // 编码 Unicode 映射表（97 = a, 65 = A）   2字节 0-65536
        // u0000-uFFFF
        char c3 = '\u0061';
        System.out.println(c3 + "\n" + (int)c3); // a
    }
}

基本运算符

Java中基本运算符分为以下七种（重点掌握前四种），分别为：

  • 算数运算符：+，-，*，/，%（取余数），++（自增），–（自减）
  • 赋值运算符：=
  • 关系运算符：>,<,>=,<=,==（等于）,!=（不等于）,instanceof
  • 逻辑运算符：&&（逻辑与），||（逻辑或），!（逻辑非）
  • 位运算符：：&，|，^，~，>>，<<，>>>
  • 条件运算符：？：
  • 扩展运算符：+=，-=，*=，/=

Java中运算符优先级排序：

指针最优，单目运算优于双目运算。如正负号。先乘除，后加减。先算术运算，后移位运算，最后位运算。逻辑运算最后计算。

以下运算符按从上到下，优先级从高到低排列，同行为相同优先级，相同优先级需要考虑结合性：

括号：()、[]

正负号：+、-

自增自减，非：++、–、!

乘除，取余：*、/、%

加减：+、-

移位运算：<<、>>、>>>

大小关系：>、>=、<、<=

相等关系：==、!=

按位与：&

按位异或：^

按位或：|

逻辑与：&&

逻辑或：||

条件运算：?:

赋值运算：=、+=、-=、*=、/=、%=

位赋值运算：&=、|=、<<=、>>=、>>>=

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
package com.zhou.base;
// 运算符逻辑顺序：从高到低
// 指针最优，单目运算优于双目运算。如正负号。先乘除，后加减。先算术运算，后移位运算，最后位运算。逻辑运算最后计算。
/*
()
一元运算符  ++  --  ！
算术运算符 先*  /  %  后  +  -
关系运算符    >  >=  <    <=
相等运算符    --    !=    ===    !==
逻辑运算符  先&&    后||
赋值运算符 =
 */
public class Demo04{
    public static void main(String[] args){
        // 算数运算符
        int a = 10;
        int b = 20;
        int c = 15;

        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        // 在有可能出现小数点时候进行类型转换
        System.out.println((double)a / b);
        System.out.println(a % b);

        // ++ --
        int d1 = a++;// a++ ：a = a + 1，但是在这种情况下，先给b赋值，再自增
        int d2 = ++a;// ++a：a = a + 1，在这种情况下，先自增，再将自增后的结果赋值给b
        //a--,--a可类比于此
        System.out.println(a);
        System.out.println(d1);
        System.out.println(d2);

        // 关系运算符
        // 返回的结果：正确、错误，即为布尔值
        System.out.println(a > b);
        System.out.println(a < b);
        System.out.println(a == b);
        System.out.println(a != b);

        //逻辑运算符
        boolean b1 = true;
        boolean b2 = false;
        System.out.println("b1 && b2:" + (b1 && b2));// 逻辑与运算：两个变量都为真，结果为真
        System.out.println("b1 || b2:" + (b1 || b2));//逻辑非运算：两个变量有一个为真，结果为真
        System.out.println("!(b1 && b2):"+ !(b1 && b2));//如果是真，则为假，反之亦然

        // 位运算符
		/*
		二进制数
		A = 0011 1100
		B = 0000 1101

		A&B = 0000 1100 如果对应位都为1，则为1，如果不是则为0
		A|B = 0011 1101 如果对应位都为0，则为0，如果不是则为1
		A^B = 0011 0001 如果对应位相同，则为0，如果不相同则为1
		~B = 1111 0010 如果对应为为1，则为0，如果为0，则为1

		0000 0010 2
		0001 0000 16  2*2*2*2
		*/
        System.out.println(2 << 3);   // << *2^n , >> /2^n
        // 结果为16，即将2的二进制数向左移3位，如上

        // 条件运算符
        // x ? y : z
        //如果x为真，则返回y，否则返回z

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

        // 扩展运算符
        int x = 10;
        int y = 20;
        x += y;// x = x + y
        System.out.println(x);
        x -= y;// x = x - y;
        System.out.println(x);
    }
}

包机制

1
2
3
4
5
6
7
// 包语句的语法格式
package pkg1[.pkg2[.pkg3...]];

// 导入包
import package1[.package2...].(classname|*);

// 一般利用公司域名倒置作为报名：com.zhou.×××
打赏
  • 版权声明： 本博客所有文章除特别声明外，著作权归作者所有。转载请注明出处！
  • Copyrights © 2022-2024 归一
  • 访问人数: | 浏览次数:

请我喝杯咖啡吧~

支付宝
微信