代码块和继承的定义与使用

最新推荐文章于 2022-01-14 21:53:13 发布

gx1500291

最新推荐文章于 2022-01-14 21:53:13 发布

阅读量175

点赞数 1

分类专栏： Java

本文链接：https://blog.csdn.net/gx123456sh/article/details/83510768

版权

Java 专栏收录该内容

35 篇文章 1 订阅

订阅专栏

1.代码块的定义与使用

根据代码块出现的位置以及关键字，分为以下三种代码块：

1.1普通代码块（没有任何修饰符）-定义在方法中的代码块

public class test{
     public static void main(String[] args){
        {
            //普通代码块
            int a = 10;
            System.out.println(a);
        }
        int a = 20;
        System.out.println(a);
     }
 }

1.2构造快（重要）-定义在类中的代码块（不加任何修饰符）

在对象产生时，优先于构造方法执行，有几个对象产生，就调用几次构造快

用于在构造方法执行前，完成一些属性的初始化操作

class Person{
    public Person(){
        System.out.println("1.Person类的构造方法");
    }
    {
        //构造快，优先于构造方法执行
        System.out.println("2.Person类的构造快");
    }
}
public class test{
     public static void main(String[] args){
         new Person();
         new Person();
     }
}

1.3静态代码块（用static修饰的代码块）

根据静态块所在的类的不同，可以分为两种类型：

1.3.1非主类中的静态代码块

在类加载时执行（啥时候用到这个类），优先于构造快执行，不管有多少个对象，只会调用一次

class Person{
    //构造方法
    public Person(){
        System.out.println("1.Person类的构造方法");
    }
    {
        //构造快优先于构造方法执行
        System.out.println("2.Person类的构造快");
    }
    static {
        //非主类静态代码块优先于构造快执行
        System.out.println("3.Person类的静态代码块");
    }
}
public class test{
     public static void main(String[] args){
         new Person();
         new Person();
     }
 }

1.3.2主类中的静态代码块

主类中的静态块优先于主方法执行

public class test{
    public test(){
        System.out.println("1.主类的构造方法");
    }
    {
        System.out.println("2.主类的构造快");
    }
    static {
        System.out.println("3.主类中的静态代码块");
    }
    //主方法
    public static void main(String[] args){
        System.out.println("4.start---");
        new test();
        new test();
        System.out.println("5.end---");
    }
}

2.继承的定义与使用

2.1意义：在现有的基础上进行功能的补充（可重用）

判断两个类之间能否使用继承（什么is a 什么）（例如：Student is a Person）

Java中类继承使用extends关键字 class 子类 extends 父类

子类（派生类）父类（超类-基类）

class Person{
    private String name;
    private int age;
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age;
    }
}
//Student类继承了Person类
class Student extends Person{

}
public class test{
    public static void main(String[] args){
        Student stu = new Student();
        stu.setName("gx");
        stu.setAge(18);
        System.out.println(stu.getName());
        System.out.println(stu.getAge());
    }
}

通过上述代码可以发现，当发生了类继承关系之后，子类可以直接继承父类的操作，可以实现代码的重用。当然了，子类也可以扩充自己的功能。

//在原有基础上进行功能的扩充
class Student extends Person{
    private String school;   //定义了新的属性
    public String getSchool(){
        return school;
    }
    public void setSchool(String school){
        this.school = school;
    }
}

2.2继承的限制

2.2.1子类对象实例化前，首先调用父类构造方法产生父类对象后在调用子类构造方法实例化子类对象

class Person{
    public Person(){
        System.out.println("1.父类Person的构造方法");
    }
}
class Student extends Person{
    public Student(){
        System.out.println("2.子类Student的构造方法");
    }
}
public class test{
    public static void main(String[] args){
        Student stu = new Student();
    }
}

通过以上代码可以发现，没有任何一条语句调用父类构造方法，因此子类对象实例化之前一定先实例化父类对象。

2.2.2Java中只允许单继承，不允许多继承（Java的单继承局限）

class C extends A,B{}

要想在Java中实现类似的“多继承”，要么多层继承，要么使用内部类

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

2.2.3在继承时，子类会继承父类的所有结构（包括私有域与其他属性、方法）

显示继承：所有非私有操作属于显示继承（可以直接调用）

隐式继承：所有的私有操作属于隐式继承（不可以直接调用，可以通过其他方法调用）

被private封装后，不可以直接调用，属于隐式继承

class Person{
    //隐式继承
    private String name;
    //显示继承
    public int age;
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
}
class Student extends Person{

}
public class test{
    public static void main(String[] args){
        Student stu = new Student();
        stu.age = 18;
        stu.setName("gx");
        System.out.println(stu.getName());
        System.out.println(stu.age);
    }
}

经典面试题

class A{
    public A(){
        System.out.println("1.A类的构造方法");
    }
    {
        System.out.println("2.A类的构造快");
    }
    static {
        System.out.println("3.A类的静态块");
    }
}
public class B extends A{
    public B(){
        System.out.println("4.B类的构造方法");
    }
    {
        System.out.println("5.B类的构造快");
    }
    static {
        System.out.println("6.B类的静态块");
    }
    public static void main(String[] args){
        System.out.println("7.start---");
        new B();
        new B();
        System.out.println("8.end---");
    }
}

因为主类中的静态块优先于主方法执行，所以6先执行与7，又因为B是A的子类，所以先执行A的静态块在执行B的静态块，然后进入主方法。子类对象实例化首先要调用父类的构造方法，因为存在构造快，所以构造快先执行与构造方法。