继承&抽象&代码块

继承

1. 概念

   Java继承通过关键字extends实现

   是面向对象三大特性之一（封装、继承、多态）

   被继承的类称为父类

   实现继承的类称为子类

2. 特点

   子类可以直接使用父类中非私有成员

   Java只支持单继承，不支持多继承，但是java可以多层继承

   • 例如：B继承A，C继承B，那么C也可以拥有A的共有属性

   其中成员变量和成员方法的访问特点是基于就近原则

   public Class A {
   	int num = 18；
   }
   
   public Class B extends A {
   	int num = 20；
           
       public void agePrint(){
           int num = 22;
           System.out.println(num);
           //这边的age会去寻找最近的age，也就是方法中的局部变量(22)，如果没有局部变量会去找本类的成员变量(20)，最后才是父类中的成员变量(18)；如果没有就报错，不考虑父类的父类
       } 
   }
   

this & super

this：代表本类对象的引用

super：代表父类对象的引用

访问构造方法：this(…) 和 super(…)

使用区别：

1. 成员变量

   this.成员变量 —— 访问本类成员变量

   super.成员变量 —— 访问父类成员变量

2. 成员方法

   this.成员方法—— 访问本类成员方法

   super.成员方法—— 访问父类成员方法

3. 构造方法

   this(…) —— 访问本类构造方法

   super(…) —— 访问父类构造方法

注意：

子类会继承父类中的数据，可能还会使用父类的数据。所以子类初始化之前会先完成父类数据的初始化。在每一个子类的构造方法的第一句默认都是super()

this()和super()都只能写在构造函数的第一行，所以他们不能存在于同一个构造函数中

方法重写

1. 在继承体系中，子类出现了和父类中一模一样的方法声明

   应用场景：当子类需要父类的功能，而功能主体子类自己特有的内容时，可以重写父类中的方法。

2. 注意事项：

   • 父类中私有方法不能重写
   • 父类非静态方法，子类必须用非静态方法重写。(父类的静态方法不能被重写，方法声明一模一样只是父类同名方法被隐藏了起来，不是方法重写)
   • 子类重写父类方法时，访问权限必须大于等于父类

权限修饰符

修饰符	同一个类中	同一个包中 子类&无关类	不同包的 子类	不同包的 无关类
private	√
默认	√	√
protected	√	√	√
public	√	√	√	√

private：只能在同一个类中访问

默认：同一个类中、同一个包中可以访问

protected：同一个类中、同一个包中和不同包的子类中可以访问

public：都可以

抽象类

1. 概述

   关键字： abstract

   当我们在做子类共性功能的抽取时，有些方法在父类中并没有具体的体现，这时候我们就需要将这些方法写为抽象方法，相对父类也要成为抽象类。(一个类中存在抽象方法，那么该类就必须声明为抽象类)

   一个没有方法体的方法应该定义为抽象方法。

2. 特点

   • 抽象类和抽象方法必须使用关键字：abstract 修饰

     //抽象类定义格式：
     public abstract class 类名{...}
     
     //抽象方法定义格式：
     public abstract 返回值类型 方法名(参数列表);
     

3. 注意

   • 抽象类不能实例化（抽象类中的抽象方法没有方法体，没有方法体就无法进行调用、调用了也没有意义，所以抽象类没有实例化的意义）
   • 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
   • 抽象类也有构造方法（其继承的子类，在初始化时依旧会调用父类的构造方法）
   • 抽象类的子类：要么重写父类中的所有抽象方法，要么自己是抽象类

final 关键字

1. 作用

   final代表最终的意思，可以修饰成员方法，成员变量和类

2. 效果

   • final修饰类：该类不能被继承（不能有子类）

   • final修饰方法：该方法不能被重写

   • final修饰变量：该变量是一个常量，不能再次赋值

     ​ 常量的命名规范：所有字母大写，多个单词之间用_分隔

     ​ 基本数据类型变量：其值不能被更改

     ​ 引用数据类型变量：地址值不能被更改，但是可以修改对象的属性值

3. 修饰成员变量的初始化时机：

   • 在创建的时候，直接给值

   • 在构造方法结束之前完成赋值

     public class A{
     	final int a;//只写这样会报错,在构造方法中赋值就不会了
         //1.final int a = 10；
         
         //2.构造方法结束前赋值
         public A(){
             a=10;
         }
     }
     

代码块

使用 {} 括起来的代码称为代码块。

1. 分类

   • 局部代码块
     • 位置：方法中定义
     • 作用：限定变量的生命周期，及早释放，提高内存利用率

   public class A {
       public static void main(String[] args) {
           //以下是局部代码块区域
           {
               int a = 10;
               System.out.println(a);
           }
           
           //System.out.println(a); a的作用范围已经抵达不到这里
   }
   

   • 构造代码块
     • 位置：类中方法外定义
     • 特点：每次构造方法执行时，都会执行代码块中的代码，并且在构造方法执行前执行
     • 作用：将多个构造方法中相同的代码，抽取到代码块中，提高代码的复用性

   class Student{
   	//构造代码块
       //每次创建对象都会执行
       {
           System.out.println("好好学习");
       }
       
       public Student(){
           System.out.println("空参数构造方法");
       }
       
       public Student(int a){
           System.out.println("带参数构造方法");
       }
   }
   

   • 静态代码块
     • 位置：类中方法外
     • 特点：需要通过static关键字修饰，随着类加载而加载，并且只执行一次
     • 作用：在类加载的时候做一些数据初始化的操作

   class Person {
       //静态代码块
       //只会在类文件加载的时候加载一次
       static {
           System.out.println("静态代码块, 执行了");
       }
   
       public Person(){
           System.out.println("空参数构造方法");
       }
   
       public Person(int a){
           System.out.println("带参数构造方法");
       }
   }