千锋教育2218期2022.11.03

复习

---

abstract关键字：
	解决问题：
		子类继承父类，去重写父类方法，导致子类执行结果无法满足特征需求，
	使用 abstract 关键字约束必须重写/实现的方法
	
	
abstract 关键字特征：
	1. abstract 关键字修饰的方法，没有方法体
	2. abstract 关键字修饰的方法，有且只能定义在 abstract 修饰的类内 或者 interface 接口内
	3. 一个非 abstract 修饰的子类，继承 abstract 修饰的父类， 要求实现父类中所有 abstract 修饰的成员方法
	4. abstract 修饰的类无法无法实例化
	5. abstract 修饰的类可以有非 abstract 修饰的方法。
	6. abstract 修饰的类在开发中，多用于【承上启下】
	
	
成员变量和局部变量
	局部变量
		1. 定义在方法大括号以内的变量，包括方法的参数
		2. 局部变量有效范围和作用范围都在对应的大括号以内
		3. 局部变量未定义不能使用
		4. 局部变量未赋值，不能参与除赋值操作之外其他内容
		5. 局部变量内存存储在【栈区】
		6. 局部变量主要用于存储方法运行过程中临时数据内容。
		7. 局部变量在一定范围内唯一，不可以重复
		
		
	成员变量
		1. 成员变量定义在类大括号以内
		2. 成员变量主要用于描述当前类的属性/特征
		3. 成员变量，在对象实例化之后，存储在内存的【堆区】
		4. 成员变量
			作用范围
				哪里处理当前对象的引用，当前对象对应的数据内容有效
			生存周期
				从实例化对象开始，到当前对象被 JVM 的 GC 垃圾回收机制收回结束
		5. 成员变量在实例化对象过程中，如果没有赋值指定数据，成员变量是对应数据类型的 "0" 值
			基本数据类型：
				byte short int ==> 0
				long ==> 0L
				boolean ==> false
				float ==> 0.0F
				double ==> 0.0
				char ==> '\0' -->  编码集 编号为 0 的字符 为不可见字符 null
			引用数据类型
				都是 null
				
			
				
final 关键字
	成员变量
		1. 定义时必须初始化
			方式1：定义成员变量初始化赋值操作
			方式2: 利用构造方法在实例化对象过程中初始化操作
		2. 一旦被复制无法修改
	成员方法
		不能被子类重写，为最终方法
	类
		不能被继承，没有子类
			Java 中的 String 类型就是一个 final 修饰类
	局部变量 
		赋值之后无法修改
	【面试】
		引用数据类型变量使用 final 修饰
			【指向不可变，指向数据空间可变】
			房本 ==> 房子 不可变
			房子里面的装修 可变

static 关键字

1. 补充多类组合

package com.qfedu.c_computer;

/*
 * 目前的代码风格
 * 	1. 纯纯的面向对象代码
 * 	2. 始终贯彻，要什么，给什么，用什么，拿什么
 * 	3. 【数据类型一致化】
 * 		基本数据类型，引用数据类型，Java 原生类型，自定义数据类型
 * 		==> 数据类型
 */
public class Demo2 {
	public static void main(String[] args) {
		/*
		 * 	实例化 Keyboard 键盘和  Screen 屏幕类对象
		 */
		Keyboard keyboard = new Keyboard("IKBC", 56);
		Screen screen = new Screen("华硕", 23);
		
		/*
		 * 实例化  Computer 电脑对象，构造方法参数对应的 Keyboard 键盘类对象和
		 * Screen 屏幕类对象
		 */
		Computer computer = new Computer(keyboard,screen);
		/*
		 * 展示当前电脑配置
		 */
		computer.show();
		System.out.println("-----------------------------");
		
		/*
		 *	屏幕出现问题，需要更换屏幕，实例化一个新的屏幕对象
		 *(这时候只是改变了 Screen 里面 screen 的值 computer里面的 screen 还没有改变 )
		 */
		Screen screen2 = new Screen("AOC", 32);
		System.out.println(screen2.getName() + screen2.getSize());
		/*
		 * Computer 对象调用 setScreen() 方法修饰  Screen成员变量对应的数据
		 *  等价于 ==> 业务逻辑换屏幕
		 *  (在 computer 里面重新调用一下 setScreen 才把 screen2 的值给重新赋值)
		 */
		computer.show();
		computer.setScreen(screen2);
		/*
		 * 展示当前电脑配置
		 */
		computer.show();
		System.out.println("-----------------------------");
		
		/*
		 * 键盘出现问题，需要更换，实例化新的 Keyboard 键盘对象
		 */
		Keyboard keyboard2 = new Keyboard("小米", 202);
		
		/*
		 * 使用 Computer 对象的 setKeyboard 方法，修饰 Keyboard 成员变量数据情况
		 * 等价于 ===> 业务逻辑，换键盘
		 */
		computer.setKeyboard(keyboard2);
		/*
		 * 展示当前电脑配置
		 */
		
		computer.show();
		System.out.println("-----------------------------");	
		
	}
}

2. static 【重点/难点】

2.1 static 修饰静态成员变量

2.11 生活案例分析

共享单车
	1. 存放空间问题
    	存放在公共区域，非个人空间
    2. 共享单车归属权问题
    	属于运营公司，非个人
    3. 共享单车出现了故障
    	该车辆所有人无法使用
    4. 共享单车个人是否有使用权
    	个人租频期间可以使用
    5. 共享单车算不算一个共享资源
    	算
    	
共享充电宝
	1. 存放空间问题
		存放在公共区域，非个人空间
	2. 共享充电宝归属权问题
		属于运营公司， 非个人 ==> 拿走之后，消费超过 99
	3. 共享充电宝出现故障
		该充电宝出现问题，或者充电宝电仓出现问题，所有人都无法使用
	4. 共享充电宝个人可以使用吗
		个人租频期间可以使用
	5. 共享充电宝算不算一个共享资源
		算
		

2.12 案例分析和静态需求引入

package com.qfedu.a_staticField;

public class Demo1 {
	public static void main(String[] args) {
        /*
        按照目前的数据处理方式，国际数据会产生大量的冗余
        是否可以考虑将国际数据 ，进行处理，变为共享特征的数据，供所有的
        Person 对象使用，不占用对象的本身的数据空间。

        */
		Person p1 = new Person(1, "火舞","Japen");
		System.out.println(p1.id + p1.name + p1.country);
		Person p2 = new Person(2, "夏洛特","Japen");
		Person p3 = new Person(3, "宫本武藏","Japen");
	}

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PpJRkAWm-1667490255849)(D:\AQF\teacher\Day15\img\01-数据冗余处理方案分析.png)]

2.13 static 关键字引入和特征分析

特征：
	1. static 修饰的静态成员变量，不推荐使用类对象调用，推荐使用类名直接调用，类对象调用 EClipse 工具会提示警告，静态成员变量和类对象无关。【没有对象】
	2. 静态成员变量无论通过哪一种手段修改，修改之后，所有使用对应数据的位置全部受到影响。
		静态成员变量对应当前【类】唯一，独一份
		静态成员变量是一个共享资源，一处修改，处处受到影响。
	3. 静态成员变量在没有对象之前可以通过类名调用，在对象之后，依然可以通过该类名调用
		静态成员变量和类对象无关【没有对象】
		静态成员变量【生存周期】是早于类对象出现，晚于类对象销毁的。

2.14 类加载问题和静态成员变量内存存储问题

类加载：
	游戏中
		读条，进度条
		王者荣耀 一局游戏进入之前的读条过程，在加载当前游戏开始之前所有的相关资源
		游戏加载过程属于游戏的准备阶段
	Java类加载是什么
		1. JVM 分析当前程序所需的 .class 字节码文件
			目前程序需要 A.class B.class C.class，其他 D.class 不需要
		2. 会根据当前程序的运行情况，分析每一个类应该执行的时间
			流程：
				1. A 执行
				2. B 执行
				3. C 执行
		3. 对应类在执行之前，会将所有的 static 修饰的内容进行处理。
			static 修饰静态成员变量
				加载到内存的【数据区】，准备就绪，已具备数据存储和数据提供能力，并且独一份
			static 修饰静态成员方法
				加载到内存的【方法区】，已经具备执行能力，所有和方法执行相关的内容全部准备就绪
					修饰符，返回值类型，方法名，形式参数列表，方法体
			static 修饰静态代码块
				加载到内存的【方法区】，并且直接执行，有且执行一次
		4. static 内容处理完毕之后，程序才可以运行。

2.15 静态成员变量存储问题

内存：
	栈区
		局部变量
	堆区
		实例化对象，数组
	数据区
		静态成员变量，字符串常量
	方法区
		所有可以执行的代码都在方法区 。 class字节码文件都存放在【方法区】
		1. 静态成员方法
		2. 成员方法
		3. 类型声明
		
静态成员变量在内存的【数据区】
	在程序加载过程中，程序执行之前，静态成员变量内存空间申请，数据类型确定，目前存储数据情况，都全部准备就绪，已经具备数据存储和数据 提供能力。
	开一个饭店，准备好的座椅板凳已经可以使用了。
【static 修饰的静态成员变量独一份，在类文件加载过程中，有且只执行一次】

2.16 static 修饰静态成员变量总结【重点】

1. 存放空间问题
    	静态成员变量存储于内部的【数据区】，属于公共区域
2. 归属权问题
    	静态成员变量属于当前类，和对象无关，【没有对象】
3. 修改问题
    	在一个程序内，静态成员变量一处修改，从修改位置开始，之后所有使用位置全部修改
4. 使用权
    	可以通过类名调用，也可以在类对象中使用
    	调用过程推荐使用类名，不推荐使用类对象【没有对象】   	
5. 共享资源
    	静态成员变量独一份，静态成员变量所有当前类的对象都可以使用，是一个公共资源
6. 生存时间问题
	静态成员变量是随着类文件加载，已经在内存的数据区具备数据存储和数据提供能力，已经可以使用。此时没有实例化对象，当前对象被销毁后，静态成员变量依然可以使用，程序退出之前，所有的对象会被 JVM 销毁，之后才会清理 static 修饰内部才能占用的空间问题。
	static 修饰的静态成员变量和类对象生存周期不同，与对象无关【没有对象】

2.2 static 修饰静态成员方法

2.21 格式

权限修饰符： static 返回值类型 方法名(形式参数列表) {
	方法体：
	
}

2.22 static 修饰静态成员方法特征总结

1. 静态成员方法推荐使用类名调用，不推荐使用类对象调用，因为静态成员变量和对象无关。【没有对象】
2. 静态成员方法不可以直接使用类内的非静态成员变量
	非静态成员变量需要类对象调用，和对象有绑定关系，静态成员方法中【没有对象】
3. 静态成员方法不可以直接使用类内的非静态成员方法
	非静态成员变量需要类对象调用，和对象有绑定关系，静态成员方法中【没有对象】
	tip:
		static 修饰方法，对应的大括号是一个静态区域，静态区域中不可以直接使用非静态内容。
4. 静态成员方法在类文件加载阶段，加载到内存的【方法区】，已经具备执行能力。
	所有和方法执行相关的内容全部准备就绪 修饰符，返回值类型，方法名，形式参数列表，方法体
	
5. 静态成员方法和非静态成员方法执行哪一个效率高？？？
	成员方法执行需要实例化对象支持
		实例化对象过程
			1. 占用一定的时间
			2. 占用一定的内存空间
		当前程序执行完成
			1. 占用一定的时间进行销毁操作
			2. 销毁过程中也需要和内存直接有数据交互。

	静态成员方法执行有且只需要类名直接调用即可，没有类对象约束，节约了时间和空间
6. 静态成员方法常用于工具类使用
	工具箱 ==> 各种各样的工具

2.23 Arrays 工具类

/*
Arrays 工具中主要包含处理数组相关数据的常用方法，所有的方法都是 static 修饰的静态成员方法，直接通过类名词用，效率优秀，方法执行所有的数据都是通过外来参数形式传入。
*/

public static string toString(int[] arr);
	用户提供一个 int 类型数据，将数组中数据使用， + 空格形式隔开，前后使用 [] 包含，返回值一个 String 字符串类型描述当前数组的数据内容
        例如:
			int[] arr = {1, 3, 5}; ==> toString ==> "[1, 3, 5]"
             
public static void sort(int[] arr);    
    Arrays 数组工具类排序方法，底层逻辑是双轴快排，默认排序结果为升序
    例如：
        int[] arr = {1, 3, 5, 7, 9, 2, 8, 4, 6};
		==> sort
        {1, 2, 3, 4, 5, 6, 7, 8, 9};

public static int binarySearch(int[] arr,int num);
	二分法查询，找出指定元素在数组中对应的下标位置，要求参数数组必须通过 sort 排序，找到的下标位置不保证是当前数组中对应数据的第几个，如果没有指定数据，返回负数。
    int[] arr = {1, 3, 3, 5, 5, 5, 6, 6, 9, 9, 20};
	int num = 5;
	==> binarySearch
    int index = 5;
    int num = 7;
	==> binarySearch
    int index < 0; 不存在

package com.qfedu.b_staticMethod;

import java.util.Arrays;

/*
Arrays 工具中主要包含处理数组相关数据的常用方法，所有的方法都是 static 修饰的静态成员方法，直接通过类名词用，效率优秀，方法执行所有的数据都是通过外来参数形式传入。


public static string toString(int[] arr);
	用户提供一个 int 类型数据，将数组中数据使用， + 空格形式隔开，前后使用 [] 包含，返回值一个 String 字符串类型描述当前数组的数据内容
        例如:
			int[] arr = {1, 3, 5}; ==> toString ==> "[1, 3, 5]"
             
public static void sort(int[] arr);    
    Arrays 数组工具类排序方法，底层逻辑是双轴快排，默认排序结果为升序
    例如：
        int[] arr = {1, 3, 5, 7, 9, 2, 8, 4, 6};
		==> sort
        {1, 2, 3, 4, 5, 6, 7, 8, 9};

public static int binarySearch(int[] arr,int num);
	二分法查询，找出指定元素在数组中对应的下标位置，要求参数数组必须通过 sort 排序，找到的下标位置不保证是当前数组中对应数据的第几个，如果没有指定数据，返回负数。
    int[] arr = {1, 3, 3, 5, 5, 5, 6, 6, 9, 9, 20};
	int num = 5;
	==> binarySearch
    int index = 5;
    int num = 7;
	==> binarySearch
    int index < 0; 不存在
    */
public class Demo2 {
	public static void main(String[] args) {
		int[] arr = {1, 3, 5};
		System.out.println(Arrays.toString(arr));
		
		int[] arr1 = {1, 3, 5, 7, 9, 2, 8, 4, 6};
		Arrays.parallelSort(arr1);
		System.out.println(Arrays.toString(arr1)); 
		
		int index = Arrays.binarySearch(arr1, 6);
		System.out.println(index); 
		
		int index1 = Arrays.binarySearch(arr1, 0);
		System.out.println(index1); 
	}
}

2.3 static 修饰静态代码块

2.1 static 修饰静态成员变量

};
System.out.println(Arrays.toString(arr));

	int[] arr1 = {1, 3, 5, 7, 9, 2, 8, 4, 6};
	Arrays.parallelSort(arr1);
	System.out.println(Arrays.toString(arr1)); 
	
	int index = Arrays.binarySearch(arr1, 6);
	System.out.println(index); 
	
	int index1 = Arrays.binarySearch(arr1, 0);
	System.out.println(index1); 
}

}

##### 2.3 static 修饰静态代码块

##### 2.1 static 修饰静态成员变量