java入门笔记

1. Java相关概念

编程：用倾向于自然语言的方式编写指令代码的过程
编译：将自然语言指令代码转化为机器语言（二进制）的过程

系统差异化：为了用不同类型的芯片实现相同的功能，就需要用不同的指令代码操作不同的计算机硬件设备
解决方法：Java 可以通过软件模拟虚拟机器（JVM），用一套代码操作相同的虚拟机器上，从而屏蔽不同计算机设备的差异，简化指令代码的编写
字节码：JVM 接收的指定代码

JDK：Java Development Kit，Java 开发工具包，封装经常使用的指令代码和编译器
JRE：Java Runtime Environment，Java 运行环境，可以直接使用编译好的字节码
src：.java 源码文件存放目录
out：.class 编译后的类文件（字节码）存放目录
jdk/bin/java.exe：启动 JVM，读取字节码文件（翻译成机器指令）

2. 第一个Java代码-Hello World

2.1 Hello World代码

package chapter01;

public class Java01_HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

执行上面这段代码，就会输出结果

2.2 流程梳理

JVM 把机器指令传给操作系统（OS），OS 通过 CPU 读取指令，执行时可能会分配内存、存储磁盘数据，最后反馈结果，将数据打印显示在控制台（CONSOLE）上。

2.2 添加注释

在 Java 中，注释的方式主要有两种：

（1）单行注释：// xxxxx
（2）多行注释：/* xxx 
xxx
*/

2.3 内存分配

数据存储：只存储数据
向量存储：存储数据类型、大小、位置（指向）
变量：可以改变的向量存储
创建变量：在内存空间中创建向量存储

3. 基本语法

3.1 变量

本质是可以改变的向量存储

声明：数据类型 + 变量名称
赋值：变量名称 = 数据
使用：直接访问变量名称即可
初始化：使用变量之前，必须给变量赋值

package chapter02;

public class Java01_Variable {
    public static void main(String[] args) {
        /*变量是可以改变的向量存储
        1.申明变量:数据类型 + 变量名称
        2.赋值变量:变量名称 = 数据
        3.使用变量
         */
        String name;
        name = "zhangsan";
        System.out.println(name);
        
        String username = "lisi";
        System.out.println(username);
    }
}

3.2 命名规则

英文拉丁字母（汉语拼音）
符号 @ # % $，但 标识符只能用下划线和 $ 符号，其他符号不能使用，包括空格也属于特殊符号，不能作为标识符使用
数字（0-9），可以使用，但不能用作命名开头
区分大小写，在大括号{}范围内命名不允许重复
关键字（保留字）：Java 中预先定义好了一些标识符名称，不允许重复定义
驼峰命名法（规范命名）：多个单词拼接，第一个单词首字母小写，其他单词首字母大写
标识符长度无限制
中文亦可命名，但容易出现乱码

关键字如图

3.3 数据存储单位和数据类型

数据存储单位：
比特（bit位）：数据运算的最小存储单位
字节（byte）：计算机数据的最小存储单位
转换：1 byte = 8 bit
其他单位：1GB = 1024MB = ……
Java 的数据类型可以确定数据范围

3.3.1 基本数据类型

整数类型：
byte  8位
short  16位
int  32位
long  64位
浮点类型：
float：单精度浮点数
double：双精度浮点数
默认情况下，小数点数据会被识别为精度更高的双精度 double 类型
如果想要设置单精度，数据需要使用 F / f 结尾
字符类型：
char
用符号（单引号）表示文字内容
布尔类型：
boolean
true or false

3.3.2 数据类型转换

1. 注意数据类型
	不同数据类型不能赋值转换
2. 注意数值范围（从小到大）
	byte -- short -- int -- long -- float -- double
3. 范围大的数据无法直接转换为范围小的数据，但可以使用小括号间接强制转换

3.3.3 引用数据类型

可以被引用的数据类型（存储时箭头的指向，变量指向引用数据类型）
变量如果是基本数据类型，在存储时不会有相应箭头（只有向量存储）
包括 string、类、数组、接口、枚举、null 等

3.4 运算符相关概念

3.4.1 运算符

参与数据运算的符号
和字符不同，无法自行定义
表达式：运算符 + 数据，符合Java语法规则的指令代码
运算符分类：

3.4.2 算术运算符

二元运算符：两个元素参与运算
3 * 2
1 / 2  //0
1.0 / 2  //0.5
5 % 2  //1
表达式的结果类型是元素种类类型最大的那一种，最小使用的类型为 int（可以强转）

一元运算符：一个元素参与运算
++, --  自增/自减运算符
++i, i++  先+1/后+1

赋值运算符：
=
将右边的表达式结果赋值给左边的变量
元素运算后重新赋值给自己，复合赋值，如：+=
如果使用 复合赋值运算符，数据的类型不会发生变化，如：byte b1 += 20

关系运算符：
比较两个数据之间的关系
==, !=, >= 等
结果为布尔类型

逻辑运算符：
描述多个条件表达式之间关系的运算符
变量 = 条件表达式1 逻辑运算符 条件表达式2
结果为布尔类型
& 与，两个条件表达式都要计算出结果，全true得true，其他false
| 或，两个条件表达式都要计算出结果，有true得true，没true得false
&& 短路与，根据第一个表达式的结果决定是否执行第二个条件表达式，如果第一个就能判断出结果（false），则不会执行第二个
|| 短路或，如果第一个就能判断出结果（true），则不会执行第二个
! 非，相反运算

三元运算符：
三个元素参与运算
变量 = 条件表达式 ? 任意表达式1 : 任意表达式2
判断，如果条件表达式结果为true，执行任意表达式1，false则执行任意表达式2

3.5 流程控制

3.5.1 流程控制基本概念

流程控制：

计算机在执行代码时对指令代码执行顺序的控制
Java 流程控制主要分三种：
顺序执行
分支执行
重复执行
顺序执行
按代码和语法出现的先后顺序执行
分支执行
根据判断条件执行分支逻辑
可选分支、必选分支（多选一）、多分支、特殊分支（switch）
重复执行
根据条件循环执行
while、do ... while、for
break 和 continue

3.5.2 分支执行

可选分支（单分支，if true or false）
必选分支（双分支，if / else）
多分支（多重判断，if / else if / {else}）
特殊分支（等值判断，switch case）
switch：
会对数据进行判断，如果等于某一个分支数据的值，会执行该分支的逻辑代码，并顺序执行后面的分支
如果一个分支都无法匹配，那么一个分支都不会执行，此时如果还想执行分支，可以增加 default 关键字（必选）
如果执行某个分支后，不想再执行其他分支，可以使用 break 关键字跳出当前分支

package chapter03;

public class Java01_FlowControl {
    public static void main(String[] args) {
        System.out.println("第一步");
        System.out.println("第二步");
        //判断条件表达式
//        int i = 10;
//        if (i == 10) {
//            System.out.println("分支");
//        }
        // 双分支结构
//        int i = 10;
//        if (i == 10) {
//            System.out.println("分支1");
//        } else {
//            System.out.println("分支2");
//        }
//        System.out.println("第三步");
        //多分支
        int i = 30;
        if (i == 10) {
            System.out.println("分支1");
        } else if (i == 20) {
            System.out.println("分支2");
        }
        else {
            System.out.println("分支3");
        }
        System.out.println("第三步");
    }
}

package chapter03;

public class Java02_FlowControlSpecial {
    public static void main(String[] args) {
        System.out.println("第一步");
        System.out.println("第二步");
        //特殊分支结构
        int i = 30;
        switch (i) {
            case 10:
                System.out.println("分支1");
            case 20:
                System.out.println("分支2");
            case 30:
                System.out.println("分支3");
            case 40:
                System.out.println("分支4");
        }
        System.out.println("第三步");
    }
}

3.5.3 重复执行

while：有条件循环
while (条件表达式) {}
先判断条件，{} 执行完毕后，重新判断条件
小心死循环
do {} while：
先执行 do{}，再判断条件
至少执行一次
for ( a; b; c)
初始化表达式（用于条件表达式中的变量初始化）
条件表达式（决定是否执行循环）
更新表达式（控制循环次数）
break 跳出当前层循环，不再执行后续操作
continue 跳过当前层的这次循环，继续执行下次循环

package chapter03;

public class Java03_Circle {
    public static void main(String[] args) {
        System.out.println("第一步");
        //1. while 有条件循环
//        int age = 30;
//        while ( age < 40 ){
//            System.out.println("循环代码");
//
//            age++;
//        }
        //2. do while
//        int age =30;
//        do {
//            System.out.println("循环代码");
//        } while (age < 40);
        //3. for循环
        int age =30;
        for (int i=30;i<40;i++){
            System.out.println("循环代码");
        }

        System.out.println("第二步");
    }
}

4. 面向对象

面向对象：是一种编程思想，一种分析事物和解决问题的方式，我们通过编程语言的语法来体现这种思想

4.1 面向对象基本概念

类和对象：
类表示归纳和整理
对象表示具体事物
类：
class 类名 { 
特征（属性）
功能（方法）
}
步骤：（比如做一道红烧排骨）
先声明类（菜）
创建对象（红烧排骨）
声明属性，属性就是类中变量
声明方法（烹饪过程，void 方法名() {}）
执行方法（对象.属性，对象.方法名()）
注意：
在对同一个对象的不同属性进行操作的时候，需要用变量来引用这个对象
Cooking c = new Cooking()
创建对象，用对象类型的变量来引用它，当处理变量时，处理的其实是引用的对象
基本数据类型不是对象，因此不是引用数据类型
用“+”拼接字符串
如果需要新菜，用new再次创建即可

package chapter04;

public class Java01_Object {
    public static void main(String[] args) {
        Cooking c = new Cooking();
        c.name="红烧排骨";
        c.food="排骨";
        c.execute();
        //TODO 面向对象
        Cooking c1 = new Cooking();
        c1.name = "红烧鱼";
        c1.food = "鲫鱼";
        c1.execute();
    }
}

class Cooking{
    //特征 属性
    //名字
    String name;
    //类型
    String type = "红烧";
    //食材
    String food;
    //佐料
    String relish="大料";
    //执行
    void execute() {
        System.out.println("准备食材:"+food);
        System.out.println("准备佐料:"+relish);
        System.out.println("开始烹饪");
        System.out.println(name+"烹饪完成");
    }

}

内存分为三个部分：栈、堆、元空间
	栈 存储方法、变量 User user
	堆 存储对象 new User()
	元空间 存储类的信息

对象是将内存地址赋值给变量，所以变量其实引用了内存中的对象，所以称之为引用对象，而该变量类型称为引用数据类型（new）
空对象（null）是特殊的对象，没有引用的对象（没有在堆中创建，箭头不存在），也称为关键字对象
所有引用类型变量的默认取值就是 null

4.2 属性

类的对象的相同特征

	语法类似变量的声明，属性类型 名称 = 值

	如果在声明属性时进行了初始化赋值，所有对象的属性就完全相同

	因此不用在声明属性时初始化，属性会在构造对象的时候默认初始化

	默认初始化值取决于属性类型（0，0.0，false，空字符，null）

	变量 是方法的一部分，作用域小，只有在当前大括号内有效

	属性 是对象的一部分，不仅在当前类中有效，可以随对象在其他地方使用

	变量使用前必须初始化，否则会报错；但属性可以不用初始化，JVM 会自动完成初始化

4.3 方法

声明和调用方式

	名词：类、属性

	动词：方法（注意调用顺序，比如先注册后登录）

	void 表示方法的结果为空

	返回值类型 + 方法()，使用 return + 返回值 返回结果

4.4 方法参数

使用外部数据控制方法内部实现的操作（参数语法）

	内部：方法名(参数类型 参数名称)

	外部：传递参数

	当方法传递多个参数时，参数个数、类型、顺序都要匹配

	当参数个数不确定，但类型相同时，可以采用 可变参数 语法声明

	格式：参数类型... 参数名称（String... name）

	如果方法头还包含其他类型参数，可变参数应声明在最后

4.5 参数传值

方法执行在栈内存中完成，在栈帧中存放参数、变量、执行逻辑

	保持CPU箭头不变，调用新方法压栈、执行完方法弹栈

	引用对象及属性存于堆中，调用新方法压栈时，传递箭头（同一个引用地址），但如果进行 字符串拼接 等操作，会创建一个新的字符串（指向新的引用地址）（传递 对象 修改属性不会），如果执行方法内的 s = s + 10，则 新s 和 原s 指向的不是同一个引用地址，因此，执行完毕后，会弹出方法内的 新s 和引用地址，打印出的还是 原s

	Java 中方法参数的传递为 值传递

	基本数据类型传数值，引用数据类型传引用地址

4.6 静态

	针对于具体对象的属性称为对象属性，成员属性，实例属性

	针对于具体对象的方法称为对象方法，成员方法，实例方法

	static：和对象无关，只和类相关（可以通过 类名. 直接访问）

	先有类，再有对象

	有成员方法的时候，静态方法（类）一定存在，因此 可在成员方法内部调用静态方法/属性，但静态方法不能访问成员方法/属性

4.7 静态代码块

	static { xxx }

	类的信息加载完成后，会自动调用静态代码块，可以完成静态属性的初始化（按照声明静态代码块顺序依次执行）

	对象准备创建时（对象创建前），也会自动调用代码块 {xxx}，但不是静态的