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

时间:2021-06-28 06:14:16

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

                内部类lambda重点摘要

内部类特点:

  1. 内部类可以直接访问外部类,包括私有

  2. 外部类访问内部类必须创建对象

    创建内部对象格式:

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

    静态内部类访问:

    外部类.内部类.方法名

    局部内部类:

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

  3. 私有成员内部类访问需在自己外部类中创建对象

匿名内部类:

  1. 前提:

    需要一个类或者接口

  2. 格式:

    new 类名/接口名(){重写方法}

  3. 理解:将继承/实现,方法重写,创建对象放在了一步进行

  4. 解释:实现了Inter接口,一个实现类对象

lambda:

  1. 格式:

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

    形式参数:

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

    ->:

    固定写法,代表指向动作

    代码块:

    我们具体的实现代码

  2. 前提:

    1. 有一个接口

    2. 接口中有且只有一个抽象方法

  3. lanmda省略模式:

    1. 参数类型可以省略,但是多个参数情况下不能只省略一个

    2. 如果有且只有一个参数()可以省略

    3. 如果代码块只有一条语句,可以省略大括号分号和return关键字

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

  1. 所需类型不同:

    1. 匿名内部类:可以是接口,也可以是抽象类,还可以是具体类

    2. lambda表达式:只能是接口

  2. 使用限制不同:

    1. 如果接口中有且仅有一个抽象方法,可以使用lambda,也可以匿名内部类

    2. 如果接口中多于一个抽象方法,只能使用匿名内部类,不能使用lambda表达式

  3. 实现原理不同:

    1. 匿名内部类:编译之后产生一个单独的.class字节码文件

    2. lambda表达式:编译之后,没有单独的.class字节码文件,对应的字节码会在运行时候动态生成

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

多态

多态的概述

一个对象,多种形态;

多态的前提

有继承或有实现

多态的代码形式(重点)

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

多态中成员访问的特点

成员变量(了解)

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

成员方法(重点)

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

多态的好处和弊端

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

多态的转型

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

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

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

判断的格式:

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

内部类

概述

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

分类

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

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

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

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

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

匿名内部类(重点)

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

语法格式

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

匿名对象

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

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

lambda

概述

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

使用前提

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

lambda的基本语法

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

省略规则

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

lambda与匿名内部类的区别

Java基础进阶:内部类lambda重点摘要,详细讲解成员内部类,局部内部类,匿名内部类,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-多态的好处

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

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

参考代码:

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();
  }
}

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

编程题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();
  }
}

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

编程题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;
  }
}

​运行效果:

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