java 基础

1. 计算机基础

1.1 常用DOS命令

盘符:     切换盘符 
dir       查看当前目录中的文件以及子目录
cd xx     切换目录
cls       清屏
..        上一级
/         根目录
exit      退出
del xx    删除
ipconfig  查看本机ip
help      帮助

1.2 进制

注意：以下所述为java程序中，且不区分大小写

十进制
二进制
八进制
	以0开头的都是八进制
十六进制
	以0x开头的都是十六进制

2. Java 加载与执行的过程

3. Java介绍

3.1 java的运行

Java是需要编译成功，才可以运行的
	使用 javac 源文件名.java // 编译
	使用 java 类名 // 运行代码

3.2 java源文件的组成

java分为三个部分
	编写类/外部结构
	main方法/主方法/程序入口
	代码部分(main内部)

3.3 java语言的特性

简单性：java中没有指针
面向对象：java是面向对象编程
安全性：运行时堆栈溢出，强制类型检查
健壮性：垃圾回收机制(GC机制)
可移植性：跨平台

4. java语法

4.1 注释

单行注释 //
多行注释 /* */
文档注释 /** * */

4.2 关键字

public class static void …

4.3 标识符

java是GBK编码

命名规则
    ○ 以字母、下划线、$开头
    ○ 由字母、数字、下划线、$组成
    ○ 大小写敏感
    ○ 不可使用关键字
命名规范
    ○ 类名使用大驼峰写法
    ○ 变量名、方法名、参数…小驼峰写法
    ○ 长度最好不要超过15

4.4 变量

4.4.1 变量的定义

可变的数值

在java中，变量需要提前声明并指定数据类型
	例: int a;
		a = 100;
		System.out.print(a);
		或
		int a = 100;
		System.out.print(a);
在java中，可以一次声明多变量，使用逗号隔开即可
	int a = 100,b = 100,c = 100;

4.4.2 变量的分类

按照声明位置分为
    局部变量
    成员变量：相当于全局变量
按照数据类型分为
	基本数据类型变量
	引用数据类型变量

4.5 转义符

\n 换行
\t 水平制表符
\" 双引号
\\ 反斜杠
\' 单引号

5. 运算符

5.1 算术运算符

+ 相加 连接 正号
- 相减 负号
* 相乘
/ 相除
% 取余
++ 自增
后置：先赋值再自身加一
前置：先自身加一再赋值
-- 自减
后置：同上
前置：同上

5.2 连接运算符

+

5.3 赋值运算符

=
+= 相当于 x = x + x
-= 相当于 x = x - x
*= 相当于 x = x * x
/= 相当于 x = x / x
%= 相当于 x = x % x

5.4 关系运算符

以上为判断所用，结果都为boolean

>
<
>=
<=
==
!=

5.5 逻辑运算符

逻辑与   & 相当于 and
逻辑非   | 相当于 or
逻辑异或 ^ 俩个值不一样为true
逻辑非   ! 取反
短路与   && 相当于 and，左边不满足，直接为false
短路或   || 相当于 or，左边不满足，直接为false

5.6 三目运算符

这里需要注意：java的三目运算符是可以嵌套的，虽然一般不推荐

条件 ? true结果 ! false结果

6. 输入

在java中使用input输入需要使用Scanner的模块
	import java.util.Scanner
	Scanner 标识符 = new Scanner(System.in);
	数据类型 标识符 = input.所需类型();
	// 如果类型为char 还需要.charAt(下标);

7. 流程控制语句

7.1 顺序语句

java中，最基础的语句，就是顺序语句，按照顺序执行

7.2 选择语句

7.2.1 if else

if(条件) {
	代码块;
}else if(条件){
	代码块;
}else{
	代码块;
}

7.2.2 switch case

注意：这里default，类似于else，是默认不满足条件，执行的内容，break也不是必需,但是会死循环

case可以叠加编写

switch(被对比内容){
	case 对比内容:
		代码块;
		break;
	default:
        代码块;
        break;
}

7.3 循环语句

7.3.1 for循环

注意：三个表达式并不是必须，可以省略，但是分号不行

for(声明变量;变量范围;自增){
	代码块
}

7.3.2 while 循环

while(条件){
	代码块
}

7.3.3 do while 循环

do{
	代码块
}while(条件)

8. 数据类型

8.1 基本数据类型

8.1.1 数值类型

8.1.1.1 整数类型

byte、short、int、long

取值范围：byte：-128-127

// 注意:在数值后面编写l或L，及表示为long类型
// 在java中，8，16进制都可表示整数值(ASCII),(都是先转换为十进制，在存变量)

8.1.1.2 浮点类型

float、double

float：保留小数点后7位
double：保留小数点后14位
    
// 注意：在小数后面，编写f或者F，及表示float类型
// java中也可以用科学计数法：e2/E2(次方)
// java中，浮点占的字节数，指的是小数部分，非整数

8.1.2 字符类型

char

// char 使用''引起来使用，且只能存放一个
// 字母是可以使用char类型比较大小的，区分大小写，小 > 大

8.1.3 布尔类型

boolean

8.2 引用数据类型

8.2.1 类

系统定义的类
用户自定义的类

8.2.1.1 赋值方式

注意：在赋值null时，其下属性皆不可调用，否则会报空指针异常

1. 将对象的内存地址赋给左侧的对象
c = new Car();

// 2. 将null赋给左侧的对象名(引用名)
c = null;

9. 方法

9.1 方法分类

内置方法
    print()
    println()
    nextInt()
	…
自定义方法
	带参
	// 注意：java的参数需要指定数据类型，返回值也同样
	不带参
	// 注意：不带参数，返回值填写void即可,main方法中也可返回，返回空即可

9.2 语法格式

[修饰符] 返回值类型 标识符(参数) {
	代码块
}

9.3 参数分类

形参
	// 形参变量是功能函数里的变量，只有在被调用的时候才分配内存单元，调用结束后立即释放。所以形参只在函数内部有效
实参
	// 实参可以是常量，变量，表达式，函数等等，但无论是何类型，在进行函数调用是，他们必须有确定的值，以便把这些值拷贝给形参

9.4 递归

在代码中，自身调用自身，就是递归，但是必须满足某个条件，否则会出现死循环，一般不建议递归太多层数，会造成资源的耗尽

经典例子

// 需求：计算 1-n的结果，使用递归求和

/* 
分析
计算方法 f(n) = 1 + 2 + 3 + 4 + 5 + 6 + 7 + …(n-1) + n，含有一定的规律
1. 递归公式：f(n) = f(n-1) + n
2. 递归终结点：f(1) = 1
例如求 1-5的和可以这么算
*/

public class Demo1 {
    public static void main(String[] args) {
        System.out.println("1-5的和为："+sum(5));
    }
   //递归求和
    private static int sum(int n) {
        if ( n == 1){
            return 1;
        }else {
            return sum(n-1)+n;
        }
    }
}

// 1-5的和为：15
// 
// Process finished with exit code 0

10. 面向对象基础

10.1 初始化

// 相当于 def __init__(name): ...
// java中叫做构造函数，一个类中，可以存在多个构造函数

public class CenterApplication {
    int anInt;

    public CenterApplication(int anInt) {
        this.anInt = anInt;
    }

    public static void main(String[] args) {
        CenterApplication ca = new CenterApplication(1);
        ca.test1();
    }
}

10.2 面向对象写法

// 其实就是类，区别在于没有static
// 在java中，添加static相当于函数，可以直接调佣，而没有的话则需要先实例化，才可调佣

public class CenterApplication {
    int anInt;

    public CenterApplication(int anInt) {
        this.anInt = anInt;
    }

    public void test1() {
        System.out.println(this.anInt);
    }

    public static void test2(int anInt) {
        System.out.println(anInt);
    }

    public static void main(String[] args) {
        CenterApplication ca = new CenterApplication(1);
        ca.test1();
        test2(2);
    }
}

10.3 封装

// 在java中，要使用私有封装属性，然后使用get/set，分别获取和赋值，来使用数据
// cpu 类

package homework05;

/**
 * @Author Q9.Gnilu0
 * @Date 2022/9/20
 * @Time 18:45
 */


public class Cpu {
    private String cpuBrand;
    private double cpuPrice;

    public Cpu() {
    }

    public Cpu(String cpuBrand, double cpuPrice) {
        this.cpuBrand = cpuBrand;
        this.cpuPrice = cpuPrice;
    }

    public String output() {
        return this.cpuBrand+this.cpuPrice;
    }
}

// motherboard 类

package homework05;

/**
 * @Author Q9.Gnilu0
 * @Date 2022/9/20
 * @Time 18:46
 */


public class Motherboard {
    private String motherboardBrand;
    private double motherboardPrice;

    public Motherboard() {
    }

    public Motherboard(String motherboardBrand, double motherboardPrice) {
        this.motherboardBrand = motherboardBrand;
        this.motherboardPrice = motherboardPrice;
    }

    public String output() {
        return this.motherboardBrand+this.motherboardPrice;
    }
}

// computer 类

package homework05;

/**
 * @Author Q9.Gnilu0
 * @Date 2022/9/20
 * @Time 18:47
 */


public class Computer {
    private String computerBrand;
    private String computerColor;
    private double computerPrice;
    private Motherboard computerMotherboard;
    private Cpu computerCpu;

    public Computer() {
    }

    public Computer(String computerBrand, String computerColor, double computerPrice, Motherboard computerMotherboard, Cpu computerCpu) {
        this.computerBrand = computerBrand;
        this.computerColor = computerColor;
        this.computerPrice = computerPrice;
        this.computerMotherboard = computerMotherboard;
        this.computerCpu = computerCpu;
    }

    public void output() {
        System.out.println(this.computerBrand);
        System.out.println(this.computerColor);
        System.out.println(this.computerPrice);
        System.out.println(this.computerMotherboard.output());
        System.out.println(this.computerCpu.output());
    }
}

// 测试类

package homework05;

/**
 * @Author Q9.Gnilu0
 * @Date 2022/9/20
 * @Time 18:55
 */


public class ComputerTest {
    public static void main(String[] args) {
        Motherboard motherboard = new Motherboard("三星", 3000);
        Cpu cpuTest = new Cpu("i7-9750H", 3000);

        Computer computerTest = new Computer("机械师", "蓝色", 14999, motherboard, cpuTest);
        computerTest.output();
    }
}

10.4 继承

注意：在没有编写父类类名时，默认继承Object类，同时Object类也是所有类的父类/超类

// 优点
// 减少代码的重复性，提高代码的复用性

语法：在类后后加 extends 父类名即可

/*
单继承
传递性
*/

10.5 多态

注意：多态会优先访问当前子类对象中的重写方法，且只能访问父类中公共部分的实例变量/实例方法

// 多态的构成
	继承
	子类重写父类的方法
	父类类型 对象 = new 子类();
	
// 优点
	减少代码的冗余性

10.5.1 多态类型

10.5.1.1 向上转型

默认构成多态时，就是向上转型，也叫做自动类型转换，由子到父

10.5.1.2 向下转型

构成多态时，访问子类独有的实例变量/实例方法，就是向下转型，也叫做强制类型转换，由父到子

这里注意，需要访问谁，就new一个谁，反之报错

instanceof 方法时用来判断对象类型的一个方法，使用向下转型时要善用

10.6 static 关键字

10.6.1 介绍

static表示静态的，可以修饰属性，方法，代码块，内部类以及静态导入

10.6.2 静态变量

当类加载在内存中时，就给静态变量分配空间，一直到程序结束，所以一般将初始化的内容用静态代码块表示，以节省空间

扩展，new对象的过程

1. 首先将一个字节码文件加载到内存中
2. 同时在堆内存中给静态变量分配空间
3. 执行静态代码块
4. 执行new 在堆内存中创建一个对象，带参数的话在该对象中存放一个实例变量
5. 执行构造方法，完成对实例变量的赋值
6. 最后将右侧对象的内存地址(引用)赋值给左侧的对象

扩展，初始化的顺序

public class LifeCycle {
//静态属性
private static String staticField = getStaticField();
//静态方法块
static {
System.out.println(staticField);
System .out. println(”静态方法块初始化");
}
//普通属性
private String field = getField();
//普通方法块
(
System.out.println(field);
}
//构造函数
public LifeCycle() {
System .out. println("构造函数初始化");
}
public static String getStaticField() {
String statiFiled = "Static Field Initial"; return statiFiled;
}
public static String getField() {
String filed = "Field Initial";
return filed;
}
//主函数
public static void main(String[] argc) { new LifeCycle();
}
}

静态属性初始化 --> 静态方法块初始化 --> 普通属性初始化 --> 普通方法块初始化 --> 构造函数初始化

10.7 final 关键字

10.7.1 介绍

final表示最终，最后，可以修饰类、方法、属性

10.7.2 修饰

其实大体相同

比如修饰类时，其类不可再被基础
	方法：不能再被重写
	属性：不能再做修改

10.8 访问权限

10.8.1 类

// 分为了公共类/非公共类
前者 该类可以在任意包中使用
后者 只能在当前包中使用
区别在于时候在类前编写public

10.8.2 成员

访问权限	在当前类中	在当前包中	在其他包的子类	在任意包任意类中
private私有的	可以使用	不可以使用	不可以使用	不可以使用
默认的	可以使用	可以使用	不可以使用	不可以使用
protected受保护的	可以使用	可以使用	可以使用	不可以使用
public 公共的	可以使用	可以使用	可以使用	可以使用

10.9 抽象类

一般会在父类方法无实现时，编写为抽象类，需要abstract关键字

// 注意，抽象类不能创建对象，其实就是抽象类也是多态的一种形式

/*
特点：
	1. 使用abstract关键字
	2. 抽象方法没有方法体，不需要编写大括号
	3. 抽象方法必须在抽象类中
	4. 子类继承抽象类时，必须重写父类方法
	5. 抽象类不能创建对象
*/

public abstract class A{
	public void a();
}

public class B{
	public static void main(String[] args) {
		A a = new B();
		a.a();
	}
}

10.10 接口

一个抽象类中只有抽象方法，就可以使用接口

// 接口使用interface关键字，接口中的抽象方法默认有public abstract

特点：
	1. 实现类实现接口时，必须重写接口中所有抽象方法，否则实现类也是抽象类
	2. 接口不能创建对象，其实也是多态的一种
	3. 接口属于引用数据类型，在内存中存放地址
注意：
	1. 接口是对功能的封装
	2. 接口是多实现，继承是单继承
	3. 接口必须不能继承类
	4. 在java中，一个类有继承也有实现，则继承必须位于实现的前面

10.11 内部类

在一个类中在编写一个类，就叫内部类

成员内部类
public void output(){
	Inner inner = new Inner();
}
Class Inner{
	// 成员内部类
}

静态内部类
public static void output(){
	Inner inner = new Inner();
}
static class Inner{
	// 静态内部类
}

局部内部类
public void output(){
	class Inner{
		// 局部内部类
	}
}

匿名内部类
public static void main(String[] args) {
	Animal animal = new Dog();
	class Cat implements Animal{
		@Override
		public void eat() {
			// 匿名内部类
		}
	}
}

11. Object类

1. 在java中,object类是所有类的超类，也叫父类，要么直接继承Object类，要么间接继承Object类
2. 在java中，当一个类没有使用extends指定继承哪个父类时，系统默认继承Object类
3. 在java中，也就是说，所有的类都有继承性

11.1 toString()

类似string方法，快捷键ALt+Insert toString快速创建，快速输出成员变量

11.2 equals()

比较字符串类型的方法，比较对象的话，可以通过重写比较，快捷键Alt+Insert equals/has 快速创建

12. 类和类的关系

继承

实现

依赖

组合

聚合