20220606某马就业班内部资料复习Day01—封装+继承+抽象类+Final关键字

面向对象-封装

• 类的定义

修饰符 class 类名{
//1.成员变量（属性）
  String name;
  int age;
//2.构造器 （初始化类的对象数据的）
  public Studennt(){}
//3.成员方法 (行为) 
  public void show(){
    System.out.prinntln(name+","+age);
  }
//4.内部类
  calss Inner{
  }
//5.代码块
  {
    
  }
}

• 类的使用

//创建对象：类名 对象名 = new 构造方法(实参);
Student s =new Studennt();
//使用成员变量:对象名.成员变量名;   //私有成员变量需要通过对应的get/set方法访问。@Data
s.name="张三";
s.age=18;
System.out.prinln(s.name+"==="+s.age);
//使用成员方法:对象名.成员方法名(实参)
s.show();

• 类封装

被认为是一个**保护屏障**，对外隐藏具体的实现细节，防止该类的代码和数据被其他类随意访问。

• 封装的原则

• 使用 private 关键字来修饰成员变量(被private修饰的内容，其他类不能直接使用)。

• 使用public修饰getter和setter方法。

• 属性的封装只是封装的一种表现形式，方法、类等都是封装的表现形式。

后期经典白学：

@Data
public class Captcha {

}

• this关键字

作用：this代表所在类的当前对象的引用（地址值）;谁(哪个对象)调用成员方法,this就代表谁(那个对象)

***见名知意:***起名字不能太随意，要表达出操作的含义。

***就近原则:***变量使用的时候，优先使用离的较近的变量。会造成局部变量隐藏了对成员变量的访问。

应用：区分成员变量与局部变量。

this.name =name;

• 构造方法

作用

• 创建对象 new 构造方法(实参)

• 对象初始化

定义格式

修饰符 类名(形参列表) {
	// 构造体代码，执行代码
  public Student(){}
  //有参构造函数
  public Student(String name){
    this.name = name;
  }
  //满参构造函数
  public Student(String name,int age){
    this.name = name;
    this.age = age;
  }
}

分类：

无参构造、有参构造、满参构造

**快捷方式：**alt+insert

后期经典白学：

@AllArgsConstructor
@NoArgsConstructor
public class Entities {

}

混淆知识点总结：

• 实参VS形参：

  实参：调用时的参数；

  形参：定义时的参数。

• 无参构造、有参构造、满参构造

面向对象-继承

• 继承的理解

• 父类中具备子类对象共有的属性和行为。

• 子类继承父类，使得子类及其对象可以直接具有父类属性和行为。

• 子类可以直接访问父类中的非私有的属性和行为

• 继承描述的是事物之间的所属关系，这种是一种:is-a(是xx的一种) 的关系。

• 继承的好处

• 提高代码的复用性;

• 使类与类之间产生了关系***(多态的前提)***;

• 继承的格式

public class 子类 extends 父类 {
	...
}

**修改变量名:**Shift+F6

• 继承的访问规则

• 构造方法

1. 子类不能继承父类的构造器**(因为构造器名与类名一致)**。
2. 子类初始化，必须先执行父类的初始化，初始化父类需要调用父类的构造方法(因为父类初始化了才能将内容继承给子类)。
3. 调用父类构造方法:super(参数)
4. 实现方式:

①默认:所有子类的构造方法第一行都会默认存在一个super()调用父类的空参构造方法

②首行:子类的构造方法中调用父类的构造方法一定要放在第一行

③手动替代默认:如果子类的构造方法中手动调用了父类的构造方法,那么子类的构造方法就不会再使用默认操作访问父类构造方法。

• 非私有成员

1. 父类非私有的成员(成员变量、成员方法等)，子类可以直接访问。

• 私有成员

1. 父类私有的成员(成员变量、成员方法等)，子类不能直接访问,但是可以通过父类中非私有方法间接访问。

• 同名成员

1. 如果子父类中出现相同的成员(成员变量、成员方法等) ，通过子类对象的引用，调用的是子类自己的成员。

• 方法重写

• 概念

子类成员方法与父类（返回值类型，方法名和参数列表）一模一样,称为方法重写,也称覆写或者覆盖。

• 使用场景

子类继承父类，但觉得父类某方法不满足当前子类的需求。则重新定义与父类相同的方法，达到对该功能的增强实现。

• 注意事项

1. 方法重写是发生在子父类之间的关系；
2. 子类方法覆盖父类方法，必须要保证权限大于等于父类权限；
3. 返回值类型，方法名，参数列表完全相同。

• @Override

1. 一种注解，用于方法重写的校验。
2. 作用:用于检查子类要重写的方法是否满足方法重写的规则(方法名是否相同、形参列表相同)

• this的使用

• 变量就近原则

变量在使用的时候，优先使用定义的近的变量，谁离得近就指向哪个变量，故this为此去调当前对象的属性。

• this作用

1. 表示存储“当前对象”的引用；
2. this指向的内容，可以理解为访问本类中的内容。

• 三种格式

1. this.成员变量 访问本类成员变量；

2. this.成员方法名(…) 访问本类成员方法；

3. this(…) 访问本类构造方法。

   

• 注意事项

如果使用this调用本类构造方法，super调用父类构造方法的操作就会被替换掉，且必须在第一行。

• super的使用

• super作用

1. 表示“父类”的引用；
2. super指向的内容，可以理解为访问父类中的内容。

• 三种格式

1. super.成员变量 访问父类成员变量；
2. super.成员方法名(…) 访问父类成员方法；
3. super(…) 访问父类构造方法；

• 注意事项

父类中没有无参构造方法，子类可能会报错。

• 继承的特点

• 单继承:类与类之间只能单继承，不能多继承

class A{}
class A2{}
class B extends A{}
class B extends A,A2{}//error

• 多层继承:类与类之间可以多层继承

class A{}
class B extends A{}
class C extends B{}

• 多个子类:同一个父类可以拥有多个子类

class A{}
class C extends A{}
class B extends A{}

混淆知识点总结：

主要还是this和super的构造函数，方法还有变量。

面向对象-抽象类

• 抽象类入门

• 概念

1. **抽象方法:**没有方法体的方法。有抽象方法的类，必须定义为抽象类;
2. **抽象类:**可以包含抽象方法的类就是抽象类

• 意义

1. 当一个父类中的方法，**子类实现各不相同时，**父类中该方法可以定义成抽象方法。

• 抽象方法格式

1. public abstract 返回值类型 方法名(形参);

• 抽象类格式

public abstract class 类名{
      //1.成员变量、2.成员方法、3.构造方法、4.抽象方法
}

• 使用形式: [** ]表示可写，可不写

1. public [abstract] class 子类 extends 抽象父类{} ;
2. 如果子类是抽象类，可以不重写抽象方法；如果子类不是抽象类，必须重写抽象方法

Note：在Java中被abstract关键字修饰的类称为抽象类，被abstract关键字修饰的方法称为抽象方法，抽象方法只有方法的声明，没有方法体。抽象类是用来捕捉子类的通用特性的 。它不能被实例化，只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板。

注意事项

1.抽象类只能通过子类创建对象；

2.抽象类可以有构造器，供子类初始化父类成员；

3.抽象类中，不一定包含抽象方法；

4.抽象类的子类，必须重写抽象父类中"所有的"抽象方法，否则子类也必须定义成抽象类；

5.抽象类存在的意义是为了被子类继承，体现的是模板思想。

• 模板设计模式

• 抽象类的意义

1. 抽象类存在的意义是为了被子类继承，否则抽象类将毫无意义

• 模板思想

1. 抽象类体现的是模板思想，模板是通用的东西;
2. 抽象类中可以是具体的实现,也可以有抽象方法;
3. 模板中不能决定的行为定义成抽象方法，让需要使用模板的类（子类）负责重写抽象方法实现。

---

• 需求

按照下述要求，使用代码实现

1. 新司机:开门,点火,双手紧握方向盘,刹车,熄火;
2. 老司机:开门,点火,右手握方向盘左手抽烟,刹车,熄火。

• 分析

1. 新老司机都能开车，需要在父类中定义开车功能；
2. 新老司机开车的姿势不同，开车姿势需要定义成抽象方法，由子类重写定义。

代码实现：

//父类Driver
public abstract class Driver {
    public void open() {
        System.out.println("开门");
    }

    public void fire() {
        System.out.println("点火");
    }

    //姿势
    public abstract void pos();

    public void stop() {
        System.out.println("刹车");
    }

    public void close() {
        System.out.println("熄火");
    }

    //开车
    public void drive(){
        open();
        fire();
        pos();//直接调用抽象方法。this.pos();
        stop();
        close();
    }
}
//子类新司机
public class NewDriver extends Driver {
    @Override
    public void pos() {
        System.out.println("双手紧握方向盘");
    }
}
//子类老司机
public class OldDriver extends Driver {

    @Override
    public void pos() {
        System.out.println("右手握方向盘,左手抽烟");
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        //按照下述要求，使用代码实现
        //新司机:开门,点火,姿势(双手紧握方向盘),刹车,熄火
        //老司机:开门,点火,姿势(右手握方向盘左手抽烟),刹车,熄火
        //使用新司机
        NewDriver nd = new NewDriver();
        nd.drive();
        System.out.println("--------");
        //使用老司机
        OldDriver od = new OldDriver();
        od.drive();
    }
}

由上可以看出，有一个父类抽象模版定义共同特性，子类只需要重写抽象方法即可获得公有和独有的特性。

Final关键字

• Final的使用

• 介绍

1. Java提供了final 关键字，用于修饰不可改变内容。

• 修饰类

1. **修饰类:**被修饰的类，不能被继承(例如:String类、Math类、Scanner类…)；
2. **格式:**public final class 类名 { //类中成员 }。

• 修饰方法

1. **修饰方法:**被修饰的方法，不能被重写；
2. **格式:**public final 返回值类型 方法名(){}。

• 修饰变量

1. **修饰变量:**被修饰的变量，**一旦赋值,不能被重新赋值，**从而被称为常量(自定义常量，所有字母大写)；
2. **格式:**final 数据类型 变量名=值; 或 final 数据类型 变量名; 变量名=值；
3. 修饰局部变量:使用前必须赋值；
4. 修饰成员变量:没有默认值，对象创建好之前必须明确赋值。

观后感

某马就业班Day1的视频，大概认真看完1-2小时，没有作业，算是巩固吧。

继续加油～