代码块的概述&继承

最新推荐文章于 2024-04-09 12:27:45 发布

奇比翼凡

最新推荐文章于 2024-04-09 12:27:45 发布

阅读量123

点赞数

本文链接：https://blog.csdn.net/wyq1614406553/article/details/89370998

版权

代码块的概述

代码块：在Java中，使用{}括起来的代码称为代码块。

分类：根据其位置与声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块。

局部代码块：在方法中出现，可以及时释放掉，提高内存利用率。

构造代码块：在类中方法方法外出现，可以把多个构造方法中相同的代码块存放到一起，每次调用构造都执行且在构造方法前执行。

静态代码块：在类中方法外出现，加static修饰，用于给类进行初始化，在加载时执行一次。
例如：看下面代码块执行的顺序

class Student {
    static {
        System.out.println(" 我爱看篮球赛"); 
    }

    {
        System.out.println("构造代码块"); 
    }

    public Student() {
        System.out.println("构造方法"); 
    }
}

class StudentDemo {
    static {
        System.out.println("的静态代码块");
    }

    public static void main(String[] args) {
        System.out.println("我爱看电视");

        Student s1 = new Student();
       Student s2 = new Student();
    }
}
输出结果：
静态代码块
我爱看电视
 我爱看篮球赛
构造代码块
构造方法
构造代码块
构造方法
注意：静态代码块只执行一次

面向对象的特征之一————继承

为什么要有继承呢：当多个类存在相同的属性和行为时，将这些内容抽取到一个类中，那么其他类要用这个功能时，只需要继承。
继承格式：通过extends关键字可以实现类与类的继承
class 子类名 extends 父类名{}
这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。
继承的好处：
1.提高了代码的复用性
2.提高了代码的维护性
3.让类与类之间产生了关系，是多态的前提。
继承的弊端：
1.增加了类的耦合性（开发的原则：高内聚（就是自己完成某个功能的能力），耦合（类与类的关系）。

父类：
public class Person {
    String name ;
    int age;
    public void  eat(){
        System.out.println("会吃饭");
    }
    public void sleep(){
        System.out.println("会睡觉");
    }
}
子类一：
public class Student extends Person {
    @Override
    public void eat() {
        System.out.println("喜欢吃烤串");
    }

    @Override
    public void sleep() {
        System.out.println("喜欢晚睡");
    }
}
子类二：
public class Teacher extends Person {


    @Override
    public void eat() {
        System.out.println("爱吃牛肉面");
    }

    @Override
    public void sleep() {
        System.out.println("经常早睡");
    }
}
测试类：
public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();
        student.name="王六";
        student.age=20;
        System.out.println(student.name);
        System.out.println(student.age);
        student.sleep();
        student.eat();
        Teacher teacher = new Teacher();
        teacher.name="张麻子";
        teacher.age=28;
        System.out.println(teacher.name);
        System.out.println(teacher.age);
        teacher.eat();
        teacher.sleep();
    }
}
输出结果：王六
20
喜欢晚睡
喜欢吃烤串
张麻子
28
爱吃牛肉面
经常早睡

Java中类继承的特点：
1.只支持单继承，不支持多继承，但是支持多层继承
2.子类继承只能继承父类的非私有成员方法和成员变量
3.子类不能继承父类的构造方法，但是可以通过super关键字区访问父类构造方法
注意：不要为了继承部分功能去继承，继承体现的是“is a”的关系

继承过程当中成员变量的关系

当子类中的成员变量和父类中的成员变量名称一样时，采用的是就近原则，先在子类的方法的局部找，有就使用，接着在子类的成员范围找，有就使用，最后在父类的成员范围找，
但是有时候我们就需要父类的，就要用关键字“ super”，我们之前也学过类似的关键字this，先来区分一下他们的关系

	引用对象	调用成员变量	调用构造方法	调用成员方法
this	代表本类对象的引用	this.成员变量	this（…)	this.成员方法
super	代表父类的引用	super.成员变量	super(…)	super.成员方法

既然有super 这个关键字，我们就聊聊继承中构造方法的关系

子类中所有的构造方法默认都会访问父类中空参构造的构造方法。为什么呢？因为子类会继承父类中的数据，可能还会使用父类的数据，所以子类初始化前，一定要先完成父类数据的初始化，其实：每一个构造方法的第一条默认语句都是 super()

注意事项：父类没有无参构造方法，子类怎么办？

1.在父类中添加一个无参构造方法
2.子类通过super去显示调用父类其他的带构造方法
3.子类通过this去调用本类其他构造方法，本类其他构造方法也必须首先访问父类构造
4.super（…）或者this (…)必须出现在第一条语句上
例如：请看下面的代码

public class MyTest2 {
    public static void main(String[] args) {
        B b = new B(30);
        System.out.println(b.a);

    }

}
class A{
    int a=10;
    public A(){
        System.out.println("这是A的汽车");
    }
    public A(int a){
        this.a=a;
        System.out.println("这是A的好法拉利");
        System.out.println(a);
    }
}
class B extends A{
    int a=20;
    public B() {
        super();
        System.out.println("这是B的汽车");
    }

    public B(int a) {
        super(a);
        System.out.println("这是B的法拉利");
        System.out.println(a);
    }
}
输出结果：
这是A的好法拉利
30
这是B的法拉利
30
20
当new子类对象的时候，传入有参方法，会先去访问父类的有参构造，接下来访问子类的有参构造。