千峰教育2218期2022.11.02

最新推荐文章于 2023-03-27 13:29:20 发布

Te Fuir54

最新推荐文章于 2023-03-27 13:29:20 发布

阅读量50

点赞数

文章标签： java jvm 数据结构

本文链接：https://blog.csdn.net/weixin_66648840/article/details/127660146

版权

复习

JavaBean 规范
	1. 所有成员变量全部私有化
	2. 必须提供对应当前类的无参数构造方法
	3. 所有私有化成员变量提供对应的 Setter and Getter 方法。

权限修饰符：
	private 
		私有化，可以用于修饰 成员变量，成员方法，构造方法，修饰的内容类外无法使用
	public 
		公开的，公共的，可以用于修饰成员变量，成员方法，构造方法，修饰的内容在符合语法调用规则的情况下，类外可以使用。
		
this 关键字：
	目前而言 this 关键字用于区分成员变量和参数变量

public class Person{
    private int  id;
    private String  name;
    private int age;
    
    public  Person() {}
    public  Person(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    
    public void setId(int id) {
        this.id = id;
    }
    public int getId() {
        return id;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
}

继承：
	关键字 ： extends
	格式：
		class A extends B {
		
		}
		A 类是 B 类的一个子类
		B 类是 A 类的唯一父类
			Java 采用单继承模式
			
	继承之后：
		1. 子类可以通过继承，得到父类中非私有化的成员变量和成员方法
		2. 子类无法通过继承，得到父类的私有化成员（成员变量，成员方法）
		
	Java 中的继承的主要目的
		1. 统一数据类型
		2. 方法延续和拓展
		
	重写：
		父类方法继承给子类使用，子类调用过程中无法满足特定的需求，需要采用重写方式满足子类的情况
		要求
			1. 必须存在继承关系，子类重写父类方法
			2. 要求子类重写父类的方法。方法声明必须完全一致
			3. 子类可以根据自身需求，重写方法体内容
			4. 建议使用 @Override 注解，开启重写格式检查

多类合作：
	【核心】
		1. 多文件编程
		2. 自定义数据类型作为方法参数【要什么，给什么，用什么，拿什么】
		3. 面向对象代码逻辑实现内容

abstract 关键字，final 关键字和多类合作

1. abstract 关键字

1.1 代码的实际问题

	目前代码中，设计 LOL 英雄基类，同时带有 qwer 四个方法对应 四个技能，子类（HappywindBoy, Vayne） 继承父类，可以直接使用已经具备执行能力的 qwer 方法，但是如果直接使用，会发现父类方法无法满足子类的特征情况，并且没有语法报错，是在用户使用的过程中发现对应问题
		此时可以使用重写操作，在子类中重写父类，满足子类特征情况

目前代码流程
	继承 ==> 调用 ==> 出现业务问题 ==> 重写 ==> 解决问题
期望的代码流程
	继承 ==> 子类强制重写【不满足语法报错】 ==> 用户完美使用
【期望】
	父类限制子类操作，必须强制重写必要方法，并非是在用户发现问题之后，再返工！！！！

1.2 使用 abstract 关键字解决以上问题

abstract 关键字作用：

父类中使用 abstract 关键字修饰的成员方法，要求子类强制重写

package com.qfedu_a_abstract;
 /*
 * 
 *  abstract 关键字演示代码，利用 Eclipse 提示信息包括快速修复功能，引导完成代码
 *  abstract 关键字作用：
 *  	父类中使用 abstract 关键字修饰的成员方法，要求子类强制重写
 *  
 *  
 *  第一步：
 *  	使用 abstract 关键字修饰目标方法
 *  	【错误一】
 *  		Abstract methods do not specify a body
 *  		abstract 修饰的方法不能有方法体【语法要求】
 *  	【语法总结】
 *  		abstract 修饰的方法没有方法体
 *  	【Eclipse 快速修复】
 *  	Ctrl + 1 ==> 选择 Remove method body
 *  	Eclipse 快速修复建议选择删除方法体
 *  
 *  第二部：
 *  	删除方法之后，代码中依然存在问题
 *  	【错误二】
 *  		The abstract method q in type LOLHero can only be defined by an abstract class
 *  			在 LOLHero 类内使用 abstract 修饰的方法 q 有且只能定义在一个 abstract 修饰类内
 *  
 *  		The abstract method q in type LOLHero can only be defined by an abstract class
 *  			LOlHero 类必须是一个 abstract 修饰的类才可以定义 abstract 修饰的方法
 *  	【语法总结】
 *  		abstract 修饰的方法必须定义在一个 abstract 修饰的类内
 *  	【Eclipse 快速修复】
 *  		Ctrl + 1 ==> Make type 'LOLHero' abstract
 *  			Eclipse 快速修复建议选择使用 abstract 关键字修饰 LOLHero 类
 *  
 *  
 *  第三步：
 *  		abstract 修饰 LOLHero 类
 *  		【错误三】
 *  		The type Pig must implement the inherited abstract method LOLHero.q()
 *  		猪类必须【实现】通过继承得到的在 LOLHero 类内使用 abstract 关键字修饰的方法 q
 *  
 *  		The type Monkey must implement the inherited abstract method LOLHero.q()
 *  		猴类必须【实现】通过继承得到的在 LOLHero 类内使用 abstract 关键字修饰的方法 q
 *  
 *  
 *  		【补充说明】
 *  			implement 实现
 *  			因为  LOLHero 类内 abstract 修饰的方法没有方法体，严格来讲有且只有方法声明对应方法，
 *  			没有实现。
 *  		【语法总结】
 *  			子类如果没有 abstract 关键字修饰， 必须【实现】父类中所有使用 abstract 修饰的没有方法体的方法
 *  		【Eclipse 快速修复】
 *  			Ctrl + 1 ==> Add unimplemented methods
 *  				Eclipse 快速修复建议选择 添加尚未实现的所有父类 abstract 修饰方法
 *  
 */
/**
 * LOL 英雄基类
 * @author lenovo
 *
 */
abstract class LOLHero {
	abstract public void q(String explain);
	abstract public void w(String explain);
	public void e() {
		System.out.println("E技能");
	}
	public void r() {
		System.out.println("R技能");
	}
}

class Pig extends LOLHero {
	@Override
	public void q(String explain) {
		System.out.println("1技能" + explain);
	}
	public void w(String explain) {
		System.out.println("2技能" + explain);
	}
	public void e() {
		System.out.println("3技能");
	}
	public void r() {
		System.out.println("4技能");
	}
}
class Monkey extends LOLHero {

	@Override
	public void q(String explain) {
		System.out.println("1" + explain);
		
	}

	@Override
	public void w(String explain) {
		System.out.println("2" + explain);
		
	}
	public void e() {
		System.out.println("3");
	}
	public void r() {
		System.out.println("4");
	}
	
}


public class Demo2 {
	public static void main(String[] args) {
		Pig p1 = new Pig();
		p1.q("霸体位移且回复血量");
		p1.w("强制位移并对路径上的敌人造成800 + lv10%点伤害");
		p1.e();
		p1.r();
		
		Monkey m1 = new Monkey();
		m1.q("无敌且收到技能伤害获得1000护盾,并且强化 下一次普攻");
		m1.w("200码位移，遇到敌人或野怪两端位移，强化下一次普攻");
		m1.e();
		m1.r();
		
	}
}

1.3 abstract 修饰的类无法实例化

package com.qfedu_a_abstract;

abstract class BaseType {
	abstract public void testAbstract();
	
	public void test() {
		System.out.println("非 abstract 修饰的成员方法");
	}
}

public class Demo3 {
	public static void main(String[] args) {
		
		/*
		 * 是否可以实例化/创建 BaseType 修饰类对应的对象？？？
		 * 
		 * 假设：
		 *		当前代码中实例化/创建了 BaseType 对象
		 *		请问当前 BaseType 对象调用 testAbstract 方法会有什么效果？？
		 * 分析：
		 * 		testAbstract 方法使用 abstract 关键字修饰，对应方法没有方法体
		 * 		没有执行目标和执行内容。【无法执行，语法报错】
		 * 
		 * 
		 * 假设不成立：
		 * 		abstract 关键字修饰的类，无法实例化/无法创建对象。
		 * 		
		 * 为什么 abstract 修饰的类内语句全部都是正常的方法，为什么还是无法实例化
		 * 		1 abstract 关键字修饰的类，【有可能】存在 abstract 修饰的方法
		 * 		2. abstract 修饰的方法要求没有方法体
		 * 		3. 如果实例化 abstract 修饰类，得到了 对应的对象，就【有可能】存钻没有方法体的
		 * 			采用 abstract 关键字修饰的方法无法执行语法报错
		 * 		开发中【有可能】出现错误 ===> 一定会出现错误 ==> 【语法错误】
		 * 
		 */
		//  BaseType baseType = new BaseType();
	}
}

1.4 abstract 关键字使用总结

1. abstract 修饰的方法没有方法体
	abstract 关键字的重点是在于修饰方法
2. abstract 修饰的方法，要求继承当前 abstract 所在类对应的子类必须强制实现对应的 abstract 方法，
	子类非 abstract 修饰，继承 abstract 对应的父类，必须实现所有的 abstract 方法
3. abstract 修饰的方法，有且只能够定义在 abstract 修饰的类内 或者 interface 接口内
4. abstract 修饰的类无法实例化
	因为 abstract 关键字修饰的类中，有可能存在只有方法声明的 abstract 修饰方法，这一类方法无法实例化对象调用执行。

2. 局部变量

2.1 什么是局部变量

定义在方法中的变量 ==> 局部变量

for (int i = 0; i < 10; i++) {
	// 循环体
}
System.out.println(i);
/* 
语法报错！！！ i 变量未定义
	for 循环条件中定义声明的变量 i 对应的有效范围是在 for 循环大括号以内，超出大括号范围无效
*/

int num = 10;
int num = 20;
/*
语法报错！！！重复定义变量 num
*/

for(int i = 0; i < 10; i++) {
    
}
for(int i = 0; i < 10; i++) {
    
}
/*
每一个 for 循环中的 i 都是各自区间有效
*/

for (int i = 0; i < 10; i++) {
    if (5 == i) {
        int num = 10;
    }
	System.out.println(num);
}
/*
int num 定义在 if 分支结构大括号以内，有效范围有且只在 if 对应的大括号以内，超出范围无效
*/

2.2 局部变量特征

特征：
	1. 局部变量先定义后使用
	2. 局部变量如果在没有被赋值的情况下，有且只能参与赋值操作，其他任何操作无法执行。
	3. 局部变量在定义对应的大括号范围有效
		大括号范围	方法体大括号，分支结构，循环结构
	4. 局部变量在有效范围以内唯一，不可以重复定义。
	5. 局部变量在内存的【栈区】 （有 【new】 才有堆）
	6. 局部变量主要用于在代码运行过程中，针对于数据的临时存储和使用
	7. 【生存周期】和【作用范围】都在对应大括号范围以内

2.3 成员变量特征

特征：
	1. 成员变量定义在 class 大括号以内
	2. 成员变量主要作用描述当前类所具备的属性。
	3. 成员变量是在实例化对象之后，存储在内存的【堆区】
	4. 成员变量
		【生存周期】从实例化对象开始，到当前对象被销毁结束。
			JVM 的 GC 垃圾回收机制
		【作用范围】
			作用范围取决于当前对象在哪里

3. final 关键字

3.1 修饰成员变量

特征总结

final 修饰的成员变量一旦被赋值，后期无法修改，可以认为是带有名称的常量

final 修饰的成员变量定义时必须初始化，赋值方式

2.1 定义时直接赋值对应的数据内容

2.2 【高阶用法】使用构造方法给予 final 修饰成员变量初始化赋值操作

package com.qfedu_a_final;
/*
 *  成员变量  final 修饰
 * 
 */

class TypeA {
	// 定义 public 修饰的成员变量 num 初始化为 10
	public int num = 10;
	/*
	 *  public final 修饰的成员变量
	 *  【报错】
	 * 		The blank final field msg may not have been initialized
	 * 			final 修饰的成员变量 msg 可能尚未初始化
	 * 
	 *  【注意】
	 *  	final 修饰的成员变量定义式必须初始化！！！
	 * 		初始化复制手段有两种
	 * 			1. 定义时直接赋值对应的数据内容
	 * 				public final String msg = "你好";
	 * 			2. 【高阶用法】 使用构造方法给予  final 修饰成员变量初始化赋值操作
	 */
	// public final 修饰的成员变量
	public final String msg ;
	
	// 要不要写无参构造方法？？？？
	public  TypeA(String msg) {
		this.msg = msg;
	}
	
	
}
public class Demo1 {
	public static void main(String[] args) {
		TypeA typA = new TypeA("测试");
		
		System.out.println(typA.num);
		System.out.println(typA.msg);
		
		// 没有 final 修饰的成员变量，重新赋值 OK！
		typA.num = 20;
		
		/*
		 * 【报错】
		 *  The final field TypeA.msg cannot be assigned
		 *  	TypaA 类使用 final 修饰的成员变量 msg 不能被赋值
		 * 【注意】
		 *  	final 修饰的成员变量一旦被赋值，后期无法修改，可以认为是带有名称的常量	 
		 *  
		 */
		//typA.msg = "早日解封"; 
	}

}

3.2 修饰成员方法

特征总结：

final 修饰的方法不能被重写
final 修饰的方法常用于核心业务逻辑，例如支付

package com.qfedu_a_final;

class TypeB {
	final public void test() {
		System.out.println("正常方法");
	}
}


class TypeC extends TypeB {
	/*
	 * 【错误】
	 * 			Cannot override the final method from TypeB
	 * 			子类不能重写 TypeB 类内 final 修饰的成员方法
	 * 【注意】
	 * 			final  修饰的成员方法为最终方法，无法被重写！！！
	 * 【作用】
	 * 			限制项目中的核心业务逻辑，重要业务逻辑
	 * 			例如 支付操作
	 */
	//@Override
	//public void test() {
		//System.out.println("重写");
	//}
}




public class Demo2 {
	public static void main(String[] args) {
			TypeC typeC = new TypeC();
			typeC.test();
	}

}

3.3 修饰类

特征总结：

final 修饰的类不能被继承，没有子类
Java 中的 String 类型就是 final 修饰的类型。

package com.qfedu_a_final;
final class TypeD {
	
}
/*【错误】
 * 		The type TypeE cannot subclass the final class TypeD
 * 		子类不能继承一个 final 修饰的类
 * 
 * 【注意】
 * 		final 修饰的类没有子类，不能被继承。一般用用于代码中的基础类型。
 * 		例如 Java 中的 String 类型
 * 
 */

//class TypeE extends TypeD {
	
//}
public class Demo3 {
	

}

3.4 修饰局部变量

特征总结：

final 修饰的类不能被继承，没有子类

Java 中的 String 类型就是 final 修饰的类型。

package com.qfedu_a_final;

class Person {
	int id;
	String name;
	int age;
}

public class Demo4 {
	public static void main(String[] args) {
		final int num;
		
		num = 10;
		/*
		 * 【错误】
		 * 	The final local variable num may already have been assigned
		 * 	final 修饰的局部变量有且只能被赋值一次，赋值之后无法修改
		 * 
		 * local variable 局部变量
		 * 
		 */
		//num = 20;
		
		/*
		 * 引用数据类型使用 final 修饰，引用指向不可变，但是指向空间数据内容可变
		 * 
		 * final 修饰就近原则，修饰谁谁不能变
		 * 
		 * 房子和装修问题
		 * 		房子地址不能变
		 * 		装修随便搞
		 */
		final Person p = new  Person();
		/*
		 * 以下哪一个正确
		 *   2 3 4
		 * 1： p = new Person();
		 * 2：p.id = 10;
		 * 3: p.name = "张三";
		 * 4：p.age = 20;
		 */
	}
}

4. 多类合作

4.1 电脑和配件问题

键盘 ==> 键盘类
	属性： 品牌名称，按键个数

屏幕 ==> 屏幕类
	属性： 品牌名称，尺寸
	
电脑 ==> 电脑类
	组成：
		CPU 内存 硬盘 键盘 屏幕 主板 显卡....
	目前考虑属性：
		键盘
		屏幕
	【知识点】
		自定义类型作为其他类型的成员变量组成。
		
面向对象的代码，想清楚生活逻辑比代码本身重要！！！

4.2 keyboard

package com.qfedu.c_computer;

/**
 * 键盘类
 * 
 * @author Anonymous
 */
public class Keyboard {
	/**
	 * 键盘名称
	 */
	private String name;
	/**
	 * 按键个数
	 */
	private int keyCount;

	public Keyboard() {
	}
	
	public Keyboard(String name, int keyCount) {
		this.name = name;
		this.keyCount = keyCount;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getKeyCount() {
		return keyCount;
	}

	public void setKeyCount(int keyCount) {
		this.keyCount = keyCount;
	}

}

4.3 Screen

package com.qfedu.c_computer;

/**
 * 屏幕类 
 * 
 * @author Anonymous
 */
public class Screen {
	/**
	 * 屏幕的品牌名称
	 */
	private String name;
	/**
	 * 屏幕的尺寸
	 */
	private int size;
	
	public Screen() {}

	public Screen(String name, int size) {
		this.name = name;
		this.size = size;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getSize() {
		return size;
	}

	public void setSize(int size) {
		this.size = size;
	}	
	
}

4.4 Computer

package com.qfedu.c_computer;

/**
 * 电脑类
 * 		成员变量组成:
 * 			键盘
 * 			屏幕
 * @author Anonymous
 *
 */
public class Computer {
	/**
	 * 电脑类成员变量 Keyboard 键盘类型。
	 */
	private Keyboard keyboard;
	
	/**
	 * 电脑类成员变量 Screen 屏幕类型。
	 */
	private Screen screen;
	
	public Computer() {}
	
	/**
	 * Computer 构造方法，所需参数是 Keyboard 键盘类对象和 Screen 屏幕类对象
	 * 思考场景:
	 * 		组装电脑老板给你准备一台显示器，一把键盘 ==> 屏幕类对象，键盘类对象
	 * 
	 * @param keyboard Keyboard 键盘类型 
	 * @param screen   Screen 屏幕类型
	 */
	public Computer(Keyboard keyboard, Screen screen) {
		this.keyboard = keyboard;
		this.screen = screen;
	}

	// 对应成员变量 Setter and Getter 方法
	public Keyboard getKeyboard() {
		return keyboard;
	}

	public void setKeyboard(Keyboard keyboard) {
		this.keyboard = keyboard;
	}

	public Screen getScreen() {
		return screen;
	}

	public void setScreen(Screen screen) {
		this.screen = screen;
	}
}

5. 作业

1. 整理笔记
2. 案例代码三遍
3. 复习数组相关内容

/**
 * 电脑类成员变量 Screen 屏幕类型。
 */
private Screen screen;

public Computer() {}

/**
 * Computer 构造方法，所需参数是 Keyboard 键盘类对象和 Screen 屏幕类对象
 * 思考场景:
 * 		组装电脑老板给你准备一台显示器，一把键盘 ==> 屏幕类对象，键盘类对象
 * 
 * @param keyboard Keyboard 键盘类型 
 * @param screen   Screen 屏幕类型
 */
public Computer(Keyboard keyboard, Screen screen) {
	this.keyboard = keyboard;
	this.screen = screen;
}

// 对应成员变量 Setter and Getter 方法
public Keyboard getKeyboard() {
	return keyboard;
}

public void setKeyboard(Keyboard keyboard) {
	this.keyboard = keyboard;
}

public Screen getScreen() {
	return screen;
}

public void setScreen(Screen screen) {
	this.screen = screen;
}

}


#### 5. 作业

整理笔记
案例代码三遍
复习数组相关内容

Te Fuir54

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
千峰教育2218期2022.11.02

目前代码中，设计 LOL 英雄基类，同时带有 qwer 四个方法对应四个技能，子类（HappywindBoy, Vayne）继承父类，可以直接使用已经具备执行能力的 qwer 方法，但是如果直接使用，会发现父类方法无法满足子类的特征情况，并且没有语法报错，是在用户使用的过程中发现对应问题此时可以使用重写操作，在子类中重写父类，满足子类特征情况目前代码流程继承 ==> 调用 ==> 出现业务问题 ==> 重写 ==> 解决问题期望的代码流程。
复制链接

扫一扫