八、面向对象封装继承相关
1.Java中类的定义格式
格式:
class 类名 {
属性描述;
行为描述;
}
类名:
要求符合大驼峰命名法，见名知意
类名这里可以认为是一个数据类型名，自定义数据类型
属性描述:
描述当前类有哪些属性
例如:
人类的身高体重，年龄姓名
行为描述:
描述当前类有哪些行为
例如:
人类的吃饭行为，睡觉行为，打游戏行为
自定义完成Person类
class Person {
/* 属性描述 【成员变量 Field】*/
// 姓名属性描述 这里暂时不需要初始化 只是描述当前类有哪些属性
// String是字符串类型，name成员变量
String name;
// 年龄描述
// int是数据类型 age成员变量
int age;
// 性别描述
// char是数据类型 gender成员变量
char gender;
/*
* 行为描述 【成员方法 Method】
* 一下方法目前不需要static 不要问
*/
// 吃饭行为描述
public void eat(String food) {
System.out.println("吃" + food);
}
// 睡醒行为描述
public void sleep() {
System.out.println("月亮不睡你不睡，你是秃头小宝贝");
}
public void game() {
System.out.println("WOT World Of Tank 坦克世界");
}
}
2.Java中创建对象格式
/*
* 这里创建一个Person对象
* 格式:
* 类名 对象名 = new 类名();
*
* 这里创建了一个Person类的对象，对象名 person
*/
Person person = new Person();
3. 构造方法
作用：
用于在开发过程中创建对象使用，创建对象目前的格式
new 类名(有可能使用到的参数);
类名(有可能使用到的参数); 这就是构造方法 Constructor
初始化当前创建对象中的成员变量数据
格式:
public 类名(所需初始化参数列表) {
初始化语句;
}
细节:
1. 构造方法的名字必须是类名，并且其他方法的名字不能是类名
2. 构造方法没有返回值类型声明
3. 初始化参数列表和正常的方法列表操作使用一致
4. 初始化语句，大多数是都是一些赋值语句
5.如果在代码中程序员自行完成了构造方法，Java编译器不再提供自动生成的无参数构造方法
6.要给用户提供一个无参数构造方法使用
7.在代码中任何没有【显式】自行声明构造方法，Java编译器会在编译代码的过程中辅助程序员完成一个无参数的构 造方法，供程序员使用
类对象内存分析图：
4.this关键字
this关键字表示对象本身
1. 调用当前方法的类对象
2. 通过构造方法创建的类对象
可以在方法中使用this关键字区分操作的是成员变量还是局部变量
this表示当前对象
可以在方法中使用this关键字区分操作的是成员变量还是局部变量
this关键字在一个构造方法，调用其他构造方法
* 注意事项：
* 1. 不能通过this关键字调用当前所在构造方法，无穷递归！！！错误！！！
* 2. this(实际参数); 根据实际参数的类型，个数和顺序来完成的
* 3. Constructor call must be the first statement in a constructor
* 通过this关键字调用其他构造方法，必须在当前方法体的第一行！！！
* 4. 能不能在一个构造方法中，通过this关键字，同时调用两个构造方法???
* 不能！！！因为构造方法调用必须在第一行，如果存在两个必然有一个在第二行，语法报错
* 5. 两个构造方法，能不能通过this关键字相互调用???
* 不允许，无穷递归！！！
* 6. 规范化，统一化方法执行操作，提高代码的安全性和一致性
5.class文件反编译
javap -c -l -private xxx.class
6.封装
归纳总结！！！
循环封装过程
方法封装功能
类封装数据
框架封装模块
一段代码使用了三遍，做成一个循环
一个循环使用了三遍，做成一个方法
一个方法使用了三遍，做成一个工具类
一个工具类使用了三遍，做成一个文档
一个文档使用了三遍，做成一篇博客
Java中规范化封装【JavaBean规范】
要求:
1. 所有的成员变量全部私有化【private修饰】
2. 要求至少完成一个无参数构造方法，其他无所谓
3. 要求给予所有的成员变量对应的setter和getter方法
4.boolean类型数据较特殊
boolean类型的成员变量getter方法要求是is开头
7.依赖关系类示例
// 汽车类
public class Car {
private String name;
private String color;
private int wheelNum;
private boolean status;
public Car() {
}
public Car(String name, String color, int wheelNum, boolean status) {
this.name = name;
this.color = color;
this.wheelNum = wheelNum;
this.status = status;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getWheelNum() {
return wheelNum;
}
public void setWheelNum(int wheelNum) {
this.wheelNum = wheelNum;
}
public boolean isStatus() {
return status;
}
public void setStatus(boolean status) {
this.status = status;
}
public void race(){
if(wheelNum == 4){
System.out.println("开着我的" + color + name + "飞驰");
setStatus(true);
}else{
System.out.println("轮子飞出去了！");
setStatus(false);
}
}
}
// 工厂类
public class Factory {
private String name;
private String adress;
public Factory() {
}
public Factory(String name, String adress) {
this.name = name;
this.adress = adress;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAdress() {
return adress;
}
public void setAdress(String adress) {
this.adress = adress;
}
public void repair(Car car){
if(car.getWheelNum() != 4){
System.out.println("修理厂：轮子废了，我们给你修理");
car.setWheelNum(4);
car.setStatus(true);
System.out.println("修理厂：修好了！");
}else{
System.out.println("修理厂：好着呢！");
}
}
}
// 程序入口执行
public class Main {
public static void main(String[] args) {
Factory factory = new Factory();
factory.setName("无所不修");
factory.setAdress("解放路");
Car car = new Car("玛莎拉蒂","黑色",4,true);
car.race();
car.setWheelNum(3);
car.race();
factory.repair(car);
car.race();
}
}
8.关联关系类示例
public class Screen {
private String brand;
private int size;
public Screen(){}
public Screen(String brand, int size){
this.brand = brand;
this.size = size;
}
public void setBrand(String brand){
this.brand = brand;
}
public String getBrand(){
return brand;
}
public void setSize(int size){
this.size = size;
}
public int getSize(){
return size;
}
}
public class KeyBoard {
private String brand;
private int keyNums;
public KeyBoard(){}
public KeyBoard(String brand, int keyNums){
this.brand = brand;
this.keyNums = keyNums;
}
public void setBrand(String brand){
this.brand = brand;
}
public String getBrand(){
return brand;
}
public void setKeyNums(int keyNums){
this.keyNums = keyNums;
}
public int getKeyNums(){
return keyNums;
}
}
public class PC {
private Screen screen;
private KeyBoard keyBoard;
public PC(){}
public PC(Screen screen, KeyBoard keyBoard){
this.screen = screen;
this.keyBoard = keyBoard;
}
public void setScreen(Screen screen){
this.screen = screen;
}
public Screen getScreen(){
return screen;
}
public void setKeyBoard(KeyBoard keyBoard){
this.keyBoard = keyBoard;
}
public KeyBoard getKeyBoard(){
return keyBoard;
}
public void show(){
System.out.println("屏幕配置：" + screen.getBrand() + "," + screen.getSize());
System.out.println("键盘配置：" + keyBoard.getBrand() + "," + keyBoard.getKeyNums());
}
}
public class Main {
public static void main(String[] args) {
PC pc = new PC(new Screen("AOC", 21), new KeyBoard("cherry", 80));
pc.show();
System.out.println("--------------------");
System.out.println("换个屏幕");
pc.setScreen(new Screen("三星", 56));
pc.show();
}
}
9.匿名对象
匿名对象
没有名字的对象，没有对象名的对象
格式：
new 构造方法(所需参数)
用途
1. 提高开发效率
匿名对象当前行使用之后，如果没有其他引用数据类型的变量保存其地址，直接销毁
2. 简化代码结构
3. 通过匿名对象直接调用成员方法
4. 使用匿名对象作为方法的参数
注意：
1. 匿名对象是为了提供开发效率，节约内存使用，同时让代码更加贴近于真实操作
2. 匿名对象常用方式
第一个是直接使用匿名对象调用成员方法
第二个是直接使用匿名对象作为方法的参数
3. 匿名对象使用成员变量无意义
10.继承
继承在开发中是一种抽象的归纳总结思想，剥离通用的属性，通用的方法，简化之后的开发压力。只需要在继承之后，满足个性化的实现即可。
通过继承可以优化代码，在JavaWEB开发中，继承大多数情况下，都是用来提高方法的复用度
关键字:
extends
格式:
class A extends B {
}
A类是B类的一个子类
B类是A类的唯一父类
【Java是一门单继承语言，一个类有且只能继承一个父类】
注意：
1. A类使用extends关键字继承B类
A类是B类的一个子类，B类是A类的唯一父类
2. 继承之后，子类可以通过继承得到父类中非私有化成员变量，和非私有化成员方法
3. 继承之后，子类不可以通过继承得到父类中的私有化成员变量，和私有化成员方法。
private修饰的内容有且只能在类内使用！
4.子类对象创建过程中，在使用构造方法时，会默认调用父类的【无参数构造方法】。
5.父类的构造方法，不是在创建父类的对象，只是在初始化父类的成员变量空间
继承内存分析图
重写Override
前提条件
1. 重写存在于继承中子类，或者接口实现类
2. 重写情况下要求子类中的方法和父类中的方法声明完全一致【除方法体以外的部分】
3. 方法体按照子类的情况来完成【大括号{}中内容】
注意事项
1. 子类重写父类方法，要求必须加上@Override严格格式检查
2. @Override会检查子类重写的方法，方法声明是否和父类一致
关键字：abstract
1. abstract修饰的方法 没有方法体
2. abstract修饰的方法，要求定义在abstract修饰的类内，或者接口interface内
3. abstract修饰的类，没有类对象
abstract修饰的类内，是有可能存在abstract修饰的方法，而abstract修饰的方法是没有方法体的，如果能够得 到一个abstract修饰类的对象，通过对象如何调用这些没有方法体的abstract方法
4. abstract修饰的类，如果类内没有任何的一个abstract修饰的方法，将无意义
5. abstract修饰的方法，在父类abstract类内没有方法体，子类如果想要使用abstract修饰的方法
必须完成方法体的实现
11.重载Overload
要求
1. 重载是要求在同一个类内，或者接口interface内
2. 重载要求方法名必须一致
3. 重载要求方法的参数必须不一致
4. 重载对于方法的返回值没有任何的约束
12.super关键字
1. super关键字可以用于在子类和父类之间，同名成员变量，同名成员方法调用时明确区分。
2. super关键字可以显式调用父类的构造方法，用于初始化父类的成员变量数据。
3. super关键字使用的格式，规范和this非常类似。
注意：
* super关键字在子类构造方法中，调用父类构造方法
* 格式:
* super(实际参数);
* 会根据实际参数来选择使用父类对应数据类型，个数，顺序的构造方法，用于初始化父类的
* 成员变量数据。
*
* 注意事项:
* 1. 在没有指定选择哪一个父类构造构造方法，作为子类初始化父类成员变量空间的操作时
* Java编译器会默认选择父类的无参数构造方法。
* 2. 选择使用父类的有参数构造方法，初始化父类成员变量空间
* 3. 父类数据的交给父类的构造方法操作，不要在子类中操作。
* 4. super关键字显式调用父类的构造方法，必须在代码的第一行
* 5. super关键字调用构造方法，和this关键字调用构造方法，是否能共存???
* 【显式】情况下不可以！！！
* 但是省略通过super关键字调用父类构造方法的情况下，Java编译器会在
* 编译的过程中，默认选择无参数父类构造方法使用
13.final关键字
final关键字可以修饰：
【局部变量】 有且只能被赋值一次，赋值之后不可以修改
【成员变量】 定义时必须初始化，未初始化报错
【成员方法】 使用final修饰的方法为最终方法，不能被重写！！！
【类】 没有子类，不能被继承，如：String类
浙公网安备 33010602011771号