Java语言基础day07（代码块，继承，方法重写，final关键字，super关键字，多态）

最新推荐文章于 2023-08-11 18:10:37 发布

蒲陈陈

最新推荐文章于 2023-08-11 18:10:37 发布

阅读量182

点赞数 1

本文链接：https://blog.csdn.net/weixin_43306403/article/details/89383800

版权

代码块

代码块：就是用一对{}大括号括起来的的内容

代码块分为四类：局部代码块，构造代码块，静态代码块，同步代码块。

局部代码快：定义在方法里面的代码。在方法中出现，限定变量的生命周期，及早释放，提高内存的利用率。

构造代码块：类中方法外。

静态代码块：再类中方法外出现。用static修饰，进行一些对类的初始化。在加载时执行一次，并只执行一次。

 public class MyTest2 {
    public static void main(String[] args) {
        Student student = new Student();
        /*
        *   100
            这是一个静态代码块
            这是一个构造代码块
            这是一个空参构造

        * */
        //再创建对象时。先执行静态代码块，再执行构造代码亏，最后执行空参构造
        System.out.println("--------");
        Student student1 = new Student();
        /*
        * 这是一个构造代码块
            这是一个空参构造*/
        //静态代码块只执行一次，因为MyTest2.class文件夹只加载一次
    }
}

public class Student {
    static int a = 100;
    public Student(){
        System.out.println("这是一个空参构造");
    }
    {
        System.out.println("这是一个构造代码块");
    }
    //静态代码块随着类的加载而加载，且静态代码只执行一次，静态代码块里只能访问静态变量
    static {
        System.out.println(a);
        System.out.println("这是一个静态代码块" );
    }
}

继承

继承：多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。（子类继承父类并可以使用）

格式：

通过extends关键字可以实现类与类的继承
class 子类名 extends 父类名{}

继承的思想：所有的子类中相同的属性和行为向上抽取作为父类，提高了代码的复用性和维护性。
继承的好处：
1. 提高了代码的复用性
2. 提高了代码的维护性
3. 让类与类之间产生了关系，是多态的前提
4. 弊端;增加了耦合性让类与类之间产生了关系
  
  开发的原则：高内聚，低耦合。
  耦合：类与类的关系，就是一个类要完成某个功能去依赖某个类
  内聚：就是自己完成某件事情的能力
继承特点：只支持单继承，不支持多继承。支持多层继承。
继承注意的事项：
1. 只支持单继承，不支持多继承。支持多层继承。
2. 子类只能继承父类所有非私有的成员(成员方法和成员变量)
3. 子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。
4. 不要为了部分功能而去继承，会增加耦合性。
继承中的变量访问原则：
1. 在子类的方法的局部范围找,有就使用
2. 在子类的成员范围找,有就使用
3. 在父类的成员范围找,有就使用
4. 如果还找不到,就报错

继承中成员方法关系

    通过子类调用方法:
  		1. 先查找子类中有没有该方法,如果有就使用
  		2. 在看父类中有没有该方法,有就使用
  		3. 如果没有就报错

super关键字

this 代表的是本类对象的引用。（可以理解为本类的一个对象，那个对象调用这个方法，方法中的this就代表那个方法）
super 代表的是父类存储空间的标识(可以理解成父类的引用,可以操作父类的成员)
```
this.成员变量----访问本类的成员变量
this.成员方法（）------访问本类的成员方法
this()--------访问本类的空参构造
super.成员变量----访问父类的成员变量
super.成员方法------访问父类的成员方法
super()--------访问父类的空参构造
```
我们在创建子类对象时，为什么会先去执行父类的空参构造？

因为有了继承关系后，在我们要完成子类初始化时，先要完成父类的初始化。

因为我们子类要去继承父类的数据，可能还要使用到父类的数据，

所以肯定要先让父类的构造方法执行来完成对父类的初始化，然后完成自己的初始化

在每个类的构造方法第一句都会默认有一条super（）语句，调用父类完成对父类的初始化

方法重写

方法重写：子类中出现了和父类中一模一样的方法声明(方法名,参数列表,返回值类型都一样)，也被称为方法覆盖，方法复写
为什么要有方法重写这种机制：
1. 当子类对父类的方法实现不满意时，子类就可以进行方法重写进行覆盖
2. 当子类想要对父类方法实现进行扩展时，也可以使用方法重写这种机制。
方法重写注意事项：
1. 父类中私有方法不能被重写。都无法继承何谈重写。
2. 子类在重写父类方法时，权限不能比父类的低，要比父类的高，或者至少要一样。（public>protected>缺省的>private）
3. 父类静态方法子类不算重写

final关键字

final关键字是最终的意思，可以修饰类，变量，成员方法。
修饰类------------被修饰类不能被继承
修饰方法----------被修饰的方法不能被重写
修饰变量----------被修饰的变量不能被重新赋值,因为这个量其实是一个常量（变量名大写）
final修饰基本数据类型表示这个数据的之不能被改变。修饰引用引用数据类型表示这个地址值不能被改变

多态

多态：某一个事物，在不同时刻表现出来的不同状态。
```
格式：	父 f =  new 子();
父类引用指向子类对象
```
多态前提：
1. 要有继承关系。
2. 要有方法重写。其实没有也是可以的，但是如果没有这个就没有意义。
3. 要有父类引用指向子类对象。
多态中的成员访问特点：
1. 成员变量：编译看左边，运行看左边。
2. 构造方法：创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。
3. 成员方法：编译看左边，运行看右边。
4. 静态方法：编译看左边，运行看左边。(静态和类相关，算不上重写，所以，访问还是左边的)
多态的好处：
1. 提高了代码的维护性(继承保证)
2. 提高了代码的扩展性(由多态保证)

多态中强转例子

public class MyTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        Animal an = cat;//多态就是向上转型
        an.eat();
        //an.cacheMouse();
        //  ((Cat) an).cacheMouse();===========     Cat cat1=(Cat)an;   				//cat1.cacheMouse();
        Cat c= (Cat) an; //向下转型
        c.eat();
        c.cacheMouse();
        System.out.println("------");

        Dog dog1 = new Dog();
        Animal an1 = dog1;
       // Animal an1 = new Dog();
        an1.eat();
        //((Dog) an1).lookDoor();
        Dog dog = (Dog)an1;//an1强转为Dog类型，才能调用Dog类型中的成员变量
        dog.lookDoor();
        
       an=new Tiger();
        Tiger t= (Tiger) an;
        //ClassCastException 类型转换异常
        //如果两者不具备继承关系不能强制转换！
        t.swim();
    }
}