Java基础进阶:内部类lambda重点摘要,详细讲解成员内部类,局部内部类,匿名内部类,Lambda表达式,Lambda表达式和匿名内部类的区别,附重难点,代码实现源码,课堂笔记,课后扩展及答案

2022-11-16 16:01:10

　　　　　　　　　　　　　　　　内部类lambda重点摘要

内部类特点:

内部类可以直接访问外部类,包括私有
外部类访问内部类必须创建对象

创建内部对象格式:

外部类.内部类对象名=new外部类().new内部类();

静态内部类访问:

外部类.内部类.方法名

局部内部类:

局部内部类在方法中定义的类,外届无法直接使用,需要在方法内部创建对象并使用,该类可以直接访问外部类成员,也可以访问方法类的局部变量
私有成员内部类访问需在自己外部类中创建对象

匿名内部类:

前提:

需要一个类或者接口
格式:

new 类名/接口名(){重写方法}
理解:将继承/实现,方法重写,创建对象放在了一步进行
解释:实现了Inter接口,一个实现类对象

lambda:

格式:

(形式参数)->{代码块}

形式参数:

如果有多个参数,用逗号分开,没有参数留空即可

->:

固定写法,代表指向动作

代码块:

我们具体的实现代码
前提:
1. 有一个接口
2. 接口中有且只有一个抽象方法
lanmda省略模式:
1. 参数类型可以省略,但是多个参数情况下不能只省略一个
2. 如果有且只有一个参数()可以省略
3. 如果代码块只有一条语句,可以省略大括号分号和return关键字

lambda表达式和匿名内部类的区别:

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

　　　　　　　　　　　　　　　　课堂笔记-多态-匿名内部类-lambda

多态

多态的概述

一个对象,多种形态;

多态的前提

有继承或有实现

多态的代码形式(重点)

父类类型 变量名 = new 子类类名();

多态中成员访问的特点

成员变量(了解)

编译和运行都看父类类型;

成员方法(重点)

编译看左边(父类),运行看右边;(子类)

多态的好处和弊端

多态的转型

向上转型: 子类对象,转成父类类型, Fu f = new Zi();

向下转型: 父类对象,转成子类类型, Zi z = (Zi)f;

为了解决类型转换异常,在转换之前,应该先判断被转的对象是否与目标类型一致;

判断的格式:

if(对象名 instanceof 类名){
    在这里转
}

内部类

概述

在一个类(A)的内部,又写了其他的类(B),此时B类就是A类的内部类;

分类

按照内部类在外部类的位置,可以分为局部内部类和成员内部类:

局部内部类: 写在了外部类的方法中;

成员内部类: 写在了外部类的成员变量位置;

真正使用的都是匿名内部类;

匿名内部类实际上是局部内部类的简化形式;
我们写了一个不带名字的局部内部类就是匿名内部类;(集类的编写,对象的创建于一体)

匿名内部类(重点)

概述:
编写的类没有名字;
语法要求,这样的类必须有一个父类或接口,并且写完这个类以后,需要立刻创建对象;

语法格式

new 父类或接口(){
    重写父类或接口的方法;
};

匿名对象

创建了一个没有名字的对象就是匿名对象;

lambda

概述

lambda是java在jdk8开始新增的一种语法,这种语法允许我们在调用带有接口类型的形参的方法时,使用lambda作为方法的实参使用;(lambda是需要根据调用的场景自动进行推导的)

使用前提

必须方法的形参是有接口类型,且接口中有且仅有一个抽象方法;

lambda的基本语法

(参数列表)->{方法体;return 返回值;}
lambda必须作为方法的实参使用;

省略规则

lambda与匿名内部类的区别

　　　　　　　　　　　　　　　　代码实现

1.内部类

1.1 内部类的基本使用（理解）

内部类概念
- 在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类

内部类定义格式

格式&举例：

/*
    格式：
    class 外部类名{
        修饰符 class 内部类名{
        
        }
    }
*/

class Outer {
    public class Inner {
        
    }
}

内部类的访问特点
- 内部类可以直接访问外部类的成员，包括私有
- 外部类要访问内部类的成员，必须创建对象

示例代码：

/*
    内部类访问特点：
        内部类可以直接访问外部类的成员，包括私有
        外部类要访问内部类的成员，必须创建对象
 */
public class Outer {
    private int num = 10;
    public class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    public void method() {
        Inner i = new Inner();
        i.show();
    }
}

1.2 成员内部类（理解）

成员内部类的定义位置
- 在类中方法，跟成员变量是一个位置
外界创建成员内部类格式
- 格式：外部类名.内部类名对象名 = 外部类对象.内部类对象;
- 举例：Outer.Inner oi = new Outer().new Inner();

私有成员内部类

将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。

示例代码：

class Outer {
    private int num = 10;
    private class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    public void method() {
        Inner i = new Inner();
        i.show();
    }
}
public class InnerDemo {
    public static void main(String[] args) {
        //Outer.Inner oi = new Outer().new Inner();
        //oi.show();
        Outer o = new Outer();
        o.method();
    }
}

静态成员内部类

静态成员内部类访问格式：外部类名.内部类名对象名 = new 外部类名.内部类名();
静态成员内部类中的静态方法：外部类名.内部类名.方法名();

示例代码

class Outer {
    static class Inner {
        public void show(){
            System.out.println("inner..show");
        }

        public static void method(){
            System.out.println("inner..method");
        }
    }
}

public class Test3Innerclass {
    /*
        静态成员内部类演示
     */
    public static void main(String[] args) {
        // 外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer.Inner oi = new Outer.Inner();
        oi.show();

        Outer.Inner.method();
    }
}

1.3 局部内部类（理解）

局部内部类定义位置
- 局部内部类是在方法中定义的类
局部内部类方式方式
- 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
- 该类可以直接访问外部类的成员，也可以访问方法内的局部变量

示例代码

class Outer {
    private int num = 10;
    public void method() {
        int num2 = 20;
        class Inner {
            public void show() {
                System.out.println(num);
                System.out.println(num2);
            }
        }
        Inner i = new Inner();
        i.show();
    }
}
public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

1.4 匿名内部类（应用）

匿名内部类的前提
- 存在一个类或者接口，这里的类可以是具体类也可以是抽象类
匿名内部类的格式
- 格式：new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }
- 举例：
```
new Inter(){
    @Override
    public void method(){}
} 
```
匿名内部类的本质
- 本质：是一个继承了该类或者实现了该接口的子类匿名对象

匿名内部类的细节

匿名内部类可以通过多态的形式接受

Inter i = new Inter(){
  @Override
    public void method(){
        
    }
}

匿名内部类直接调用方法

interface Inter{
    void method();
}

class Test{
    public static void main(String[] args){
        new Inter(){
            @Override
            public void method(){
                System.out.println("我是匿名内部类");
            }
        }.method(); // 直接调用方法
    }
}

1.5 匿名内部类在开发中的使用（应用）

匿名内部类在开发中的使用
- 当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码

示例代码：

/*
    游泳接口
 */
interface Swimming {
    void swim();
}

public class TestSwimming {
    public static void main(String[] args) {
        goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("铁汁, 我们去游泳吧");
            }
        });
    }

    /**
     * 使用接口的方法
     */
    public static void goSwimming(Swimming swimming){
        /*
            Swimming swim = new Swimming() {
                @Override
                public void swim() {
                    System.out.println("铁汁, 我们去游泳吧");
                }
            }
         */
        swimming.swim();
    }
}

2.Lambda表达式

2.1体验Lambda表达式【理解】

代码演示

/*
    游泳接口
 */
interface Swimming {
    void swim();
}

public class TestSwimming {
    public static void main(String[] args) {
        // 通过匿名内部类实现
        goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("铁汁, 我们去游泳吧");
            }
        });

        /*  通过Lambda表达式实现
            理解: 对于Lambda表达式, 对匿名内部类进行了优化
         */
        goSwimming(() -> System.out.println("铁汁, 我们去游泳吧"));
    }

    /**
     * 使用接口的方法
     */
    public static void goSwimming(Swimming swimming) {
        swimming.swim();
    }
}

函数式编程思想概述

在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作”

面向对象思想强调“必须通过对象的形式来做事情”

函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”

而我们要学习的Lambda表达式就是函数式思想的体现

2.2Lambda表达式的标准格式【理解】

格式：

(形式参数) -> {代码块}
- 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
- ->：由英文中画线和大于符号组成，固定写法。代表指向动作
- 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容
组成Lambda表达式的三要素：
- 形式参数，箭头，代码块

2.3Lambda表达式练习1【应用】

Lambda表达式的使用前提
- 有一个接口
- 接口中有且仅有一个抽象方法
练习描述

无参无返回值抽象方法的练习
操作步骤
- 定义一个接口(Eatable)，里面定义一个抽象方法：void eat();
- 定义一个测试类(EatableDemo)，在测试类中提供两个方法
  - 一个方法是：useEatable(Eatable e)
  - 一个方法是主方法，在主方法中调用useEatable方法

示例代码

//接口
public interface Eatable {
    void eat();
}
//实现类
public class EatableImpl implements Eatable {
    @Override
    public void eat() {
        System.out.println("一天一苹果，医生远离我");
    }
}
//测试类
public class EatableDemo {
    public static void main(String[] args) {
        //在主方法中调用useEatable方法
        Eatable e = new EatableImpl();
        useEatable(e);

        //匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("一天一苹果，医生远离我");
            }
        });

        //Lambda表达式
        useEatable(() -> {
            System.out.println("一天一苹果，医生远离我");
        });
    }

    private static void useEatable(Eatable e) {
        e.eat();
    }
}

2.4Lambda表达式练习2【应用】

练习描述

有参无返回值抽象方法的练习
操作步骤
- 定义一个接口(Flyable)，里面定义一个抽象方法：void fly(String s);
- 定义一个测试类(FlyableDemo)，在测试类中提供两个方法
  - 一个方法是：useFlyable(Flyable f)
  - 一个方法是主方法，在主方法中调用useFlyable方法

示例代码

public interface Flyable {
    void fly(String s);
}

public class FlyableDemo {
    public static void main(String[] args) {
        //在主方法中调用useFlyable方法
        //匿名内部类
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s);
                System.out.println("飞机自驾游");
            }
        });
        System.out.println("--------");

        //Lambda
        useFlyable((String s) -> {
            System.out.println(s);
            System.out.println("飞机自驾游");
        });

    }

    private static void useFlyable(Flyable f) {
        f.fly("风和日丽，晴空万里");
    }
}

2.5Lambda表达式练习3【应用】

练习描述

有参有返回值抽象方法的练习
操作步骤
- 定义一个接口(Addable)，里面定义一个抽象方法：int add(int x,int y);
- 定义一个测试类(AddableDemo)，在测试类中提供两个方法
  - 一个方法是：useAddable(Addable a)
  - 一个方法是主方法，在主方法中调用useAddable方法

示例代码

public interface Addable {
    int add(int x,int y);
}

public class AddableDemo {
    public static void main(String[] args) {
        //在主方法中调用useAddable方法
        useAddable((int x,int y) -> {
            return x + y;
        });

    }

    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

2.6Lambda表达式的省略模式【应用】

省略的规则
- 参数类型可以省略。但是有多个参数的情况下，不能只省略一个
- 如果参数有且仅有一个，那么小括号可以省略
- 如果代码块的语句只有一条，可以省略大括号和分号，和return关键字

代码演示

public interface Addable {
    int add(int x, int y);
}

public interface Flyable {
    void fly(String s);
}

public class LambdaDemo {
    public static void main(String[] args) {
//        useAddable((int x,int y) -> {
//            return x + y;
//        });
        //参数的类型可以省略
        useAddable((x, y) -> {
            return x + y;
        });

//        useFlyable((String s) -> {
//            System.out.println(s);
//        });
        //如果参数有且仅有一个，那么小括号可以省略
//        useFlyable(s -> {
//            System.out.println(s);
//        });

        //如果代码块的语句只有一条，可以省略大括号和分号
        useFlyable(s -> System.out.println(s));

        //如果代码块的语句只有一条，可以省略大括号和分号，如果有return，return也要省略掉
        useAddable((x, y) -> x + y);
    }

    private static void useFlyable(Flyable f) {
        f.fly("风和日丽，晴空万里");
    }

    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

2.7Lambda表达式的使用前提【理解】

使用Lambda必须要有接口
并且要求接口中有且仅有一个抽象方法

2.8Lambda表达式和匿名内部类的区别【理解】

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

　　　　　　　　　　　　　　　　课后练习

多态问答题

1.1 请用一句话描述出用代码怎样实现“多态”？

有继承或者实现关系,有方法重写,父类引用指向子类对象

1.2 请写出多态的好处和弊端；

好处:

提高程序的扩展性.定义方法的时候,使用父类型作为参数,在使用的时候,使用具体的子类型参与操作

弊端:

不能使用子类的特有成员

1.3 请写出多态的向下转型的意义

为了使用多态的子类对象中特有的内容

内部类问答题

2.1 请问有几种形式的内部类？

成员内部类

局部内部类

2.2 请问内部类会被编译成class文件吗？

会

2.3 请问下面横线处分别填写什么代码，才能实现打印出注释的结果

class Outside{
        private int a = 100;
        class Inside{
            private int a = 200;
            public void show(){
                int a = 300;
                System.out.println(new_Outside().a);//100
                System.out.println(this.a);//200
                Ssytem.out.println(a);//300
            }
        }
    }

2.4 请问下面横线处分别填写什么代码，才能实现打印：

class Outside{
        public void show(){
            __int a=10;________
            class Inside{
                public void show(){
                    System.out.println("a = " + a);//10
                }
            }
            Inside in = new Inside();

            __in.show_____
        }
    }

2.5 请按要求填写代码：

    interface Animal{
        public  void show();
    }
    class Cat implements Animal{
        public  void show(){
            sout("猫")
        }

    }
    class Test{
        public static void main(String[] args){
//子类调用代码:
        fun(new Cat);//请用子类的形式调用
//匿名调用代码:
        fun(new Animal() {
            @Override
            public void show() {
                System.out.println("猫");
            }
        }));//请用匿名内部类的形式调用
        }
        public static void fun(Animal a ){
            a.show();
        }
    }

lambda问答题

3.1 Lambda练习

给定一个导演 Director接口，内含唯一的抽象方法makeMovie，且无参数、无返回值，请使用lambda表达式在Test中补全代码完成调用,打印输出“导演拍电影啦！”字样

public interface Director {
    void makeMovie();
}
public class Test{
    public static void main(String[] args) {
        //请使用Lambda和省略格式调用invokeDirect方法,打印输出“导演拍电影啦！”字样
//填写代码为:
invokeDirect(()->
    System.out.println("导演拍电影了"));

    }

    private static void invokeDirect(Director director) {
        director.makeMovie();
    }
}

3.2 Lambda练习

给定一个计算器Calculator接口，内含抽象方法calc (减法)，其功能是可以将两个数字进行相减，并返回差值;

请分别使用Lambda的标准格式及省略格式调用 invokeCalc 方法，完成130和120的相减计算并输出计算结果;

public interface Calculator {
    int calc(int a, int b);
}
public class Test10InvokeCalc {
    public static void main(String[] args) {
        //请分别使用Lambda【标准格式】及【省略格式】调用invokeCalc方法来计算130-120的结果
invokeCalc(130,120,(a,b)->a-b);
    }

    private static void invokeCalc(int a, int b, Calculator calculator) {
//填写代码为:
 int result = calculator.calc(a, b);
        System.out.println("结果是：" + result);
    }
}

编程题1-多态的好处

请模拟生活中"养殖场老板指挥员工饲养动物"的场景;员工类中包含饲养动物的方法,而老板类(就是测试类)可以面向员工对象调用员工类的方法;代码关系示意图如下:

参考代码:

package day3.No_5;

import javax.sound.midi.Soundbank;

//老板类
public class Demo {
    public static void main(String[] args) {
        Yuangong y = new Yuangong();
        y.Wei(new Dog());
        y.Wei(new Cat());
        y.Wei(new Pig());
    }

}

//动物类
abstract class Dongwu {
    public abstract void eat();
}

//狗类
class Dog extends Dongwu {

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

//猫类
class Cat extends Dongwu {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

//猪类
class Pig extends Dongwu {

    @Override
    public void eat() {
        System.out.println("猪饿着减肥");
    }
}
//饲养员
class Yuangong {
    public void Wei(Dongwu d) {
        d.eat();
    }
}

运行效果:

编程题2-接口形式的多态

按照要求完成以下内容：

1.已知电脑类(Computer), 有开机和关机的功能,以及使用鼠标和键盘的功能

2.已知鼠标类(Mouse), 也有连接电脑和断开电脑的功能
        connet():打印鼠标连接了
        disconnet():打印鼠标断开了
3.已知键盘类(Keyboard), 也有连接电脑和断开电脑的功能
        connet():打印键盘连接了
        disconnet():打印键盘断开了
总结,只要是符合USB设备的东可以连接电脑和断开电脑的功能
请编写测试类, 测试电脑开机, 电脑使用鼠标, 电脑使用键盘, 电脑关机的功能

参考答案:

package day4.No_1;


interface usb {
    void connet();

    void disconnet();
}

class Shubiao implements usb {

    @Override
    public void connet() {
        System.out.println("鼠标链接成功");
    }

    @Override
    public void disconnet() {
        System.out.println("鼠标断开成功");
    }
}

class Jianpan implements usb {

    @Override
    public void connet() {
        System.out.println("键盘连接成功");
    }

    @Override
    public void disconnet() {
        System.out.println("键盘断开成功");
    }
}

interface KaiGuan {
    void kai();
    void Guan();
}

class Diannao implements KaiGuan {
    public void useUsb(usb usb){
        usb.connet();
        usb.disconnet();
    }

    @Override
    public void kai() {
        System.out.println("开机");
    }

    @Override
    public void Guan() {
        System.out.println("关机");
    }
}

class Test {
    public static void main(String[] args) {
        Diannao d=new Diannao();
        Shubiao s = new Shubiao();
        Jianpan j=new Jianpan();
        d.kai();
        d.useUsb(s);
        d.useUsb(j);
        d.Guan();
    }
}

运行效果:

编程题3-自定义数据类型参数

分析以下需求,并用代码实现

(1)人类:
        a.属性:姓名,身高
(2)男朋友类:
    a.属性:姓名,身高
    b.行为:挣钱(输出语句模拟),逛街(和女朋友一块逛街,用上女朋友类)

(3)女朋友类:
    a.属性:姓名,身高 
    b.行为:做饭,洗衣服(洗某一件衣服,用衣服类作为形参)

(4)衣服类:
    a.属性:品牌,颜色

(5)测试类:
    a.创建女朋友对象,为姓名,身高赋值,调用做饭和洗衣服方法

    b.创建男朋友对象,为姓名,身高赋值,调用挣钱和逛街方法

参考答案:

package day4.No_2;

import javax.naming.Name;

public class Demo {
    public static void main(String[] args) {
        System.out.println("男朋友");
        Man m = new Man();
        Women w = new Women("小红", 160);
        m.Zhengqian();
        m.Guangjie(w);
        Yifu y = new Yifu("红色", "破大衣");
        System.out.println("---------");
        System.out.println("女朋友");
        w.Zuofan();
        w.Xiyi(y);


    }
}

//人类
class Ren {
    private String name;
    private double shengao;

    public Ren() {
    }

    public Ren(String name, double shengao) {
        this.name = name;
        this.shengao = shengao;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getShengao() {
        return shengao;
    }

    public void setShengao(double shengao) {
        this.shengao = shengao;
    }
}

//男朋友类
class Man extends Ren {
    public Man() {
    }

    public Man(String name, double shengao) {
        super(name, shengao);
    }

    public void Zhengqian() {
        System.out.println("挣钱");
    }

    public void Guangjie(Women women) {
        System.out.println("和" + women.getName() + "逛街");
    }
}

//女朋友类
class Women extends Ren {
    public Women() {
    }

    public Women(String name, double shengao) {
        super(name, shengao);

    }

    public void Zuofan() {
        System.out.println("做饭");
    }

    public void Xiyi(Yifu yifu) {
        System.out.println("洗路边捡的" + yifu.getYanse() + yifu.getPinpai());
    }
}

//衣服类
class Yifu {
    private String Yanse;
    private String Pinpai;

    public Yifu() {
    }

    public Yifu(String yanse, String pinpai) {
        Yanse = yanse;
        Pinpai = pinpai;
    }

    public String getYanse() {
        return Yanse;
    }

    public void setYanse(String yanse) {
        Yanse = yanse;
    }

    public String getPinpai() {
        return Pinpai;
    }

    public void setPinpai(String pinpai) {
        Pinpai = pinpai;
    }
}

运行效果:

码农公寓

内部类lambda重点摘要

课堂笔记-多态-匿名内部类-lambda

多态

多态的概述

多态的前提

多态的代码形式(重点)

多态中成员访问的特点

成员变量(了解)

成员方法(重点)

多态的好处和弊端

多态的转型

内部类

概述

分类

匿名内部类(重点)

语法格式

匿名对象

lambda

概述

使用前提

lambda的基本语法

省略规则

lambda与匿名内部类的区别

代码实现

1.内部类

1.1 内部类的基本使用（理解）

1.2 成员内部类（理解）

1.3 局部内部类（理解）

1.4 匿名内部类（应用）

1.5 匿名内部类在开发中的使用（应用）

2.Lambda表达式

2.1体验Lambda表达式【理解】

2.2Lambda表达式的标准格式【理解】

2.3Lambda表达式练习1【应用】

2.4Lambda表达式练习2【应用】

2.5Lambda表达式练习3【应用】

2.6Lambda表达式的省略模式【应用】

2.7Lambda表达式的使用前提【理解】

2.8Lambda表达式和匿名内部类的区别【理解】

课后练习

多态问答题

1.1 请用一句话描述出用代码怎样实现“多态”？

1.2 请写出多态的好处和弊端；

1.3 请写出多态的向下转型的意义

内部类问答题

2.1 请问有几种形式的内部类？

2.2 请问内部类会被编译成class文件吗？

2.3 请问下面横线处分别填写什么代码，才能实现打印出注释的结果

2.4 请问下面横线处分别填写什么代码，才能实现打印：

2.5 请按要求填写代码：

lambda问答题

3.1 Lambda练习

3.2 Lambda练习

编程题1-多态的好处

编程题2-接口形式的多态

编程题3-自定义数据类型参数

相关文章

　　　　　　　　　　　　　　　　内部类lambda重点摘要

　　　　　　　　　　　　　　　　课堂笔记-多态-匿名内部类-lambda

　　　　　　　　　　　　　　　　代码实现

　　　　　　　　　　　　　　　　课后练习