Java常见面试知识点：继承、接口、多态、代码块

末蓝、 2022-09-04 07:47 148阅读 0赞

# 问题：Java常见面试知识点：继承、接口、多态、代码块 #

答案：

1.继承

继承中构造方法的访问特点  
子类中所有的构造方法默认都会访问父类中无参的构造方法  
为什么？  
• 子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。 子类初始化之前，一定要先完成父类初始化。  
怎么初始化?  
• 构造方法的第一条语句默认都是：super()  
注意：如果我们编写的类，没有手动指定定父类，系统也会自动继承Object（Java继承体系中的最顶层父类）

看如下代码：

package com.xy;
    
    /**
     * @ProjectName: day01
     * @Package: PACKAGE_NAME
     * @ClassName: Fu
     * @Author: 杨路恒
     * @Description:
     * @Date: 2021/8/10 0010 18:53
     * @Version: 1.0
     */
    public class Fu {
        int a;
        public Fu(){
            this.a=6;
        }
        public void show(){
            System.out.println("1");
        }
    }
    
    
    
    
    package com.xy;
    
    /**
     * @ProjectName: day01
     * @Package: com.xy
     * @ClassName: Zi
     * @Author: 杨路恒
     * @Description:
     * @Date: 2021/8/10 0010 18:53
     * @Version: 1.0
     */
    public class Zi extends Fu {
        int a;
        public Zi(){
            //子类在初始化之前，一定要先完成父类数据的初始化
            //子类在初始化之前，一定要先访问到父类的构造方法，完成父类数据的初始化
            //系统在每一个构造方法中，默认隐藏的一句代码super()
            super();
            this.a=66;
            System.out.println(this.a);
            System.out.println(super.a);
        }
        public Zi(int a){
            super();
            System.out.println(a);
        }
        public void show(){
            System.out.println("2");
        }
    
        public static void main(String[] args) {
            Zi zi=new Zi();
            zi.show();
            /**
             * 1.方法重写：在继承体系中，子类出现了和父类一摸一样的方法声明（方法名，参数列表，返回值类型）
             * 2.方法重载：在同一个类中，方法名相同，参数列表不同，与返回值无关
             */
        }
    }

继承中构造方法的访问特点  
如果父类中没有空参构造方法，只有带参构造方法，会出现什么现象呢?  
•子类通过super,手动调用父类的带参的构造方法  
•子类通过this去调用本类的其他构造方法，本类其他构造方法再通过super去手动调用父类的带参的构造方法  
注意：this(…)super(…)必须放在构造方法的第一行有效语句，并且二者不能共存。

2.抽象

•抽象方法：将共性的行为（方法）抽取到父类之后，发现该方法的实现逻辑无法在父类中给出具体明确，该方法可以定义为抽象方法。  
•抽象类：如果一个类中存在抽象方法，那么该类就必须声明为抽象类

模板设计模式  
•设计模式(Design pattern)是 被反复使用、多数人知晓的、经过分期目的、代码设计经验的总结。 使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。  
•模板设计模式：把抽象类整体就可以看做成一个模板，模板中不能决定的东西定义成抽象方法  
让使用模板的类(继承抽象类的类)去重写抽象方法实现需求。

3.接口

接口中成员的特点  
• 成员变量  
只能是常量  
默认修饰符：public static final  
• 构造方法  
没有  
• 成员方法  
只能是抽象方法  
默认修饰符：public abstract

JDK8版中接口成员的特点  
• JDK8版本后  
•允许在接口中定义非方法，但是需要使用关键字default修饰，这些方法就是默认方法作用：解决接口升级的问题  
接口中默认方法的定义格式：  
• 格式：publicdefault返回值类型方法名（参数列表）\{ \}  
• 范例：public default void show() \{ \}  
接口中默认方法的注意事项：  
• 默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字  
• public可以省略，default不能省略  
• 如果实现了多个接口，多个接口中存在相同的方法声明，子类就必须对方法进行重写

JDK8版中接口成员的特点  
• JDK8版本后  
1 .允许在接口中定义非抽象方法，但是需要使用关键字default修饰，这些方法就是默认方法作用：解决接口升级的问题  
2 .接口中允许定义static静态方法  
接口中静态方法的定义格式：  
• 格式：public static返回值类型方法名（参数列表）\{ \}  
• 范例：public static void show()\{ \}  
接口中静态方法的注意事项：  
・静态方法只能通过接口名调用，不能通过实现类名或者对象名调用  
• public可以省略，static不能省略

package com.xy;
    
    /**
     * @ProjectName: day01
     * @Package: com.xy
     * @ClassName: testInter
     * @Author: 杨路恒
     * @Description:
     * @Date: 2021/8/11 0011 18:29
     * @Version: 1.0
     */
    public interface testInter {
        int num=66;
        public default void show(){
            System.out.println("JDK1.8");
        }
        public static void study(){
            System.out.println("静态");
        }
    }
    
    
    
    package com.xy;
    
    /**
     * @ProjectName: day01
     * @Package: com.xy
     * @ClassName: test04
     * @Author: 杨路恒
     * @Description:
     * @Date: 2021/8/11 0011 18:28
     * @Version: 1.0
     */
    public class test04 implements testInter{
        @Override
        public void show() {
            System.out.println("666");
        }
    
        public static void main(String[] args) {
            /**
             * 成员变量：只能是常量，系统会默认加入三个关键字
             *          public static final
             * 构造方法：没有
             * 成员方法：只能是抽象方法，系统会默认加入两个关键字 ，public abstract
             */
            System.out.println(num);    //接口变量是常量
            System.out.println(testInter.num);//接口变量是final修饰
            test04 test04=new test04();
            test04.show();
            testInter.study();
    
        }
    }

4.代码块

代码块概述与分类  
在Java中，使用｛｝括起来的代码被称为代码块  
分类：  
• 局部代码块  
位置:方法中定义  
作用：限定变量的生命周期，及早释放，提高内存利用率  
• 构造代码块  
位置：类中方法外定义  
特点：每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行  
作用：将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性  
• 静态代码块  
位置：类中方法外定义  
特点：需要通过static关键字修饰，随着类的加载而加载，并且只执行—次  
作用：在类加载的时候做一些数据初始化的操作

package com.xy;
    
    /**
     * @ProjectName: day01
     * @Package: com.xy
     * @ClassName: jubu
     * @Author: 杨路恒
     * @Description:
     * @Date: 2021/8/11 0011 12:59
     * @Version: 1.0
     */
    public class jubu {
    
    
        public static void main(String[] args) {
            /**
             * 局部代码块
             *      位置:方法中定义
             *      作用：限定变量的生命周期，及早释放，提高内存利用率
             */
            {
                int a=66;
                System.out.println(a);
            }
    
        }
    }
    
    
    
    
    package com.xy;
    
    /**
     * @ProjectName: day01
     * @Package: com.xy
     * @ClassName: gouzhao
     * @Author: 杨路恒
     * @Description:
     * @Date: 2021/8/11 0011 13:02
     * @Version: 1.0
     */
    public class gouzhao {
        /**
         * 构造代码块
         *      位置：类中方法外定义
         *      特点：每次构造方法执行的时候，都会执行该代码块中的代码，并且在构造方法执行前执行
         *      作用：将多个构造方法中相同的代码，抽取到代码块中。提高代码的复用性
         */
    
    
        public static void main(String[] args) {
            Student1 student1=new Student1();
            Student1 student11=new Student1();
    
        }
    }
    
    class Student1 {
        {
            System.out.println("我是构造代码块");
            System.out.println("好好学习");
        }
    
        public Student1() {
            System.out.println("空参构造方法");
        }
        public Student1(int a) {
            System.out.println("有参构造方法");
        }
    }
    
    
    
    
    
    package com.xy;
    
    /**
     * @ProjectName: day01
     * @Package: com.xy
     * @ClassName: jingtai
     * @Author: 杨路恒
     * @Description:
     * @Date: 2021/8/11 0011 17:21
     * @Version: 1.0
     */
    public class jingtai {
        /**
         * 静态代码块
         *      位置：类中方法外定义
         *      特点：需要通过static关键字修饰，随着类的加载而加载，并且只执行一次
         *      作用：在类加载的时候做一些数据初始化的操作
         */
        public static void main(String[] args) {
            Person person=new Person();
            Person person1=new Person();
        }
    }
    class Person{
        static {
            System.out.println("我是静态代码块");
        }
    
        public Person() {
            System.out.println("我是Person类的空参数构造方法");
        }
        public Person(int a){
            System.out.println("我是Person类的带......参数构造方法");
        }
    }