Java面试知识点：多态、内部类

缺乏、安全感 2022-09-04 11:42 201阅读 0赞

# 问题：Java面试知识点：多态、内部类 #

答案：

多态中成员访问特点  
• 构造方法：同继承一样，子类会通过super访问父类构造方法  
• 成员变量：编译看左边（父类），执行看左边（父类）  
• 成员方法：编译看左边（父类），执行看右边（子类）

多态中的转型  
• 向上转型  
从子到父  
父类引用指向子类对象  
• 向下转型  
从父到子  
父类引用转为子类对象

避免强转出现的问题  
•关键字 instanceof  
•使用格式：  
变量名 instanceof 类型  
通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果

内部类：  
成员内部类  
成员内部类，也属于（成员），既然是成员就可以被一些修饰符所修饰  
• private  
私有成员内部类访问：在自己所在的外部类中创建对象访问。  
• static  
静态成员内部类访问格式:外部类名.内部类名对象名=new外部类名.内部类名();  
静态成员内部类中的静态方法：外部类名.内部类名.方法名();  
  
匿名内部类  
概述：匿名内部类本质上是一个特殊的局部内部类（定义在方法内部） 前提：需要存在一个接口或类  
格式：  
new类名或者接口名。\{ 重写方法；  
）；

package com.xy;
    
    /**
     * @ProjectName: day01
     * @Package: com.xy
     * @ClassName: test06
     * @Author: 杨路恒
     * @Description:
     * @Date: 2021/8/12 0012 17:39
     * @Version: 1.0
     */
    public class test06 {
        public static void main(String[] args) {
            InterIml interIml=new InterIml();
            interIml.show();
    
            /**
             * 匿名内部类：
             *  前提：需要存在类、接口
             *  格式：
             *       new 类名、接口名(){
             *
             *       }
             */
            new Inter(){
    
                @Override
                public void show() {
                    System.out.println("匿名内部类");
                }
            }.show();
    
            //匿名内部类的理解：将继承、实现，方法重写，创建对象，放在了一步进行
            //解释：实现了Inter接口的，一个实现类对象
            Inter1 inter=new Inter1(){
    
                @Override
                public void show() {
                    System.out.println("1");
                }
    
                @Override
                public void show1() {
                    System.out.println("2");
                }
            };
            inter.show();
            inter.show1();
        }
    }
    
    interface Inter{
        void show();
    }
    interface Inter1{
        void show();
        void show1();
    }
    class InterIml implements Inter{
    
        @Override
        public void show() {
            System.out.println("匿名内部类");
        }
    }

lambda表达式：  
Lambda表达式的标准格式  
• 方法形式参数为空，说明调用方法时不需要传递物  
• 方法返回值类型为void ,说明方法执行没有结果返回  
• 方法体中的内容，是我们具体要做的事情  
Lambda表达式的代码分析  
・ () :里面没有内容，可以看成是方法形式参数为空  
• -> ：用箭头指向后面要做的事情  
• ｛｝：包含一段代码，我们称之之为代码块，可以看成是方法体中的内容  
组成Lambda表达式的三要素：形式参数，箭头，代码块  
Lambda表达式的省略模式  
省略规则：  
• 参数类型可以省略，但是有多个参数的情况下，不能只省略一个  
•如果参数有且仅有一个，那么小括号可以省略  
• 如果代码块的语句只有一条，可以省略大括号和分号，甚至是return

Lambda表达式和匿名内部类的区别  
所需类型不同  
• 匿名内部类:可以是接口，也可以是抽象类，还可以是具体类  
• Lambda表达式：只能是接口  
使用限制不同  
• 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类  
• 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式  
实现原理不同  
• 匿名内部类：编译之后，产生一个单独的.class字节码文件  
• Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

package com.xy;
    
    import java.util.Random;
    
    /**
     * @ProjectName: day01
     * @Package: com.xy
     * @ClassName: test07
     * @Author: 杨路恒
     * @Description:
     * @Date: 2021/8/13 0013 12:31
     * @Version: 1.0
     */
    public class test07 {
        public static void main(String[] args) {
            useShowHandler(new ShowHandler() {
                @Override
                public void show() {
                    System.out.println("匿名内部类");
                }
            });
            useShowHandler(() -> {
                System.out.println("lambda");
            });
            useStringHandler(new StringHandler() {
                @Override
                public void printMessage(String msg) {
                    System.out.println("匿名内部类" + msg);
                }
            });
            useStringHandler((String msg) -> {
                System.out.println("lambda");
            });
            useRandomNumHandler(new RandomNumHandler() {
                @Override
                public int getNumber() {
                    Random random = new Random();
                    int number = random.nextInt(10) + 1;
                    return number;
                }
            });
            useRandomNumHandler(() -> {
                Random random = new Random();
                int number = random.nextInt(10) + 1;
                return number;  //如果lambda所操作的接口中的方法有返回值，一定要通过return语句，将结果返回
            });
            useCalculator(new Calculator() {
                @Override
                public int calc(int a, int b) {
                    return a+b;
                }
            });
            useCalculator((int a,int b)->{
                return a+b;
            });
        }
    
        public static void useShowHandler(ShowHandler showHandler) {
            showHandler.show();
        }
    
        public static void useStringHandler(StringHandler stringHandler) {
            stringHandler.printMessage("6");
        }
    
        public static void useRandomNumHandler(RandomNumHandler randomNumHandler) {
            int number = randomNumHandler.getNumber();
            System.out.println(number);
        }
    
        public static void useCalculator(Calculator calculator){
            int calc = calculator.calc(6, 66);
            System.out.println(calc);
        }
    }
    
    interface ShowHandler {
        public void show();
    }
    
    interface StringHandler {
        public void printMessage(String msg);
    }
    
    interface RandomNumHandler {
        public int getNumber();
    }
    
    interface Calculator{
        public int calc(int a,int b);
    }