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

问题：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);
}