代码块，继承，方法重写，final关键字

代码块

在Java中被{}括起来的代码被称为代码块
代码块根据位置和声明可以分成三类：局部代码块、构造代码块、静态代码块。

1. 局部代码块:在方法中出现，限定变量生命周期，及早释放，提高内存利用率。
2. 构造代码块：在类中方法外出现，多个构造方法方法中相同的代码放在一起，每次调用都执行，并且在构造方法前执行。
3. 静态代码块：在类中方法外出现，加了static修饰，用于给类进行初始化，在加载的时候就执行，并且只执行一次。
   例：静态代码块的调用

public class MyTest2 {
    public static void main(String[] args) {
        new Student();
        new Student();
        new Student();
    }
}
public class Student {
    static {
        System.out.println("静态代码块");	//静态代码块只执行一次，最先执行
    }

    {
        System.out.println("构造代码块");	//构造代码块每次都调用，第二执行
    }

    public Student() {
        System.out.println("构造方法");		//构造方法每次都调用，在执行构造方法
    }
}

只要记住静态代码块最先执行，其次是构造代码块，最后是构造方法。

继承

为什么要继承？就是多个类存在相同属性和行为时，将这些内容抽取到单独一个类中，那多个类无需定义这些属性和行为，只要继承那个类就好。
格式：
通过extands关键字可以实现类与类的继承
class 子类名 extands 父类名{}

public class Father {
}
public class Son extends Father{
}

单独的类称为父类，多个类可以称为子类

通过继承就得到了一些好处

1. 提高了代码的复用性
2. 提高了代码的维护性
3. 让类与类之间产生了关系，是多态的前提

有利有弊，则弊端：

类的耦合性增强了
因为开发原则是：高内聚，低耦合
耦合就是类与类的关系
内聚：就是自己完成某件事情的能力

继承的特点：

1. Java只支持单继承，不支持多继承。
   比如一个子类只能有一个父类
2. 支持多层继承。
   一个子类有一个父类，但是父类自己还可以有一个父类

class GrandFather{
    
}
class Father extends GrandFather{
    
}
class Son extends Father{
    
}

继承的注意事项：

1. 子类只能继承父类的所有非稀有的成员
2. 子类不能继承父类的构造方法
3. 构造方法不参与继承，父类构造方法用于子类初始化父类成员。
4. 不要为了部分功能而去继承。
5. 继承体现的是is a 的关系。

继承中成员变量的关系：

当子类中成员变量与父类成员变量名称一样时，在子类中访问变量就遵循就近原则。
先在子类方法的局部范围找，找不到就在子类的成员范围找，找不到就在父类的成员范围找，再找不到就报错。

super

在子类局部范围通过super来访问父类成员变量

this和super的区别：
this代表的是本类对象的引用
super代表的是父类存储空间的标识（可以理解成父类的引用，可以操作父类的成员）

this就是调用本类中的成员变量，成员方法，构造方法
super就是调用父类的成员变量，成员方法，构造方法

继承中构造方法的关系

子类中所有的构造方法默认都会访问父类中空参构造
因为子类会继承父类的数据，可能还会使用父类的数据，所以在子类初始化之前，一定要先完成父类数据的初始化。
每一个构造方法的第一条语句默认都是super（）

class Animal{
    public Animal(){
        super();//默认语句，调用父类的空参构造
        System.out.println("父类空参");
    }
}
class Cat extends Animal {
    public Cat() {
        super();//默认语句，调用父类的空参构造
        System.out.println("子类空参");
    }
}

在构造方法的第一条语句默认有一句super（）语句，不写默认在

继承中构造方法的注意事项

在父类没有无参构造，子类应该怎么做？

1. 在父类中添加一个无参的构造方法。
2. 子类通过super去显示调用父类其他的带参的构造方法
3. 子类通过this去调用本类的其他构造方法

注意: super（）和this（）必须在第一条语句上
例：

class Fu{
public int num = 10;
public Fu(){
System.out.println("fu"); 		 //fu
}
}
class Zi extends Fu{
public int num = 20;
public Zi(){
System.out.println("zi");		 //zi
}
public void show(){
int num = 30;
System.out.println(num);		 //30
System.out.println(this.num); 		 //20
System.out.println(super.num);		 //10
}
}
class Test {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}

可以通过例题掌握super和this的用法。

继承中成员方法关系

当子类方法名与父类方法名一样的时候，通过子类调用方法。
先查找子类中有没有该方法，没有就在父类中查找，没有就报错。

方法重写

首先明白什么是方法重写
方法重写就是子类中出现和父类中一模一样的方法声明（方法名，参数列表，放回值类型）也被称为方法覆盖。
为什么会出现方法重写：就是因为子类对父类的方法实现不满意，或者说是对父类的方法进行拓展。
判断是不是方法重写：

@Override //注解 可以检测这个方法是不是重写父类的方法
public void show() 
@Override//如果不是方法重写，那@Override就会报错
public void test(){

方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这既沿袭了父类的功能，又定义了子类特有的内容。

class Animal{
public void eat(){
System.out.println("吃饭");
}
}
class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃骨头");
}
}
class Cat extends Animal{
@Override
public void eat(){
System.out.println("猫吃鱼");
}

上述代码说明了动物在吃饭的方向进行拓展，狗吃骨头，猫吃鱼。

方法重写的注意事项

1. 父类中私有方法不能被重写
2. 子类重写父类方法时，访问权限不能更低，最好一样

class Animal{    
 	public void eat(){ 
  class Dog extends Animal{     
	 @Override   
  	 public void eat() {//方法重写时访问权限不能低public最好一样

3. 父类静态方法，子类也必须通过静态方法进行重写（这个算不上方法重写，但是现象确实如此。
4. 子类重写父类方法的时候，最好声明一模一样。

final关键字

为什么会有final
由于继承中会有一个方法重写的现象，而有时候我们不想让子类去重写父类的方法，这种情况Java给我们提供了一个关键字final。
final：最终的意思，可以修饰变量，成员方法，类。

final修饰变量变成了自定义常量，不能被重新赋值。

final int NUM=100; //自定义常量 ，常量的命名规范 字母全部大写

final修饰方法子类不能重写，只能继承。

class Fu{
    public final void show()
 class Zi extends Fu{
    @Override
    public void show() {	//final修饰方法子类不能被重写，所以此语句会报错

final修饰类，此类不能被继承。

final class A{
    
}
class B extends A{	//此时B不能别继承
    
}